diff --git a/README.md b/README.md index b26bad5..3219cdb 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,54 @@ # Computational Mechanics 03- Initial Value Problems +## Learning to frame engineering equations as numerical methods -![Warning: Under -Construction!!](https://publicdomainvectors.org/photos/under-construction_geek_man_01.png) +Welcome to Computational Mechanics Module #3! In this module we will explore +some more data analysis, find better ways to solve differential equations, and +learn how to solve engineering problems with Python. + +[01_Catch_Motion](./notebooks/01_Catch_Motion.ipynb) + +* Work with images and videos in Python using `imageio`. +* Get interactive figures using the `%matplotlib notebook` command. +* Capture mouse clicks with Matplotlib's `mpl_connect()`. +* Observed acceleration of falling bodies is less than $9.8\rm{m/s}^2$. +* Capture mouse clicks on several video frames using widgets! +* Projectile motion is like falling under gravity, plus a horizontal velocity. +* Save our hard work as a numpy .npz file __Check the Problems for loading it back into your session__ +* Compute numerical derivatives using differences via array slicing. +* Real data shows free-fall acceleration decreases in magnitude from $9.8\rm{m/s}^2$. + +[02_Step_Future](./notebooks/02_Step_Future.ipynb) + +* Integrating an equation of motion numerically. +* Drawing multiple plots in one figure, +* Solving initial-value problems numerically +* Using Euler's method. +* Euler's method is a first-order method. +* Freefall with air resistance is a more realistic model. + +[03_Get_Oscillations](./notebooks/03_Get_Oscillations.ipynb) + +* vector form of the spring-mass differential equation +* Euler's method produces unphysical amplitude growth in oscillatory systems +* the Euler-Cromer method fixes the amplitude growth (while still being first +* order) +* Euler-Cromer does show a phase lag after a long simulation +* a convergence plot confirms the first-order accuracy of Euler's method +* a convergence plot shows that modified Euler's method, using the derivatives +* evaluated at the midpoint of the time interval, is a second-order method +* How to create an implicit integration method +* The difference between _implicit_ and _explicit_ integration +* The difference between stable and unstable methods + +[04_Getting_to_the_root](./notebooks/04_Getting_to_the_root.ipynb) + +* How to find the 0 of a function, aka root-finding +* The difference between a bracketing and an open methods for finding roots +* Two bracketing methods: incremental search and bisection methods +* Two open methods: Newton-Raphson and modified secant methods +* How to measure relative error +* How to compare root-finding methods +* How to frame an engineering problem as a root-finding problem +* Solve an initial value problem with missing initial conditions (the shooting +* method) +* _Bonus: In the Problems you'll consider stability of bracketing and open methods._ diff --git a/images/.ipynb_checkpoints/damped-spring-checkpoint.png b/images/.ipynb_checkpoints/damped-spring-checkpoint.png new file mode 100644 index 0000000..cb78d51 Binary files /dev/null and b/images/.ipynb_checkpoints/damped-spring-checkpoint.png differ diff --git a/images/.ipynb_checkpoints/double_pendulum_animation-checkpoint.gif b/images/.ipynb_checkpoints/double_pendulum_animation-checkpoint.gif new file mode 100644 index 0000000..81f5a58 Binary files /dev/null and b/images/.ipynb_checkpoints/double_pendulum_animation-checkpoint.gif differ diff --git a/images/.ipynb_checkpoints/pendulum_spring-checkpoint.png b/images/.ipynb_checkpoints/pendulum_spring-checkpoint.png new file mode 100644 index 0000000..323f0de Binary files /dev/null and b/images/.ipynb_checkpoints/pendulum_spring-checkpoint.png differ diff --git a/images/bisection.png b/images/bisection.png new file mode 100644 index 0000000..6c9439d Binary files /dev/null and b/images/bisection.png differ diff --git a/images/bisection.svg b/images/bisection.svg new file mode 100644 index 0000000..61715ca --- /dev/null +++ b/images/bisection.svg @@ -0,0 +1,299 @@ + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + xsolution + + + + xupper + xlower + + xmid + + + + region of interest + + + f(x) + x + + diff --git a/images/shooting.png b/images/shooting.png new file mode 100644 index 0000000..8bb9983 Binary files /dev/null and b/images/shooting.png differ diff --git a/images/shooting.svg b/images/shooting.svg new file mode 100644 index 0000000..b494211 --- /dev/null +++ b/images/shooting.svg @@ -0,0 +1,937 @@ + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + y(t) + t + y(0) + desired y(T) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/notebooks/.ipynb_checkpoints/02_Step_Future-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/02_Step_Future-checkpoint.ipynb index bde138e..a103501 100644 --- a/notebooks/.ipynb_checkpoints/02_Step_Future-checkpoint.ipynb +++ b/notebooks/.ipynb_checkpoints/02_Step_Future-checkpoint.ipynb @@ -374,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 199, + "execution_count": 310, "metadata": {}, "outputs": [], "source": [ @@ -391,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": 200, + "execution_count": 311, "metadata": {}, "outputs": [], "source": [ @@ -401,7 +401,7 @@ }, { "cell_type": "code", - "execution_count": 201, + "execution_count": 312, "metadata": {}, "outputs": [], "source": [ @@ -419,7 +419,7 @@ }, { "cell_type": "code", - "execution_count": 202, + "execution_count": 314, "metadata": {}, "outputs": [], "source": [ @@ -429,7 +429,7 @@ }, { "cell_type": "code", - "execution_count": 203, + "execution_count": 315, "metadata": {}, "outputs": [ { @@ -438,7 +438,7 @@ "array([ 1.6 , -0.00981])" ] }, - "execution_count": 203, + "execution_count": 315, "metadata": {}, "output_type": "execute_result" } @@ -452,7 +452,7 @@ }, { "cell_type": "code", - "execution_count": 204, + "execution_count": 316, "metadata": {}, "outputs": [], "source": [ @@ -469,7 +469,7 @@ }, { "cell_type": "code", - "execution_count": 205, + "execution_count": 317, "metadata": {}, "outputs": [ { @@ -504,7 +504,7 @@ }, { "cell_type": "code", - "execution_count": 206, + "execution_count": 318, "metadata": {}, "outputs": [ { @@ -595,7 +595,7 @@ }, { "cell_type": "code", - "execution_count": 207, + "execution_count": 319, "metadata": {}, "outputs": [], "source": [ @@ -632,7 +632,7 @@ }, { "cell_type": "code", - "execution_count": 208, + "execution_count": 320, "metadata": {}, "outputs": [], "source": [ @@ -643,7 +643,7 @@ }, { "cell_type": "code", - "execution_count": 209, + "execution_count": 321, "metadata": {}, "outputs": [], "source": [ @@ -653,7 +653,7 @@ }, { "cell_type": "code", - "execution_count": 210, + "execution_count": 322, "metadata": {}, "outputs": [], "source": [ @@ -664,7 +664,7 @@ }, { "cell_type": "code", - "execution_count": 230, + "execution_count": 323, "metadata": {}, "outputs": [], "source": [ @@ -681,7 +681,7 @@ }, { "cell_type": "code", - "execution_count": 231, + "execution_count": 324, "metadata": {}, "outputs": [ { @@ -719,7 +719,7 @@ }, { "cell_type": "code", - "execution_count": 232, + "execution_count": 325, "metadata": {}, "outputs": [ { @@ -784,6 +784,144 @@ "\n", "4. _Computational Physics with Python_, lecture notes by Eric Ayars, California State University, Chico. Available online on the author's website: https://physics.csuchico.edu/ayars/312/handouts/comp-phys-python.pdf" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problems\n", + "\n", + "1. Integrate the `fall_drag` equations for a tennis ball and a [lacrosse ball](https://en.wikipedia.org/wiki/Lacrosse_ball) with the same initial conditions as above. Plot the resulting height vs time. \n", + "\n", + "_Given:_ y(0) = 1.6 m, v(0) = 0 m/s\n", + "\n", + "|ball| diameter | mass|\n", + "|---|---|---|\n", + "|tennis| $6.54$–$6.86 \\rm{cm}$ |$56.0$–$59.4 \\rm{g}$|\n", + "|lacrosse| $6.27$–$6.47 \\rm{cm}$ |$140$–$147 \\rm{g}$|\n", + "\n", + "Is there a difference in the two solutions? At what times do the tennis ball and lacrosse balls reach the ground? Which was first?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Projectile motion with drag](../images/projectile.png)\n", + "\n", + "The figure above shows the forces acting on a projectile object, like the [lacrosse ball](https://en.wikipedia.org/wiki/Lacrosse_ball) from [Flipping Physics](http://www.flippingphysics.com) that we analyzed in [lesson 01_Catch_Motion](./01_Catch_Motion.ipynb). Consider the 2D motion of the [lacrosse ball](https://en.wikipedia.org/wiki/Lacrosse_ball), now the state vector has two extra variables, \n", + "\n", + "\\begin{equation}\n", + "\\mathbf{y} = \\begin{bmatrix}\n", + "x \\\\ v_x \\\\\n", + "y \\\\ v_y \n", + "\\end{bmatrix},\n", + "\\end{equation}\n", + "\n", + "and its derivative is now, \n", + "\n", + "\\begin{equation}\n", + "\\dot{\\mathbf{y}} = \\begin{bmatrix}\n", + "v_x \\\\ -c v_x^2 \\\\\n", + "v_y \\\\ g - cv_y^2 \n", + "\\end{bmatrix}, \n", + "\\end{equation}\n", + "\n", + "where $c= \\frac{1}{2} \\pi R^2 \\rho C_d$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Create a `projectile_drag` function that returns the derivative of $\\mathbf{y}$, given $\\mathbf{y}$ e.g. \n", + "\n", + " $\\mathbf{\\dot{y}} = projectile\\_drag(\\mathbf{y})$\n", + " \n", + " Below is the start of a function definition, be sure to update the help file. \n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 241, + "metadata": {}, + "outputs": [], + "source": [ + "def projectile_drag(state,C_d=0.47,m=0.143,R = 0.0661/2):\n", + " '''Computes the right-hand side of the differential equation\n", + " for the fall of a projectile lacrosee ball, with drag, in SI units.\n", + " \n", + " Arguments\n", + " ---------- \n", + " state : array of two dependent variables [y v]^T\n", + " m : mass in kilograms default set to 0.143 kg (mass of lax ball source wiki)\n", + " C_d : drag coefficient for a sphere default set to 0.47 (no units)\n", + " R : radius of ball default in meters is 0.0661/2 m (tennis ball)\n", + " Returns\n", + " -------\n", + " derivs: array of four derivatives [?? ?? ?? ??]\n", + " '''\n", + " \n", + " rho = 1.22 # air density kg/m^3\n", + " pi = np.pi\n", + "\n", + " return derivs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Integrate your `projectile_drag` function using the Euler integration method. Use initial conditions from the saved data in lesson [01_Catch_Motion](01_Catch_Motion.ipynb), there is a numpy `npz` file in the data folder if you want to check your results from lesson 1. The initial conditions in the provided npz file are\n", + "\n", + "\\begin{equation}\n", + "\\mathbf{y}(0) = \\begin{bmatrix}\n", + "x(0) \\\\ v_x(0) \\\\\n", + "y(0) \\\\ v_y(0) \n", + "\\end{bmatrix}\n", + "= \\begin{bmatrix}\n", + " 0.5610~m \\\\ 2.6938~m/s \\\\\n", + "-0.1858~m \\\\ -0.0759~m/s \n", + "\\end{bmatrix},\n", + "\\end{equation}\n", + "\n", + "Compare your converged numerical integration to the data points in [projectile_coords.npz](../data/projectile_coords.npz). Is there a noticeable effect of drag on the lacrosse ball?" + ] + }, + { + "cell_type": "code", + "execution_count": 326, + "metadata": {}, + "outputs": [], + "source": [ + "npz = np.load('../data/projectile_coords.npz')\n", + "t3=npz['t']\n", + "x3=npz['x']\n", + "y3=npz['y']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/notebooks/.ipynb_checkpoints/03_Get_Oscillations-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/03_Get_Oscillations-checkpoint.ipynb index 9a34693..bea1f08 100644 --- a/notebooks/.ipynb_checkpoints/03_Get_Oscillations-checkpoint.ipynb +++ b/notebooks/.ipynb_checkpoints/03_Get_Oscillations-checkpoint.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "###### Content under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License © 2017 L.A. Barba, N.C. Clementi" + "###### Content modified under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License © 2020 R.C. Cooper" ] }, { @@ -21,7 +21,7 @@ "* form the state vector and the vectorized form of a second-order dynamical system;\n", "* improve the simple free-fall model by adding air resistance.\n", "\n", - "You also learned that Euler's method is a _first-order_ method: a Taylor series expansion shows that stepping in time with Euler makes an error—called the _truncation error_—proportional to the time increment, $\\Delta t$.\n", + "You also learned that Euler's method is a _first-order_ method: a Taylor series expansion shows that stepping in time with Euler makes an error—called the _truncation error_ —proportional to the time increment, $\\Delta t$.\n", "\n", "In this lesson, you'll work with oscillating systems. Euler's method doesn't do very well with oscillating systems, but we'll show you a clever way to fix this. (The modified method is _still_ first order, however. We will also confirm the **order of convergence** by computing the error using different values of $\\Delta t$.\n", "\n", @@ -31,23 +31,20 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ - "import numpy\n", - "from matplotlib import pyplot\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", - "pyplot.rc('font', family='serif', size='14')" + "plt.rcParams.update({'font.size': 22})\n", + "plt.rcParams['lines.linewidth'] = 3" ] }, { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "def eulerstep(state, rhs, dt):\n", @@ -76,13 +73,14 @@ "A prototypical mechanical system is a mass $m$ attached to a spring, in the simplest case without friction. The elastic constant of the spring, $k$, determines the restoring force it will apply to the mass when displaced by a distance $x$. The system then oscillates back and forth around its position of equilibrium.\n", "\n", " \n", - "#### Simple spring-mass system, without friction." + "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ + "## Simple spring-mass system, without friction.\n", "Newton's law applied to the friction-less spring-mass system is:\n", "\n", "\\begin{equation}\n", @@ -115,7 +113,7 @@ "\\dot{v} &=& -\\omega^2 x\n", "\\end{eqnarray}\n", "\n", - "Like we did in [Lesson 2](http://go.gwu.edu/engcomp3lesson2) of this module, we write the state of the system as a two-dimensional vector,\n", + "Like we did in [Lesson 2](./02_Step_Future.ipynb) of this module, we write the state of the system as a two-dimensional vector,\n", "\n", "\\begin{equation}\n", "\\mathbf{x} = \\begin{bmatrix}\n", @@ -138,10 +136,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true - }, + "execution_count": 42, + "metadata": {}, "outputs": [], "source": [ "def springmass(state):\n", @@ -154,10 +150,10 @@ " \n", " Returns \n", " -------\n", - " derivs: array of two derivatives [v - ω*ω*x]^T\n", + " derivs: array of two derivatives [v - w*w*x]^T\n", " '''\n", " \n", - " derivs = numpy.array([state[1], -ω**2*state[0]])\n", + " derivs = np.array([state[1], -w**2*state[0]])\n", " return derivs" ] }, @@ -170,14 +166,12 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": true - }, + "execution_count": 43, + "metadata": {}, "outputs": [], "source": [ - "ω = 2\n", - "period = 2*numpy.pi/ω\n", + "w = 2\n", + "period = 2*np.pi/w\n", "dt = period/20 # we choose 20 time intervals per period \n", "T = 3*period # solve for 3 periods\n", "N = round(T/dt)" @@ -185,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 44, "metadata": {}, "outputs": [ { @@ -211,21 +205,17 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": true - }, + "execution_count": 45, + "metadata": {}, "outputs": [], "source": [ - "t = numpy.linspace(0, T, N)" + "t = np.linspace(0, T, N)" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": true - }, + "execution_count": 46, + "metadata": {}, "outputs": [], "source": [ "x0 = 2 # initial position\n", @@ -234,22 +224,18 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": true - }, + "execution_count": 47, + "metadata": {}, "outputs": [], "source": [ "#initialize solution array\n", - "num_sol = numpy.zeros([N,2])" + "num_sol = np.zeros([N,2])" ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": true - }, + "execution_count": 48, + "metadata": {}, "outputs": [], "source": [ "#Set intial conditions\n", @@ -266,10 +252,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true - }, + "execution_count": 49, + "metadata": {}, "outputs": [], "source": [ "for i in range(N-1):\n", @@ -285,40 +269,40 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": true - }, + "execution_count": 67, + "metadata": {}, "outputs": [], "source": [ - "x_an = x0*numpy.cos(ω * t)" + "x_an = x0*np.cos(w * t)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 68, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAE1CAYAAAA2zJNzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAElCAYAAAAlet80AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAIABJREFUeJzt3Xd4FPX2x/H3SaX3IN0AKh1RI0hRkCZFwQKCDUEFe0XFdu1esf9s9yroVUQRERVRQRAQEEUkIEgTQUEJIASkpyfn98cMusY0QrIzuzmv58mT3Z3Zmc/szs6Z71RRVYwxxpjiiPA6gDHGmNBlRcQYY0yxWRExxhhTbFZEjDHGFJsVEWOMMcVmRcQYY0yxWREpJhGZKSKXe53DlAwRuUREZhfQvZuIJAUpy5si8mgwxhUsIvKgiLxdQsMaLiKLCunnaxE5KZ9uJfJdioiKyHFHOxx3WPNF5Kp8uv352YlIIxE5KCKRJTDOD0Wkz9EOp8wUERHpIiLfiMg+EfnDnclOLe7wVLWvqk4oyYxlRUn++EqKqr6jqr0PPz/ajO5CIc39wR/++6Rk0hY67s0iEh+MceUz/qAV3HzGfw5wQFW/9ypDaVHV31S1kqpml8DgxgKPHe1AykQREZEqwKfAi0ANoD7wEJBejGGJiJSJz80ctRvcH/zhv3NKc2QiElWaww8h1wATvQ7hd6r6HVBFRBKOZjhlZWF4AoCqvquq2aqaqqqzVfUH+LN5/LWIvOi2VH4UkR6H3+yuVT4mIl8DKUCTwObn4ea1iDwtIntEZJOI9A14f2MRWSgiB0Rkjoi8XFDT3h32o27L6aCIfCIiNUXkHRHZLyJLA9c0ReR5EdnidlsmIqcHdGsvIolutx0i8qz7ejkReVtEdovIXneYx+STZ4yIbHXzrxeRHiJSR0RSRKRmQH+niEiyiESLyHEissD9PHeJyHtuPwvd3le60zbEff1sEVnhZvlGRNoGDHeziNwhIj+IyCEReV1EjhFnk+Lhz7R6PtkXiMgF7uMubgujn/u8p4isCPwOC8rodhstIjtFZLuIjMjvOyyI5LE5pqCWTxE+mzEi8gNwKHchEZF+IrLW/Zy2isjtBWT6WkSec8fzi4h0cl/f4k7z5QH9x7rz+2/ufPWKiJQXkYrATKCe/NUCq+e+LUZE3nKzrJGAhZeItHDn+71utwEB3WqKyHR3Hv4OaFrAZxsDdAcWBLxWXpxNhHtEZC1waq733CUiP7u51orIeQHd8pyPA/QUkQ3usF8WEQl47xUiss7tNktEjg3o1kuc5cw+EXkJEIpAROLdeSXKfT5fRB5xv7sDIjJbRGoF9H+aO8/sFZGVItIt1yDnA/2LMu58qWrY/wFVgN3ABKAvUD1X9+FAFnArEA0MAfYBNdzu84HfgFZAlNvPfOCqgPdnAiOBSOBaYBsgbvfFwNNADNAF2A+8XUDe+cBGnB9LVWAt8BPQ0x3/W8AbAf1fCtR0u40GfgfKBYz7MvdxJeA09/HVwCdABTfzKUCVPLI0A7YA9dzn8UBT9/EM4NqAfp8DXnQfvwvci7OiUg7oEtCfAscFPD8Z2Al0cLNcDmwGYt3um4FvgWNwWpE7geXASUAsMA94IJ/P8uGATPcAPwNPBHR7PuA7XFRAxm7uPPKw+/33w1mhqJ7PeP+cP/Lo9rdx5R4f8Cbw6BF8NiuAhkD5PMa1HTjdfVwdOLmATFnACHc8j+LM8y+7n3Fv4ABQye3//4DpOC37yjjz0uMBn1VSruE/CKS5n1sk8DjwrdstGmd+vwfnN9LdHVczt/tkYApQEWgNbM39+QWMpxVwKNdrY4Gv3KwNgdWB+YDBQD2ceXUIcAioW8T5+FOgGtAISAb6uN3OdaepBc7v8j7gG7dbLZxlwCB32m91P/v85pcHcZcXOL8/BaIC5rOfcVaUy7vPx7rd6uMs9/q5+Xu5z+MChn0b8OFRLV+P5s2h9Od+mW8CSe4XNh04JuAH9OdC333tO/5a+M4HHs41vPn8vYhsDOhWwf2i67gzVxZQIaD72xReRO4NeP4MMDPg+TnAigLevwc40X28EGfTXa1c/VwBfAO0LeRzOw5nIdYTiM7VbQjwtfs4Eqd4tXefvwWMAxrkMczcC+j/Ao/k6mc90NV9vBm4JKDbB8B/A57fCEzLJ38P4Af38efAVfy18FoAnB/wHRZWRFJxf7zuaztxi3I+32EKsDfg75G8xpV7fPy9iBTls7migO/vN5wVhn+sIOTqbziwIeB5GzfTMQGv7Qba4aw1H8JdmXC7dQQ2BXxWeRWROQHPWwKp7uPT3XknIqD7u+57InFW0JoHdPt37s8voFtn4Pdcr/2Cu3B3n4/KnS9X/yuAgUWcjwOLyhTgLvfxTODKgG4R7vxwLDDs8DzodhOc5VJxi8h9Af1eB3zuPh4DTMw1rFnA5QHPRwLzCpo3CvsrK5uzUNV1qjpcVRvgrM3Uw1mbOmyrup+q61e3n8O2FDKK3wPGleI+rOQO44+A1/42LHczwOFm/z0B/ewIeJyax/NKAcMY7Tab94nIXpzWy+Em7ZU4ayk/irPJ6mz39Yk4M9RkEdkmIk+KSHTuiVLVjcAtODPyThGZHLB54mOgpYg0wVnL2afOdlaAO3F+HN+5myeu+OdH9qdjgdFuk3uvOw0N+fvnX+TPI5fFwAnibKprh7NQaOg2+dvjFNmi2q2qWQHPUwoYL8BNqlot4O9fRzCuw4ry2RQ0b16Asyb6q7tZpmMB/eb+TFHVvD7nOJwVpWUBmT53Xy/I7wGPU4By7maZesAWVc0J6P4rzpp0HM6a/JZc3fKzB6dlFKheQe8XkWEBmwv34iwfDv9+CpuPc0/T4fnhWOD5gGH+4Q6nfu487nKnsOVLQQrKMDjXvNMFqBvQf2WcFZxiKzNFJJCq/oizttc64OX6gdszcVoQ2wLfVszRbQdqiEiFgNcaBmS5Rv/a8frvIx24OPs/xgAX4mxaqYazKU7c4W9Q1YuA2sATwFQRqaiqmar6kKq2BDoBZ+OsIf2Dqk5S1S44M6W6w0FV03DWvi4BLiNgZ6aq/q6qI1W1Hs6a8H8k/6OdtgCP5VrgVlDVd4/088gjewqwDLgZWK2qGTgtsNuAn1V119GOoxgO4SyEARCROgX0W5TPJt95U1WXqupAnO9/Gs73dbR24RSUVgGZqqrq4YXXkf5WtuEU9sDlUSOczVbJOC35hrm65WcDzvEv9QNe257f+939FOOBG4Ca7u9nNX/9fo5kPg60Bbg61/dWXlW/yZ3HXe40zG9AR2ELTkskMENFVR0b0E8LYOXRjKRMFBERae6urTdwnzcELsLZzn5YbeAmcXYKD8b5cGcc7bhV9VcgEXhQRGLcNcGSPEqnMs6PLBmIEpH7cfYBASAil4pInLuWd3iNI1tEzhSRNuIcb74fZ5PBPw4bFJFmItJdRGJxtmmn5urvLZxNIQNwNtMdft/gw583ztqhBrxvB9AkYBjjgWtEpIM4KopIfxHJvUZZXAtwFhKHd7bOz/U8L7kzlqSVQCsRaSci5XBaefkp9mfjzm+XiEhVVc3E+Z6P+tBQd14aDzwnIrXdcdUXkbPcXnYANUWkahEHuQSnsN7p/v664fxGJqtzKOuHOL+fCiLSEme/UH7ZMoE5QNeAl6cAd4tIdXeevDGgW0WceTPZnY4RBKxcFjIfF+QVd5yt3OFUdZcrAJ/hfP/nuy2xm3A2fZe0t4FzROQsEYkU52CabgHTA87nNPNoRlImigjOTroOwBIROYRTPFbj7IQ+bAlwPM5a1mPAIFXdXULjvwRnm/FunB2W71GMw4vzMQtnJvgJp5mext+bxn2ANSJyEHgeGOq2IOoAU3EWLOtwFqh5HTEWi7NjchdOs7k2zg5QAFT1ayAHWK6qmwPedyrO530QZ//Tzaq6ye32IDDBbWJfqKqJONtmX8L5oW7EKUwlZQFOsV2Yz/O8/C1jMcf7kvz9PJFlAKr6E84O+jk4a875njhXAp/NZcBmEdmPc+jrpcWZkDyMcbN86w57Ds5BGIdb+u8Cv7ifX738BwNu63AAzkEvu4D/AMPc4YBT8CvhzH9vAm8Uku1VnOk+7CGc38YmYDZ/bzGvxdnnuBin+LUBvg54b0HzcUHT9BFOi32y+/msdqcPt/U7GOd3tRtnufN1PoMqNlXdAgzE+b0m4ywX7sBd7otzntyhgE3QuPPp6XkMLl+Hjx4q00RkOM5OrS5BGt97wI+q+kAwxlfaRGQeMElVX/M6izEA4hxCfaOG4QmHJUVEPgBeV9Wj2uJiJycFgVvx/8BZE+qNs3YwtsA3hQh32k7GmSZjfCFYK4ShTFUvKInhWBEJjjo423Vr4hzKd204rCGJyASc4+FvVtUDXucxxgSfbc4yxhhTbGVlx7oxxphSYEXEGGNMsVkRMcYYU2xWRIwxxhSbFRFjjDHFZkXEGGNMsVkRMcYYU2xWRIwxxhSbFRFjjDHFZkXEGGNMsVkRMcYYU2xWRIwxxhSbFRFjjDHFZkXEGGNMsVkRMcYYU2xWRIwxxhRb2N/ZsFatWhofH+91DGOMCSnLli3bpapxhfUX9kUkPj6exMREr2MYY0xIEZFfi9Kfbc4yxhhTbFZEjDHGFJsVEWOMMcVmRcQYY0yxWRExxhhTbL4pIiLSUES+FJF1IrJGRG7Oox8RkRdEZKOI/CAiJ3uR1RhjjMNPh/hmAaNVdbmIVAaWicgXqro2oJ++wPHuXwfgv+5/Y4wxHvBNEVHV7cB29/EBEVkH1AcCi8hA4C1VVeBbEakmInXd95a477/+nE9++B2JrURU1XrUqVOX42pX4qRG1akU65uPzhhjSMnIYvWWPWz65Sf27Ummdkwm53ZtD9WPLdXx+nJJKCLxwEnAklyd6gNbAp4nua/9rYiIyChgFECjRo2KnaPGD+MZsH0TFUmjjvxB5g+RbNAGvJnTnB3VE7ht5AiqV6lU7OEbY8zRSPr1ZzYs/hj99RsaHlpLW9lJAyqzVyujMRWh6eiyV0REpBLwAXCLqu7P3TmPt+g/XlAdB4wDSEhI+Ef3ooq+6G327DjAlrQs5u9NJXlHEhlbVxL3xzKGHppItf8+A837w0nD+Ca9Cac0rkFsVGRxR2eMMYVLPwg/vAerplJj6yoOZrRiSU4LVtCd6LjjadbwGOJrVaRxrYq0alWn1OP4qoiISDROAXlHVT/Mo5ckoGHA8wbAttLKU69aeepVKx/wSlOgKykZWezYn45E74HVH5I5dSQV90byUPS5tOhxGUPaxxMT5ZtjFowxYSBr3+9s/PhxmiZNI7pJF+h8E79VTGDuoiR6t6rDmONrUblcdNBzibN7wXsiIsAE4A9VvSWffvoDNwD9cHaov6Cq7QsabkJCgpb2tbOWb97Fx++/yXkH3iGabN4odxk9B1zGWa2OwZksY4wpprT9bPn0caqumcgHmZ34quZgXr9lUKkvW0RkmaomFNqfj4pIF+ArYBWQ4758D9AIQFVfcQvNS0AfIAUYoaoFVohgFBE3H5+v2s7imRMZfuh/bNAGfHHsrdxyQXcaVK9Q6uM3xoQZVQ5+/wGZM8YwN70lz2VeQESNRtza8wTObVefiAgrIkERrCJyWHaOMunrn9g/52kuYgafxY3ksusfAGuRGGOK6tBukieNYv/W9YxJH8GaqFbc0P04ruzSmHLRwdnvWtQiYhvuS1hkhHDZ6c0YfPuLvHbcfxgqX8DkS+DQbq+jGWNCwS8LyHmlM59trUCftMeQYzsy65YzuP7M44JWQI6EtURKW1Y6zH0YXTed8fUepW/PXjSsYZu3jDG55OTA/Mfh+4lw7n+YkdKCpD0pXNmlCZGlvOkqL0Vtifjq6KywFBULZz3GvP31uWD19Ty+biTnXXI9nY+r5XUyY4xfZKSwd9IVZO37nVpXfwWV4ujndaYiss1ZQZJw9kherPsEt+S8xXdv3sXH3yd5HckY4wf7t7P/ld7M/+UQZ+y4lRV7gn+Y7tGwIhIkVctH869RFzP1pDc5K+I7dn8wmjcX/ex1LGOMl3b/TMp/uzN+Z0tuybia/ifF07JuFa9THRErIkEUGSHccu7pfHvGW7SN+IVKs27h/2avJdz3Sxlj8rDzRw6N68Oj+/vyYtZAru7alCcHtQ25E5VDK22YuKJnOzb3nUgt2Uf7ZXeQnpHhdSRjTDBt/4GU1/pz74FBTMruwd19m3N33xYheXKyFRGPDOrYnKiLJ9G+XgzlPrvJOTLDGBP+dq4jZ+L5/CtjGNNyuvDIwFZc3bWp16mKzYqIh7o0b0DURe/Avi3kfHorC9bv9DqSMaY07dkMb19ARJ9/M2LkLTw8sBWXdYz3OtVRsSLitZgK6EWT+XXtEn6ceAvTvt/qdSJjTGk48Ds5E86FLrdC2wtpXb8qw0K8gIAVEV+QclX4qv0r9Ij4npUfPsk3P+/yOpIxpiSl7SftjYG8vLcDUyL6eJ2mRFkR8Ylh3dsxo+2LXBMxjUkTX2X97we8jmSMKQnZWaS+ezmf7W3EM2nn8M3GXWF1RKYVER+5/vwevNHgMR7S//LE65PYeSDN60jGmKOU8dkY1m79gzEpl3Jak5o8MahtSB6FlR8rIj4SGSHcMvwixle7mccyxnLvW3PIyLKjtowJVTnfvsquVbMZcfB64mtX49VLE8Lu7qdWRHymXHQkV1x1I59G9WL03sdISU3xOpIxpjg2fUXq3LEMOXgrlKvKa8MSqFohtC5pUhRWRHyoduVy9L72GU6Ib0S1hQ94HccYc6T2byNn6pWMzryOrRzDixefTHytil6nKhW+KiIi8j8R2Skiq/Pp3k1E9onICvfv/mBnDJZja1Um4oJx8Mt8cpa9xfZ9qV5HMsYURVYGTLmciA4jGXPDdYy9oC1dT4jzOlWp8dul4N/Euf3tWwX085Wqnh2cOB4rV5X9506AN/pxV0w2L9x8KVXLh19z2JiwMvs+qFATuoymcUQEjcO0BXKYr1oiqroQ+MPrHH4SW7cFr5W/gvtSnuL+95eE1aGBxoSddZ+wZ+UnTKp/DxpGR2AVxFdFpIg6ishKEZkpIq3y6kFERolIoogkJicnBztfiYqNiuT8EXewTprS6aenmPjtr15HMsbkZd9W0qfdzJX7R/HA7CQ27TrkdaKgCLUishw4VlVPBF4EpuXVk6qOU9UEVU2Iiwv9bZHxtSoSPfBZEiLWs+Kz8azZts/rSMaYQDnZpL8/kvHpvViuJzCmT3OaxFXyOlVQhFQRUdX9qnrQfTwDiBaRMnGf2b4nH8+M5v/m3sgJjH33C9Iys72OZIxx5Sz6Pzbu2MezaWfTo3ltruzS2OtIQRNSRURE6oh7qqeItMfJv9vbVMFz5aABTI09j2v3PsM73272Oo4xBiApkbSvXuSqA1cTV6U8Tw0+MazOSC+Mr4qIiLwLLAaaiUiSiFwpIteIyDVuL4OA1SKyEngBGKplaE9zhZgo2l/8APHVohgeOcvrOMaYjBQyplzJmNTL2U5Nnhx0IjUqxnidKqh8dYivql5USPeXcA4BLrNOiq8Fw9+E13rC8T0h7gSvIxlTds17hPRj2rE5uheXNKga1ueD5MdXRcQUUc2m0P1eMj8YxXttXuPSzsd5nciYsufXxbD6Qypft5gPY6uRnVNmNor8ja82Z5miS283nOU7lR0zHufLH+2OiMYEVUYK2dOuQ/s9BRVqEB0ZQbno8LqwYlFZEQlRsdFRbOjwb0ZEfc64D2ZyMD3L60jGlBlZcx9mwYEGXJ1Yj30pmV7H8ZQVkRA2tGdH3qt0Gbelv8TTM9d6HceYsuG3b0lfPoXRBy9m486DxEaX7cVo2Z76EBcVGcEZF48hEiVr6f9Y9qtdMcaYUpWVQcZHN3BX6mXsoQr/Pr9Nmd2MdZgVkRDXqn51vm/3MLdGTeXJ9+eTnmUnIRpTWnK+fp5VKTX4JOtUhiQ05LQmNb2O5DkrImHgknPO4tOYfly57yW+3hDa1wozxrd2/0zGope4ad/F1KpUjnv6tfA6kS9YEQkD5aIjaXvxw5xeYy/d9Tuv4xgTflTJmH4rL2WezVbieHBAy7C8S2FxWBEJEyc1rkP5816Az++GjLJx9VBjgmb1B0Sl7iIr4Rp6tzyG/m3qep3IN+xkw3AS3wWO7UTSxw+zoe1ozmxW2+tExoS+1D0w614ihrzNXQ3bkJOjZeraWIWxlkiYWXL8rVRY/Tb/mWrnjhhTErLnPkrm8X2g4akARERYAQlkRSTMnNq6BR9Vuogb08bz/BfrvY5jTGjbsYaMlR9y9poz+XK9XRkiL1ZEwkxEhNB+yF3Ulr1sWzyF9b8f8DqSMaFJlYxPbufpjPNYvz/abk2dDysiYahNo1osOuEu7omayGMfLbWZ35jiWDuN5OQdvJnejZ4tatO9+TFeJ/IlKyJhavD5Q1gpLUjYOoHPV//udRxjQktGCukz7uG2/RcTGRXN/We38jqRb1kRCVNVK0ST2vV+Loucw9R5i601YswRyFn0f3yb0YQl2oJrujalUc0KXkfyLV8VERH5n4jsFJHV+XQXEXlBRDaKyA8icnKwM4aSgWecysb4i/hvnU/skERjimrvb2QsfpW7D1xI/Wrlua5bU68T+ZqvigjwJtCngO59gePdv1HAf4OQKWRFRUZw6iUPEZP0LWxZ6nUcY0LD7PvY1mwYkTUacm//FmX+AouF8dXJhqq6UETiC+hlIPCWe1/1b0WkmojUVdXtQQkYimIqQo9/kTNzDF92mUSPlnW8TmSMf/36DWxdTpMbXmWOxBAT6bf1bP8JtU+oPrAl4HmS+9rfiMgoEUkUkcTkZLsgYUarC9nw+16mv/MCq7fu8zqOMf6kis6+D7r/C6LLExsVaZuBiyDUikhe3+g/9hir6jhVTVDVhLi4uCDE8reY6CiWnHA7d0ZN5vHpy2wnuzF5WfMhSbsP8NDmluxNyfA6TcgItSKSBDQMeN4A2OZRlpAycOBg1srxnJQ0iZl2yK8xf5eVTvrnD3Dn/sFMWprEoQy7L09RhVoRmQ4Mc4/SOg3YZ/tDiqZq+WgOnnE/V0bN5LWZS8jMzvE6kjG+od+NZ1VGHRbntOKq0xtTv1p5ryOFDF8VERF5F1gMNBORJBG5UkSuEZFr3F5mAL8AG4HxwHUeRQ1JZ3ftyNyYMxm4/20mf/eb13GM8YfUPWTMf4a7DwymVqVYru12nNeJQorfjs66qJDuClwfpDhhJzoygmpn3UP3T3pxxZyFnH9yAyrG+moWMCboshY8zazsk9mgDRjb+wQq2W/iiPiqJWJKX49TWvBN3BBerjuDCjF2/Lsp4/b8StayiTxy6DyOr12JwQkNC3+P+RsrImWMiHD2qEeov/d7ZNv3XscxxlvzHmFR9fNIpjp3nNWMSLtXyBGzdltZFFMRuo2BOQ+wb9AHVK0Y43UiY4Jv2/ew6St63riMT3dl06peFa8ThSRriZRR2u5Sdm/bzG1jn+OX5INexzEm+OY+DGfcDrGVaF2/qp1YWExWRMooiYphRu2R3Cbv8MysdV7HMSa4Nn3FgW3rWV5rgNdJQp4VkTKs1wUjyZIoItd+xPe/7fE6jjHBoUr67Id46MBABo1PJGlPiteJQpoVkTKsTrXyrG05mtujpvDUjFV2ORRTNmyYzR+7k/kwqxPntqtPg+p2r5CjYUWkjOs/8EJ+i6hP0y0f8PXG3V7HMaZ05eSQOushHjx0HlGRUdza6wSvE4U8KyJlXJVy0Ww/5Xauj/qY52f9YK0RE97WTmP7gUxmZSdwyWmNaFjDWiFHy4qIof9ZfVkbcTyDc2ZxMD3L6zjGlI7sLNJmP8z9By+gUmw0N5xplzcpCVZEDBViojjl8qe4MP0DKku613GMKR0r32VTRhUW5bTmis7x1KwU63WisGBFxABQNb4dND4DvnvV6yjGlLysdFjwBHXOfYyruzblii6NvU4UNqyImL90u5vMRS9x3+RFZNml4k04SXwDjmlF9eanc3ffFlSrYFdpKClWRMyfsmscx5zsdsStfp2Pvt/qdRxjSkb6QbIXPk1W13u8ThKWrIiYP0VGCNJ1DMMiZ/PGnGVkZFlrxISB717lO21Jj0l/sHrrPq/ThB1fFRER6SMi60Vko4jclUf34SKSLCIr3L+rvMgZznp17sCimC6cc3Aq7yVu8TqOMUcn/SCZX7/MfXvP5o+DGTSobncsLGm+KSIiEgm8DPQFWgIXiUjLPHp9T1XbuX+vBTVkGRAZIVTqeRdDI79k0tzvSMu0e02bELZ0PInShp+1PiM6x9u+kFLgmyICtAc2quovqpoBTAYGepypTOp6ajsWlOvO4NSpTFz8q9dxjCme9INkLnqR+/f2o3JsFFd2aeJ1orDkpyJSHwjcfpLkvpbbBSLyg4hMFZE8b0MmIqNEJFFEEpOTk0sja1iLiBDi+tzFeZGL+OzrRLJz7Cx2E4ISX2e5tGKDNmBEl8ZUrRDtdaKw5KciktfF/HMvvT4B4lW1LTAHmJDXgFR1nKomqGpCXFxcCccsGzq1a8mW+EG82+Ibu9ubCT0Zh8j86oW/WiGd7byQ0uKnIpIEBLYsGgDbAntQ1d2qeviU6vHAKUHKVuaICG0v/Bfl10+DfXa4rwkxiW+wp9YpHKzazFohpcxPt8ddChwvIo2BrcBQ4OLAHkSkrqpud58OAOxuSqWpYi046VKyFz3HxlMeoFmdyl4nMqZwGSnwzQvUvvRDvqzV0jbHljLftERUNQu4AZiFUxymqOoaEXlYRA7ffuwmEVkjIiuBm4Dh3qQtO5JPvJpDS9/lpnGfkZJhF2c0IWDZm9DgVKjTmpioCMrHRHqdKKz5pogAqOoMVT1BVZuq6mPua/er6nT38d2q2kpVT1TVM1X1R28Th79atRswr3xvhmZ8aEdqGf/LTCVj4XO8GT2EPw5leJ2mTPBVETH+IyLU7nMn50Uu4oMFiRyyS8UbP1s2gR+0KQ8ujWTCN5u9TlMmWBExherYtjkLK/RyWiPfWmvE+FRmGhkLn+XBff2pHBvFiM7xXicqE6yImEKJCLX6jOH8yK/4cMEya40Yf1r+Fqtz4lmtTezs9CCyImLgM6gAAAAfcUlEQVSKpGPbFiys0Ish1hoxfpSVTsaCZ3lg3zlUjo2y+4UEkRURUyQiQlyfOxkc9RXxsQe8jmPM330/kbU5DVllrZCgsyJiiuy0ti2p2P4S+ux73+soxvwlK52M+c/wwL6zrRXiAT+dbGh8TkSI7HIr/Oc06HwzVKrtdSRjYMU7RNdtyZjzL2Hb3jRrhQRZoUVERGoUYTg5qrq3BPIYv6tSl7QWF7DynQdZ2/oORtg1iYyXsjLgq+eQQa/TqWEtr9OUSUVpiWxz/wq6Cl8k0KhEEhnfW3HsCJovP4u7fz+TCxMaUjHWGrTGIysnkVolnvIN23udpMwqyj6RdaraRFUb5/cH7C7toMY/OpzYmm8qnMmFmdOYsHiz13FMWZWdSfqXT3HpxjO5c+pKr9OUWUUpIh1LqB8TJkSEGmeNYUjkfKYu+N7OGzHeWPkuGzLjWKbNqFPVbnvrlUKLiKqmlUQ/Jrx0OLENSyp0ZXDmx3beiAm+7EzS5j3JQ/vPsfuFeKzIh/iKSIKIfCQiy907C64SkR9KM5zxLxGhWu8xDI38kvcXrLAr/Jrg+mEKP2fWYKk2t/uFeOxIzhN5B3gDuAA4Bzjb/W/KqA7t2rKk/OmcnzGN2Wt2eB3HlBXZWaTNe4KH9w+wVogPHMlhNcmHL8luDDitkQYD7qXHtLOJbmbbpE2QrHqfTelVWaItuMlaIZ47kiLygIi8BswFDt+iFlX9sMRTmZDRumUb2DgAvv0PdL/P6zgm3GVnoQufYlH9G6meFW2tEB84kiIyAmgORAM57msKlFgREZE+wPM45528pqpjc3WPBd7Cubf6bmCIqm4uqfGbYjp9NIw7kx8bD+PY+vXtTnKm9Kz+AKlUm5HDhnNxRrado+QDR/INnKiqbUoriIhEAi8DvYAkYKmITFfVtQG9XQnsUdXjRGQo8AQwpLQymSKqHs+qSp2Z+/oDVDrrX1x1ehOvE5lwlJMNC5+Cfk+BiBUQnziSHevfikjLUksC7YGNqvqLqmYAk4GBufoZCExwH08FeohIQWfSmyA52P5mhkXO5u35q0jNyPY6jglHaz7it7RyfJ7SjJwc9TqNcR1JEekCrBCR9aV0iG99YEvA8yT3tTz7UdUsYB9QM/eARGSUiCSKSGJycnIJRjT5OS0hgRXlOnBO2nTeWWLnjZgSlpNN6pzHuXdPf+6YuooDaXZIuV8cSRHpAxwP9KZ0DvHNq0WRe3WjKP2gquNUNUFVE+Li4koknCmYiFCuxxiGR83i7QWrScu01ogpQWunkZQazVc5bRjROd6OyPKRIhcRVf01r78SzJIENAx43gDnwo959iMiUUBV4I8SzGCOQsdT2/NDbAL9Uz9h0pLfvI5jwkVODilzxvLowQFUjo22+4X4TKFFRESWl0Q/RbAUOF5EGotIDDAUyH1eynTgcvfxIGCeqtrGUZ8QEWK738mIqM+ZMN9aI6aErPuY7YeEBTlt7a6FPlSUwxtaFLLvQ3BaBEdFVbNE5AZgFs4hvv9T1TUi8jCQ6J7o+DowUUQ24rRAhh7teE3J6tihI199eRJ3V/+KtMyzKBdth/uao5CTQ8oXj/PoIWuF+FVRikjzIvRTIqucqjoDmJHrtfsDHqcBg0tiXKZ0iAidRowlauIAiLwfsLVGcxR+/ITkVPgypx03WSvElwotIiW838OUAVF1WkJ8F0h83bmNrjHFkZMDC56kzoD7uXd3SwYnNPA6kcnDkRydZUyR5Zx+B+kLX+Cq8fNt34gpnvUzICKS2Jb9GXlGE2uF+JQVEVMq5JiWLM05gWM3T+G9pVsKf4MxgVTJmPc4aZ1uBzuf2NeO5H4i/2dnh5uiEhGk6xiujvqM179cY60Rc2TWz2T73hQ6fhjLd5vsKH4/O5KWyEFguohUBBCR3iLydenEMuGgY6eubIxpTs+UmUxJtNaIKSJVDn3xGP8+NICsHDjhmEpeJzIFOJKTDe8D3gXmi8giYDRwV2kFM6EvIkLQM+7k6qhPeH3eWtKzrDViiuCnz9m1P4XZOQl2XkgIOJLNWT2AkcAhIA64SVW/Kq1gJjx07NydTdEn0C3lc6bYvhFTGFUOzXZaIZViY+y8kBBwJJuz7gX+pardcM4Wf09EupdKKhM2IiKE7DPu5JqoT/ho6S/YBQZMgX6axa79h6wVEkKOZHNWd1Vd5D5eBfQFHi2tYCZ8dOzSEz2mNZNP3Ygdm2Hypcqh2Y9aKyTEFPsQX1XdDvQowSwmTEVECPUGPEjM4uchK73wN5iyacNsJCeDpNrdGW6tkJBxVLcGU9XUkgpiwlyDU6B2c9KWvsXGRhfSuv5RX27NhBNVmP84FXrdy6ctziAjO6fw9xhfsJMNTdAktb2R3bOe4LoJi+1ILfN3G2ZDVgY0P8e5GnSUXbgzVFgRMUFTr3VXfo+qT6dDXzB1WZLXcYxfqHJw1qO8FTOE3/akeZ3GHCErIiZoIiKE1E53cH3kx7w6bz0ZWbbJwoBumM0f+/bzwMYmfLxiq9dxzBGyImKCqmO3/uyKrkuHg9YaMfzZCnk8ZSBVK8QyvHO814nMEbIiYoIqMkI41Ol2boicxivzfrTWSBmnG77gj337+TznVEae3oTK5eze6aHGF0VERGqIyBcissH9Xz2f/rJFZIX7l/vWuSZEdDxzAHuja3Pqgbl8sNxaI2WWKgdmPcoTKQOoXrEcl3eK9zqRKQZfFBGca3DNVdXjgbnkf02uVFVt5/4NCF48U5IiI4SDp41mdLnpNKpm5wKUVbrhC/bs3cvMnPaMOqMJlWKP6owD4xG/FJGBwAT38QTgXA+zmCDo2P1c6jY4ls6pC7yOYrygSuqcf/NU2kBqVCzHsI7Hep3IFJNfisgx7hnwh8+Er51Pf+VEJFFEvhWRfAuNiIxy+0tMTk4ujbzmKEVERiBdx8DCJyE7y+s4Jtg2zqGCpnLTjbfz5KC2VIixVkioCto3JyJzgDp5dLr3CAbTSFW3iUgTYJ6IrFLVn3P3pKrjgHEACQkJdsU/v2rSjbTYWkx7/WmiTrmUQafYPbTLBFWY9wiceQ8n1KnKCXXs6gWhLGhFRFV75tdNRHaISF1V3S4idYGd+Qxjm/v/FxGZD5wE/KOImBAhwtIm19F54WiG7TmJASfWIybKL41jU1p03XRS0rOo0Pxs7HKcoc8vv9jpwOXu48uBj3P3ICLVRSTWfVwL6AysDVpCUyo6dR/A79EN6Lx/Ju/Z3Q/DX042hz5/mOt/78cN7670Oo0pAX4pImOBXiKyAejlPkdEEkTkNbefFkCiiKwEvgTGqqoVkRAXGSFkdL2HG6KmMW7OalIz7Jpa4Sxn1VR+OxTF/Jx2tG9cw+s4pgT4Ym+Wqu4mj8vKq2oicJX7+BugTZCjmSDodHovvv2qOb1TPuOtxc25umtTryOZ0pCdScrsR3gkdRj1q1VgaPuGXicyJcAvLRFThokI0b3u45qoT3lz/mr2p2V6HcmUgqzl77A+tRqLc1pxS8/j7Uq9YcKKiPGFU07tzPryJ3FB5qd8s3GX13FMSctKJ33u4zyWegFN4ypy3kn1vU5kSogVEeMLIkLdcx/ilkpz6NO0nNdxTAnLWPI/vk+vz3I9gdt7NyMq0hY94cK+SeMbTZu3I6pFP/jmJa+jmJKUkULU4ufY1PZWTmtSgz6t8zpdzIQqX+xYN+ZPZ9yJjuvK17UG0TQ+nrpVy3udyByt78YR0eg0LjvvHC5VRcTODgkn1hIx/lL9WFZW7cna9x/hhbkbvE5jjlbafvSbF6HbPQBWQMKQFRHjO9X73MXgyAV8lbiSTbsOeR3HHIWU+c8xJ6M1E38pj6pdgSgcWRExvnNs/HF8H3cuN0W8z7Nf/OR1HFNcB3YgS8fz0KHzmP/jTmuFhCkrIsaXWgy+n+6RK1j/wxJWJe3zOo4phoOzH2VyxulsJY7RvZt5HceUEisixpfqHnMM3x87gjFRk/n3jHW2KSTU7NoAa6fxfOZAzmtXn5b1qnidyJQSKyLGt9oPuoNmkVvJ2bSI+evtvjChZO+n9/FyWj9Soqoy+ixrhYQzKyLGt6pWqcTmtrfyfzU/pH18da/jmCLS35aQ9Vsi/8vuw4jO8dSvZodphzMrIsbXupx7DXUrRVLx50+9jmKKQpWsWf/izZiLKF+hItd1O87rRKaU2cmGxt8iIqDXQ/DZaA417kNEVAzlY+zCfb61fibRGfu5ZfQDnLM7jarlo71OZEqZtUSM/zXtzu7ourz89H28utBuZOlb2Vkw50Ho+SBR0dE0q1PZ60QmCHxRRERksIisEZEcEUkooL8+IrJeRDaKyF3BzGi8tS3hLkZkv8/bC9ew80Ca13FMHtKXTeTXtPLsrNPV6ygmiHxRRIDVwPnAwvx6EJFI4GWgL9ASuEhEWgYnnvFam1PPYGPlU7k8ZxrPfWGXQ/Gd9INkznmMm3efz03vrfA6jQkiXxQRVV2nqusL6a09sFFVf1HVDGAyMLD00xm/qHvB41waOYdFS5fx044DXscxAQ7MeZK5ac1YocdxWy87pLcs8UURKaL6wJaA50nua/8gIqNEJFFEEpOT7fyCcBHf+ASW1x3CmKhJPPzJWjsB0S/2bCZi2Rs8njGEs9vWtXunlzFBKyIiMkdEVufxV9TWRF4X3slzKaKq41Q1QVUT4uLiih/a+M7JQ+/nlMiNZPz8FbPX7vA6jgH+mHYXr6b3Zk9UHHf3a+F1HBNkQTvEV1V7HuUgkoCGAc8bANuOcpgmxFSvVo2Fbe7gsTXj2BUzzOs4ZV72pkVkbUlkXPaTXNOjqZ1YWAaF0uaspcDxItJYRGKAocB0jzMZD3QaOIqm9WrR8cAsr6OUbTnZpH1yJ4+kDaF61apc07Wp14mMB3xRRETkPBFJAjoCn4nILPf1eiIyA0BVs4AbgFnAOmCKqq7xKrPxTlRUJBF9x8K8RyFtPzk5tm/EEyveoWLFSoy89naeGnSinQRaRkm475xMSEjQxMREr2OYUpD+/igW74xiWs2R/N/Qk7yOU7ak7YeXEuCid6H+KV6nMaVARJapar7n7R3mi5aIMcWxq8NdnLhzOj+sTGTp5j+8jlOm7Jn5CL/X7mIFxFgRMaGrfqMmrGx8FQ9HvcH901aTlZ3jdaQyQX9fTcSq9+i/tieTlvzmdRzjMSsiJqR1GHo3x0Qd4rids3jzm81exwl/quyeciNPpZ+PVoyjX5s6XicyHrMiYkJa+XKx7Os+lnuj32HcFyvYtjfV60hhLWXp2+z4Yx+Tsntwd9/mVKsQ43Uk4zErIibkJZzel41VOnJtzmQe+sQO2Cs1qXvInn0/d6WPICG+FoNOaeB1IuMDVkRMWDjukqcZEPktzXQTGVm2b6Q07Pr4Pqaln8w6acoj57ZGJK+LSJiyxoqICQt16tQn+qwHuC39FWJsri55SYlEbZjBU5kXcmWXxnavEPMn+7mZsFHltBEgEbDsDTsBsSRlZcDHNxDbfyyXdjuRm3oc73Ui4yNWREz4iIiAAS+QOedRLn32A1Zs2et1ovCw6FmoHk/5ky7kzj7NqRhrd9U2f7EiYsJL7RZ8U2sQI/e9wB1TVpCele11opCW8/ta0r5+hdTeT4LtAzF5sCJiwk6Hyx6hYfR+2uyeyQtz7S6IxZaTze53R/FwyvkMm5pk928xebIiYsJOuXLlyOj/AvdET+KDBctYlbTP60ghac+XL7JpbzbvZp/JVac3saOxTJ6siJiw1PKUM/ix7nk8GPkGt09ZYYf9HqGc5I1Efv0sd2ZcSb+29TmrlZ2ZbvJmRcSErVOGPU7zqO002zWb5+f+5HWc0JGdRfLEy3k6/VwOVjyWhwa08jqR8TErIiZsla9QkUP9/8ODMW9xStWDXscJGTtn/Juf9kYwMbsXT1zQllqVYr2OZHzMiogJa60SulKp2810X3c/5NiRWoXauoyKP7zB7RmjuKhDPD1aHON1IuNzvigiIjJYRNaISI6I5HsTFBHZLCKrRGSFiNidpkyRxJxxq/Pg6+f5bXeKHWWUn4wU+HAUFQc+w4OX9OS+/i28TmRCgF/OGloNnA+8WoR+z1TVXaWcx4STiEg471VSXz6dmz6P4dLzz7WLB+Zl9n1Q72RofT59vc5iQoYvWiKquk5V13udw4Sxag1Z2fpunol8ibEfJ7J51yGvE/nK3sT32fH9Z2w89QGvo5gQ44sicgQUmC0iy0RkVH49icgoEUkUkcTk5OQgxjN+1mHAKJKrteUeHc81ExNJzbB9JABZyT8jM0YzMuV6xn75u9dxTIgJWhERkTkisjqPv4FHMJjOqnoy0Be4XkTOyKsnVR2nqgmqmhAXF1ci+U3oExFajhzPidFbOGnXx9w3bbXtH8lMY9ebF/Fs+rn8Xqklj5/fxutEJsQEbZ+IqvYsgWFsc//vFJGPgPbAwqMdrik7qlSuSvKFb3H7u+dw+feNmRxfnYvaN/I6lmeS3ruVVfur8LaexaSLTiKush3Oa45MyGzOEpGKIlL58GOgN84OeWOOSNPm7djY/kH+E/08r81eVmY3a+1YMJ6sDV8yJnMUo3s3o0OTml5HMiHIF0VERM4TkSSgI/CZiMxyX68nIjPc3o4BFonISuA74DNV/dybxCbUdeh/JXuO7cNndV6jfGTZuyRK+qbFxHz5CFdm3MbpbY7j2q5NvY5kQpSE+zbhhIQETUy0U0pMHnKy4d2hUK0R9H8GVS0bFxncvw3Gd+frFvfxzObGvH1VByrE+OVof+MXIrJMVfM9b+8wX7REjPFERCRc8Dq6eRGLJj3ODZO+D/87ImYcgsmXQPuRdO53KVOv6WQFxBwVKyKmbCtXhd3nTKD5T//l4JrPeXzmuvA9Yis7i9/GDWVPxSbQ5TYAIiLKQMvLlCorIqbMq9WoOVt7j+e56P+wdNEXvLLgF68jlTxVfp5wNZt27KX7hvPZk5LpdSITJqyIGAOc2Oksfur0JONjnmHqrLlM/u43ryOVqJ8/eIDUzcu4LvNmbj2rFdUrxngdyYQJ2xhqjOu0sy5m0YHdTFj1BEM/iqVSuV6c3bae17GO2saPnyB61WRGZDzA5d1aM6xjvNeRTBixlogxAboMupGNTYYxKfoRJs78KuTviLjhk2eIXf4aQ9Pvo2/HE7njrGZeRzJhxoqIMbl0HXY/Sc2G8070I8QcCN3NWocWvUL5xP8yNP1eep52Mg8NaFU2DmE2QWVFxJhcRIROl9xHVJeb4c2z0d0/s+SX3V7HKjpV+OpZKi59mZ/6vEPPjgk8PNAKiCkdtk/EmPy0HwmRMaS+2psnDtxAwul9uKtPc18fFqs52Rz8+A4qb18MV86ie5V6dPc6lAlr1hIxpiCnXE7iiQ/zWswz/LpoMtdPWk5apj+vtZWReohVL1zIjyu+YVXvyVAl9A8KMP5nRcSYQpzR/xJ+6/c2D0e/ReN1r3DBy4vY5LObWu38bT1bnjmDX3cfZETW3SSl2iG8JjisiBhTBO06dOPQsM/pE7uK23f/i0tf+IzpK7d5HQuA1Qs+JOJ/vXkntSOPl7+Dt6/pSt82db2OZcoIKyLGFFGTps1oPHoembVaMEXuYvG86WR7eK2tlJSDLPrPtdSadxvXpd/IT40v49Obz6Bdw2qeZTJljxURY45A5YoV6HXTK2xIeJhHsp4jcsZoSNvPvtTM4F5zKymR6NfOJGXHzwzIHEuXngOZcEV7atiZ6CbI7OgsY46QiNDtnEuhZ3+Y/S94uQPvRV3ErKhu3N2/NQnxNUpt3D9u2MBxq54hatN8ons/SrZ24o1aFWlVr2qpjdOYgtj9RIw5Sn/8uIgtk28jOieNl7IGsufYsxjV9QS6nhBXIocDqyrL164nedbTnLZvBknxg2h90aNQrkoJpDcmb0W9n4gvWiIi8hRwDpAB/AyMUNW9efTXB3geiAReU9WxQQ1qTB5qNO9CzF1fM2fam4xaN45qW9/jnYk9eK5SD844uQ3XdmtKxdgj+6mpKht3HOCHb2dTefVEOmR+xw/Zp3OuPMWQxqfR2gqI8QlftEREpDcwT1WzROQJAFUdk6ufSOAnoBeQBCwFLlLVtQUN21oiJpj2p2Uyb9Z0ola+zenZ37KOJiT0GETUcd2gdkve+34HNSvGUrtKLNUrxBAVKWRlK/tSM6lXrTw1cvbAtuUkzp1K3R1fkqYxvJvdnYUVenLWqa0Y3imempVivZ5MUwaEVEtEVWcHPP0WGJRHb+2Bjar6C4CITAYGAgUWEWOCqUq5aM4deAE555zPdxuSOLhuLlEH18BH16J7NnFyZi2251TnFyqTqrFEkU15Saeu/EH58ntBMqH+yURVa8NNyfcS3/wU+rapy13N4oiKtONgjP/4oojkcgXwXh6v1we2BDxPAjrkNQARGQWMAmjUqFFJ5zOmUBERwmnNGkKz4X++dvDgQeZ8NpcDyVuISN1NdnoKGRpJZkQsB2Nq069LAj1PSwARmmdmMyUygkgfX2LFGAhiERGROUCdPDrdq6ofu/3cC2QB7+Q1iDxey3NbnKqOA8aBszmrWIGNKWGVK1Xi2iEDi9RvuejIUk5jTMkIWhFR1Z4FdReRy4GzgR6a946aJKBhwPMGgD9OGTbGmDLKFxtZ3aOuxgADVDUln96WAseLSGMRiQGGAtODldEYY8w/+aKIAC8BlYEvRGSFiLwCICL1RGQGgKpmATcAs4B1wBRVXeNVYGOMMT7Zsa6qx+Xz+jagX8DzGcCMYOUyxhhTML+0RIwxxoQgKyLGGGOKzYqIMcaYYrMiYowxpth8ce2s0iQiycCvRzGIWsCuEorjBcvvvVCfhlDPD6E/DV7kP1ZV4wrrKeyLyNESkcSiXITMryy/90J9GkI9P4T+NPg5v23OMsYYU2xWRIwxxhSbFZHCjfM6wFGy/N4L9WkI9fwQ+tPg2/y2T8QYY0yxWUvEGGNMsVkRMcYYU2xWRHAuRS8i60Vko4jclUf3WBF5z+2+RETig5+yYEWYhuEikuxeJXmFiFzlRc78iMj/RGSniKzOp7uIyAvu9P0gIicHO2NBipC/m4jsC/j87w92xoKISEMR+VJE1onIGhG5OY9+/P4dFGUafPs9iEg5EflORFa6+R/Kox//LYtUtUz/AZHAz0ATIAZYCbTM1c91wCvu46HAe17nLsY0DAde8jprAdNwBnAysDqf7v2AmTh3uDwNWOJ15iPM3w341OucBeSvC5zsPq4M/JTHPOT376Ao0+Db78H9XCu5j6OBJcBpufrx3bLIWiLQHtioqr+oagYwGch9D9OBwAT38VSgh4j46ebXRZkGX1PVhcAfBfQyEHhLHd8C1USkbnDSFa4I+X1NVber6nL38QGce/bUz9Wb37+DokyDb7mf60H3abT7l/vIJ98ti6yIODPZloDnSfxzxvuzH3VujrUPqBmUdEVTlGkAuMDdDDFVRBrm0d3PijqNftbR3VQxU0RaeR0mP+4mkpNw1oQDhcx3UMA0gI+/BxGJFJEVwE7gC1XN9zvwy7LIiojThMwtd/UvSj9eKkq+T4B4VW0LzOGvtZlQ4ffvoDDLca5FdCLwIjDN4zx5EpFKwAfALaq6P3fnPN7iu++gkGnw9fegqtmq2g5oALQXkda5evHdd2BFxFmbClwrbwBsy68fEYkCquKvTReFToOq7lbVdPfpeOCUIGUrKUX5nnxLVfcf3lShzh06o0Wklsex/kZEonEWvu+o6od59OL776CwaQiF7wFAVfcC84E+uTr5bllkRQSWAseLSGMRicHZWTU9Vz/Tgcvdx4OAeeru2fKJQqch17brATjbi0PJdGCYe4TQacA+Vd3udaiiEpE6h7ddi0h7nN/ebm9T/cXN9jqwTlWfzac3X38HRZkGP38PIhInItXcx+WBnsCPuXrz3bLIF/dY95KqZonIDcAsnKOc/qeqa0TkYSBRVafjzJgTRWQjTtUf6l3ifyriNNwkIgOALJxpGO5Z4DyIyLs4R87UEpEk4AGcHYuo6ivADJyjgzYCKcAIb5LmrQj5BwHXikgWkAoM9frHn0tn4DJglbtNHuAeoBGExndA0abBz99DXWCCiETiFLcpqvqp35dFdtkTY4wxxWabs4wxxhSbFRFjjDHFZkXEGGNMsVkRMcYYU2xWRIwxxhSbFRFjjDHFZkXEmCISkZoBlxD/XUS2Bjz/phTGd/jy/a8V0E95d/wZfjzz2oS/Mn+yoTFFpaq7gXYAIvIgcFBVny7l0b6nqjcUkCkVaCcim0s5hzF5spaIMSVARA66/7uJyAIRmSIiP4nIWBG5xL3Z0CoRaer2FyciH4jIUvevcxHG0codzgr3aszHl/Z0GVMYa4kYU/JOBFrgXJbiF+A1VW0vzp32bgRuAZ4HnlPVRSLSCOeSNS0KGe41wPOq+o57jbTIUpsCY4rIiogxJW/p4QsTisjPwGz39VXAme7jnkDLgPsJVRGRyu7NlPKzGLhXRBoAH6rqhpKPbsyRsc1ZxpS89IDHOQHPc/hrxS0C6Kiq7dy/+oUUEFR1Es4VmFOBWSLSvYRzG3PErIgY443ZwJ87zEWkXWFvEJEmwC+q+gLOJcHbll48Y4rGiogx3rgJSHB3kK/F2d9RmCHAavcy582Bt0ozoDFFYZeCN8anRGQ4kFDQIb4B/W52+91V2rmMCWQtEWP8KxXoW5STDXFugJUTtGTGuKwlYowxptisJWKMMabYrIgYY4wpNisixhhjis2KiDHGmGL7fyPLS5jmmKGFAAAAAElFTkSuQmCC\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "# plot solution with Euler's method\n", - "fig = pyplot.figure(figsize=(6,4))\n", + "fig = plt.figure(figsize=(6,4))\n", "\n", - "pyplot.plot(t, num_sol[:, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", - "pyplot.plot(t, x_an, linewidth=1, linestyle='-', label='Analytical solution')\n", - "pyplot.xlabel('Time [s]')\n", - "pyplot.ylabel('$x$ [m]')\n", - "pyplot.title('Spring-mass system with Euler\\'s method (dashed line).\\n');" + "plt.plot(t, num_sol[:, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", + "plt.plot(t, x_an, linewidth=1, linestyle='-', label='Analytical solution')\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('$x$ [m]')\n", + "plt.title('Spring-mass system with Euler\\'s method (dashed line).\\n');" ] }, { @@ -358,6 +342,7 @@ "A graphical explanation can help here. Remember that the derivative of a function corresponds to the slope of the tangent at a point. Euler's method approximates the derivative using the slope at the initial point in an interval, and advances the numerical position with that initial velocity. The sketch below illustrates two consecutive Euler steps on a function with high curvature.\n", "\n", " \n", + "\n", "#### Sketch of two Euler steps on a curved function.\n", "\n", "Since Euler's method makes a linear approximation to project the solution into the future, assuming the value of the derivative at the start of the interval, it's not very good on oscillatory functions.\n", @@ -383,19 +368,15 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "Let's see what it does. Study the function below carefully—it helps a lot if you write things out on a piece of paper!" ] }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": true - }, + "execution_count": 69, + "metadata": {}, "outputs": [], "source": [ "def euler_cromer(state, rhs, dt):\n", @@ -414,7 +395,7 @@ " mid_state = state + rhs(state)*dt # Euler step\n", " mid_derivs = rhs(mid_state) # updated derivatives\n", " \n", - " next_state = numpy.array([mid_state[0], state[1] + mid_derivs[1]*dt])\n", + " next_state = np.array([mid_state[0], state[1] + mid_derivs[1]*dt])\n", " \n", " return next_state" ] @@ -428,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 70, "metadata": {}, "outputs": [ { @@ -441,8 +422,8 @@ } ], "source": [ - "ω = 2\n", - "period = 2*numpy.pi/ω\n", + "w = 2\n", + "period = 2*np.pi/w\n", "dt = period/200 # time intervals per period \n", "T = 800*period # simulation time, in number of periods\n", "N = round(T/dt)\n", @@ -451,13 +432,13 @@ "print('The time increment is {}'.format( dt ))\n", "\n", "# time array\n", - "t = numpy.linspace(0, T, N)\n", + "t = np.linspace(0, T, N)\n", "\n", "x0 = 2 # initial position\n", "v0 = 0 # initial velocity\n", "\n", "#initialize solution array\n", - "num_sol = numpy.zeros([N,2])\n", + "num_sol = np.zeros([N,2])\n", "\n", "#Set intial conditions\n", "num_sol[0,0] = x0\n", @@ -478,41 +459,41 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": true - }, + "execution_count": 71, + "metadata": {}, "outputs": [], "source": [ - "x_an = x0*numpy.cos(ω * t) # analytical solution" + "x_an = x0*np.cos(w * t) # analytical solution" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 72, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbYAAAE1CAYAAACLLcUGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n0zRN0yzl/wMU/309FRR0EwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "iend = 800 # in number of time steps\n", "\n", - "fig = pyplot.figure(figsize=(6,4))\n", + "fig = plt.figure(figsize=(6,4))\n", "\n", - "pyplot.plot(t[:iend], num_sol[:iend, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", - "pyplot.plot(t[:iend], x_an[:iend], linewidth=1, linestyle='-', label='Analytical solution')\n", - "pyplot.xlabel('Time [s]')\n", - "pyplot.ylabel('$x$ [m]')\n", - "pyplot.title('Spring-mass system, with Euler-Cromer method.\\n');" + "plt.plot(t[:iend], num_sol[:iend, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", + "plt.plot(t[:iend], x_an[:iend], linewidth=1, linestyle='-', label='Analytical solution')\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('$x$ [m]')\n", + "plt.title('Spring-mass system, with Euler-Cromer method.\\n');" ] }, { @@ -531,30 +512,32 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 73, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbgAAAE1CAYAAACV5PW1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4XMW1wH+j3iXLKpbc1CzbcsENd2wZG2N6SSChBXgQ\nSCEJLyGFkJfwSIGENF5CKiGQBBJI6GBs3HvvXcUqrrKKJatLuzvvj7lXWq1lW5J3dbfM7/v2k/bs\nLWfv3jtn5pw5Z4SUEo1Go9Fo/I0gqxXQaDQajcYTaAOn0Wg0Gr9EGziNRqPR+CXawGk0Go3GL9EG\nTqPRaDR+iTZwGo1Go/FLtIHTaPoRIcQ9QojdQggphHjaan2cEUIsMHRrE0K8YrU+Gmvpr3tVCBFr\nnKdGCFHqzmP32cAJIcYJIV4TQuwzlNsjhNghhPidEGKeO5V0OmeUEKJECPEzTxxf436EEI8LIW61\nWg9PIoSYKoSoFULc4iI/77tLKV+TUk64zPO9IYQoMhqecuP5c331OsFVSrnc0O3k5ejXV4QQ4UKI\nx4QQ64UQu4y2ZZ8Q4n0hxBeEEEOs0CsQ8NS92hOklPXGed5397FD+rKTEGIssAX4AzBFStlqyKcB\nHwJxwCp3KemEHSgHznjg2BrP8DiwGnjXYj08SSNQBtS5yD3y3aWUnxFC5KOese9LKV9x3aYvBs5K\nhBCpwEeoa3iflLLEkEehruPvgS8AHm9wAxS/fE77ZOCAB4BI4H9N4wYgpdxijK6ucINu52Gca64n\njq3R9BUp5QE8dM9fBjdZrUAveRNIAuZIKZtMofH/T4QQacBVVimn8VGklL1+Ab8GJDCum8+igFTj\n/wRgN1ADlAKfAjYBhcAx4DuAMLYdaWzbgOpJfApYi+oZS5RR7fjc6XxvoEZ1EpgDvAXsA0qAb3ej\nXwLwF6DK2G4JcKOxfznwxkW+9z2GDhJ4BvghsBU4bVyTYOA6YDlwHDWaTXU5Rj7wjnEc8/UUEOay\nXSrwV+AAsNPY7rdAltM2C4D1wB5gB7AOeKIHv98F9zN0awKajXNmG/JnjN+wBnjOkE0GlgJ7jeNs\nAX5g3AN5xv5txj7md/2ckx7m/qVAsfG7X+XO693D+zkF2G+c5yTwjtNnPwUOO72/GTiIGrX9Dfi0\nk45PG9v05Lub3+lp1DNxAtV7TumhzvnGMR5wkb/iLDO+W3fPzXeAIuMY+S7HKAVecZGFGroWAoeN\n3+tnQKTTNuuM30YC44DFqGes49pc4LssMrb5zkW2GQk8b/w/z+n6vgJ8EXU/VxjHyTC2y0YZznJD\n753AZ1yO6dzmfBZYY9wDHxnXLsf4Xcz9p3ajWw7wH1RbVQhsA251+rxH+nZzXOfreQWqrSo29JiO\nes7+iHqOi4EHuzlGLOpZKTF+t8PAk0CQJ+5VYD6q3S4xrscSYHI3292MajdOotqNrxrXprS3z+9F\nn5M+7QQ3GF+6BHgQiLvE9q8ALcZNEG7IbgRsuNz4xo1WATwHCNQocw/GQ2h8vtplnwcMfT4CBhiy\n23F5eFExxzUo45plyIYAu+imsbjI95HGjzfTeD8e5T79LfBlQxZn3HSuDcUfgJ8Dwcb7JGAz8AuX\n7T4xXqHG+0FAgakjkGlcU+fG7HZAXkL3S+4HvGhsk+iy72+BR43/Y4Bq4AdOn88w9stwkpW6XgND\nPgVlRH9DZyfnW0CreV3dcb17cU8L4BTwTxd5gXH+PCfZp4Hfd6Oj673c7Xd32v4YMN94PxD1PPVI\nf3po4FyeK9fnxjxG/qX0Bv6NCg3kGe8HoxrzD1y2e9o45mtArCH7neu1cdnnRWOfOb38zUpRDeRj\nxvtYVNuRAQxHdWJfp/MZugFoN7d3uTYVwNdd7qUPgWdRbZAwrkERxrNrbGue522MTipwJ+AA7uip\nvhf5jub1/L2THm+iDN/TGEYGeAzVnmY77RsKbETdw+mGLA+oBH7r7nsVZbTsdD6TAvgJqsN8pdN2\nC43tfkzXZ/803mDgDIWeQjVQEmX9VwFfA5K62fYVY7vhLvIPjS+f4HKz1QERTrI0IOoiD+oDxvHv\ndJIJVC/7R06y64zt/ttl//vpvYFzfbD3oRr8ECfZb4HjLtsNM7+Lk+wLqF6kcJI1AH922e4WjB4k\nqpGVwCyXbX58Cd0vuR9qZCWBrzjJwlGjpHjj/RRjm3tcjvMNnAzjhR4c43esBaKdZEHG9svddb17\neU//wbj3zIZqHLAd1Vh9z2m714GF3ej4tIus2+/utP1HLrLf9VR/Oo1TOV29ATXd3cdchoFz2u4p\nl+0eMuSznWRPG7IZTrJ4umkXnD5fbOyT28vfqxQ40s3zFYpqc9qBQS6fvwvUm/ex07WpxjCEhuw3\nhk4Tu3l2cpxkrxj3x1CX86wDCnuq70W+o3k9JzvJPoVLO4bqKEvgYSfZA3T/jP4QZWCGueteRbW3\nJcA+l+1CUR2jtU6yLSgjG+ayfzFuNnB9nkUppfwxavTzeZShmowaCh8VQtzezS61UsoyF9lmVCxv\nuou8SErZ4nSuU9LJL38RDjrtI1E3bZrT5/nG360u++3pwbFdOezyvgY4KqW0Oclczw+qUf+WEGKT\nOQMV+C4QjRqlmawAHjJmzF0nhAiTUr4npTR134Iygu8KIf5XCDEGQEr51CX0vuR+UsodqGvykNN+\ntwMrpZTmRIrDKFfFH4UQvxBCXCmEEFLKX0gpay6mgDFxYDawU0rZ6HReB8pVeJUQItRlt75e797w\nLqr3frXx/jaUC2iz8T9CiDBgFu6ZRHXI5X0Vvdf/+1LKCeYLD8xEA641/q5zkZvPzfxu9tlv/iOl\nrJNSVnlAry7nMc5VLqVsR+lcJqU87bL9FpT3YZaL/Kixn4l5Dxc4yaqNv86/0bWoRvmYy/H2ADlC\niOE91PdSON//vdENuv/dglCu055yqXs1FzVy3uK8kfHddgGzhBAxQoho4Epgt5SyzWk7ieq0upXL\nyoOTUlZLKV+SUt4OJKNGQnbgFSFEnMvmrjPMoPOHGugir++jSg0u7x2oOI2JeR7XBrjW9UDdTLue\n4rJJo8t7eQFZxzUWQgjgPeBelI97nNEofd/YJNxp3zuBb6N874uBCiHEc0KIcADjgZqCatAeB/YL\nIfYKIS46uaAX+/0VuEIIMcl4/xDwstNxGoCpwEvAfahOQ5EQ4sGLnd9gAOp3meB6nYExwFljG2d6\nfb37wErUfXqb8f4W1HV6B5hkNFbzgXU9bJQuRXf36+U+kw/IbmZVXiZJxt8/uPxWf0W52KK70eO8\nZ1gI8ZLL7/0F46MS4+8g1316wIXaiiTOf86h0xAku8i7u5dw7oCZMrq2KUlASjf38SLUtUmiK31q\n2y6gh3Pn8EK6Abzvotszhm6ubfTFuNS9ap7rQtc8CNX+DkCN1rrb7rx2+HLpa5rAFJQfusNaSzXD\n8W9CiGGoIfAouo6U4rs5lGlwqrv5zBOY50l0kSe4big9k/+RgxpFflNKWXixDY3r+TzwvGFkvoYy\neDbge8Y2R1CjvC+j/N9PA+8IIcZKKV1HPM7H7sl+/0BNInhICFGDcqWscTnOSeBxIcQTKL/694CX\nhRDHpJTLL/L1zqI6QhuklF4z209K2SaEWAzcIoR4HmiSUlYIId5BXYvbgdEog+dr2Dn/ee9pA2eO\nvu4zRvd9Qkr58AU++hD4EiqGu7a7DYwcuFHAmh52Lqo4/zmHzjansgfH6AlVQJWH2ovLxfzd5ksp\nPd3Gmue60DV3oNpfaby62+68dvhy6Wtv8UZUrKU77MZf1xsowTB+zkxDxfE291GP3rLa6bzOjO+n\n84cZfx0u8nTXDYUQ/zL/l1LulFLejxrCjzc+ny+EeNj4vEVK+SZqZBiMCiR3S0/3Mx6I94G7UbO+\nXnHqJZqJ/k8Z29qklItR9wV0vZ7tqB4bQohkIcQCw928DhgvhHDucSKEuEoI8eKF9O8H3kXNYH0e\nw5BJKYtQrqVPowz5kh4e67zv7nZtL4AQYqcQYqiT6DTne0pG9/Bw5ved2M15XhRCXNb0fSnlxyiX\n/KNCiMgLbPYKyh3b05HzUmC4kV/nzFTUaGR9X3TthiVAlqvHSggxUgjxTyFEX1Ox3EG3v5sQIsTQ\nbaST+HLv1QJUHK9L22qEGiagOrMNxkh0GzDRcPeb2wlgbHcHNlJE+sTluENuF6qUi3BSZDpqpPGe\nNBI1nWgAfmy62IQQN6CG8T+VUrp9aHoBlqJ6iP8thMgy9BhM11iTJzmC8qU/IoQYZJx/OGqSiSuf\nEULcZb4RQmQDQ1FT4jH+f9LQ32Qe6jp38YO70Jv9Xkb1qh4HXnX5bCDwDSGEszGdhxphrnaSlaBi\ntaBGQN81/n8C5dZ4RggRZHzHIajgdZc4xeUghAgVquLHr3u4y2LUTM5b6TpSeweYCexxcRddjAt9\n9/4gka7uqhXAKCHEBADD+PWowoyUcg0qHecps1EUiq+inuGdbtD3DlSn+H0hRIYpFEIkCiH+iJrS\n//leHO9plLv5F2Y8VwhxHaoT9qSU8pwbdAaVFtMI/J9T25aImvVY7hIj7m9eBzYAPzWNhHEtnkXF\ny5xjeJd1rxqd368BeUKILzp99APUbFHnAdH/oFyVP3CSfZ1uXNRCiCeBk0KIz/RGH2fFev1CBRT/\nF9ULP0BnHoaZ0xXhsv0rKOt+DcrAFKCmnT5J5zRR53ydBuP/LzsdI6Obz7NRM9/MPLiDqLQF19yO\nLU7HSUA13FWoPIz3UA2zBO6/xPe+ns6cp9Oohz62G71ijc/MHJbdwPXGMbKBD1BT0jeiRgy/dNbf\n2O4JVM7JXmP/PRjTmI3PM1HTq/cbn+9DpRXMuMR36PF+qA7QMVxmUMnOWVs/M/TaZfzdYH5Pp+1m\nGPfIflzyiFA9u49QszN3okby97v5eo80ZOflCF3kGn2ICoI7yybS/bT8T7vouOpi372b7/SOse1/\nXPS/9iL6LXbatgr1bLm+bHRN1wg17rMy4/d6FRVrlKip78+j8iNdc6Iijf1DUM92AaqTtts4xlCn\nc7zv8h3+2st2JQzVSG6h877fjUoZGuS03YRu9Lytm+PloKb2O+fB3eX0eXdtTnf30jzgm3TmDRah\nRpPmcbKAf6Hu492onNBv0Nm29UjfbvR3vZ7d6fFNOvPszHvqfadjRBu/7VE62+rfYKRTufteNe6h\ndXTmwS1FVbty/W43o9qek8b1+oFxP7WZ39XY7mHgHHBNb+4l82X+AB5FqMKt+VLKDI+frA8IISaj\npoN/Wkr5ltX6eBNCiA9RDZVPXhchxAuoh2ms7PnIS6PR+AEBt5qAEOKP3fjlzZiRO1wtfoPharkC\nz0w99zhCiBkol9SN2rhpNIFHwBk4VIP9PXNygxEDexJ4XZ4fNww4hBCzhBC/N94+Brwq3TMlvt+R\nUm4CxkhVK1Kj0QQYHnVRCiESUBMOhqGSKw+isu/dkSTbV50eQmX4J6N8yKEo//kz0inxMFAxUhIW\nowL+5ajafa45MBqNRuP19EsMTqPRaDSa/iYQXZQajUajCQC0gdNoNBqNX6INnEaj0Wj8Em3gNBqN\nRuOXaAOn0Wg0Gr9EGziNRqPR+CXawGk0Go3GL9EGTqPRaDR+iTZwGo1Go/FLtIHTaDQajV+iDZxG\no9Fo/BJt4DQajUbjl2gDp9FoNBq/RBs4jUaj0fgl2sBpNBqNxi/RBk6j0Wg0fok2cBqNRqPxS7SB\n02g0Go1fog2cRqPRaPwSbeA0Go1G45eEWK2Ap0lKSpIZGRlWq6HRaDQ+w44dO6qklMlW63G5+L2B\ny8jIYPv27VarodFoND6DEKLMah3cgXZRajQajcYv0QZOo9FoNH6JNnAajUaj8Ut8IgYnhLgR+BIQ\nDkQDZ4FvSyn3WqqYRqPRaLwWXxnBvQL8Q0o5X0o5HdgDrBBCpFqrlkaj0Wi8FV8xcGullK87vf8F\nkAQstEgfjUaj0Xg5PmHgpJS3u4iajb/h/a2LRqPRaHwDn4jBdcMMoAV432NnqCqCmBSIiPPYKTT+\nTVObjSX7T7OpuJrT51qICQ9hREoMX54UTnhbLYRFQ2I2BPlEP1PjhRSdqef93ScpqmygvsVGenwk\nszNjuSmtDkIiIGWU1Spais8ZOCGEAP4H+J6U8swFtnkEeARg2LBhfTvR1j/Crtdg8CS46uuQNQ+E\n6KPWmkDC7pC8tqWM55ceob7FBkAkLdwXvIy7j64gbA8QOwhaaqGtEa64C2Z9TXWoNJoecKK2mR+8\nd4Dlhyo6ZKNEOZ8NeZv5B/ZBchbk3Qwp37FQS+sRUkqrdegVQohngSFSyvt6sv2UKVNkXyqZtNsd\nvLz6IA8OPEjYup/CoPFw8/9BeGyvj6UJLH61rIAXVhQCMHFYAg8Or+aaA9+hJmEMVRMe44or54AQ\nNLbaOHxoP5NPvg77/wM3/BLG3Gqx9hpvR0rJPS9tYWNxNVFhwdwyLoUH2//J8PK32T30fqKm3c+4\nnOGXdQ4hxA4p5RQ3qWwZPmXghBCPA/nAp6WUtp7s01cD9/339vO3TWVMzUzk5XvHEbPyKSjbBPe/\nr3rfGs0FaGy18ZV/7uLOKUNZJDbBR0/ATb+G0Td1bGOzO3jo1e2sK6zkuU+N5860Svj3AzDhbsgP\n7F635tJU1rfywooCvjJnKKmLHwZ7G3zqLxDjnvKR/mLgfMb5L4R4GLge+IyU0iaEyBJCLPDU+e6a\nOozUuHC2ltTwpTcO0n79r2D8HfDqTdDQrWdUE8C0tNtxOFRnMTo8hJcfuJJFQVtg8bfgc+92MW4A\nwUGC8UPicUj4zlt7+aQ2HR5eAQfegdU/teIraLycojMNmAOS5NhwfnRjLqmLH1LzBO59223GzZ/w\nCQMnhPgs8BTwY2CcEGIKcA0w21PnHJ0Wx5uPzmBgdBhrCyr5wfsHYM43YfTN8Ma9YGvz1Kk1PobD\nIfnyazv52hu7abXZlfDETvjwv+Het2DQuPP2EULwjYUjeXzBCBwSvvqvXeyvC4P7P4A9/4Q9b/Tz\nt9B4MwdO1nHjb9bx3Xf2YTc6Uix+AoLD4bY/QbDPTafoF3zCwAF/BzKA1cA24/UHT590+MBo/vLA\nlYSHBPH6lnI+3HsS5j0FUQNh6ZOePr3GR3h5QwkrDp9hXWElZ861QmMVvPk5uPHXkDb+ovt+bf4I\n7pg8hJZ2B1/55y4aQxPhs6+p++uULtSjMVzer++ipd1Bu10SJIAdr8CxrXD7H7Vxuwg+YeCklKFS\nStHN62lPn3vC0AS+d2MeAE++vY8T51rhtj9A4TIoWOrp02u8nAMn6/jpksMA/OxT4xmaGAUffR3y\nblGz2C6BEIIf3jqWkamxlFQ18swHByF1DCx6Dt5+BGytnv4KGi/nhx8e5GhVIyNTY/nRrWMRNUdh\n+f/CZ/6hJ71dAp8wcFZz77RhXJOXyszsgYQECYiIh1tehA8eh+azVqunsQi7Q/Lk2/tot0vumz6c\nhWMGwf634cxhuPp/enyciNBgfnP3RMJCgqhqaKXN5oBxd8DAbFj9nAe/gcbb2VRczb+2HSMsJIjf\n3D2RiGDg3S/B3G9B0gir1fN69Ni2BwghePHuSYSFOPUHMq+CUderntRNv7ZOOY1l/H1TKXuP15EW\nH8G3rxsFLXWw5Dvw2dchNKJXx8pNjWXp43PIGBiFMPMtb/wV/G6GMnapee7/AhqvptVm56l39wHw\n5fwcclNjYdtfVD7u1Ect1s430CO4HuJs3KSU2OwOuPp7cPhDOL3PQs00VlDT2MYvlhUA8PTNY4gJ\nD4E1P4MRC2FI32ZXZyZFdxo3UInfc7+tjKYPpfNo3MPfN5VxtLKRrORovpCfpbxFq5+F636mq9/0\nEH2VesnuY7Xc/vuNvLKxFCIHqJylJU/qBijAEMCtEwYzb2Qy144ZpEq77X4d5n//so+973gdj/59\nO7VNbTDlv6ChAo4svnylNT7FHZOH8ujcLJ6+aQzhIcEqfWTUjZecuKTpRBu4XlLT2Mqu8lp+u6qI\ncy3tMOkB1QAVr7BaNU0/MiA6jB/eOpa/3H+lEqz+Ccx8zC3ltn665DBLD1Tw+9XFaobcNT+EFc+A\nw37Zx9b4DvFRoTx53Wjm5CZDbTns/Zeaxa3pMdrA9ZJ5I1OYmplIbVM7L68vUQ1Q/ndg5Y/1KC4A\nCQoSUHEQSta5LS7yrUUjAXhlYymV9a0w4ho1W+7AO245vsa7aWqz0W53dBWu/TlMflAnc/cSbeB6\niRCCr1+TC8CrG0tparNB3m1ga9FpAwFAxbkWbv7tet7bfaJTuPpZmPVVCI9xyznGD0lgwehUWm0O\nXtlYoiYVzHtKnUeP4vye360qJv/51aw8bBRSrimBQx/AzK9Yq5gPog1cH5iWmcjEYQmcbWrnjW3H\nVMB3zjdhg55N6e/8ZX0Je4/XsWT/aSWoKoKyjTDlIbee54v52QD8bVMZ9S3tkJUPkYlqUpPGb6lv\naefVTaWcqG0mPjJUCTe9CJMfgKhEK1XzSbSB6wNCCL44VzVAf157VLkTRt8MdSfg+A6LtdN4irqm\ndl7bXAbAl/JzlHDz72DKgxAW5dZzTR4+gKmZidS32Hh9S7kaxc18DDb+1q3n0XgXr20pp77FxtTM\nRCYPT4SmGtj3Jkx9xGrVfBJt4PrIgtGp5KTEcK7FxpHT9SoWN/0LsEk3QP7Kq5tKaWyzc9WIJMYN\niVeNz/634MrPe+R8X3IaxTkcUs2ga6hQJZo0fkdLu52/rC8BOn97dvwVRt4AcWkWaua76ETvPhIU\nJPjNXRNJT4jsdCVMvA/WPq9mPCX0caFVjVfSbnfwD2P09gVj9M62v8DoGyE21SPnnJubzJPXjeKW\nCYPVZBaCYfqXVCdq6N88ck6NdXy8/xSV9a2MGhTL3NxkVdB9y5/g3v9YrZrPokdwl8HotLhO4wZq\n2YoJ98Bmj9eB1vQzyw5WcKa+lZyUGGZmD1Q1Irf9GWY85rFzCiF4dG42g+KdqqJMvFfN2Kwp8dh5\nNdbwj83lANw/M0Ml/O//D6SM6nY1Ck3P0AbODbS029lRVqPeTHsU9rwO7c3WKqVxK2/vVLMm75k2\nTDU+hz6A5FGQMrpfzu9wSBpbbWqm5sR7lOtK4zfUNbVzuq6F2PAQbpmQroTbXoJpX7RWMR9HG7jL\npL6lnVnPreSuP29RlScShsHgyXDwPatV07iR39w1kZ99ajy3TxqiBDteUTPb+oGNRVVc/YvV/Hjx\nISWYdD/s/ifY2/vl/BrPEx8VytpvzePtL80kKiwETu+H+tMqB1LTZ7SBu0xiI0IZMzieNpuD/+w4\nroST7ocdr1qrmMatRIYFc+eVQ5VLuroYzhyCUTf0y7mTY8MprW7ivV0naGi1qSryA3PgyMf9cn5N\n/xAcJBiRaix/s/NvKtwRFGytUj6ONnBu4N5pakLJ61vK1ZLyuYugugiqCi3WTHO5tNsdtLS7JFfv\n+jtc8VkICe8XHUakxjI1M5HGNjvv7DISzCffrxpBjc9z6NQ5VbHGpL0Z9v0bJt1nnVJ+gjZwbuDq\nUSmkxoVztKqRneW1EBIGE+6CnXoU5+t8cqCCK3+8XNWFBOUW3P06TPpcv+pxj9GJesv0Eoy+GU5s\nh9pj/aqHxv089c4+pj+7gg1FVUpw6ANIn6hnYrsBbeDcQEhwELdMGAzA2zud3JR7/qWm+mp8lrd3\nHqe+xUa4uVxSwVJIzILkkf2qx8K8QcSEh7D7WC3FlQ0qsXzsp2HXP/pVD417KTE6xREhQUwclqCE\nO17t9w6Uv6INnJu4baIycB/uPUWrza5WY07M1qsM+DBVDa2sKagkOEhwszmzbe+/YMLd/a5LZFgw\ni8YOAuBd00054W6ljy7y7bO8Y3SIF41NU5NLasvhzEEYeb3FmvkH2sC5idFpcYwaFEtafASnaluU\ncPwdypeu8Uk+2HMSm0OSn5tMUkw4NNfC0TXKPWgBtxudqLWFhisrfSIEhcAJXR7OF3E4JG8bnZVP\nTVK/LfvfgrxbVJhDc9noSiZu5I1HZhAf5ZT4nXcbLH8GWhvcVmle03+YuW+3mY3PoQ8gay5EJlii\nz/Ssgbzy4JXMyklSAiFg3B2w980+ryKusY7tZWc5fraZ9PgIpmcNVMK9/4brn7dWMT9Cj+DcSBfj\nBhA9EIZNh8MfWaOQps8Unaln34k6YiNCWDDaKMW1701lUCwiKEiQPzKF0GCnx3bcHXDgbbDbLNNL\n0zfMeP2tE41SbBUHoKUOhs2wWDP/QRs4D1Ba1ciBk3Xqzfg7tZvSB1l9pBKA68YOIiI0GM6dglN7\nYcS1FmumaGg1FsUcmA3xQ6FktdUqaXpJQ6uN4CDBrYbrmX3/hnGfUstvadyCvpJu5uN9p8j/+Wqe\n+/iwEoy8TlV/b6yyVjFNr3hodiYff+0qHjULK+9/S1XzD424+I79wI8+PMikHy7rnFY+/k7Ypwvy\n+hq/vXsS259aQG5qLDgcsO8tGHen1Wr5FdrAuZnpWQMJDhJsLK6mprENwqIhdyEcfNdq1TS9QAjB\n6LQ4spON2On+t1Tv2guIiQihzeZg8b5TSjDmdji8GNpbrFVM02sGRBuTSY5vU6kfqWOsVcjP0AbO\nzQyIDmNm9kDsDsknB4xVn/NugYPvW6uYpsc0t7lULqk9BmdLIeMqS/Rx5YZxam2wTw5WKDdlbCoM\nGgtHV1msmaYntNsdbCutUWv8mRx6X7UTQlinmB+iDZwHMBugxfsNA5c9H07uUgtkaryeW15czy0v\nbuBErbEixKEPVF5ScOjFd+wnRqTGMiIlhtqmdjYWVyvh6JuVnhqvZ2NxNXf8YRP3/mWLEkipDJxF\n6Sf+jDZwHmDhmEHKTVlUpVYYCIuCrHw9m9IHKKiop6CigbLqRlJijVqTh96HPO9qfK4zO1F7DTfl\n6BtV8WW9woDXY/5mUzISleDUHpXPqN2TbkcbOA+QaLgpbQ7JJwcqlDDvFt3D9gHMuNbCvFQ1Hb++\nAioOqg6KF2F6CZYePK3clPFDIDETStdZrJnmYtjsDpYeVJ6dG8er37Bj9Kbdk25HGzgPcd3YNCJD\ng6lsMKqm31n4AAAgAElEQVSEj1gI5Zug5Zy1imkuyrKDqkNy3Vij8Tn8oVqTq59WDugpuakxZCdH\nU9vUzt7jRkqKdlN6PdtKz1Lb1E5WUrSaPSmlis9r96RH0JVMPMRtEwdz+6TBKocKICIOhs9UxXrH\nW5csrLkwJ2ubOXDyHFFhwczINipLHPoApjxorWLdIITgZ5++gtS4cIYMiFLC0TfBy4vg+p/rdcS8\nlOWHVAfqmjyjeEDlEbU8zuBJFmrlv+gRnIeIDAvuNG4mo29S7giNV7LCaHzmjEhWv13zWTi+HXIW\nWKxZ90wePqDTuIFK+o5JUVPONV6HlLLDwC0wDdyhD1T8VLsnPYI2cB6m1WanoKJevRlxrSrWq5fQ\n8UpWHD4DODU+RSsgY5bKZfRybHaH+mfkdVCwxFplNN1S1dBGU5udAVGhTBo2QAkLlqjfTOMRtIHz\nICdrm5n0zDLu/vMWlfMSkwzJuVC2wWrVNN3wf3dN5Dd3TWT+qBQlKFgKud5RmutCfLj3JFf/fDV/\nWndUCXIXwRFt4LyR5Nhwtjw5n/cfm01wkICGM1BVCMNmWq2a36INnAdJi48gISqMqoZW9hyvVcLc\na1XDqfE64iJCuemKdFVdwm6DouVeU3vyQoQECY5WNbLcmBxD+iRoqlKJ6RqvIyhIMDTRcCsXLoPs\nfL00jgfRBs6DCCE6gsmm753cRVDwsV6k0suQrr/H8W1q6n38YGsU6iFXjUgmLDiIXcdqqWpoVYV6\nRyyEgk+sVk3jRGOrTeXEOlOwBHK1e9KTaAPnYcylVpYfVPEdUseqZNyqQgu10jhjsztY8Ms1PPHv\nPbS0G2W6CpaozoiXEx0ewsycgUgJK40YovISaDelN/HRvlNM/tFynv34kBLYWlU8fsQ11irm52gD\n52GmZiYSGx7CkYp6jtU0qdlSugHyKnaUnaW4spGdZWc7Z74WLPUJAwfOnSjDS5A1D45tUQvtaryC\n5QcrsDskQ81Zr2UbIHkkRCdZq5if4zMGTggRJoR4VghhE0JkWK1PTwkLCWLOyGTA1U2p43Dewnmz\nJ8+WQlM1pE+0TqleMH+0mhSzrrBKjUAj4tQK30dXW6uYBoCWdjvrCtXSRuZv5QsTmPwBnzBwhkFb\nA6QDPpfBusC4qfeZFScy56j6c81nLdRKY7L6iDJw80Y6NT4jFvrMwpNp8ZGMSY+jud3O5qNG8eXc\nRdpL4CVsLamhud1OXlocafGRKv5+5GOf8RD4Mr5SySQGuA8YAnzOYl16zYLRqax6Ip+MgYZ7IjRS\n5VcVrYBxn7ZWuQDnZG0zBRUNxISHMHm4U27SZO+rXnIxvrEwlyAhmJ5lVGDJvRbW/0otpOkjhtpf\nWVOgVofPNzw5VBWAw66LK/cDPnHnSyn3SymLrNajr8RGhJKZFI1wrlage9hewVqj8ZmRPZCwkCAV\ntzq2FbLnWaxZ77h6VCr5I1M6Y4iJWRARD6d2WauYpsPAzc01DFzBErUIsq5e4nF8wsD5Ex2LaeYs\ngOKVqoetsYzzGp/SdaouYHishVq5iZxroGil1VoENGfqWyiuVB6CSaaHoGi5coFrPI5fGjghxCNC\niO1CiO2VlZVWqwPAidpmrnthHTf+xljOJGEoRA2E03usVSzA+VJ+Do8vGME8s3pJ8UrIvtpapfrI\nusJKvvD3Hbyz67gS5FwNxSusVSrASYmNYNtTC/jz56ao5ZfaGuHETsiYbbVqAYFfGjgp5Z+klFOk\nlFOSk5OtVgeAlNhwjtc0UVzZqNIFQK30XaQbICsZNySexxfkMjghUgmKVqjfxQc5VtPMkgOnWWKu\nJD9sJpzep5dospikmPDO1SlKN0DaBP/wEPgAfmngvJHQ4CBm5aicF9MtRvbVULzKQq00XThbCq31\nKhnfB5mTq+6vDUXVahHUsCgYciWUrLVYs8BESnl+hZziFT4X3/VltIHrR+Yas6jMiQ1kzIJTu1Wj\nqul3nnpnH39YU0x9S7sSFK9UjY+PzjocMiCKnJQYGlpt7Co3ap/mzNduSovYWlLD7J+u4v9WOFUt\nKl6pfhNNv+CbT7KPMseYyLCxuJo2m0MtwzJ4MpSss1izwKOqoZXXtpTzq2UFKjYCPu2eNJkzQt1j\nawqMsl3ZV6tGVdPvrC2s5ERtM7VNRgeq9pgqIDDoCmsVCyB8wsAZVUxWA782RP8SQrxtoUp9YnBC\nZEcPe2e5keStGyBLWFeoRtHTsgaqqfX2dtXR8HH3kekl6HCDp+SpuofVxRZqFZh0zNA189+KV6gy\naj7qIfBFfOJKSynbpJT5UsoJUkohpZwupbzdar36gjkdvaMB0i4kS1hzxCU94MQOGDBMrYjtw0zL\nTCQ8JIj9J85RWd+qcq10J6rfqWpoZf+Jc4SHBDEtM1EJtXuy3/GVSiZ+w2euHMq0zESmmRUnUseq\n5OKaEkjMtFa5AEFKyYZiVdLqqhFGsVs/cE8CRIQG8/mrsoiNCCEkyEgkzr4a9r8FUz9vrXIBxEbj\n/pqamWh4CGxq9YBFP7VYs8BCG7h+Jjc1ltxUpynCzj3sxIesUyyAKDzTQGV9Kymx4YxIiVHC4hWw\n4Gkr1XIbT1w7sqsgax58+N9ga9OLa/YTG4ziyubMaU7uhLjBEJdmoVaBh0+4KP2enPnahdSPbChS\njc/M7IGqfFpTDVQWwNBpFmvmIaIHwsBsOL7Vak0CAikl6417bLZp4MwZupp+RRs4Czhwso6v/WsX\nv/zkiBJk5asSUQ67lWoFDNnJMdwwPo1r8gYpQdkGGDYNQsKtVcyN7Co/yy+XFXQWFcjKVy4yTb/w\n/B3jeXzBCPLS4pSgZK0aSWv6FW3gLKCl3c57u0/y4d5TShCTArHpKidO43Hm5Cbz4t2TuGG84S4q\nXe93pZP+vO4o/7eisHMyU+ZcKNEGrj8QQjAzO4nHF+QSFCSgvRlO7ladKE2/og2cBYwfkkBMeAhH\nqxo5VdeshFlzdcUJqyhdDxlXWa2FW5mZrVxjG4uVq4yh0+D0fl1UwAqOb4PUPF2eywK0gbOA0ODO\nqcMbiowFKjPnaBdSP7C+sIoVhypoaLUpQVMN1JZDmn8l35qxn03F1TgcUpXtGjwJyjZZrJl/43BI\nHnt9Jy+tO6rKpYFfegh8BW3gLGJmjlk30OhhD5+lenq2Vgu18n9eXFXEQ69u7yyXVrZBjW6CQ61V\nzM0MHxjF4IRIzja1c/CUUWxZuyk9zqHT5/hw7yleXl/SmaZRsk4bOIvQBs4iZjsZOCklRCZAUq4y\nchqP0NxmZ0fZWYSAGWYeop82PioOpL5jh5syc442cB5mo+GRmZmTpGbotjWp2PrQ6RZrFphoA2cR\nuakxJMWEc6a+leLKBiXMmqvdlB5ke1kNbXYHY9LjGBBt5IP5YfzNZLaRxL7edIMPngRny5RbVuMR\nzksPOL4NUsdAeIyFWgUu2sBZhBCCB2dl8I1rcomNMNxjmXP0RBMPYsY7O5JvG6uh7pjfxd9MZmQP\nJD0+guGJUUoQHArDput7zEO02RxsLVGdh5kd67/5bwfKF9CVTCzky/NyugqGTlcLVLY26B6fBzDj\nnbOMGYYq/206BPvnY5ASG8GG71ytXGUmZhxuzK3WKean7D5WS3O7nREpMaTERShh6XqY84S1igUw\negTnTYRFQfpEKNcz3dxNbVMb+0/WERYcxJUZRvHbUv+MvznTxbiB9hJ4ENM92eEhaGuCU3v8t0KO\nD6ANnMUcPHmOF1cVUVhh5CdlzYWjqy3VyR85VddCTnIMk4YnEBkWrIQBMn37bGNb52zd1LEqBld3\nwlql/JC8tFiuyUtl3ihjRYrjW3X8zWL80zfjQ/x9cxn/3FoOwIjUWOVCWqxdGu5mdFocy74+l5Z2\noxxaY5Vq5P188cmmNhtTf7IcKWH3DxYSEx4CmVepUdyEu6xWz69YNDaNRWOdiimXrlfXWmMZegRn\nMWYweosRnFYz3Ur1TDcPERFqjN78PP5mEhUWQl56PDaHZEeZsciuzofrHwLEQ+DNaANnMdOyVDxo\ne2mNqnygZ7q5naY2G8fPNnUV+mn+W3dMN+6xzUfNqjlGWTgpLdTKv1hXWMm6wkqa2wwPQVsTnNqr\n428Wow2cxaTERpCVHE1Tm519J+qUUE8EcCtrjlQy+6er+Oo/d3UKA6h3Pd1Iau8wcAOz1d/qYos0\n8j9+vbyQ+/6ytTOp/tgWGDQWwqKtVSzA0QbOCzivAcqYrVxoGrdgXtccc3HThko4dxIGjbdQq/5j\nyvABBAcJ9h6vo7HVphbZzZgNZeutVs0vaGqzsfd4LUECpnTM0NX5b96ANnBeQKeBM+Jug8bDuVOq\nIdZcNmZ80yxwHSjxN5PYiFDGDo7H7hyHGz5LNcKay2ZnWS3tdsmY9HjiI42iDQHkIfBmtIHzAqZn\nJpIUE86gOGPBzaBg1QDrUdxlU9PYxuHT9YSHBHHF0AQlLF0XcLPbpmclIgQUnjHKwmXMhtINOg7n\nBraUKA9BRweqrVEVbBg61UKtNKDTBLyClLgItj01v2tSbsZs1QvUFScui61G4zNxWELnDMrS9TDx\nXgu16n8enp3FF+dmkxBl1OBMzFJ/a452xuQ0fcJ0gZueGBV/G6fjb16AHsF5CedVnMiYpUdwbsB0\n+3Y0Pg2Vyv0bIPE3k+TY8E7jBkYcTt9jl0tzm53dx2oRAq7MdIq/BZiHwFvRBs6LONfSzq5yI0Yy\n6AqoO64SkjV9xow5dRi4svUwfIZyAwcgUkpabcZUdtNLoOkzJ2qbSU+IJC8tTsffvBBt4LyEs41t\nTHxmGfe8tMXIhwvRcTg38OajM3j94WlM6Ii/Be7stvd2n2D6syt4YXmhEgzXcbjLJSclhjXfnMeb\nj85QgtYGOL0fhuj4mzegDZyXMCA6jOEDo7rmww2fpRogTZ+JDAtmZk5SZ/wtgBK8XYmLCKXiXGvX\nfDiHTVXO0VwW0eHGdIZjWyBtvCqcrrGcS04yEULM6eUxW6SUW/uoT0AzPWsgRysb2Xy0mknDBqiR\nxvtfsVot/6HhDDScVhMAApApGQMIEnTkw0WHh3TG4RIzrVbP52izOahtbiMlNqJTGMAeAm+kJyO4\n1b18/ctt2gUY5+XDpV2hFuTUdSn7xGf/tImHX93G6boWJShdD8NmBmz8LTYilHGDXepS6jhcn9lR\ndpapP17Bo3/f3inU8TevoicGbo2UMqinL6DM00r7K9MzXetShqhcGh2H6zW1TW1sKalhbUEVCVE6\n+G9yftWcq7QbvI+Y13BwguGObG2AigMw5EoLtdI40xMDd7qXx+zt9hqDlLhu6lLqOFyf2FpSg5Qw\noUv+W+AleLtyfl3KHLC1wFndL+0tHQneRjFrjm1WXhcdf/MaLmngpJS9WjSqt9trumI2QAdOnlOC\njKu0C6kPmOW5zFEx9RXQUKEW/AxgXONwHXUp9T3WK1ra7ewsV/lv03T+m9fitlmUQog33HWsQObL\n83LY9tQC7ps+XAnSJ+j14frAedUlytar0XCAxt9MYiNC+fFt4/jnI9MJDzEef53w3Wt2H6ulzeZg\nZGpsZwK9doF7Hb0q1SWEiAe+CkwE4gHn8hsT3KhXwDI4IbKrIDgUhl4J5Ztg1A3WKOVj1DW3c/DU\nOUKDBROHDVBC3fh0cNfUYV0FGVfBhhesUcZH2eJaIae1ASoO6vibl9HbWpRvADHARqDR5bMMdyik\n6cTukAQHObmQtIHrEdvM+NvQBCLDnPLfJj9orWLeSlIutDdDbTkkDLv09pqO+Ju5mCzlm5W3JTTy\nIntp+pveGrhkKeXk7j4QQpxzgz4a4K0dx/n1igLunjqcL+Znq4oTi5+wWi2fYXR6HN+/MY+BMYbr\nqP40NFYGfPzNmT+tLWZDUTW/u2eSyoczJzNN0AauJ/zxvslsLzur8lVBTWDS+W9eR29jcLuEEBEX\n+OzU5SqjUYQEC47VNLPJnOmWPlFVfW8+a61iPsLghEj+a3Ymt0wYrASlZvxNF+4x+WjfadYUVHbN\nh9MLoPaY2IhQ5o1M0fUnvZzePvFfB34mhPiuEOJBIcTnzBfwfQ/oF5CYfv0dZj5cSBgMmaLcIJre\noxuf8zBnl5quNj2T8jJorYczh3T8zQvprYF7DPgy8DWUQftfp1eGWzXrBiHEzUKIbUKItUKIDUKI\nKZ4+pxWkxkWQlRRNY5ud/WY+nG6AesSOshqeX3qY3cdqO4V6+vZ5nFc1J3mUmihRd9xCrXyDx17f\nyZde20F5dZMSlG9WXpbQCzm3NFbRWwP3EDBKSpkqpcx0fgHrPKBfB0KIycDrwP1SyjnAs8BSIcQg\nT57XKszkUTOfS1V+1wbuUiw9UMGLq4pZdtCoN3DuFDRVQcoYaxXzMsx8uD3HamlqM/Lhhs/URQUu\nQavNzrKDFSzed5rocF1AwNvprYE7IKUsvMBnn7lcZS7Bk8BSKeVBACnlh0AFakTpd5xXcWLwJKgu\ngpY6C7Xyfs7Pf9ug42/dEBsRylijLuXOMmO0m3GVaqw1F2Tv8TpabQ5yU2MYGBOuhNoF7rX09qn/\noxDicSFEujhvCWredpdSF2ABsN1Ftg24xsPntYRpmaqB3lZSg83ugJBwGDxZx+EuQn1LO/tP1BES\nJJg83Hl2m258usOswNFZl1InfF+KzcUuHaiWc3DmMAz2y2iJz9PbNIEPjL+/ADjfxnkGIUQiKrHc\ndabmaeC6flGinxkUH8F3rx9FXlp8pzBjtmqwc6+1TjEvZnvpWRwSJgyNJyrMuLVL18OVD1urmJeS\nPzKFk3UtjBti3GPJo6G5FupOQPxga5XzUsyQgdkBpXyz8q7o+JtX0lsDtwd4vBu5AH51+epckGjj\nb6uLvBU4r7KpEOIR4BGAYcN8N6/nkTnZXQUZs2HpU9Yo4wOc5548dwqaqnX87QLMykliVk5SpyAo\nyBjFbYTxd1inmJfSZnOwvcwwcGaCt85/82p666J8Vkq5ppvXasCTLa9ZNSXcRR4ONLluLKX8k5Ry\nipRySnJysgfV6mcGT4aqAuUW0ZzHZrN3bRo4nf/We4bP1nG4C7D3eC0t7Q5GpMSQpONvPsEln3wh\nxELzfynlmxfaTkq52HV7dyGlrAFqAdcZk4OAYnefz1twOCQvrTvKl1/fid0hVRwufaKOw3WDlJIx\n6XFkJUUzZbiuLtFTGlptrDp8hjUFlUqg01EuSHpCJN+5bhSfm5mhBC3noPKI6nhqvJKedG2/08tj\n9nb7nrIccI3kTjHkfklQkOBvm8r4aO8pDnZZPkf3sF0RQvCT28ax8ol8VXoKdO+6B2wqrubBV7bx\n4soiJUjJg+Ya5d7VdCE9IZIvzM3uXOmjfJOOv3k5PYnBZQohelOlJKGvylyC54DVQojRUspDQojr\ngTTgRQ+dzyuYnpVIeU0Tm49Wq8kAGbNh2f9YrZb3c+6kKm2Wkme1Jl7N1IxEhFDLv7S029XisMON\n2ZTjPm21et5N6TrInGO1FpqL0JMRXBkwrxevI55QVEq5A7gH+JsQYi0q5netlNKvVxA3Z2t15sNN\nVtOSdRyuC2sLKjlT39IpKF2vJkzo+NtFiY8KJS8tjja7g53lTnUptZegCwUV9bywvJC9x10q5GgP\ngVdzyRGclDK/H/ToEVLK94H3rdajPzFna20trVHL54RGKLfIsS0wwi9TAHtNY6uN/3plGxLY+4OF\nykWp4289ZlrmQA6cPMfmozXMzE5Sjfa2l6xWy6tYfqiCXy0voKK+hfFDElTBhapCHX/zcnT31ssZ\nMiCKoYmR1LfYOHTKjMPpHrYzO8rOYnNIxg6O1/G3PmCuabbF9BKkjFHpFfV+7RzpFZtdFzgtM+Jv\nIa4TuzXehDZwPsB5bsqM2bpmoBOd+W9GblLdCdXDTh5toVa+w9RMFYfbZcThCAoy1ofTsykB2u0O\ntpcaBi7TOf9Nx9+8HW3gfIB5I1O4Ji+VjIFGvvvgKWp5jtZ6axXzEs5L8Nb5b70iISqMUYPiGDog\nklN1RhxTG7gO9p2oo6nNTlZyNClxxoxJ7SHwCXpbyURjATeMT+OG8WmdgtAIIx9uC4xYYJ1iXkBj\nq429x+sIDhI6/+0yeOdLM9UMSpOM2bD9ZesU8iLO60A116rC54MnWaiVpif0qosrhPCjsiA+jo7D\nAV3jb7ERenXlvtLFuAGkjoXGSh2Ho5v4W/lmNblEx9+8nt76cDYKIbI8oonmojS32dlQVMUOoxae\nrvyuKKlqJEg4x9+OQ+s5tYCnptecqG2mzebQcTgnhgyIZFBcRNf4m17/zSforYFbjDJyXcbmQog5\nQgjd2nqQD/ee5J6XtvCHNUeVYMiVUHFQrcIcwNw/M4M9P1jII1cZ/S5z9Kbjb73mwb9uZdZzK9nV\nkQ+nO1EAP7ltHJuevNop/qZd4L5Cr1oBKeXXgJ8Dq4QQC4UQE4QQS4BVQLknFNQoTPfI1pIaHA4J\noZGQPgGO6bqUsRGhTotP6sanrww3JjGZLjldl7KTjqXBmmuhuhjSdfzNF+h1N1dK+XPgJ8CHqAVH\n64HxUsq73KybxokhAyIZnBBJXXM7h08bsycDvAFqabcjpewq1PG3PmO6eTvSUVLHQkMF1FdYqJW1\nbC+t4WxjW6egfBMMmQIhYdYppekxvZ1kMlQI8UfgGZRxawU+klIe8IRymk6EEB0rMG8pMRqg4bMC\nOh/uhRWFTPnRct7ZdVwJao8pl62Ov/WJqUa+5c7ys7Ta7BBk1qUMzE5Uu93B517eyqQfLaO6wViK\nskR7CHyJ3o7gCoGJwI1SylnAzcCvhBB6Fc5+wHRTdvSwh1wJFQcCNg63+Wg11Y1tJEQZvWlz9NZP\nK837G4nRYYxMjaXV5mDPsTolDOBOlJn/lpkUrV3gPkpvDdy9UsqpUsplAFLKlUA+8EUhxO/crZym\nKx11Kc04XFgUpF2h6lIGGN3nv2n35OVynpsygN3g5+e/nYWaoyoHVeMT9HaSyX+6ke0BZqEMncaD\nDEuMIi0+gpiIECpNl0mAznTbXnYWu0MyNj2uM/+tZK1evuQyMVdD32aUpmLQOGg4DQ1nLNTKGs7L\nfyvdAEOn6vibD+GWSiZSyjIhxCx3HEtzYYQQLHl8DvGRoZ3CjNmw6ifWKWURW1x712dLwd4KSbnW\nKeUHzMpJ4rWHpzFpmDEqDgqGYTPVKG7s7dYq149csP6k7kD5FG5LFpJSnnXXsTQXpotxAxgyFU7v\nh7ZGaxSyiPPcRyVrVWxEx98ui/jIUGblJBEZ5ly2K/C8BN3WnyxZqwss+xg6G9ZHqaxvdYrDjQ+o\nOJwZfwsSMCXDGGmU6N61xwjAONwRIxWnowPVUKlWqUi7wkKtNL1FF1v2Qe55aTMbiqpZ+vgcRg6K\n7Zzpln211ar1CxGhwfz7CzMoPNOg4m9Sqt71vCetVs0vKKlq5CeLDxEWEsSLd0+CQePh3CnVyMcE\nRjnau6YOY9GYQbTaHEpQug6Gz4Rg3WT6EnoE54MkGVOWO/LhAqyHHRwkmDhsAHdOGaoE1UUQHAoD\nMq1VzE+ICQ9h2cEKVh46Q7vdYeTDzQi4fLgB0WEMindyT+r6kz6HNnA+yHn5cEOnwul9AReH66Bk\njXJP6vibW0iODSc7OZrmdjt7jzvnwwWGgWu3O7qpkKNd4L6INnA+iGngthytUQ9iWDQMGgvHtlqs\nmedpbLVx70tbeHFVUWcjZE4w0biN8zpRAbSK/EvrSpj53Ere3HZMCc6dhKYaSBljrWKaXqMNnA+S\nMTCKlNhwqhvbKDxjVDEJEDfl9rKzrC+qYumB06oArsOhvrd2H7mV8wzcoPGqoW+otFCr/mFjcRWn\n6loIDzWax5J1eoUKH0X/Yj6IEIIZ2aoB2lhUpYSZc5Srzs8xv+/M7CQlOHMQIuIhfoiFWvkf050S\nvlttdjW5YvhMv7/HWm32jiT3jntMFxDwWbSB81FmGQ/fxmIzDjcdzhyClnMWauV5NhQrAzcrx6wu\noWMjniA5NpyRqbG0tDvYVV6rhFlz/d7A7SqvpaXdwcjUWJJjjfqT2sD5LHrOq49y9egU/nL/FKaa\nVRZCI2DwZJWQO/I6a5XzEGcb2zhw8hxhIUFcmWF875K1MO7T1irmpzw4K4PGNjsZxjpxZOXD5t9b\nqZLH2WB6CHJ0hRx/QBs4HyUpJpz5o1O7CrPmwtHVfmvgNh2tRkqYPGwAEaHB4LArg37TC1ar5pd8\nduqwroLkUWBrgZoSSPTPlAzTwM1ydk/qCjk+i3ZR+hNZ+XDUf11IHY2P2bs+tQdi0yEmxUKtAggh\n/DrWW9/Szh5jhQpz5Q5dIce30SM4H+ZYTRPPLTmMlJLf3TMZ0iZA/Sm1AnNs6qUP4GNcNSKZhlYb\n+SMNg6aTbz3OvuN1LDlwinkjU5iSkQiZc6F4JUx+wGrV3E5kaDD//Px0is6rkPNdq1XT9BFt4HyY\n6PAQFu87RWhQEM1tdlUgN2O26mGPv9Nq9dzOorGDWDR2UKegdJ1fNrTexCcHT/PiqmKa2xzKwGXl\nw/KnVXqGn02bDwkOYmpmYmdcu6rQqJCTYalemr7jX3dogJEYHUZeWhxtdgfby4z1u7Ly/dpN2YG9\nHcq3qAobGo8xK0fFokz3MAlDISJOpWf4O6VrdYUcH0cbOB9ndkcDZKQLZBoTTVxLDfk4/9lxnKUH\nTtPYalOCEzvURIeoRGsV83MmDksgIjSIIxX1nKlvUcJM/0sXqKxv5XMvb+XVjaWdwqNrdIUcH0cb\nOB9npmsPO2kESDvUHLVQK/cipeSnSw7z6N93cKK2WQmLV0L2PGsVCwDCQ4I7UjI2mTmX5mxdP2Jj\ncRVrCypZfqhCCRx2FX/T95hPow2cj3NlxgBCgwX7T9ZR29Sm3ClZ+X7VABWeaaCyvpXk2HBGpMQo\nYfGqgFkeyGpmu3aiMuZA+WblJvYTNhoeENMly8ldEJcOsYMuspfG29EGzseJCgth0rABSOlUN9DP\nXNWjPTcAACAASURBVEiduUkDVf3J5loVAxo63WLNAoNZTm5wKSVED1QTL07ssFYxN9JRIcfMf9Md\nKL9AGzg/4O5pw/jWopHkpcUrQdZc5V5xOKxVzE2Y8UXTHUvpOhg6TVVv0XicvLQ4xqTHMTsnqXMB\n0Ky5fjOZqby6ieNnm4mPDCUvPU4Ji1dClnZP+jo6TcAPuGXC4K6CuHSITobTeyF9gjVKuQmb3cGW\noy7uIx1/61eCggQffdVlskVmPqz7BeR/2xKd3Mn6jgLeAwkOEtBar56d4TMt1kxzuegRnL+Sla8M\ngY+z+1gt9a02MpOiGZwQqYTFK7X7yGqGz1BGoLXeak0um7UFagmgjg5U6XoYPAnCoizUSuMOtIHz\nE4rONPDC8kKWHzRmgeUs8AsD19RmZ9SgWObmJitBzVFob4aUPGsVC0CqG1p5b/cJ2u0OtcjukCnK\nFe7jXDs2lWvHpHbeY7oD5Tf4hItSCDEI+DMwTkqZYbE6XsnWkhp+tbyARWMGsSAvVVU0+c9/qR52\neKzV6vWZObnJzMlNxu4w8vqKV6nYiE6+7Xc+86fNFJ1pID0hUqUO5CyAouUw6garVbssbps4hNsm\nOq0nWLwKPvWSdQpp3IbXj+CEEAuBj4Bgq3XxZubkdk7l9rceNqBiIwBHV+n4m0VcNULdY2uOGKt6\nZ89XBs6figrUHoPmGrWCucbn8XoDB9iAfGCrxXp4NUMGRJGdHE19q61zgUqzAfJRjlY2UFrV2Cmw\n25TBzsq3SqWAxnThrTFiVqSMVr9JdbGFWl0ef1xTzOojZ1SnEFQHKivf7+psBipe/ytKKVdKKX0/\nkt0PzM1VVfbXFJxRAtOF5KM97N+uKiL/56v5x+YyJTi5E+KG6ORbi5ieNZDwkCD2naijqqFVuYlz\nfLcTVdXQyrMfqwo5HS7wohU6PcCP8HoDp+k5c0f6Tw/b4ZCsLVDTtzuquxd+AiMWWKhVYBMRGsy0\nLLUW3/pCo6qJ2YnyQczvMDUzUS2ga7epEVyOvsf8Bb80cEKIR4QQ24UQ2ysrK61Wp9+YlplIeEgQ\n+0+co7Let3vYB0+do6qhlbT4iM7yXIWfwIhrrVUswJljxuHMTlRWvirb1d5smU59xfwOHbMnj22B\nhOEQl2ahVhp3YomBE0L8SAghL/HK7+vxpZR/klJOkVJOSU5OdqPm3k1EaDA3jEvjtomDaWm3K6GP\n9rCdGx8hBNSfhrOlMHSqtYoFOPkjkwkSUN9irOoQmQCpeVC20VrFeonDIVlXqO6xfMPzQeEnkKs7\nUP6EVWkCPwP+cIltAmfo5UZ++RmXyiVZ+fDeY6qHHRpphUp9Yq1r77pwmcpNCg61UCtNdnIMu/5n\nIfFRTr9DzgIVu8qZb51ivUR5CNpIj48gO9nJQ3DTC9YqpnErlozgpJTnpJTHL/FqtUI3v6Ojh73B\nak16TH1LOzvKzhIcJDrrTxYu1e5JL0AI0dW4gU+6wTs8BCMND0HtMeUlGDzZYs007sQvY3CBTn1L\nOx/tPUVxZYMSjLhGjYB8hCOn6wkLCWLysAHER4aCrQ2OrtXBfy9CSknRGWNyc9pElTtWU2KtUr0g\nNiKEjIFRHTOPKfxE3V9BOt3Wn/B6AyeEmCqEWA08AAwSQqwWQnzfWq28m198UsCXX9/JWzuOK8HI\n6+HIYp9JF5iSkcjO/7mGX9x5hRKUb4KkHIgJnHiqN2N3SPJ/vpprfrVWTWYKClKxq4IlVqvWYz43\nI4NVT+SzMC9VCQqX6fibH+L1Bk5KuVVKmS+lzJBSRhj/P2O1Xt7MgtHqoe1Yndis23jmoEUa9Z6I\n0GCGJhrFbgs/gRELrVVI00FwkCArKRopYdVhI+fS7ET5EEIIgoIEtLeoAsu6/qTf4fUGTtN7pmYm\nEhseQkFFA2XVjSpdwEcaoLqmdlpt9q5CbeC8jgXGyGeZ2YnKyocTu9RitF7OqsNnOFXnlNZQth5S\nx0BUonVKaTyCNnB+SFhIUEfS9/JDRg87dxEc8X4X0m9XFTLpmWX8x3Sv1pSoRjPNt9e18zfmj1IG\nbl1hpUpJCYtW66d5+WSTlnY7X3xtBzOfW6mqsQAUfAK5ugPlj2gD56dcY/SwO5bPGT4LqguhvsJC\nrS6OlJJlBytobLMzdICR0lCwRI3edG1Ar2JQfATjh8TT0u5gg7FgKCOvgyMfW6vYJdhQVEVLu4Ox\n6fEkxYSruHTBx3qGrp+iWw0/JT83heAgwdbSGuqa2iEkTBVf9uKJAMWVjZRWN5EQFcrk4QOU8NCH\nMPpGaxXTdMt5sd7cRWoEZ2+3UKuLY3o05o82Zk+e3gciSLkoNX6HNnB+SnxUKNMyE8lLi+P0uRYl\nHHm9V/ewVxgN5dUjUwgJDoLGarVqdFa+pXppusc0cB2rV8SlQWKW11Y1cThkxz1m6s7hD2HUjXp9\nQT/FJxY81fSNvz54JeEhTnk9IxbAh/8NbU0QFmWdYhfAHAmYExgo+FgZNx+qwBJIjE6L5a0vzmTC\n0IRO4cjrlJcga651il2AfSfqOFOv6puOSY9TwsMfwfU/t1YxjcfQIzg/potxA4gcAOkT4OhqS/S5\nGNUNrewoO0tosOhYWFO5J2+yVjHNBRFCMHn4gM7FaEEZuMMfeWXOpdmBmj86RVUvqSmBhjO6vqkf\now1cAFBQUc9Rs6rJqBuUW8bL2FhcjUPCzOwkYiNCobVB5SaNuMZq1TQ9oK7ZiLuljlV/K/Zbp8wF\nqG+xERosWJhnrCd4+CNlkHX1Er9FGzg/568bSlj4q7X8cc1RJRh9s3qwbW3WKubCTVeks+Ibc/nW\nopFKULwChkxRo06NV/O1f+1i8g+XUVBRr2JZebfAgXesVus8nr55DNu/dw0zs9Wadh3xN43fog2c\nnzPbKFa89OBp2u0OiB8MySO90k2ZnRzDmPR49ebQB3r2pI8QERKMzSH5aO8pJRhzKxx41yvdlPGR\noWoCU32FquzjhbFCjfvQBs7PGZEay4iUGGqb2tlYXK2EebfCwXetVcyJjrXrTNqaVPLt6FusUUjT\nK64frxYIXbzPMHDpk8DR7lVuym2lNdjsjk7BwXch9zoICbdOKY3H0QYuALh+nNEAmT3svFtU2S4v\ncVM+8vcdXPfCOg6crFOCwk9g8ERdXNlHmJk9kISoUArPNLi4Kb2jE1VYUc8df9jEwl+vRZqjyv1v\nw9hPWauYxuNoAxcA3GD0sLu4KQeOgJI1FmsGtU1tbCyqoqCinrR4Ix1g/1u68fEhQoODuNaYuNHh\npsy7TY2SvMBN+ZExspwyfEDn2m9VBTq/MgDQBi4AyO3OTTnmVq+YCLD0wGlsDsnM7IEkRodBa72K\nD+rgv09huik/2ndKjZIGT1IeAovdlFJ2xgZNTwYH3lHx3ZAwCzXT9AfawAUIN4xPIzY8hNNmFfUx\nt6nZlO3NF9/Rw7yz6wQAN41PV4IjH8OwGbqyu48xM3sgA6JCOVrZQHlNk3JTjr0d9v3bUr0OnDxH\n4ZkGEqPDmGWuDn9AuycDBV3JJED4r9mZfGFuNhGhRs5PXLpK+j6y2LKH/fjZJjYfrSE8JIjrxhm5\nSdo96ZOEBgfx4t2TyEmJISUuQgmv+Cz8/XaY/wPLcs06O1BphAYHQXUx1J2A4bMt0UfTv+gRXIAQ\nFxHaadxMrrgL9rxhjULAe7tPAmrlg9iIUGiohLJNKvlW43PMzEnqNG7w/+2dd3yV1f3H398khECQ\nYZiGERCQioCEMARZirP+HIAoWhXFvUf9WalWWtuqtMUJdVCkKqhYkbqqaGUoSzYoAgqGIIaIyggj\n8377x3lirjFgxt33+369nte95zznOefzzXPzfJ+zofkvILUpfLkgLHpKSn0//MbOy2ztItfOdM3z\nifZuHw+Yg4szDhaV8tHn3vYmXc6CnCVuuaIw8J63lc+IsofPupnOuaU0DIseIzD4fFq+skmP0bA2\nPC9R23cfpF5yAh2aptKjdSPw+WD1DDj+4rDoMUKPObg4orCklAEPfcAlU5e6HY3rNoBjTnfNgmHg\npav7MfniTLf2pCqsmg497eETzSzZ8h0DJ8zlntne4JJuI2HD21C0P+Ra2qWlsuDOobx4dT83ejL7\nQ/fy1KpHyLUY4cEcXBxRNymRfh2ORLW8eZAeF8Kal8KiJ6VOImd2a+VWlshdA0X51jcS5bQ5sj7b\ndx9kzqc72FtQDA2aQ9u+buHsMCAitChrNl093dXebGucuMEcXJwxvKdrDpy5bJsbzt1+MOzfCblr\nQ6ahsKSU/IIKm2Kung49LrKdu6Oc9Mb1OKFDGoUlPl7/4SVqNKx6PqQ61mzb7VopyijYAxvfge6j\nQqrDCC/2NIkzhhzTjFaNUtjy7X43Jy4hETIvg+VTQ6bh9dVf0/fP/+XpBZtdREkhrPsXHD86ZBqM\n4HFhnzYAvLBkq3uJ6nIW7NzojhCgqtz16lpOfGguS7d48z4/nQ3tB7pBL0bcYA4uzkhKTODC3m0B\n9wACIPNSNzeoYG9INExfmsOBolIa1/cm2q7/N7TsBk0yQlK+EVxOP64laanJbNiRz8qcXW5CdeYl\nIXuJWpmziw078mlcrw492zZx/bvLp0LPS0JSvhE5mIOLQy7s04bEBGHO+jzy9hZAw1auqTIEo90+\n2b6H1dt20zAlqXxy99Inoe+1QS/bCA11kxK5oHdZLS7HRWZe5n5fRQeCXn5ZmaN6tyE5KQG+Wuaa\nKDudGvSyjcjCHFwc0qJhCqce24JjWzVkZ36hi+w91r3lBnntwOlLXa1xRK/W1EtOhK+Wuz7AzqcF\ntVwjtIzu0xYR1xdWXOqDJu2gdZ+gj9j9fn8Rb63LRQRGey0VLH0K+lxl/btxiM12jFMmjjreOZgy\nMga5vrCcxdCuf1DK3H2giNmr3MCDi/u2c5FLn4I+V9uuyjFGmyPrM+u6/nRv3ZjEBG/UYu+xMPfP\n0PNXQRvJ+NKyHIpKfAzu3Iy2afVhby588R788m9BKc+IbOyVJk75kXMD93bb7zpY+FjQynxu8VYO\nFpcysFNTOjZv4Dad/Pxd98AzYo6ebZuUOzeAjqe4+XBBWtmkoLiUqR9lAzBmQIaLXPEsHDcS6jUO\nSplGZGMOLs7ZvHMfE97ZgM+nztFsXwF564NS1qa8fACuH9LRRSybAl2HQ70mQSnPiAzy9hawYusu\n9xI14Bb46OGglJNfUEKf9k04Lr0hQzo3cwuJL3/WtRAYcYk5uDjG51Mum/oxk+dtZs76PKhTD/pd\nCwsfCUp5T1yUyTu3DqRfhyPdiM1lU6D/TUEpy4gM1n61m4EPzeW2l1e7HbW7X+CmC3y9KuBlNTui\nLpMv7sWr1/V3K5esfB5a94bmXQJelhEdmIOLYxIShCtPbA/A3+dvdnOWssa6HbV3bQ1KmV1aNnQP\nn2VToOMwSDs6KOUYkUHXoxpxVOMUcr4/4DYeTUqG/jcGrRYHbhQnJUWw8FEYdEfQyjEiH3Nwcc4F\nvduSlprMmm27WfD5t66vIvOygNbi5m78htXbdpdHFObDkr/DwNsDVoYRmSQmCNcMdi8xk+Z+QalP\n3e8r+6OATfwu9Sm3v7yaRZu/LY9cPR2adoL0XgEpw4hOzMHFOfWSE7l6UAcAHvqP1xfX/2a38sN3\nm2ud/8GiUu5+dR3nTlrIx19+7yIXT4IOQ9x2KkbMMzwznfTG9diUt49ZK79yi3z3vxn++4eA5D97\n1XZmrdrOna+sdVMSig7A/Alw0r0Byd+IXszBGVzWP4NWjVJYn7uXf6/ZDqlpcMIN8MH9tc572qJs\nduwt4Lj0hmS1a+K25ln6JJz02wAoN6KBukmJ3HFqZwAmvreJguJS6HsNfL0acpbWKu+C4lImvrcJ\ngF+f1tltarpkMrTpA62t9hbvmIMzSKmTyO2nuAfQo+9/7pqR+l3nHj45S2qc7449BUya+wUAd53e\nhYQEgQ/+CN0vtGW54oxzj0/nF60akrungKfmb3EDmoaOg3fHuX3aashT87ewffdBurQ8gnN6pEP+\nDtdCcPLvAqjeiFbMwRkADM9szZj+GUy7vI+bu5ScCqf9Cd68DUqLfz6DSrj/zfXsKyzh1GNbMLBT\nM+cwN70LQ+8OsHoj0klIEO77v2M5oUMav+zeykX2GO0m+K+cVqM8s7/dz6R57gXq92d3dS9Q79wN\nvcbY4CUDMAdneCQmCOPP7kpG09TyyK7nwRGtYPET1c7v/fV5vLUul3p1Ernv7K5uVNubtzmnmdIo\ngMqNaKFfhzRmXNXXTfIHNy/urIddrT5/R7Xy8vmUca+to6jEx4jM1vTtkAafv+/mcQ66MwjqjWjE\nHJzxE1SVlz7OYV9RKZw1ERY97vpLqojPp/x1jhshd8epnUlvXM/15zVuC8eNCJZsIwoQb4kun09Z\ns203tOjqpqbMvq5aTZXbdh1gU94+0lKTGXdmF9j/Lbx+I5z9GCTXD5Z8I8owB2f8hAf+s4HfzFrH\n3bPWoY3bwRkT4NWxbnh/FUhIEKZf2Zdbh3XiigHt4Yv33SK750yy3ZQNSkp9jP3nMkb8fRHLsr+H\nwXe5JbwWP17lPNqlpfLOrQN5+tIs0urXgdnXu0nkHYYETbcRfUS0gxORuiJyvYjMF5EPRGSFiDwj\nIrZrYRAZldWG+smJvLHma/7y7kboNhLaD4JXxhy2P079diJIa1CXW4d1JmHnZ/DatTD8GTc604h7\nkhITOLpZA0p8ylXPLWfz9wUwYgosngwb3jrstfsKS3743rRBXXq1awLv3etevk66J9jSjSgjoh0c\n0Al4ELhaVU8CBgAdgVlhVRXjdGzegEkXZ5KYIEyet5mH39uEnjEBJAH+fWOlTq6k1Me419bx+zc+\ndaMwwc2jmzEKTnsAMgaE2AojkvnNGV04uUtzdh8o5ldTlrKxoAmMngGv33TIxZg37sjnlInzmThn\no3uZUoUPJ7qVdy6cDol1QmyFEelEuoM7CDylqhsBVLUAmAwMFJE2YVUW4ww9pjkTRnQnQeDR/37O\nra98wu5fPg0HvoMXR7sNJD1y9xzk8mnLePHjbcxYmsOnX+9x0wuePQMG/Rq6nx9GS4xIJCkxgccv\n6knvjCbk7ilg5JOLePO7Vuj50+CVy2FN+ea7qsoba77m/CcXkbungMVbvqOwsNCNmFz7MlzyGtQ/\nMnzGGBGLaJA3uAw0InIW8AbQSVW/+Ln0WVlZunz58uALi1HeW5/HTS+upKDYx+UDMrjvzM7w7jh8\n69/gy5538dL+TF5csYN9hSU0rl+Hf45sS4+t07w+tydsI1PjsBQUl3Lby6v5zyduFOXMa06gT/1c\ndOal7G/YiaUdbmDKZ3VYvOU7AE4/thmP9dtH8vv3QKN0GP607UYRBERkhapmhVtHbYlGB/cn4AxV\nzaxKenNwtWfzzn38bc5G/nxeNxrXTwbgsanT6JP9JB1lO+t87anXqCmZDfNJ/n6jGyk59B7rczOq\nhM+nvLgsh2cXZvPOLQNJSkxAiw8y+U83c77O4RttTI4cRbeWKbQu/AJJbgAn3u76hm3QUlAwBxcG\nRKQ5sA44R1UPucSGiFwNXA3Qtm3bXlu3Bmdl/Hjm2udXkLvnIAObHWBE6720Ty2Chulucdu6DcIt\nz4hCSkp9JCWW95pc9dxyiosKGXXUToY0O0D91FRI6+TWMDXHFlTMwdWmUJE/Aj+3GOFQVZ3nd00y\nMAd4QVWnVLUsq8EZhmFUj1hxcElhKncC8OTPpNlZ9kVEEoEZwNvVcW6GYRhG/BIWB6eqe4G9VUkr\nbumDqcB6VZ3gxQ0DtqjqluCpNAzDMKKZSJ8mAPAE0Ap4XUSyRCQLGAW0Da8swzAMI5IJVxNllRCR\nAcD1XvCUCqdnhFiOYRiGEUVEtINT1YWADZcyDMMwqk00NFEahmEYRrUxB2cYhmHEJObgDMMwjJgk\nqlYyqQkishOoyVImTYFvAywn1JgN4Sfa9UP02xDt+iH0NrRT1WYhLC8oxLyDqykisjzaZ/KbDeEn\n2vVD9NsQ7fohNmwIB9ZEaRiGYcQk5uAMwzCMmMQc3KF5OtwCAoDZEH6iXT9Evw3Rrh9iw4aQY31w\nhmEYRkxiNTjDMAwjJonopbpqg4ichVvHsi6QCuwC7lLVtX5pxgPnArv9Lj2oqmdUyOtK4DrgoHdc\nq6qbvXMZwBJgQwUJvwBeUtVbIlm/d74dMBG3gPVBoBC4XVXX1UR7mGxohtuGqTOQAmwHblDVbRGi\nvyHwMHCFqla6/JyIjANGAkWe/utU9Zua6g+TDS2BZ4BuqppRG+2h1C8idYGxwAVAKdAIWAncraq1\nGp4fynsgIpcDl3g2HAEocJ+qzqmNDVGLqsbkgZszcpFf+EHcHnMt/OLGA0N+Jp9zgG+All74RmAz\nkOKFM4BpFa4R4Eugf6Tr9+I+BGYCCV74FmAbUDdK7kECsBh4gfJm9weBT4CkCNDfE1jh/Y31EGlu\nBj4DGnjhvwILI+j/oCo2nOqleRvIrq32UOoHjsNt4XWMF04B5gILosUGL81nwCC/8E1AAdA0EPcj\n2o6wCwiaYTCrQrgZ7m3mEr+4qvyolgN/8wvXAfYAY/3C6RWuGQp8Fg36vbh8XG2hLHysV1bPaLAB\n6Ovl27uSskZGgP5+QEtgzCEergnADuAmv7gWXlknR8g9OKwNXpqTcLWG8QTOwYXqHhwN/KVC3Ple\nWW2iwQYvTd8K4W5eWccH4n5E2xGzfXCqOrxC1EHvs25V8xCRJkAv3AO2LN9iYDXe9j2qWqyq2ytc\nOga3SWuNCZV+j1eB80Sknhe+GPBRy5UTQmhD2d6AeX5pdgLFwODqqS4nEPq9fJao6o7DJOmOc2j+\nNuYBOfx0m6hqEUIbUNUPVDW/OvlWodyQ6FfVzap6ZyDKqiTvUN6DpWXfRSQV1xozF6hVd0O0ErMO\nrhJOwFXVX68Qf4WIzBORhSLyvIh09jvX3vvMrXDNDqBDZYWISANck9pzAdDsTzD1j8U1SX4tIluB\nO3B9DzXuvzoEwbIh2/v8YRNcEWmBq+m1DoRwj5rorwpldlT5d1YLgmVDqAil/hOAVar6RQDyqphv\nUG0Qkdm4Zv0WuFaM0prLjV7iwsGJiAD3Avfojzvtc4A1wDDgRGA9sEJEyh6qqd5nYYUsC4H6hyhu\nFDDPewMPCCHQPw3Xl9jG+/wVri0/YATZhuXAQmCciNQTkQTg97gaXGKY9VeFmvzOqk2QbQg6odQv\nIs2BKynfcDkghMoGVT0XOBK3Du8SEUmrlfBoJdxtpKE4gAeA56uQTnA/iEe8cCau/XpIhXQvAx8f\nIo8PgbOjRT9wvJdmsN/5FOAAcGI02OCFGwOP4gabzMWNuFxChQFAodZf4dwYKu//Ge7ZmFEhfikw\nM9z3oCo2VEgzngD1wYVJfzIwD7gyWm2oYMu3wB8CbUs0HDE7TaAMEbkVN2R/5M+lVVUVkS+Bjl7U\nl95nywpJW+JG8VUs62hcZ/XbNRb80zyDrb+sGSTbL58CEckDRgAf1Ux5OaG4B6q6G9ff4F/uXcAr\nNZTtn09t9FeFLd5nS/zugxf+oBr5HJIQ2BBUQqVfRBKBGcDbqjql2kIPn3dQbfBqh0nq+qjL8ikS\nkc1A1xpIjnpiuonSmzt1JnCBqpaISAcRGeZ3/tFKLkvHNRegqrtwzV9ZftfUAXoA71dy7Rjc21lJ\nFOkvGyDTyi9NIm6k14EosQERGVqh3La4/rfXwqm/iqzFDZDxt7E5rk+xst9ZtQiRDUEjVPo9BzEV\nWK+qE7y4YSJS637QENnQjsp/760o/z+PL8JdhQzWAVyIe/sfjHtwZAHXAOP90nyJX3Miru+pGL/h\n8bgBI3l4c1ZwbfI/mkfmxSfgmhSOiSb9uIEYn+Dm1iR6cTd7+fSKBhu8uE+Aod73JFwT5l8iQb/f\nuTEcfh7ceiDVC0/A9StKtNjgl2Y8gZsmEMp7MAmY41dOFm4NyCHRYAOu/7yAH0+XucHLJysQ9yPa\njrALCJph7qZqJYf/j+oiXBPQPGARsKDsIVkhrytxqxp8hHuj7lhJmmEEYGJuOPTj3vxmAstwfViL\ngTOjzIa/4pzeh16a/8ebuB5u/bia2DzcajfqfZ9cSXm/BVbh+g5nAc0j5R5UxQagjxefjXvQzgN+\nFw36gQGHKEepvYMLlQ0pwN24/+MFuP/j+cCw2v6OovWwxZYNwzCMmCSm++AMwzCM+MUcnGEYhhGT\nmIMzDMMwYhJzcIZhGEZMYg7OMAzDiEnMwRmGYRgxiTk4wzAMIyYxB2cYgIhke1uVlB0qIhv8wjtE\nZIiIpItInoikh0HjPD+dp1ch/fFe2g0ikh0CiYYRUcT8YsuGUVVUdUjZdxFR4EFVneaFp3mnCoCN\nlG9aGWqmqer4qiRU1dXAEBEZg1s+yzDiCnNwhuF45GfOz8atr/gdMCgEegzDqCXWRGkYgKoe1sGp\n6mxgv9fkV+DVihCRW8qaAEVkjIi8KyJbRORyEWkjItNF5FMReVFE6vrnKSK3i8hqEZkvIgtE5KTq\n6haRNBH5l4gs8rS9JSJ9q5uPYcQiVoMzjCqiqjtxTX7ZfnGPisgeYDJQrKqnicgpwJvAg8CluP+z\njbhV5f8JICJjcZuy9lHVXSKSBXwkIt1VdVM1ZN0PHFDV/l6+fwDOwG2WahhxjdXgDCMwJOC26AG3\nzU0y8LmqlqpqIW6F955+6e8F/qFuvztUdTmwDri2muWmAy1FJMULPwq8UDMTDCO2sBqcYQSGnept\ndKuqB9zemeT6nd8PNAIQkSNwWxRdWmE0ZAPvqA4P4voHt4rITOBZVV1ZMxMMI7YwB2cYgaG0CnFS\nIfywqj5Tm0JVdbGIZADDgSuAFSJyk6o+UZt8DSMWsCZKwwgxqpqPt/u7f7yInCciF1cnLxE5DyhS\n1emqejJu49drAibWMKIYc3CGER7uBy7xal+IyJFe3Lpq5nMLbjf5MuoA1RmkYhgxizVRGoYfYKaV\nYQAAAMdJREFUInIC8IAX/I2IdFTVe7xzzYBXgJbeuQa4Cd934gZ6zMGNlJzlXf+IiNwOnO4diMjj\nqnqTqv7D64t7W0S+xzVn3qWqa6sp+RngPhG5GzewJRe4sUbGG0aMIaoabg2GYVQBEZkHzKvqSiZ+\n140BxqtqRuBVGUbkYk2UhhE97ADOre5alLga3VfBFmcYkYbV4AzDMIyYxGpwhmEYRkxiDs4wDMOI\nSczBGYZhGDGJOTjDMAwjJjEHZxiGYcQk5uAMwzCMmOR/5qH0ZLCPjtcAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAElCAYAAAAlet80AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAIABJREFUeJzsnXd4FNfV/z9Hq15QB4EASYjeiyg2GDBgG9xr4iSOux0n9pv6pjjFb5pj/9KbE8dOsZ24JY67caObjuhFFIEECAGSEOpde39/3BlpEZKQhKTZXd3P8+yj3buzO98dzcy595xzzxWlFAaDwWAwdIUApwUYDAaDwXcxRsRgMBgMXcYYEYPBYDB0GWNEDAaDwdBljBExGAwGQ5cxRsRgMBgMXcYYEYcRkfdF5C6ndRh6BhF5WkR+0M77PxSRf/WSllwRWdQb+zKAiMwXkbxu+q5UEVEiEtgd39edGCPSSURkjoisF5FSESkWkXUiMr2r36eUWqKUer47NfYVrItquNM62kMp9ZBS6ifQPTcV6zdXikiFx+Nb3aO2S3quEpE1IlIuIoUislpErndKj5P4wvnYE3idVfNmRKQf8C7wReDfQDBwGVDbhe8SQJRS7m4VaegLTFJKZffWzkQkUCnV0Er7rcDfga8D1wHl6OvhDuDtjn5Pb+Dkvv0epZR5dPABZAAl7bx/N7AO+ANQCuwHFnq8vwp43NqmGhhutd3v8fm1wC+Bs0AOsMTj82nAGvTFugx4CvhXO3pWAT8F1gMVwDtAPPAiUAZsAVI9tv8dcNx6bytwmcd7M4BM673TwK+t9lDgX8AZoMT6zgFt6Pk2cMLSfwBYCCQBVUC8x3bTgEIgyDpGq63jWQS8am2zBlBApfXbPm21XwvssLSsByZ6fG8u8E1gl/W5vwEDgPc9jmlsB86DUOv/l2C9/j7QAPSzXv8U+K31/DnrdYT1GbeltwIYBPwQ3SF5wdKwF8hoZ98KGN7Ge88BP/V4PR/Ia/H7F1nPA4DvAIet/92/gTjrvVRrP/cBx4A1rexLrPe+2YHr4TdAsXUcAqzjdRQosH53dIv93oM+D88CDwHTrf9ZCfDHFvu4F8iytv0QSGlxrB4GDgE5rejrtv3RyvloH3/gG9ZvPQnc4/Fd0dbvL7SOx/eBAOs9F/o+UAQcsX6HAgKdvg+edxydFuBLD6CfdcE9DyyhxQ3HumgagK+hb4CfRt/87ItzlXXhjUOPAoM434jUAw9YJ9EXgXz0iAVgg3ViBQNz0Df0CxmRbCDdOmH3AQeBRdb+XwD+4bH9HWgjE2id+KeAUI99f956HgnMsp5/AW2cwi3N07Bupi20jLIu1EHW61Qg3Xq+FPiix7a/Af5gPX8Z+B765hMKzPHY7pwbKjDVulhnWlruQt84Q6z3c4GNaMORbG27DZgChAArgP/r4LmwBrjFev4R+ma8xOO9m6znz2Hd2GlxU7fafgjUAFdbmp8ANraz3+4yIl+1jsVg67f/BXjZ43+jrPMjAghrZV+jrW3S2tF6N/p6+B/rnApD34SzgWHWefQ68M8W+33a+l9faR2bN4H+Hv+zedb2N1rfNcb6/u8D61scq4+BuDZ+Q0/sb3iL498A/Bh9rV+N7jDFWu+/ALwFRFlaDgL3We89hO6EDrH0r8QYEf94WCfQc+geRgN62D5ANV80TTd9q20zzTffVcCPW3zfKs41Itke74VbJ04SMNTaX7jH+//iwkbkex6vfwW87/H6OmBHO58/i3adgL4x/gir9+2xzb206PG38V3DrQtyERDU4r1PA+us5y608ZphvX4BeAYY3Mp3trxo/wz8pMU2BzxuArnA5zze+y/wZ4/X/wO82cHz4CfA762bySngK8CTnD9KeY4LG5FlHq/HAtXt7FehOw8lHo+rWu6rtf1xrhHJ4txR8kB0ByaQ5pvrsHZ0zLa2CW1nm7uBYy3algNf8ng9qpX9Jnu8fwZrlOnxP/uq9fx9rJuu9ToAfZNO8ThWC9rR1xP7a2lEqvG48aOvgVno87wWGOvx3heAVdbzFcBDHu9diZcaERNY7yRKqSyl1N1KqcHAeLRL4rcem5xQ1n/d4qi1jc3xC+zilMe+qqynkdZ3FHu0nfNdVhaQHWj9rsc2pz2eV7fyOtLjO74hIllW0kAJevSSYL19HzAS2C8iW0TkWqv9n+hh/Ssiki8iPxeRoJY/Smkf/lfRN80CEXlFROzj8hYwVkSGAVcApUqpzdZ730K7TjaLyF4Ruff8Q9ZECvANESmxH+ienOfx7/DxuACr0TeJqcBudI93HvoGka2UKurg94DH/xx9Uwq9QBbOVKVUjMfjw07syyYFeMPjOGUBjehRmk1759cZ662BF9hPy/N9EPqasDmKNiCe++3o/ygF+J3HbyhGnyvJ7ey/Nbpzfy05o86NxVRZ35eA9ii0PBb2dw1qod1zO6/CGJGLQCm1H937G+/RnGwFzW2GokcnTR/r4u5OAnEiEu7RNsRDy0NKqUjr8bPOfrmIXIaOWXwKPdyOQbvixPr+Q0qpz6CH+f8PeE1EIpRS9UqpHymlxgKXomMSd7a2D6XUS0qpOeiLUVnfg1KqBu2T/xzwebRhsj9zSin1gFJqELqn9qd2MmCOA4+3uMGGK6Ve7uzx6ADr0b3om4DVSql96P/1NWgD0xpd/d93lEr06NUmqZ1tj6Pdb57HKlQpdcJjmya9rZxfB6zvuOUCmlr+5nz0/9/GHmGfpvMcB77Q4jeEKaXWt7P/i6Ej++soRegRWMtjYR//k3hc39Z7XokxIp1AREZbvfXB1ushwGfQvmWb/sCXRSRIRG5Du7+WXuy+lVJH0YHtH4pIsIhcgnZHdRdR6Iu5EAgUkcfQMSAAROQOEUlUOpusxGpuFJHLRWSCiLjQbpZ6dI/2HERklIgsEJEQtN+5usV2L6DdH9ej3XT2526zjzfavaY8Pnca7Vu3eRZ4SERmiiZCRK4RkaiuHBBrXsXdrb1njQi3ogOettFYjzZ0bRmR00C8iER3RU8H2AFcLSJxIpKEHvm1xdPA4yKSAiAiiSJyQ0d3ZI22vw78QETuEZF+IhJgpcA/085HXwa+JiJpIhIJ/AydLNGVzKmngUdFZJz1G6Kta66nuND+Wp6PbaKUakR3nB4XkSjr//B1ms/9f6PvI4NFJBadBOGVGCPSOcrRQdtNIlKJNh570EFom03ACHRP43HgVqXUmZZf1EU+B1yCdiX8FHiVLqQXt8GHaJ/vQfTQuYZzh9OLgb0iUoHO4rrdGkEkAa+hDUgW+gba2uS5EHTMoAjtvukPNLndlFLr0JlL25RSuR6fm44+3hXo+NNXlFI51ns/BJ633AufUkplopMS/og2ONlow9RpRCQYnWSwsZ3NVqMDpps9Xkeh40fnYY1cXwaOWJoHtbZdB9jZYp6I7U79J7ATHfv4CH1+tMXv0MfzIxEpR//OmZ0RoZR6DR3Puhc9wjiNPi/faudjf7d0rkFnH9agY1GdRin1Bno0+4qIlKGvxSVd+a5u2t8P8TgfO/CV/4MePR5BZ2W+hD4+oDtEH6L/n9vQCQhNWO7Fp7v+a7oPO+vH0A1Yvdb7LZdNb+zvVWC/Uur/emN/PY2IrABeUkr91Qu0zAEetlx4BoOhDcxIxIcQkekikm65DRYDN6DTEX0e0bP+p9J+77nXUEqtNQbEYLgwZsa6b5GEHtbGo1OMv6iU2u6spItHRJ5H5+B/RSlV7rQeg8HQcYw7y2AwGAxdxrizDAaDwdBljBExGAwGQ5cxRsRgMBgMXcYYEYPBYDB0GWNEDAaDwdBljBExGAwGQ5cxRsRgMBgMXcYYEYPBYDB0GWNEDAaDwdBljBExGAwGQ5cxRsRgMBgMXcYYEYPBYDB0GWNEDAaDwdBljBExGAwGQ5cxRsRgMBgMXcYYEYPBYDB0Gb9f2TAhIUGlpqY6LcNgMBh8iq1btxYppRIvtJ3fG5HU1FQyMzOdlmEwGAw+hYgc7ch2xp1lMBgMhi5jjIjBYDAYuowxIgaDwWDoMsaIGAwGg6HLGCNiMBgMhi7jNUZERIaIyEoRyRKRvSLylVa2ERH5vYhki8guEZnqhFaDwWAwaLwpxbcB+IZSapuIRAFbReRjpdQ+j22WACOsx0zgz9Zfg8FgMDiA1xgRpdRJ4KT1vFxEsoBkwNOI3AC8oJRSwEYRiRGRgdZnu5/T+yA+HQJDeuTrDf7PmYpa3t6Zz668UgrKa0iIDGHqkGjuGtkA9VUQHgcxQ52WafBRlFJsO3aW93ef4mhxFXUNblLiw7lmVBQzIwogKglihvSoBq8xIp6ISCowBdjU4q1k4LjH6zyr7RwjIiIPAg8CDB3axQtUKfjg23BiG6QvgHnfhqTxXfsuQ5+jqq6B3y0/xN/X5lDfqABIoJTLA9/mlkPrYUsMhEZD+SkICoXp9+tHcITDyg2+wu68Ur77xm52nyi1WhSzA/awJOctpu7Kgf6j4JKH+54REZFI4L/AV5VSZS3fbuUj6rwGpZ4BngHIyMg47/0OCqH41v/y3uYs7gj5BPnnTTD18zD/u+DyusNm8DK+8soOPt53GhFYMLo/98buZMa+n3J04BJOX/o+kSPHAXD8TCX1+TsZlvU0bPkr3PYcJE9zVrzB66mua+TBf2ZyslSPbm+fFMNnT/+K6JJ9rBt8PyVX3UlibHSvaPGqu6GIBKENyItKqddb2SQP8DSrg4H8ntCilOIL/8xkS+5Z9mTM5YmHPkXA6/fDy5+GT7+oe48GQxs8du1Yquoa+OZVo5l8+GnY8RLc9QYjBk1p2uZsZR13/WMLheW1/O3u3zKjei28+Cm45pcw7iYH1Ru8nbBgF8/emcE7O/P5yswowl++GVIugbv+wZW9fG/ypuwsAf4GZCmlft3GZm8Dd1pZWrOA0p6Kh4gIX5ibTmhQAK9mHueJNUVwx+vaBfHq56Chtid2a/Bhquoamp4PiQvnxftnMfnwX2DvG3D/cvAwIKBvBKOSoiivbeC+57dwIO5yuPNNWPot2PdWb8s3+ADZBRVNz8cnR/Po3HjCX74JJt4G1/3Okc6t1xgRYDbweWCBiOywHleLyEMi8pC1zVLgCJANPAt8qScFLRo7gL/dNZ0gl/DsJzn8a8sJuOkZcIXA0m/25K4NPkZFbQPX/WEtv1t2CJ33Aex8FXa+DHe9A5HnF0MNDXLxx89OZcn4JMprGrjnH5s5EzkS7ngN3v2ajscZDBbv7Mznit+s5m9rc3RDQx28egeMuR7mOnc/8hojopRaq5QSpdREpdRk67FUKfW0UuppaxullHpYKZWulJqglOrx8ryzhyfw5M0TAfjxu/vIKqiCm/8CxzfB1ud6evcGH+GxN/dwuLCSpbtPUlPvhpO74MNH4faXILJ/m59zBQi/+fRkpg6NIb+0hm++tguVNBGu/S38+06oLOrFX2HwVo6eqeTR13ejlEdg+MNHITweLv+ek9K8x4h4M7dMG8xnZgylrsHN/7y8nZqAcPj0v2DZj+DMYaflGRzmrR0neH37CcKCXDz1uSmEBTTA6w/AVU/AgLEX/Lw9IokOC2LF/gJe2HAUxl4P426E977eC7/A4M00NLr58is7qKhtYMn4JO6ZnQoHP4RDH8NNT0OAs7dxY0Q6yA+uHcPIAZFcNiIBt1KQMALmfQve/BK4G52WZ3CIs5V1/OgdPZXpsevGMrx/FKx6EuKHw8RPdfh7BsWE8eTNExCB/JJq3Xj596EgC/a0lmNi6Cu8sOEoO4+XMDA6lCdvnojUlMA7X4UbntIxWofxquwsbyY8OJB3/+cyggM97O6ML+gA6NbnYPp9jmkzOMcT72dRXFnHrGFx3D59iJ6guu0F+NIGkNYy0ttmyYSBLP/6PIYlRuqGoFC48c/wymdh+EKvuGEYepeTpdX86qMDAPz4hvFEhwfBOz+C0VdD2mUOq9OYkUgn8DQgDY1uPYxc8nNY9QRUn3VQmcEJdh4v4d+ZeQS7Anj8pgnaV/3Bt/XE1HbiIO3RZEBsBmfAiCthzS8uWq/B9/jFhweorGvkqnEDuGLsAB1r2/8uLPi+09KaMEakC3yw5xQLf72a9dlFMHAijL4GVv0/p2UZepnosCCuHDuAe+akkp4YCfvfg4pCyLj3or5XKcWK/af5yivbcbsVLHwMtr8IRdndpNzgK3xt0UhumTqY718z1qqi8SjMfxTCYp2W1oQxIl0gu6Cco2eqePKD/Tqd8/Lv61TOkuMX/rDBb0hNiOCZOzP49lWjdVxsxU/gyp9cdEWD2gY33319D2/tyOedXfl6VHPJw7DqZ92k3OArDIkL51efmsSQuHDIXg6VhTD1LqdlnYMxIl3g3jlpJEaFsCuvlI/3ndZzADLuMS6HPkpAgOjgd0g/GL7oor8vNMjF168YCcBvPj5Io1vBzIcgZ42OuRj8nrKa+ub5RqBHISsfh/nf8bqyS8aIdIHw4EC+OC8dgD+vPqz/2Zd+GbLehuIch9UZepr12UV89tmNbDpyRje4G2H1k7Dge50OprfFzVOTGRIXRu6ZKj7YcwpCIvU5tuqJbvl+g3fz1Vd2cO0f1pJ10iofePBDXSVj7I3OCmsFY0S6yO0zhhATHsT2YyVszinWJb2n3QMb/+S0NEMP86dVh1l/+Iz+vwNkvQNhcZA2r9v2EegK4MG5dkclW3dUpt8PR9ebuUl+TtbJMlbsL+BwYQX9o6xlKNb+Bub+r+NzQlrD+xT5COHBgdx9aSqgRyMAzHgQdv0bqoqdE2boUXbllbA2u4iIYBd3XpKqGzc8BZc+0m2jEJvbpg0mITKYPSfKWJtdBMHh2m264alu3Y/Bu/jzKn0/uX36UOIjQyAvE8rzdXkTL8QYkYvgrktSCQtysf9kOaXV9dBvIIxaYsqh+DF/Wqkv8Dtmpeic/eObobIARl/b7fsKDXJx75w0AJ5ff1Q3Tn8A9rxmOip+yrEzVby7K5/AAOGBucN044Y/wswvel0sxMY7VfkIsRHBvPTATMYO6kdIoEs3XvIwvHgbXPIIBAY7K9DQrZwoqeajfacIcknTzZ31f4BZX4IAV4/s845ZKQQFBHD7DGsFhKgBMPo6yPybo0X3DD3DPzfm4lZw45RBJMeEwdmjcGQVXPd7p6W1iRmJXCRThsY2GxCApAmQMBL2/Nc5UYYe4eVNx3ArWDx+IAP6heokity1MPlzPbbPfqFBPDB3GFGhQc2NlzwMm581yxH4GTX1jfxnax6gvRwAbHoaptwBof2cE3YBjBHpJkqr6tljL1M560t6lTqD3+B2K97YfgKAO2ZaSy5v/QdM/qzOnOoF6hrc1DY06qKO/cfogL7Bbzh0ugKlYEJyNJOGxEBdlZ5/NuNBp6W1izEi3cCeE6XMfGIZX355u86iGb4IyvLh9F6npRm6iYAA4e1HZvP4TeOZkRan13LY8TJMu7tX9v/qlmNc8sRy/pOpe6pMvQu2Pd8r+zb0DhMGR7Ppuwv5w2esxcv2vQXJGRAz1FlhF8AYkW5gdFIUMWHBHCmqZMORMzoANuUO2Goucn8iPjKEz81MQUTg4Ae6knPCiF7Zd2iQizOVdby46ZjuqIy+Rk88LD7SK/s39A6hQS5SEyL0i20vwNQ7nRXUAbzKiIjI30WkQET2tPH+fBEp9Vj58LHe1tgaga7mwOeLG4/pxil3wO7/QH21g8oM3UFVXYOeNe7Jtud7tfzE4vFJxEcEk3WyjG3HSiAwBCbdDtv+2WsaDD3H1qNnqahtXl6ZwoNQfFhne3o5XmVEgOeAxRfY5hOPlQ9/3AuaOsSnpw9BBD7ed5rSqnqITYFBk43f2g94amU2c/7fCt7ffVI3lByHE1v1wlG9REigi1unDQbgv9tsl9adsOMlaKzvNR2G7qemvpF7/rGZ6T9dxumyGt24/QWY9BlwBbX/YS/Aq4yIUmoN4JMJ8AOjw5idnkBdo5t3d+frxql3GZeWj+N2K97cns/J0hpiI6yU7e3/ggm3QVBYr2q5eao2Iu/uzKemvhESR0Fsqi6JYfBZVuwvoKymgfT+ETrrr6EOdr7iE64s8DIj0kEuEZGdIvK+iIxrbQMReVBEMkUks7CwsNeE3TQlGYA3tuksHkZdDQX7oORYr2kwdC+bcoo5UVJNckwYM1LjdCG8Xa/orKxeZlRSFGMH9qOspoGV+wt04+TPaj0Gn+V1a2R50xTdSeDwcr0yZny6g6o6jq8ZkW1AilJqEvAH4M3WNlJKPaOUylBKZSQmJvaauMXjkwgPdhHoEt1TDAzWLg8zZ8RnsS/wm6cm62q9eZkQEAQDJzui5+apuqOy5lCRbhh7PRxZDdUljugxXBxnKmpZdaAQV4Bw/aRBunH3f/RI10fwKSOilCpTSlVYz5cCQSKS4LCsJiJCAtnwnYW88uAlhAZZExAnfAp2v+asMEOXqK5rZKkVB7FHmez+j147vZvrZHWUm6cO5r9fvJSf3TReN4TFQtpcE3vzUd7ZmU+DWzFvZCKJUSFQWw6Hlnlltd628CkjIiJJIvrqFZEZaP1nnFV1LtHhLQJhQy/RvUSzDoTP8dG+U1TWNTJ5SIxetraxAfa+DuNvcUxTXEQw01JiEU8jNuE2bdwMPsfr1gRWe4TJ/qWQcglExDuoqnN4lRERkZeBDcAoEckTkftE5CERecja5FZgj4jsBH4P3K7OWbnFO1BKsSuvhOPFVbp084RbzEXug6w+qONpN0623Aw5q/TELy/xVZdWWVlZI6+Ckzug7KSzggydoqpOp/RGhgSyaMwA3bj73z7lygIQL7wHdysZGRkqMzOzV/f5q48O8IcV2Xxh7jAevXoMnNoNL38WvrrLMTeIofM0uhWZucUM7x+pS3K//gUYNAVmPXThD/cgSinu/scW1mYXsf47C3RGz5tfggHjdF0tg09xtrJOZ/5VFMIfpsE3siA4wmlZiMhWpVTGhbbzqpGIvzBnuA7TvLf7pJ5dPGC8Xgsib4vDygydwRUgzBwWrw1IfQ0ceB/G3eS0LESEkMAAGt2qee7KhFtN7M1HaUod3/cmjLzSKwxIZzBGpAfISI0jMSqEvLPV7D5RqkcfY2/QtXAMPkF1XeO5DUdWQtJ4XYrdC7hm4kAAlu4+pRtSL4OzuXoipMHrKaqo5cCp8nPXUc96W98nfAxjRHoAV4CwZHwS4HGRj7lenyR+7j70B8pr6sn46cfc9ffN1De6deO+t71qZbkFo/sTHBjAlqPFFJTV6JnNo66G/e86Lc3QAf6TmcdVv13D4+9l6YbKM5C/A9IXOiusCxgj0kNcPcHuKdourXEgLji502FlhguxPKuAyrpGqusaCXIF6LIiB9+HMd2/emFXiQoNYu6IRJSC9/fYHZXrtLEzeD126nhGapxuOLAU0i/Xbm8fwxiRHmJ6ahwJkSEcK65ib36Z5dK63uTz+wD2BX71BD2aJPcTiBsG0YMdVHU+10zU+t6z4yLpl0PBXig/7aAqw4U4XlzF7hOlRAS7mD/Kmgyd5V0j3c5gjEgP4QoQFo8fQGx4kE71BRhzgz5ZDF5LTX0jaw7p1N7F4/Vo0ttcWTaLxgwg2BXA9mNnKaup15V9h18BB95zWpqhHT7ap438/NH99aTkmlI4ugFGXOmwsq5h1ljvQb61eDQ/un48rgArrTd5KtRVQsF+6D/aWXGGVlmXXURNvZuJg6NJig4FdyPsfw/u874ih1GhQfzt7gzGD4qmn7187pjrYOtzkHGvo9oMbbPMMiJXjrWSNA5+BKmzvXoJ3PYwI5EepF9oULMBAe3SGnOdcWl5Mcuy9AXeNPnr+GaI7K/dWV7IZSMSm1NEAUZcoet7VZ91TpShTUqr6tmcW4wrQJg/sr9uzHpb3xd8FGNEeoHymnqOnqnUL0Yt0aviGbwOpRQrrOq4TUbk4Ac+sTCQ2630wlnBEbpXe3iF05IMrXCwoJzwIBczUuN0iaSGOl1Ac8RVTkvrMsaI9DBrDhYy9Scf8/03rcUah14KRYegosBZYYbzEBHeeWQOv7xtEmMGRunGgx/CyAutk+Ysf1qVzawnlvOJFcth5FVwwHRUvJHpqXFs/cEV/PrTk3TD0XWQOBIie6/aeHdjjEgPMz45mka3YuORM5TX1Ovy8Onz4dDHTksztEL/fqHcOm2wLnB4NheqimDQVKdltUtNXSMF5bVNrjhGXAXZH+uCkQavIzgwgIHR1oJmBz/URt+HMUakh4mLCCYjJY76RsWag9YaECMXG5eWF3JeHbmDH+kbcoB3XyaLrADt8qwC/Ruik3U6simz41UUV9adWwlBKT3/aKT3u0vbw7uvDj9h0VgdQGvqKQ6/QvtBG+ocVGXw5HhxFXN/sZJffXSgufHgBz7RSxw/KJoB/UI4WVqj5ySB6ah4Ib9ffogpP/mI17bqhc4oOqhHiwNaXaDVZzBGpBdYaAVpVx4ooKHRrf2fiSO1P9TgFSzLOs3x4mqOFFkJELUVOjMr/XJnhXWAgABpOseaOiojF5u1170IpRTLsk5TU+9mWKJVYNHupPh4ZW9jRHqB9MRIhiVEUFJVz9ajVurlyKvMRe5FLM/SiQ5X2FlZR1bC4AwIiXJQVcdZNEaPdu3fwaCpOp5zNtc5UYYmDpwuJ+9sNQmRwUweHKMbfSBpoyMYI9JLLLQu8l15pbph5GLtDzUFGR2nsraBzTnFBAjMG2llyRz8wKcu8EvTEwgNCmD3iVJdkDEgQM+APviR09IMwKoDOnNu/qj+BAQIVBXDyV2QdpnDyi4erzIiIvJ3ESkQkT1tvC8i8nsRyRaRXSLi3WkzHtw3ZxibvruQB+Zak9YGjNf+0KKDzgozsPHIGeoa3UwaEqMn7rnd+uY70nfKUIQGufjpjRN47aFLiLMnH468ysRFvITVTUbE6qQcXgGpcyAozEFV3YNXGRHgOaC97t8SYIT1eBD4cy9o6haSokP1CnQ2IuYi9xLsZXDnjrAu8JPbISzGa2ept8Wt0waTkRpHoMu6rIddruM6tRXOCuvjVNQ2kHlUj3TtBev0SNd3Oint4VVGRCm1BihuZ5MbgBeUZiMQIyIDe0dd96CUak7zG74Ispc7K8jQZETm2b0oQmttAAAgAElEQVTE7OU+WwzvHEL7waDJkLvWaSV9mm1Hz1LfqJg8JIaYcGuke3iFztL0A7zKiHSAZMBz6bY8q+0cRORBEckUkczCwsJeE3chNhw+w9xfrOSbr1lriqRdBie26qKMBkdQSvH4jRP44vx0JtkBz8MrfCIrqzX+k3mcO/66iV15Jbph+EI4bDoqTjJ3ZCJrvnk5P7zeSuU9tRPC4yFmiLPCuglfMyKt5cKdF5lWSj2jlMpQSmUkJnpPOYGk6FCOF1fzyaEiXecoJAoGToZck+rrFCLCnBEJfHvxaF0ss6YUTu2GlNlOS+sSO/NKWJtdxMr9VucpfYGpo+UFDI0PZ6LdScle7pMrGLaFrxmRPMDTfA8G8h3S0mlS48MZGhdOaXU9O+2eYvrl5iL3JnLWwJAZPhvwnGdVhl190Er1HTBBG8azRx1U1Xc5rwoCWCPdBb0vpofwNSPyNnCnlaU1CyhVSp10WlRHEZGmFNI1lh/euBuco6a+kS/+ayv/2ni0+WL38Qv8kvR4glzCjuMllFbV61Tf9AXmHHOI59bncuVvVvPm9hO6obZcL5Gd6psj3dbwKiMiIi8DG4BRIpInIveJyEMi8pC1yVLgCJANPAt8ySGpXWauZUTsYC5Jk6DqDJQcb+dThp4gM/cs7+85xYubjumCi0r5vKshMiSQaSmxuBWszbZqtRmXlmOsOVjIwdMVNLitTkrOJ5A8TZfs9xO8yogopT6jlBqolApSSg1WSv1NKfW0Uupp632llHpYKZWulJqglMp0WnNnsXuKO4+XcLayTvcUhxmXlhPYLp+mCYbFR6CxDvqPcVDVxXOeSyt9gXbTmaq+vUpNfSMbjpwBYO4IK7X38HKfHum2hlcZkb5AZEggGSlx5/YUjUvLEZpSe0d6TABLX+DztYzmeYx2lVJ6ZcaYoXDC5/pcPk1m7llq6t2MHdiP/vYcscMr9PXuR5g11h3gK4tG8Ih7ONNSYnVD+gL44FHdU3SZf0lvUFBWw8HTFYQFuZr/D9nLYcKtzgrrBsYMjOK2aYOZNCSGBrciyCXNLq2hs5yW12ewO4mX2aOQ4hw98bO/b1ftbYkZiTjArGHxzB6eQGiQSzdEJUG/ZMjf7qywPsT6w9rNMCMtjuDAAF2W/+g67Vr0cUSEX9w2iTtmpRBkz15PX2gmtvYy6ywjMnt4C1eWl69P01n869f4MsNNBk1v0nyBx+uGvM0Qnw4R8Q6q6kGGzoLCA7rwn6HHKamqY09+KcGuAKanxunGwyv9Lh4Cxog4xsr9Bdz//Bbe2G4tUDPscr1QlaFXmJEWx+WjErnMrpeVswaGzXdSUreilGLl/gKeeD9Lr2ETGAJDZ5oSKL1EaJCLZz+fwXevHk1YsAvcjfrYD5vntLRuxzjgHSLvbBXLsgoICXJx05TBuqd4cqcugeJH6X/eym0ZQ7gtw2Peau5auOzrzgnqZkSEH72zl9wzVVw1LompQ2MhbR7krIax1zstz+8JDXI1LVsMwOk9EJGoXdd+hhmJOITtJ91w+Axut9KGY9BkOLbBYWV9kPpqyN8BQ/wr6HypdY6tt7MA0+bqEZeh98ld6xdrh7SGMSIOkZYQwcDoUIor69h/qtxqnGtcWr3A2zvz9RoiDW7dkLcFBoyFkEhnhXUzdtnxddk6iYCkiVBZCGU+UynIJzlZWs0jL21rnqUO2oikznFOVA9ijIhDiAiXptsXud1TtNwNhh7D7VY89tYebn9mI/kl1boxdy2k+l8v8ZJh8YjA1mNnqalv1FlBqZfpWdOGHmPtoSLe3XWSd3dZxtrdqDP/UowRMXQzc0boTKB1hy0jkjwNzhwxGTQ9yL6TZZRU1ZMcE0ZKfLhuzPnEL3uJsRHBjB3Yj7oGN5m5Z3Vj2lzTUelh7PRxu5PIqd0QOQCiBrTzKd/FGBEHsU+yzTnF2rUSGGwyaHoYz9ReEYG6Kp3QMGSmw8p6Btul1VQdYdh8HRdprbqs4aJRSjUd6zn2JEM/dmWBMSKOMqBfKHfMGsr/XjlKry8CJvjZw6yzeolNE8DytsCAcX4XD7G5dHgC6YkRxNvrrscPB3eDrhNm6HayCyooLK8lMSqEEf2tc8pP3aU2JsXXYX5644RzG9LmwesPOCPGz6ltaGRzTgtXgx9nzYAu/Lf8G/ObG0SaY2/x6Y7p8lfske6l6dZI190Ix9bD9b93WFnPYUYi3kbSBCuDxmeWSfEZth8roabezagBUSRGhejGXP+Mh9hIa8UkzWi3x1ib3WKke2oXRCbpIph+ijEiXsCGw2f4+Qf7qaxtgACXvqmZi7zbKamqZ1B0aPMFXlcFJ3f5bTzEkxMl1Ww75hlcXwNut7Oi/JA5w+OZPTy++Rzz83gIeJkREZHFInJARLJF5DutvH+3iBSKyA7rcb8TOrubJz/Yz59WHWZzrpWVlTbPGJEeYPH4JNZ9ZwHfXjJKN+RthqTxfl8hYOfxEmY/uYL//c9O3RAzBEKjoWCfs8L8kLtnp/Hi/bNIjrGWV/Zzdyl4kRERERfwFLAEGAt8RkTGtrLpq0qpydbjr70qsoe4NF2n+m464mlEVpsMmh5ARAgJtKon+3nA02bsoH6EBbk4UlhJQXmNbjRzknoedyMc3eC380NsvMaIADOAbKXUEaVUHfAKcIPDmnqFmWm6yudGaxU0EkaYDJpupqiiluLKunMb/XR+SEuCXAFkpOo1U5o7KiYu0t28szOfrUfPUt9ouQlP7oR+AyEy0VlhPYw3GZFkwHOh8TyrrSW3iMguEXlNRIa08j4i8qCIZIpIZmFhYU9o7VYyUuNwBQi7T5RSUdtgZdCYi7w7eX59LlN/8jF/WpWtG+oq9SSwITOcFdZLzBqmR7tNHZW0uXB0vVkyt5toaHTz6Ou7ueXP6ymqqNWNfSAeAt5lRFpbk7SlP+cdIFUpNRFYBjzf2hcppZ5RSmUopTISE72/FxAZEsiE5Gga3YpMOy6SOkeXSjB0C/bNc2T/KN1wfLPOhPPzeIjNeUYkIgGiB8OpnQ6q8h/2nSyjoraBlPhwBkZ7xEP6gLvUm4xIHuA5shgMnFMpTil1RillmXmeBab1krYep/ki9zAiuWtNXKQbqK5rZOfxUkRguuU67Cu9RJuJg6MJC3JxuLCSwnLrEkqZbaojdBO2cZ6VZi1q1tgAxzbqY+zneJMR2QKMEJE0EQkGbgfe9txARAZ6vLweyOpFfT3KrGFxDI0Lp1+YNf8zNg0QExfpBrYfO0tdo5uxA/sRHRakG3M/8fusGU/suEiQSzhgV41OnQO5ZrTbHdixppnDrE7KqZ3Qb5Dfx0PAi2asK6UaROQR4EPABfxdKbVXRH4MZCql3ga+LCLXAw1AMXC3Y4K7mXkjE1nzLY/1vUWaRyNmZvFFYfcSZ9q9xLpKOLUHBveNeIjNk7dMJC48WK+0B7qX/PaXdRZRgMtZcT5Mo1uxOcc2ItY51odGul5jRACUUkuBpS3aHvN4/ijwaG/r6g1anVmcOlvHRabd1fuC/IiN1gU+y+4lHt8EAydCcLiDqnqfprkLNpGJOnvo1C4YNMUZUX7AvvwyymsbGBoXfu78kCl3OCusl/Amd5YBKCivIetkmX6RepmJi1wkdQ1uduWVIKLXVQf6VC+xNRrdqjkN1R7tGrpMQXkNCZEhTan6fSkeAsaIeBUbDp9hxuPLefT13bohbhgoN5zNcVaYDxMcGMCmRxfx4n0ziQm3Ktn2kayZ1vjtsoNM+fFHfLj3lG5ImW3iIhfJwjED2PK9hfzohnG64eROnfkWkeCssF7CGBEvYsLg6PPni5iL/KKJDg9qWm+c2gorHjLdWVEOEeQKoKymoTnVN3WOrjLrbnRWmI8jIoQHW9EBPy/q2RJjRLyINueLGHdD93F8Ewyc1OfiITZ2XKgplTyyv1517/QeB1X5LmU19ZTV1J/b2MdGusaIeBmtzhc5us7ERbpATX0jc3++kq+8sr150a8+Hg+ZkBxDWJCrafEkwHRULoL/ZOYx+Ucf8euPD+qGxgbdUekj8RAwRsTraO4pWu6G+OHQWAclRx1U5ZvsOF7CseIqDpwqxxVgZb/1cSMSHOhRRyvHw6VlXKZdYuORM7gVDI2zRrYnd0D0EIiId1ZYL2KMiJfRah0tExfpEk2ziO3c/doKOL23z9TLaovzSqCkWKNds75Ip3B7zg9pyvzrW/EQ6IAREZG4DjxiekNsX8COiyil2N+U6mvcDV3BnkXcPD9kIwyaDEFh7XzK/zkvLhI1ACISTVykk+w/VU5pdT3JMWEMsUcifWD9kJZ0ZLJhvvVorUCijQsY2i2KDPzqU5PoHxVCVKhVoiN1Dqz7rbOifIzahsamlfxmpPW9WcTtMSE5hh9cO7bZuELzxNaBE50T5mM0VUKwj2NjPRzbBDc/66Cq3qcj7qwspdQwpVRaWw/gTE8L7UukJ0Y2GxCAhJFQXw1nTVyko+w8Xkptg15PPS7Cc36IMSLBgQHcNyeNcYOimxvtia2GDmPHlJqKLp7cCbEpEB7Xzqf8j44YkUu6aRtDJ1FK6awiu46WKQ3fYZrjIdYFXVsOp/f1uXpZHSZltomLdAKlmuMhTTG3nDV9spNyQSOilKrpjm0MneNXHx1g+uPLWJtdpBtMcL1TXDF2AP975UiumThINxzbpOtDBYU6K8xLKK+p55cfHuCrr2zXDf0GQlicWXe9g4gIH31tHn/5/DSGxPWt9UNa0uHsLBHJEJE3RGSbtbLgbhHZ1ZPi+jJ1jW6KKurYcNhOw7xMZ34YOsSYgf14ZMEIj3pZfS9rpj1Cg1z8bW0Ob+7I95gvMtuMdjtBYlQIV41L0sVTG+v1Qmcplzotq9fpTIrvi8A/gFuA64Brrb+GHsAeIjfl8ieO0iXMS4638ylDm5h4yDl4rrtuu2VMR+UiyN8Bsal9Lh4CnTMihUqpt5VSOUqpo/ajx5T1cTJSYnEFCLvySqm054uYnmKHeGdnPk+tzCa3qFI31JZD4f4+Wy+rLc6fLzJbr7tu4iLt4nYrrvvDWv73PzupqbdqjuX2zXgIdM6I/J+I/FVEPiMiN9uPHlPWx4kKDWL8oH40uhVbj+pUVVLMfJGO8OqW4/ziwwPszbfm2RzbaOIhrWBPkGsyItHJENJPG1xDmxwsKGf3iVLWHioiJNC6hfbB+SE2nTEi9wCTgcVoN5bt0uo2RGSxiBwQkWwR+U4r74eIyKvW+5tEJLU79+9tnNdTNJMOL0hdg5vMoy2WKjXxkFaZODiG0KAADhVUUFRh6mh1FM9JrM3xkC0wtG8mqXbGiExSSmUope5SSt1jPe7tLiEi4gKeApYAY4HPiMjYFpvdB5xVSg0HfgP8v+7avzdynhFJHA21ZVB6wkFV3s3uEyXU1LsZ3j+ShMgQ3WjiIa0SHBjAtJSWcZE5cNQYkfY4r5xO/naIS+2T8RDonBHZ2MpNvTuZAWQrpY4opeqAV4AbWmxzA/C89fw1YKG0uq6sf5CRGsu3F4/mseusxW4CAnT2h4mLtMnGlqVOasqg8AAkZzioyntZMn4gn8oYzMBoy9Vnp5KbqtGtopRiU8v11HPW9MnUXpvOrLE+B7hLRHKAWnQZFKWU6q46CcmAZ+pRHjCzrW2UUg0iUgrEA0WeG4nIg8CDAEOH+m41lqjQIL44P/3cRntm8cRPOSPKyzmvl2jiIe1yx6wUIKW5IWYIhERqw9t/tGO6vJVDBRUUV9YxoF8IqfEe9bJmPOisMAfpjBFZ3GMqNK2NKFp2hzqyDUqpZ4BnADIyMvyrS5UyGzb9xWkVXkl9o5vMXLtelmc8pO/2ErtEyhx93IwROQ/PToqIQEMd5G2B2/7hsDLn6LA7yzOtt4dSfPOAIR6vB6MLP7a6jYgEAtFAcTdq8DrOVtbx++WH+PE71kzi/mOhuhjKWh4aQ1l1PQvH9GdmWhz9o6yRh4mHXJCiilre3ZXPnhOlusEE19tkemocX14wnOsnWZUQ8rdD3DAIi3VWmIN0pBT8tu7YpgNsAUaISJqIBAO3A2+32OZt4C7r+a3ACqX823kbECD8ZtlB/rkxl+q6RisuYkqgtEZ8ZAh//OxUXv2ClSVTUwZFB2GwiYe0x4sbj/HIS9t5bWuebrDnI/n3pdUlxgzsx9evHMXCMQN0Q27fjodAx0YiY6wyJ209dgMJFytEKdUAPAJ8CGQB/1ZK7RWRH4vI9dZmfwPiRSQb+DpwXhqwvxEdFsS4Qf2ob1RNpc1Jvcxk0HSEYxsgeSoEhjitxKs5bzXNmKEQFK4NsKF9+vD8EJuOxEQ64hhtvFghAEqppcDSFm2PeTyvAW7rjn35EjPT4tlzooyNR84we3iC7ilu6VtrFlyIhkY3aw4VkpEaRz+7jL6Jh3SISUNiCAkMYP+pcs5W1hEbEWy5tD7R5XYMAKw6UEB2QQWLxgwgNSHCiodkwm19c36ITUeq+LYaC2nxyOsNsX2Vpjpa9kp0/cdB1RkoO+mgKu9iT34Z9z6XyU1Pebj5TDykQ4QGuZgyVC9OuslzvoiJi5zDa1vz+Ol7Wc2VtfO3QXw6hPXthV3NGus+wIzUOERgx/ESXavHjouY+SJN2K6YplUMa0qh6BAkT3NQle9wXsHPlNnaiJi4CKDnhzTPQbLnh5iRLhgj4hNEhwcxJqkfdY1uj7iI6Sl6ct4iVEc3aANi4iEdYmaaXR3BGonEpui16IsOOajKezhcWElRRS0JkSGkJ0boRuMuBTq3nshv/Xl2uLdz9YQkbpw8iMgQK4xl9xQNNDS62dJylTlzgXeKKUNjCAtyERwYQF2DVcXXni9iOKeToueH1MKJrTB0lsPKnKczkw0rgLdF5HalVKWIXAn8n1Jqdg9pM3jwyIIR5zYMGA+VhVB+CqKSnBHlJezJL6OyrpFhCREM6OcxP2Txk84K8yFCg1xsf+wKQoNczY2pcyB7GUy/zzlhXsJ5lRBObIP44X0+HgKdm2z4feBlYJWIrAW+QR9IsfVamuaLmNGIfYE31TKqLoEz2Tq919BhzjEg0Owy7eNxkVbjISZpo4nOuLMWAg8AlUAi8GWllBnr9iIlVXV8tPcURwordINZpAqAo2eqAI94yLGNJh7SRZRSHLOOJ7EpEBja5+MiFbUNTBkaw/D+kR7xkDWQNtdZYV5CZwLr3wN+oJSaj54t/qqILOgRVYZW+d3yQzz4z628tcMqeWKC6wA8cfMEtnxvEYuaZhF/0ucngHWFRrdi9pMrmPfLlZRW1evG1Nl9fmJrVGgQz96Zwcdfm+sRD9lm4iEWnXFnLVBKrbWe70av+/HTnhJmOB87g6YpDXPAeKg4DeWnHVTlHSRGhRBhJx2YoHqXcAUIg2PDUQo255r5Ii1pyis6sRUSRkBotLOCvIQup/gqpU4CC7tRi+EC2MuZbjtmzxdxWfNF+u5FXl3XolhCdQmcOQyDTDykK5xXAqWPx0WUUqzLLqKqrqG50cRDzuGi5okopaq7S4jhwsRGBDM6KYq6Bjc7j5foxj5ejPGhf23lsp+vaJ4/c2yDLrgYGOysMB9lZstJhzEp4ArWiQp9kMOFlXzur5tY9KvVNNV6zVkDqSYeYmMmG/oYzUvmGneDXj+kmOPF1STHhOlGM4v4opg6NJYgl7A3v4zS6noQ6dNZgPaIbGpKrHZn1deYeEgLjBHxMWyXVlNPMWkCVJyCigIHVTnDnhOlrcwP+cS4Gi6CsGAXk4fEoBRNEzj7ckfl/PkhmbooZWg/B1V5F8aI+Bgz0uIIEKiqa9TD6wAXDL2kT6b62qOxmXZqb1UxFOeYeMhFYidwbGkZXO9jcZE262WZzL9z6MyMdYMXEB8ZwvbHriQ6LKi50b7Ix93knDAHsEdjTRf40XUwdKaJh1wkn8oYwsIx/RmfbGUfxaZCQKBOWEgY7qi23qTNelmXfd1ZYV6GGYn4IOcYEOiT7gbPell2z1kHPE0v8WIZGh/OlKGxBLms24NIn5wvcl69rLoqyN8BQ0w8xBOvMCIiEiciH4vIIetvqwsWi0ijiOywHi2Xzu1TKKUoKK/RL5Im6rVFKgqdFdWL2PWy0hIiSIq24iE5n5hZxD1FH+yoHDpdDniMdI9v1DHIkEgHVXkfXmFE0DW4liulRgDLabsmV7VSarL1uL6Nbfye6rpGZj+5grk/X6krrga4dLZIH4qLjE6K4sX7Z/KdJdbCmxUFUJ4PAyc5K8xPWH+4iM/9dSO//thaIrcPxkV+dMN41n9nAddNHKQbTCelVbzFiNwAPG89fx640UEtXk9YsIuIkEBq6t3syrPmi/SxnmJokIvZwxO4apxVwTj3E52KGuBq/4OGDtHQqFiXfYbVB6ysv9g0kAAoPuKssF5mUEwY0eGW+zhnjQmqt4K3GJEB1gx4eyZ8/za2CxWRTBHZKCJtGhoRedDaLrOw0D9dPM3zRVrMLO6r5JiCeN3JtJRYXAHCnvwyyms854v0jZqr9Y3ucxtqyqBwPwye4YwgL6bXjIiILBORPa08bujE1wxVSmUAnwV+KyLprW2klHpGKZWhlMpITEzsFv3eRvNyplYaZtJEKDsBlUUOquod9pwo5f7nM3l9W15zowmqdysRIYFMHBxNo1uRedRzNc2+4TL9+r93svBXq5o7acc2wKApEBTqrDAvpNeMiFJqkVJqfCuPt4DTIjIQwPrb6sw5pVS+9fcIsAqY0kvyvY4Z1qTDzNyzOi7iCtRxkT4wGvnkUBHLsk6z2TagpXl6TfX+Y50V5mc0jXYPe452P/H7uIhSig2Hz3C4sJKESCtdPGcNpM1zVpiX4i3urLeBu6zndwFvtdxARGJFJMR6ngDMBvb1mkIvIzEqhBH9I6mub2SHXUcrbS7krHZWWC+w/rAebV06PEE35Fiz1AO85XT2Dy6xjMh624jEDQNx+f36IgdPV1BUUUv/qBDSE61MLOMubRNvueqeBK4QkUPAFdZrRCRDRP5qbTMGyBSRncBK4EmlVJ81IgCzrZuofVNl2Hw44t9GpKa+sWkm9aXpHuupmwu825meGkewK4A9+aWUVNXpuMiweX7fUVmXra+n2cMT9PwQuxKCWSmzVbxixrpS6gytlJVXSmUC91vP1wMTelmaV3PHrKEsHp/ElKHWOs/9x2m3TslxiBnirLgeYtuxs9TUuxmdFEVCZIh2reSsgTlfc1qa3xEW7OLhy4czoF8IgfbEw2HzYd9bMOMBJ6X1KLYRaeqk2JUQXEHtfKrv4hVGxNA1hvePYrhnHltAgE5BzFkNU+5wTFdPsj5bu1bsURhnc6CxHuL7TjmO3uQri0ac25A2F5Z+E9yNfplO3dDobkpWaTrHTNJGu3iLO8vQXQyb79curXWHbVeDZ0G8udrVYuh5opL04+QOp5X0CDvzSqmobSAtIYJBnssLGHdpm5iRiI+zJbeYp1ZmMyE5mm9cOUpnkKz8mXbz+OGN9aYpycRHhDDDs17WMJM105OsPljIyv0FPDQvXZeYSZunOyrJ05yW1u2MHdiPf9wznRp7xUxTCeGCmJGIj1Pf6GbVgUI+3metsx6XBoEhemKUH3LnJan89a4MIkMCtaE0QfUe54X1uTy3Ppe12R4JHH4aXA8LdnH5qP4smTBQN+SsMZUQLoAxIj7O1KGxhAQGsP9UOUUVtbpx2Hy/dmk1UXRQG8zYVKeV+DV2bMAOOJM6G/Iy9Sp//o7ppFwQY0R8nNAgV9PEw6Z8/jT/TMN8ds0R1h4qosEuSWHWuu4VPI2IUgpCoyFxNORtdlhZ97LpyBm+9OJWPthzqrnxyGoTVL8Axoj4AZemWxf5IaunmDZPl6dobHBQVfdSUFbD40uzeOCFTNz2hOnDKyD9ckd19QVGDogkITKEgvJasgsqdOOweXBklaO6upsVBwpYuvsU249ZZV6Kc6CuEgaMc1aYl2OMiB9gZyrZmUtEJup5IvnbHVTVvdijrOlpcQQHBui03tx12nVn6FFEpPkcy/bfia3npY8fWak7KX6YoNKdGCPiB4wbFE10WBB5Z6s5dqZKN6bNg5xVjurqTuyb1xw7tTcvE2JTICLBQVV9h9nWaHetdaNl8AydvFFT6qCq7qOkqo49+aUEuwKYnqrdwxxeCekLnBXmAxgj4ge4AoQvzU/nxzeMIyrUytoeNs9veopKqaaRiO26071Ec4H3FpcOj2fkgEjGDIzSDUGhMDjDb6r6bjxyBqVgytAYwoJdejJlzhoz0u0AZp6In/CFeS2q4qdcCq/dq9eFDg53RlQ3cfRMFSdKqokND2LswH668fAKWPB9Z4X1IQbHhvPR11rMx0mz4iKjr3ZEU3eytmmka3VS8rdDv2Q9sdLQLmYk4q+EROn1oI+ud1rJRbPmkF5Y7NL0BAICBKrPQkEWDJnlsLI+Tvrl2pj7OEop1hy0KiGMsIyISdroMMaI+BFbjxbzs6VZZJ0s0w3DF8Lh5c6K6gYCRBgcG8a8kdYCYzmfwJCZZoEgBzheXMX7u0/qF0mTtEE/e9RZURdJo1vx+VkpXDF2AJMGW8VMjRHpMMaI+BFvbD/BM2uONM9eH74Ispc5K6obuGNWCp9863JumTZYNxxeYeIhDlBZ28Dlv1zFwy9to7SqXhf89IOOSqArgAfmDuPZOzNwBYheCvfUbhh6qdPSfAJjRPyIuSN0T331QWtd+aRJei0EH+8pgk4zdQVYqZZ26qWhV4kICWRaSixu5ZFOnr4Qsn3biJxH7lpdF8zHY4m9hVcYERG5TUT2iohbRDLa2W6xiBwQkWwR+U5vavQFLh2eQGCAsP3Y2eaeYvoCn+4p7s4rpaDco7xG8RGorzZL4TrEvFFWR+WA1VFJX6Ddi431DqrqOrUNjfzm44NsPVrc3Gg6KZ3CK4wIsAe4GVjT1gYi4gKeApYAY4HPiIi5k3gQGRJIRqruKTYVyxu+yKd7it98bSczHhsHEZEAABx3SURBVF/O1qPWLOLDK2CYmQDmFHZcavXBQl0CJTJRF/087pslULbknOV3yw/x/Tf3NjdmL9fnmKFDeIURUUplKaUOXGCzGUC2UuqIUqoOeAW4oefV+RbzRupVqlYfLNANPtxTPF1Ww/5T5YQFuRifbKX2HvoYRlzhrLA+zNiB/UiMCuFUWQ2H7BIoPhx7szP/5o60srLOHIa6Ckia6KAq38IrjEgHSQaOe7zOs9rOQ0QeFJFMEcksLCzsFXHegj/1FO3YzqXp8YQEunTV2Nx1JqjuICLCZVYabJNLy4eNiP0bmjL/Dn0Mw6/QrmBDh+i1IyUiy0RkTyuPjo4mWvNfqFbaUEo9o5TKUEplJCYmdl20DzJmYBTTUmK5cmwS1fXWwjo+epHbRsT2w5O7VhfDC49zUJVh3shEQgIDOFtVpxsGZ+jkjfLTzgrrJKdKazhwupzwYBcZKdY5degjGHmls8J8jF6bsa6UWnSRX5EHDPF4PRjIv8jv9DtEhP9+sUVq4vBF8P63YNH/OSOqCzS6FWutqsTNvURzgXsDV41L4qpxSYQGWQs1uYJg2Fwdr5r8GWfFdYI1HiPd4MAAXbH3+Ca47R8OK/MtfGnMtgUYISJpIhIM3A687bAm38AHe4o7jpdQWl1Panw4KfERehXDQx/CiKucltbnCQ1yNRsQGx8c7TaNdJsmsa6BQVP0eimGDuMVRkREbhKRPOAS4D0R+dBqHyQiSwGUUg3AI8CHQBbwb6XU3ra+s69TUF7Dq1uOUVZTr3uK6fMh+2OnZXWYQ6fLCQwQ5o/SiQKcydbJAWZtB6+hvtHNkUI7uH6FTiX3oTVskqJDSYgMaT7HDn4II8xIt7N4RQFGpdQbwButtOcDV3u8Xgos7UVpPssjL21nc04xESGBXDtxEIy6GrLegSl3OC2tQ9w+YyhLJgyktsGK6xz8UGdlmdRer+B4cRVX//4TIoID2fDoAiQ6GWKGwvGNkDrHaXkd4gfXjuV7V4/R9diU0kH1z7/utCyfwytGIobuZ9EY3btaZpdAGXGlLg1fX+2gqs4RHRZE/yirPtahj0wv0YsYHBtGeLCLU2U17M23arWNuhoOvO+ssE4SYFdBKNgHAS5IGOmsIB/EGBE/ZdGYAQCs2F9AfaNbZzQNnKj9vl5OUUUtjW6PxLvacjixVZceN3gFItJ0jjXVahu5GA4s1b16L0YpxXu7TlJiZ5dBcyfFjHQ7jTEifsqwxEiGJUZQVtNAZq4123vkYp/oKX7lle3MeHxZ8yz1I6tg8HQIiXRUl+FcFo3VRmRZlmVEBk7Sc3mKDjmo6sLsP1XOwy9tY/FvP9FzqQAOfgQjTdJGVzBGxI+5YkyLi3zU1XDwA3C7HVTVPqXV9Ww6UkxJdT3piRG68cD72gAavIpLhsUTHuxib34Z+SXVuhc/aokejXgxtot33shEREQXKT29x2diOd6GMSJ+jGdPUSkFCcMhOBJO7nBYWdusPlhIg1uRkRJLTHiwzvY58D6MvsZpaYYWhAa5mipHL/fsqHj5aHfZfl0SaKEVN+TA+3o56aAwB1X5LsaI+DFTh8aSGBVCckwYFbVW6uWoJV59kds3oyssA8ixDRAzRD8MXofdUdl+rEQ3pF2mg9SVRQ6qapuCshp2Hi8hJDCAOfYqhvvfhdHXOSvMh/GKFF9Dz+AKENZ++3Jdd8pm1NXw/jdhwfecE9YG9Y1uVjb1Ei0jYi5wr+bKcQP4MHkuIwdY8arAEN2rP/QRTP6ss+JaYbl1fs0enkB4cKCepZ7zCdz4J4eV+S5mJOLnnGNAAIbMgLJ8KDne+gccZEtuMWU1DaQnRpCWYM1S3/8ejLnWaWmGNugXGsSopCgdW7AZdbX+v3khdjzEziwjezkMngZhsQ6q8m2MEekDuN2KzNxiiivrdC78yMW6h+9lfGLVyrpyXJJuOLlTz7ZPHO2gKkNHKa22lhsYuVinktdVOiuoBUopahoacQVI0zwq9r8Ho00n5WIwRqQP8O3/7uLWpzfwzk6rXuXYG2HveQUCHOdbV43izYdn87mZQ3XD/nf1BW5y972a6rpGbvrTOmY/uYKa+kY9Jyl5mnZpeREiwov3z2LL9xbRv1+oLqNz6EOTtHGRGCPSB7ADiO/tOqkbhs2HwgNQesIxTa0hIkweEsPg2HDtysp6B8aYeIi3ExbsoqFRUVHb0FTUkHE3wt43nRXWBnERwfpJzhqIGwb9BjkryMcxRqQPsHDMAIIDA9hytJiCshoIDLZqaXlPEeQae+0Tm4J92h2SnOGMIEOnuHrCQACW7rY6KqOv06Xh66ocVNVMZW0Du/JKmicXAux9Hcbd7JwoP8EYkT5AZEgg80YmohS8v+eUbvSinqLbrZj/i1V8+i8bmktR7HldazQrzPkE11hGZNm+07pDEBEPyVO9xqW1LOs01/9xHf/z8nbd0FCn4yHjbnJWmB9grtA+gn2Rv2f3FIddDoX7daaWw2QePcupshpOlFQTHRakXVl7/gvjb3FamqGDDI0PZ0JyNJV1jc0urbE3wj7v6KjYrtyMFCsL6/AKnbAR3eoK24ZOYIxIH2HhmP7apZVbzOkml9YS2PeW09J4b5c2ZNdMGKhTRfO362D6wMkOKzN0Btul1RR7G3OdTqF12KVVXlPP6oOFiMASS6PppHQfxoj0EaJCg5g/MpHEyBByi6zUy/G3wu7/OKqrvtHNO9ZN57pJVoDT9lWbrCyf4tqJ+ga9NrtIV46OSNCFMx2upfX+nlPUNriZkfr/27vz+Kqqa4Hjv5WbAUiAYAhTmBFFkEFMGZWhUBHqBBWFapVWqz7Fqa21VV+fHVTqWC1WxbFaRKiII4oiFKWMAUIkzCCQADIEgYQh43p/7BOImEC43JGs7+eTDzc7556zNndYZ++zz95n0LheLbccwroZ0PHysMZ1uoiIJCIiI0UkW0TKRKTKK6kisklEvhKRTBHJCGWMp4NHRnRm/u8H0bNtiitoOwD25YZ11tU5a3ax50AR7Rsl0alZPTc55IppdpYYhVqcUYeXrktnzj0DiPN5Xy1dR8Hyt8Ia17SlbhTiiO5e19W6T10rN6lRGKM6fUREEgFWACOA6ix2MVBVu6mqDds5SSlJCfhiKpzd+2Kh88iwfsinLXMf8OHd01xX1ub/Qq160Lhj2GIy/hvcsTF1a8UdLejwY8hZBPk7whLP1r2HmL8xj4TYmKNdWcsnQ+crwxLP6SgikoiqrlLVNeGOo6bYc6CIjE173C9droasyWGZHv5wcSlfeH3VV3TzzhIzJ0K3a0IeiwmswpJSDhaVQHyiSyQr3g5LHBt2FnBGYjyDOzamXq04KNgFm+baqKwAiogkchIU+FRElojITVVtJCI3iUiGiGTs2rUrhOFFvg27Cujx0ExunbjUrR7YpDMk1IUt80IeS604H1/eO5AXrj2fZsm13QqGq6e7xGai1pTFOfR8+HP+OW+zK+h6NSyfFJZY+p2VysL7BvHHyzq5gqzJ0GGYe8+bgAhZEhGRmSKyopKfk7m61VdVuwNDgdtEpF9lG6nqBFVNV9X01NTUgMR/umjbMJHmDWqzM7+Q/67f7S5eh7HfOrlO/NG5srLfdQsDJdlrFs1SkuLZe7CYd5bmupv7Wl/oLfy0MizxxPliaJiU4IaOW0s34EKWRFR1sKqeW8lPtceYquo279+dwDSgR7DiPV2JCCO6Nwdg8mJvJt/OV7m71wvzQxbHvkPFFJUc04WWOTEipw83J6ffWamkJMazbmcBy3L2ukk/u1wNy94IaRzz1u8+OikkuKHjRQegVd+QxnG6i5ruLBFJFJG65Y+Bi3AX5M1Juiq9Bb4YYUb2N24alHpN3dli1pSQxfC3mWvpM24WM7K9O+jzNkDeelvn+jQQ54vhynR3ovKvBV6X1vljXGs3RPeM5B8u5sbXM+j18OfsLih0hZlvupMUmwUhoCLif1NEhotILtAb+EhEZnjlzUSkfJB5Y2CuiCwHFgEfqeon4Yk4ujWpX4vB5zSipEyPtkZ+cANkvOKa/EF2qKiUqUty2V1QSFqytyTpklfd2aov7vhPNlHhmh6tEIEPs7bz7YEiaNAKmqe7e4BC4N1lWzlYVErXFvVdV1Zhgbu4by3dgIuIJKKq01S1uaomqGpjVR3ilW9T1WHe442q2tX76aSqD4U36uh2ba9WAExatMVdYG8zAIoPuuGYQfZB1jb2Hy6ha4tkzk2r77oYlk2EHr8M+rFNaLRMqUP/s1IpKinj7SW5rjD9F+5EJchUlX8t2ALANT3d+5yst1w3VnLLoB+/pomIJGJCr2+7hrRtmMiZjet6i1XFeB/yl4N+7IleF8e15euGZE2Blr2gQeugH9uEzrXeF/iSzd+6gvYXQcFO2JYZ1OMu2fwta3bkk5IYz5BOTVzreuEE6HlzUI9bU9ka6zVUTIzw0R0XUju+wvK53a6Bp7vBgd1uyoogyMzZy/LcfdSrFeumOVGFhS/A0HFBOZ4Jn4EdGjHt1j50a5HsCmJ8cP71sPgluHx80I772rxNAFz1gxbEx8bAhtnu2K0vDNoxazJridRg30kg4Fak63SF+1IPkuf/swGA0T1bUivOB5u+BBTa9A/aMU14+GKE81o2+O766+f/3C02tn97UI65Oe8A07/aTmyMHOmyZdEE6HGTzcUWJJZEDBmb9jDhC/flTt87XZdWEIb7Hi4uZfOeg8THxnBD3zaucP4/7ANeA6zdkc/6nQWuhdvlaljwj6Ac52BRKemtz+Dybmlu0EbeBtiyALpcFZTjGUsiNd6u/EJGv7iAcR+vdrP7prSDNv1gyWsBP1atOB/T77iAD8Ze4Na4/mYFbFtqI2ZOc1OX5HLRU1/w109Wu4I+Y909I4e+Dfixzmlajyk39+bhEee6grlPuZOU+MSAH8s4lkRquNS6CQw/L40yhRe+2OgKL7gb5j8LJYUBP56IcHYTb8qJL5+A3mMhrnbAj2MiR7+zUkmIjeGzlTtYuyPfjZA662J3bSRIEmJ9sDcHVn9oF9SDzJKI4eb+7RBxZ4xb9x6Cpl2hUUd3B3mAvLM0l5w9FW4027UGvv7CjQgzp7XUuglcld4CgPGz1rvCvne6a2+FBQE5xp4DRYx9cynrdlTohp37FJz3M3etzwSNJRFDu9QkLuvajKLSMp741JtMeeD9MOexgNxhvDnvAL99O4vBT84hr/zu4c//5L5IEpJOef8m8t3cvy3xvhjeX76NFVv3QaNz3GCK+YEZpfXs7PV8mLWdh6evcgV5GyB7GvS9KyD7N1WzJGIA+M1FZxPnE6Yt28rKbfuh+fnQogcsfO6U9/34p2spKVMu69qMlKQEd6FzW6brqzY1QvMGdbiutxstNe5j79rIoP+Fhc+7e0dOQc6eg7wxfzMicM+QDq7w8z9B79sgMeWU9m1OzJKIAdyqdNf2aoUqPPO5t9LhoD/AvPGQ/43f+124MY8Plm8jPjaGu390llu3ZMb9MPA+iKsVoOhNNLht4JnUrRXL3PW7+WzlDndzaZdRMOsvp7Tfv3y0kqLSMq7olkbHZvXcSUrOIuj1P4EJ3ByXJRFzxB0/bM+YPq15ZERnV5DSzk2cN+M+v/ZXVFLGA++6OTJvHdDOrRmy5FV341fX0QGK2kSLBonx/OpHZzHivDTOa+ndgDjgd7B2BmxZ6Nc+P1+1gxnZO0iM93HvxR2gtBg+vBuGPGQjskLEkog5okFiPA9e1okGifFHC/vdA7mLYd3Mk97f83M2sG5nAa1T6nBL/3ZuidTZD8ElT9lMqjXUmD6tefLqbm5SRIDaye4L/8O7oaTopPa1/3Axf3gvG4BfXXQ2TerXgnl/h3rNbOXCELJPsqnU4eJS3liwmbLY2nDpM/D+7W46lGrae7CICd6Q4YeGd6aWT+DdWyD9BmjcKVhhmwhX8e71w8WlrNq+H879iRv2O+vPJ7WvrJx97C4opEvz+lzfu5W7zjZ/PPz4Cbt5NYRs7ixTqRv/mcHc9bvJP1zMrQMGQpeR8O6tMPqtarUikuvE8+5tfZi7bjd9z2wI/33azdbb/94QRG8i3e6CQq59aSG78gv54PYLaHb5s/DChdC2P5w5uFr7uKB9Qz68/QLifDHElhyAqTfA0EdtIs8Qs5aIqdSYPq0BePSTNby/fBsMfMBNhTLzD8d9nlZYj+TMRnUZ07cNrP7ITW/yk5fAZ+ctBs6oE0/DpATyDhQx5tVF7IupByNehHduPuEyugWFJUcet29cl9YN4mHK9W6mhc5XBjt0cwxLIqZSgzs25r5hbrjkr6dk8kH2bhg10V0EnftUpc/Zf7iYn728iDcXbjla+PUX8P4dMHqSreVgjoiJEZ79aXfaN0pi7Y4CrntlEXkN0+HicTBxpLvPoxKzV++k77hZvJe51RWUFrsWcowPhj4WwhqYchGRRETkMRFZLSJZIjJNRJKr2O5iEVkjIutF5HehjrOm+eWFbbmpX1uKS5XbJy3jybm7KPzpVFg+GT7+nfsAe1Zs3ceVz81j7vrdPDVzrVujZPlk+PfPYeRrkNY9fBUxEal+nThe+0UP0pJrszxnL8P/MY8l9QdB/9/Cq0O/M2KrpLSM5/6zgRtfz2DfoWLmrc9DD+2FSaPdHFwjX7NWbpiIhmA51BMGIXIRMEtVS0TkrwCqeu8x2/iAtcCPgFxgMTBaVY/b9k1PT9eMjIzgBF4DqCovfrmRh6e7G8Qeu7ILIzslwdRfUrx3K9md7+WN7S15N+sbSsuUtqmJTLy8AU0zHoVdq+Gq1+1CujmunfmHueG1DL7aug9fjLDkgcEk585G3xvLnjaXMrvhaF5cdog13pQmY/u15NfNVyGf/R+ccwkMediWVQ4CEVmiqukn3C4SkkhFIjIcuFJVrzmmvDfwYPnSuSLyewBVfeR4+7MkEhgLN+bx1uIcHh/ZFV+MgCqPPPpnhh+YQpIcIrusNc0aJtMxfie+AzvcKKy+d9oNhaZaDheX8vdZ61i1PZ9XxvwAgK1bc5j93J1c6pvPWm3OntgmpDcRUvZmQ+rZ8MMHoFWfMEd++qpuEonE9t8vgMmVlKcBORV+zwV6VrYDEbkJuAmgZUvrhw+Enm1T6Nm2whQSIsyK68+SJoP4cdO9XNLsAKm1geRWruvKzgzNSagV5+OeIR0oKS07UtakaXP+1fAuFibfzai0nQw84xDxSSluctAGrcIYrakoZElERGYCTSr50/2q+p63zf1ACVDZ9LGVDfyutBmlqhOACeBaIn4FbE7os1/ZaoQmsGJ9Ry/T+mKET+7qF8ZoTHWELImo6nEHf4vI9cAlwCCtvI8tF2hR4ffmwLbARWiMMeZkRcrorIuBe4HLVLWquccXA+1FpI2IxAOjgPdDFaMxxpjvi4gkAowH6gKfiUimiDwPICLNRGQ6gKqWAGOBGcAqYIqqZocrYGOMMRFyYV1Vz6yifBswrMLv04HpoYrLGGPM8UVKS8QYY0wUsiRijDHGb5ZEjDHG+M2SiDHGGL9F3LQngSYiu4DNfj69IVD9lZgiU7TXIdrjB6tDJIj2+CH0dWilqqkn2ui0TyKnQkQyqjN3TCSL9jpEe/xgdYgE0R4/RG4drDvLGGOM3yyJGGOM8ZslkeObEO4AAiDa6xDt8YPVIRJEe/wQoXWwayLGGGP8Zi0RY4wxfrMkYowxxm81KomISAsRmS0iq0QkW0Tu9MofFJGt3gzCmSIyrMJzfi8i60VkjYiUL817doVtM0Vkv4jcFU118Mrv9vaxQkQmiUjQ17INcPx3erFnh+r/3586iEiKt32BiIw/Zl/ni8hXXv2eEZHKFl+L9Do8JCI5IlIQitgDGb+I1BGRj0RktbefcdFWB+9vn4jIcm8/z4uIL1T1QFVrzA/QFOjuPa4LrAU6Ag8Cv6lk+47AciABaANsAHzHbOMDvsHdmBM1dcAtN/w1UNvbbgowJoriPxdYAdTBzUY9E2gfoa9BInABcAsw/pi/LQJ641bu/BgYGoV16OXtryAUsQcyfu/9M9B7HA98GaWvQT3vXwGmAqNC9VrUqJaIqm5X1aXe43zcuiRpx3nK5cBbqlqoql8D64Eex2wzCNigqv7eFX9SAlyHWKC2iMTiPkxBXykygPGfAyxQ1YPq1pqZAwwPbvTOydZBVQ+o6lzgcMVyEWmK+/DPV/cN8DpwRfAi/05MAamD97cFqro9aMFWHk9A4vfeP7O9x0XAUtyqqUEX4Ndgv/cwFpcMQzZiqkYlkYpEpDVwHrDQKxorIlki8oqINPDK0oCcCk/L5fsv8ihgUhBDrdKp1EFVtwKPA1uA7cA+Vf00JIF7TvE1WAH085r4dXDrzlRcPjkkqlmHqqTh6lOusvdX0J1iHcIuUPGLSDJwKfB5wIM88bFbc4p1EJEZwE4gH3g7GHFWpkYmERFJwjX57vIy+HNAO6Ab7gv1ifJNK3n6kQwvbpney4B/BzXgSpxqHbw35uW4LqJmQKKIXBv0wMuDOsX4VXUV8FfgM+ATXJdXSbDjrugk6lDlLiopC+mY+wDUIawCFb/XGp8EPKOqG4MUblXHDkgdVHUIrossAfhhcKL9vhqXREQkDveCTVTVdwBUdYeqlqpqGfAiR7t7cvnu2W1zvtvlMxRYqqo7gh/5UQGqw2Dga1XdparFwDtAnyiKH1V9WVW7q2o/YA+wLhTx+1GHquTy3a6TY99fQRWgOoRNgOOfAKxT1b8FJ9rKBfo1UNXDwPu4E8SQqFFJxBv58jKwSlWfrFDetMJmw3FdJeBejFEikiAibYD2uAuh5UYT4q6sANZhC9DLG50iuGs7q6IofkSkkfdvS2AEIXot/KhDpbzrCPki0svb53XAe0EI+XsCVYdwCWT8IvIXoD4QshF+3nEDUgcRSSp/jteiGgasDnzEVQjmVftI+8GNbFAgC8j0foYBbwBfeeXvA00rPOd+3IigNVQYtYG7EJ0H1I/iOvwR92Zb4T0/Icri/xJYievKGhThr8EmXGupANcC6eiVp3v//xuA8XizSERZHR71fi/z/n0wWuLHtf4UdwJVvp8bo+k1ABoDi73ts4G/A7Gh+jzYtCfGGGP8VqO6s4wxxgSWJRFjjDF+syRijDHGb5ZEjDHG+M2SiDHGGL9ZEjHGGOM3SyLGVJM3T1f59NzfHDNd97wgHG+MiOwSkZeOs01t7/hFItIw0DEYcyKx4Q7AmGihqnm4+YwQkQdxU58/HuTDTlbVsceJ6RDQTUQ2BTkOYyplLRFjAkC8BZlEZICIzBGRKSKyVkTGicg1IrJI3OJT7bztUkVkqogs9n76VuMYnbz9ZHozvLYPdr2MORFriRgTeF1x653sATYCL6lqD3Er192Om6PpaeApVZ3rzf01w3vO8dwCPK2qE70ZpEO3ep0xVbAkYkzgLVZvkSYR2QCUr9PyFTDQezwY6ChHV8OtJyJ11S1OVJX5wP0i0hx4R1VDNmuxMVWx7ixjAq+wwuOyCr+XcfTELQborardvJ+0EyQQVPVN3Po1h4AZIhKyNSOMqYolEWPC41PgyAVzEel2oieISFtgo6o+g5vdtUvwwjOmeiyJGBMedwDp3gXylbjrHSdyNbBCRDKBDrg12Y0JK5sK3pgIJSJjgPTjDfGtsO0mb9vdwY7LmIqsJWJM5DoEDK3OzYZAHO6aizEhZS0RY4wxfrOWiDHGGL9ZEjHGGOM3SyLGGGP8ZknEGGOM3/4f6DViZK1SUZwAAAAASUVORK5CYII=\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "istart = 400\n", "\n", - "fig = pyplot.figure(figsize=(6,4))\n", + "fig = plt.figure(figsize=(6,4))\n", "\n", - "pyplot.plot(t[-istart:], num_sol[-istart:, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", - "pyplot.plot(t[-istart:], x_an[-istart:], linewidth=1, linestyle='-', label='Analytical solution')\n", - "pyplot.xlabel('Time [s]')\n", - "pyplot.ylabel('$x$ [m]')\n", - "pyplot.title('Spring-mass system, with Euler-Cromer method. \\n');" + "plt.plot(t[-istart:], num_sol[-istart:, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", + "plt.plot(t[-istart:], x_an[-istart:], linewidth=1, linestyle='-', label='Analytical solution')\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('$x$ [m]')\n", + "plt.title('Spring-mass system, with Euler-Cromer method. \\n');" ] }, { @@ -602,25 +585,23 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": true - }, + "execution_count": 74, + "metadata": {}, "outputs": [], "source": [ - "dt_values = numpy.array([period/50, period/100, period/200, period/400])\n", + "dt_values = np.array([period/50, period/100, period/200, period/400])\n", "T = 1*period\n", "\n", - "num_sol_time = numpy.empty_like(dt_values, dtype=numpy.ndarray)\n", + "num_sol_time = np.empty_like(dt_values, dtype=np.ndarray)\n", "\n", "\n", "for j, dt in enumerate(dt_values):\n", "\n", " N = int(T/dt)\n", - " t = numpy.linspace(0, T, N)\n", + " t = np.linspace(0, T, N)\n", " \n", " #initialize solution array\n", - " num_sol = numpy.zeros([N,2])\n", + " num_sol = np.zeros([N,2])\n", " \n", " \n", " #Set intial conditions\n", @@ -642,17 +623,15 @@ }, { "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": true - }, + "execution_count": 75, + "metadata": {}, "outputs": [], "source": [ "def get_error(num_sol, T):\n", " \n", - " x_an = x0 * numpy.cos(ω * T) # analytical solution at final time\n", + " x_an = x0 * np.cos(w * T) # analytical solution at final time\n", " \n", - " error = numpy.abs(num_sol[-1,0] - x_an)\n", + " error = np.abs(num_sol[-1,0] - x_an)\n", " \n", " return error" ] @@ -666,13 +645,11 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": true - }, + "execution_count": 76, + "metadata": {}, "outputs": [], "source": [ - "error_values = numpy.empty_like(dt_values)\n", + "error_values = np.empty_like(dt_values)\n", "\n", "for j in range(len(dt_values)):\n", " \n", @@ -681,38 +658,40 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 77, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAGlCAYAAAArqoUwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\no2yAV00AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "# plot the solution errors with respect to the time incremetn\n", - "fig = pyplot.figure(figsize=(6,6))\n", - "\n", - "pyplot.loglog(dt_values, error_values, 'ko-') #log-log plot\n", - "pyplot.loglog(dt_values, 10*dt_values, 'k:')\n", - "pyplot.grid(True) #turn on grid lines\n", - "pyplot.axis('equal') #make axes scale equally\n", - "pyplot.xlabel('$\\Delta t$')\n", - "pyplot.ylabel('Error')\n", - "pyplot.title('Convergence of the Euler method (dotted line: slope 1)\\n');" + "fig = plt.figure(figsize=(6,6))\n", + "\n", + "plt.loglog(dt_values, error_values, 'ko-') #log-log plot\n", + "plt.loglog(dt_values, 10*dt_values, 'k:')\n", + "plt.grid(True) #turn on grid lines\n", + "plt.axis('equal') #make axes scale equally\n", + "plt.xlabel('$\\Delta t$')\n", + "plt.ylabel('Error')\n", + "plt.title('Convergence of the Euler method (dotted line: slope 1)\\n');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "What do you see in the plot of the error as a function of $\\Delta t$? It looks like a straight line, with a slope close to 1. On a log-log convergence plot, a slope of 1 indicates that we have a first-order method: the error scales as ${\\mathcal O}(\\Delta t)$—using the \"big-O\" notation. It means that the error is proportional to the time increment: $ e \\propto \\Delta t.$" + "What do you see in the plot of the error as a function of $\\Delta t$? It looks like a straight line, with a slope close to 1. On a log-log convergence plot, a slope of 1 indicates that we have a first-order method: the error scales as ${\\mathcal O}(\\Delta t)$—using the \"big-O\" notation. It means that the error is proportional to the time increment: $ error \\propto \\Delta t.$" ] }, { @@ -740,10 +719,8 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": true - }, + "execution_count": 221, + "metadata": {}, "outputs": [], "source": [ "def rk2_step(state, rhs, dt):\n", @@ -774,25 +751,23 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": { - "collapsed": true - }, + "execution_count": 405, + "metadata": {}, "outputs": [], "source": [ - "dt_values = numpy.array([period/50, period/100, period/200,period/400])\n", + "dt_values = np.array([period/50, period/100, period/200,period/400,period/1000])\n", "T = 1*period\n", "\n", - "num_sol_time = numpy.empty_like(dt_values, dtype=numpy.ndarray)\n", + "num_sol_time = np.empty_like(dt_values, dtype=np.ndarray)\n", "\n", "\n", "for j, dt in enumerate(dt_values):\n", "\n", " N = int(T/dt)\n", - " t = numpy.linspace(0, T, N)\n", + " t = np.linspace(0, T, N)\n", " \n", " #initialize solution array\n", - " num_sol = numpy.zeros([N,2])\n", + " num_sol = np.zeros([N,2])\n", " \n", " \n", " #Set intial conditions\n", @@ -807,46 +782,79 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": { - "collapsed": true - }, + "execution_count": 406, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 406, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t,num_sol[:,0],'s')\n", + "plt.plot(t,x0*np.cos(w*t))" + ] + }, + { + "cell_type": "code", + "execution_count": 407, + "metadata": {}, "outputs": [], "source": [ - "error_values = numpy.empty_like(dt_values)\n", + "error_values = np.empty_like(dt_values)\n", "\n", "for j, dt in enumerate(dt_values):\n", " \n", - " error_values[j] = get_error(num_sol_time[j], dt)" + " error_values[j] = get_error(num_sol_time[j], T)" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 408, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiAAAAGlCAYAAADDHE3qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nnQABANoJEACg3Te5vvRQXIymOQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "# plot of convergence for modified Euler's\n", - "fig = pyplot.figure(figsize=(6,6))\n", - "\n", - "pyplot.loglog(dt_values, error_values, 'ko-')\n", - "pyplot.loglog(dt_values, 5*dt_values**2, 'k:')\n", - "pyplot.grid(True)\n", - "pyplot.axis('equal')\n", - "pyplot.xlabel('$\\Delta t$')\n", - "pyplot.ylabel('Error')\n", - "pyplot.title('Convergence of modified Euler\\'s method (dotted line: slope 2)\\n');" + "fig = plt.figure(figsize=(6,6))\n", + "\n", + "plt.loglog(dt_values, error_values, 'ko-')\n", + "plt.loglog(dt_values, 5*dt_values**2, 'k:')\n", + "plt.grid(True)\n", + "plt.axis('equal')\n", + "plt.xlabel('$\\Delta t$')\n", + "plt.ylabel('Error')\n", + "plt.title('Convergence of modified Euler\\'s method (dotted line: slope 2)\\n');" ] }, { @@ -863,201 +871,332 @@ }, { "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# An implicit integration approach\n", + "\n", + "In the Modified Euler's method, which is a type of second order Runge-Kutta method, we increased the accuracy of the method by approximating the average slope over the time step. The Euler method assumes the slope is constant during each time step. We can increase accuracy the accuracy of our average slope with an _implicit_ *predictor-corrector approach*. \n", + "\n", + "Heun's method is an integration method that uses the same second order Runge Kutta method, but with one important distinction. It uses the actual derivative at the next state as part of its correction. \n", + "\n", + "$y_{i+1}=y_{i}+f(t_{i},y_{i}) \\Delta t$\n", + "\n", + "$y_{i+1}=y_{i}+\n", + "\\frac{f(t_{i},y_{i})+f(t_{i+1},y_{i+1})}{2} \\Delta t$\n", + "\n", + "The error is $ error \\propto \\Delta t^2.$ This is the same convergence as the Modified Euler's method. Let's compare the two methods. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Using Heun's method\n", + "\n", + "The problem with an _implicit_ method is that our unknown $\\mathbf{y}_{i+1}$ is on both sides of the equation. In an _explicit_ method (such as the Euler and Modified Euler) we estimate the next state, with an equation that is only based upon the current state as such\n", + "\n", + "$\\mathbf{y}_{i+1} = f(\\mathbf{y_{i}}),$\n", + "\n", + "but with an implicit method we have a nonlinear function where\n", + "\n", + "$\\mathbf{y}_{i+1} = g(\\mathbf{y}_{i},\\mathbf{y}_{i+1}). $\n", + "\n", + "This extra step introduces the topic of solving a nonlinear problem with a computer. How can we solve an equation if the value we want is also part of our function? We'll take a look at methods to solve this next module, but for now lets set a tolerance `etol` for the _implicit_ Heun method and see what the resulting solution is. \n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 416, "metadata": {}, + "outputs": [], "source": [ - "## What we've learned\n", + "def heun_step(state,rhs,dt,etol=0.000001,maxiters = 100):\n", + " '''Update a state to the next time increment using the implicit Heun's method.\n", + " \n", + " Arguments\n", + " ---------\n", + " state : array of dependent variables\n", + " rhs : function that computes the RHS of the DiffEq\n", + " dt : float, time increment\n", + " etol : tolerance in error for each time step corrector\n", + " maxiters: maximum number of iterations each time step can take\n", + " \n", + " Returns\n", + " -------\n", + " next_state : array, updated after one time increment'''\n", + " e=1\n", + " eps=np.finfo('float64').eps\n", + " next_state = state + rhs(state)*dt\n", + " ################### New iterative correction #########################\n", + " for n in range(0,maxiters):\n", + " next_state_old = next_state\n", + " next_state = state + (rhs(state)+rhs(next_state))/2*dt\n", + " e=np.sum(np.abs(next_state-next_state_old)/np.abs(next_state+eps))\n", + " if e" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t,num_heun[:,0],'o-',label='implicit Heun')\n", + "plt.plot(t,num_rk2[:,0],'s-',label='explicit RK2')\n", + "plt.plot(t,x0*np.cos(w*t))\n", + "plt.ylim(-8,8)\n", + "plt.legend();\n", + "#plt.xlim(np.max(t)-5,np.max(t))\n", + "#plt.xlim(np.max(t)-period,np.max(t))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## References\n", + "## Discussion\n", + "\n", + "Change the number of steps/time period in the above solutions for the second order Runge Kutta and the implicit Heun's method. Why do you think the implicit method does not have an increasing magnitude of oscillation? " + ] + }, + { + "cell_type": "code", + "execution_count": 419, + "metadata": {}, + "outputs": [], + "source": [ + "dt_heun = np.array([period/50, period/100, period/200,period/400,period/1000])\n", + "T = 2*period\n", + "\n", + "num_heun_time = np.empty_like(dt_heun, dtype=np.ndarray)\n", "\n", - "1. Linge S., Langtangen H.P. (2016) Solving Ordinary Differential Equations. In: Programming for Computations - Python. Texts in Computational Science and Engineering, vol 15. Springer, Cham, https://doi.org/10.1007/978-3-319-32428-9_4, open access and reusable under [CC-BY-NC](http://creativecommons.org/licenses/by-nc/4.0/) license.\n", "\n", - "2. Cromer, A. (1981). Stable solutions using the Euler approximation. _American Journal of Physics_, 49(5), 455-459. https://doi.org/10.1119/1.12478\n" + "for j, dt in enumerate(dt_heun):\n", + "\n", + " N = int(T/dt)\n", + " t = np.linspace(0, T, N)\n", + " \n", + " #initialize solution array\n", + " num_heun = np.zeros([N,2])\n", + " \n", + " \n", + " #Set intial conditions\n", + " num_heun[0,0] = x0\n", + " num_heun[0,1] = v0\n", + " \n", + " for i in range(N-1):\n", + " num_heun[i+1] = heun_step(num_heun[i], springmass, dt)\n", + "\n", + " num_heun_time[j] = num_heun.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 420, + "metadata": {}, + "outputs": [], + "source": [ + "error_heun = np.empty_like(dt_heun)\n", + "\n", + "for j, dt in enumerate(dt_heun):\n", + " \n", + " error_heun[j] = get_error(num_heun_time[j], T)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 421, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n" - ], "text/plain": [ - "" + "0.00015967121365578762" ] }, - "execution_count": 26, + "execution_count": 421, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", - "from IPython.core.display import HTML\n", - "css_file = '../style/custom.css'\n", - "HTML(open(css_file, \"r\").read())" + "i=-1\n", + "get_error(num_heun_time[i],T)" + ] + }, + { + "cell_type": "code", + "execution_count": 422, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot of convergence for modified Euler's\n", + "fig = plt.figure(figsize=(6,6))\n", + "\n", + "plt.loglog(dt_values, error_values, 'ko-',label = 'Runge Kutta')\n", + "plt.loglog(dt_heun, error_heun, 'rs-',label = 'Heun\\'s')\n", + "plt.loglog(dt_values, 5*dt_values**2, 'k:')\n", + "plt.grid(True)\n", + "plt.axis('equal')\n", + "plt.xlabel('$\\Delta t$')\n", + "plt.legend(loc='lower right')\n", + "plt.ylabel('Error')\n", + "plt.title('Convergence of RK2 and Heun\\'s method\\n');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What we've learned\n", + "\n", + "* vector form of the spring-mass differential equation\n", + "* Euler's method produces unphysical amplitude growth in oscillatory systems\n", + "* the Euler-Cromer method fixes the amplitude growth (while still being first order)\n", + "* Euler-Cromer does show a phase lag after a long simulation\n", + "* a convergence plot confirms the first-order accuracy of Euler's method\n", + "* a convergence plot shows that modified Euler's method, using the derivatives evaluated at the midpoint of the time interval, is a second-order method\n", + "* How to create an implicit integration method\n", + "* The difference between _implicit_ and _explicit_ integration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "1. Linge S., Langtangen H.P. (2016) Solving Ordinary Differential Equations. In: Programming for Computations - Python. Texts in Computational Science and Engineering, vol 15. Springer, Cham, https://doi.org/10.1007/978-3-319-32428-9_4, open access and reusable under [CC-BY-NC](http://creativecommons.org/licenses/by-nc/4.0/) license.\n", + "\n", + "2. Cromer, A. (1981). Stable solutions using the Euler approximation. _American Journal of Physics_, 49(5), 455-459. https://doi.org/10.1119/1.12478\n", + "\n", + "3. Chapra, Steven, _Applied Numerical Methods with MATLAB for Engineers and Scientists_ 4th edition. ch. 22.3 Improvements to Euler's method\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problems\n", + "\n", + "1. Show that the implicit Heun's method has the same second order convergence as the Modified Euler's method. _Hint: you can use the same code from above to create the log-log plot to get the error between $2\\cos(\\omega t)$ and the `heun_step` integration. Use the same initial conditions x(0) = 2 m and v(0)=0m/s and the same RHS function, `springmass`._" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. " ] } ], @@ -1077,9 +1216,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.2" + "version": "3.7.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/notebooks/.ipynb_checkpoints/04_Getting_to_the_root-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/04_Getting_to_the_root-checkpoint.ipynb new file mode 100644 index 0000000..3a721c1 --- /dev/null +++ b/notebooks/.ipynb_checkpoints/04_Getting_to_the_root-checkpoint.ipynb @@ -0,0 +1,1515 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Roots of Nonlinear functions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## It's not always possible to analytically solve for a given variable. \n", + "\n", + "In the last [Module 03](./03_Get_Oscillations.ipynb), we created an _implicit_ Heun's method that created the following problem: How can we solve for a value of $y$, a dependent variable, when the function is a function of $y$, in an equation format it becomes\n", + "\n", + "$y=f(y,parameters)$\n", + "\n", + "where $parameters$ are known inputs to the equation, but the variable $y$ is not separable from the function $f$. We can rewrite the problem as \n", + "\n", + "$0=y-f(y,parameters).$\n", + "\n", + "Many times, we may have a deeper problem such as wanting to know when two functions are equal to each other:\n", + "\n", + "$0 = g(y,parameters) -f(y,parameters)$\n", + "\n", + "where $g(y,parameters)$ in the previous equation was $g(y)=y$. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "# Getting to the root of a problem\n", + "\n", + "This is a very common problem in engineering designs. You may have mathematical models for designs, but you can't explicitly solve for the variables you can control or see [1]. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Freefall example:\n", + "Consider an observation of an object, with a known shape, so its drag coefficient c=0.25 kg/m. If the object reaches a velocity of 36 m/s after 4 seconds of freefalling, what is its mass?\n", + "\n", + "$v(t)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)$\n", + "\n", + "We can plug in the known parameters, $t=4~s$, $v=36~m/s$, $c_d=0.25$ kg/s, and $g=9.81~m/s^2$, but we cannot separate $m$ from the $\\tanh$ and $\\sqrt{}$.\n", + "\n", + "$36 = \\sqrt{\\frac{9.81m}{0.25}}\\tanh(\\sqrt{\\frac{9.81*0.25}{m}}4)$\n", + "\n", + "Instead, we can use computational methods to solve the problem by creating a new function f(m) where\n", + "\n", + "$f(m)=36 - \\sqrt{\\frac{9.81m}{0.25}}\\tanh(\\sqrt{\\frac{9.81*0.25}{m}}4)$. \n", + "\n", + "When f(m) = 0, we have solved for m in terms of the other variables (e.g. for a given time, velocity, drag coefficient and acceleration due to gravity)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "plt.rcParams.update({'font.size': 22})\n", + "plt.rcParams['lines.linewidth'] = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "g=9.81 # acceleration due to gravity\n", + "\n", + "def f_m(m,v=36,t=4,c_d=0.25,):\n", + " ''' define a function f(m) that returns \n", + " v(t)-sqrt(mg/cd)*tanh(sqrt(gcd/m)*t)\n", + " \n", + " arguments:\n", + " ---------\n", + " m: mass of object\n", + " c_d: drag coefficient default=0.25 kg/m # drag coefficient\n", + " t: time of velocity measure default=4 seconds\n", + " v: velocity measure at time, t default=36 m/s\n", + " \n", + " returns:\n", + " --------\n", + " f_m: the difference between v(t) and sqrt(mg/cd)*tanh(sqrt(gcd/m)*t)\n", + " if f_m ==0, then mass is correctly chosen\n", + " '''\n", + " \n", + " f_m = v-np.sqrt(g*m/c_d)*np.tanh(np.sqrt(g*c_d/m)*t)\n", + " return f_m\n", + "\n", + "m=np.linspace(60, 200,100); # possible values for mass 50 to 200 kg\n", + "plt.plot(m,f_m(m))\n", + "plt.plot(m,np.zeros(len(m)))\n", + "plt.xlabel('mass, m (kg)')\n", + "plt.ylabel('f(m)');" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true, + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.12322824302261637" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f_m(149)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "The Brute force method is plot f_m vs m and with smaller and smaller steps until f_m ~ 0, but we can do much better. \n", + "\n", + "We will look at two classes of methods, most numerical solutions use a combination of these two types of solvers:\n", + "\n", + "1. Bracketing methods\n", + "2. Open methods\n", + "\n", + "In __Bracketing__ methods, we choose an upper and lower bound and find the best solution in that range.\n", + "\n", + "In __Open__ methods, we choose an initial guess, then we have a function that brings us closer to the solution with every iteration.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "## Incremental searching ( a smarter brute force approach)\n", + "\n", + "If you consider a range of possible masses, e.g. 50 kg - 200 kg, then we can evaluate our function $f(m)$ at evenly-spaced intervals and look for x-axis crossings. If the value of $f(m_{i})$ is positive, and the value of $f(m_{i+1})$ is negative, then the correct mass is somewhere between $m_i$ and $m_{i+1}$. \n", + "\n", + "Take a look at the implementation we have below of the `incsearch` function. \n", + "\n", + "There are a few key lines to look at:\n", + "\n", + "```python\n", + " x = np.linspace(xmin,xmax,ns)\n", + " f = func(x)\n", + "```\n", + "\n", + "In these two lines, we are dividing the interval into `ns`-equally-spaced values (our default is ns=50). Then, we evaluate our function ($f(m)$) `ns` times for each value. \n", + "\n", + "```python\n", + " sign_f = np.sign(f)\n", + " delta_sign_f = sign_f[1:]-sign_f[0:-1]\n", + " i_zeros = np.nonzero(delta_sign_f!=0)\n", + "```\n", + "\n", + "On these three lines, we are looking for sign-changes in the array `f`. First, we get just the sign of each array value with `np.sign`. Then, we look at the changes in sign with the difference between f[i] and f[i-1] for i=1...len(f). Finally, we get the indices sign changes by looking for nonzero elements in `delta_sign_f`. \n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discussion\n", + "\n", + "Why can't we just consider cases where `delta_sign_f>0`? Why do we care about all nonzero sign changes?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "def incsearch(func,xmin,xmax,ns=50):\n", + " '''incsearch: incremental search root locator\n", + " xb = incsearch(func,xmin,xmax,ns):\n", + " finds brackets of x that contain sign changes\n", + " of a function on an interval\n", + " arguments:\n", + " ---------\n", + " func = name of function\n", + " xmin, xmax = endpoints of interval\n", + " ns = number of subintervals (default = 50)\n", + " returns:\n", + " ---------\n", + " xb(k,1) is the lower bound of the kth sign change\n", + " xb(k,2) is the upper bound of the kth sign change\n", + " If no brackets found, xb = [].'''\n", + " x = np.linspace(xmin,xmax,ns)\n", + " f = func(x)\n", + " sign_f = np.sign(f)\n", + " delta_sign_f = sign_f[1:]-sign_f[0:-1]\n", + " i_zeros = np.nonzero(delta_sign_f!=0)\n", + " nb = len(i_zeros[0])\n", + " xb = np.block([[ x[i_zeros[0]+1]],[x[i_zeros[0]] ]] )\n", + "\n", + " \n", + " if nb==0:\n", + " print('no brackets found\\n')\n", + " print('check interval or increase ns\\n')\n", + " else:\n", + " print('number of brackets: {}\\n'.format(nb))\n", + " return xb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test our function\n", + "\n", + "To test our `incsearch` function on a known function, let's try finding all the times that $sin(x)$ crosses the x-axis from $x=-1...7$. Our function should return values at $x=0,~x=\\pi/2,~x=\\pi.$\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of brackets: 3\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAckAAAFSCAYAAACZniTxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAIABJREFUeJzsnXd4HNXVuN8jWbLcu9x7x9jGBRcM2Kb3btP5DL8QIATSSSD5wEm+kOT7SKMTQjCE3lsgdBkbjHvHDdtykXuXrC7d3x93dne03qbVrmZXOu/zzDMze8ucvVPOLeeeK8YYFEVRFEU5lgyvBVAURVGUVEWVpKIoiqKEQZWkoiiKooRBlaSiKIqihEGVpKIoiqKEQZWkoiiKooQhrZSkiOSJiBGR/Bjjz3Li6zyXGBCRGVpesSMiU3zlJSJ9vJYnVkRkuIg8JSJbRKRURHaKyHsickEC8m4jImeIyD0i8paI7HCV0aw65Cuu9z/mb0CE/C4Qkd+JyH9EZJ2IHBCRChHZKyKzReSnItKmjtfoJCL/T0SeF5FvRKRIRMpEpEBE3hGRq0QkM868f+Mqi4Q9fyLSRERucsqlwJF3l4gsFJG/isjEOPPtKSK3i8jTIrJIRLY5z95REVnvfKtPiZLHjKD/HG5bFd+/D4MxJm02IA8wQH6M8Wc58Y3XsqfDBszQ8qpVeU3xlRfQx2t5YpT5v4Ayl9zB26N1zH9WhLxn1SHf7wTllV9HOfdFkNO37QAmxJn/OKAihmvMBTrWMu+hIe5hnZ8/YDCwPIq8cd1D4PsxlIUBngQyw+QxI8Y8ViXynUmrlqSiKPEjIpOAfwDZwCrgbCAXGAO85US7TUTuSsDlyoAFwMN1zUhEcoH/BSqB7XXNz+Fb4CHgaqxC6wF0BSYAf8PK3xX4QES6xJF/c6AJcMC5zrlAL6ADMAl4w4k3CXhXRGL6FouIAH/H3sNNccgVLt9+wOfACOAI8CvnuAPQE7gQ+BdQFOclSoD3gZ8BZ2AVfUdgCHANsMyJ9x3gdzHk1yrCdmKcMoYmkRo32Rvakkx2+c7Q8qpVeU2BxNXk60He+Y6su4AOQWECfOSEFwKd4rzGJGAskOX6ra6tkJec9H+s7TegDmU1zSX3fXGkHwX8BMiJEOfvrmtMjzHfW53484BfJ+L5c+79HNezMdCDZ7MpsMSR4SjQPEQcT75P2pJUlEaAiIzFtpgA/tcYs98dbuxX6BfOaUvg+niuY4z50hizyBhTEbewLkTkXOBKYAtWKdQXrwGHneOxtU1sjFlqjPmTMaY0QrRfAtXO8bnR8hSRrsAfsC1qn7JMBFcAJzvH3zPGbEhQvjFjjCkDnnNOm2NbmilBo1WSwUYqItJXRJ4QkXyXMcPzIjIsQh4+w6A85/xUx1hhl5PHtyLygIi0j0GediLyKxGZLyL7nQHz7SLyYqTB8hAyTHTSbHMMEZaFSxuDTLUuE1faTiJyv4gsF5EjIlIiIhtF5MkoZTozFsMMlxHHrBBhwWUyQkSec8rTV66zRKR/DP/jQhH5WKxhx1ERWSUi94pI8xjSthCRu0TkKwkYhuwTkTUi8qqI3CwiLaLlkyAudB2/EiqCMWYJsNE5vSjpEkXBKZvHnNM7jDHF9XVtp9JQ6ZxGUnR1ucZeYI9z2i2GJA8BbYAHjTHLEyjKLc5+ozHmjYgxk4u7YpWUMo+L+m5W17FJnkeCulupOQg8DjjoOndvZcBlUfLPwz5oVWHyKAAGR5BzKrA/TFrf9psYZLgN+2K70y2rRfnWuUxc/+dQhP9SCfwwTNqZsdxj17MwK0qZXIl94ULJcQAYHuEaf4rwH1YAl7rO+wSl7Qqsj3JPDTC2nt6d95zrbY8S7zkn3pEEXjuu7lbgz066N0Pc95i+AXWQ+XSX3Hcl6RpZrmfzlShxL3TibQVaOr/NJMzzVwsZmhEwMPpzsHzJLOOga2UAsx05DgJNQ8SZ4fu/rt+yky1bo21JBvEy9mGdAXR3thnAbuwA+YsiclyE9AOwtbzFwFlAJ2Ag9iGuwNYS3xWRnOCEIjIa+ABojzWmuA7o45yPAf7pRP1vEflOBBmGAA8CX2MNMjoDvYF7IqSJRFxlIiIDgXexNd4DwPccOTpjWyergUzgLyIyLU7ZYmUA8Ax2LO4srJFKT+CHQDnQDngiVEKnrH/snC4EzqTmfR2CVaLh+F8nbjFwF3A81lChD3CKk/diQnSZiUjLOm7ZIeQZ7OyjGXtsdvatRCSW1k1ScN6LO7GGInfW0zWbicggEbkbeN35eQvwaJIueQF2LA7gqwhytQQecU5/YIyJ13gmFKOxBkYAC0Wkt4j8Q0R2A+VOz8tCEfmxiDRL4HV903o6i8iZwIfAqU7QvcZ2v0ZKu0REyoEyESkUkS9E5IdJ6Zmpr5pCgmobeSSnJVkEDAoRZwj2I2eAdyPlj7XOCjXYfIMrzk9ChC93pW8W5n/81omzNzhOkAxzqEPNKkFl8pYTVgKMDBHeFljnxNkZLC+JbUkabAWkSYg4P3bFGRIUlkNgikAs9zVUS9LXM/CDOO5DtNZntG1miDx9vQKvRbn2Ha58wray4/w/x9yrMPEzCVQgfhIU5rvvMX0DYrjW8WHKsNp5drol4johrpsNrHGudYQI00Cwld9j3jcS05K82pXHT7DjsOGeq+WJKA/seG+o/HcDt0RINyOGZ38jMCKR90pbkpaHjTHrg380xqwlUIM7T0Q6R8jjFybEmIkx5llgkXN6oztMRKZizawBvmOMKQmT9/1Yi6+O2BZROH5qjCmPEF4bal0mYk31fWNfj5kQ4ybGmEMEDES6YGvTyeQHxpjKEL/Pch0Hm4xfgDV9h9juayh8tfOCGOVMNr4adrSxHvcz2DJJskTjR9gWzgrsdAwvmI99B3YkKf8HsRVOsNaz+0JFEpFxwO3Yiun3kyCH22HC/dgpFL8H+mJbuUOwcxfBfqteExFJghzl2PHndyLEKcH2DF2C7RlpAbTG9sy86MTpB3wkIt0TJZgqScubEcJ8A9kZ2DlUoTgKfBxDHseJSFvX72c4+/3AunDdZ9ia9VonbjhLu/3GmPkRZKgt8ZTJSQSeqVcjpH+PwMc4opeNOrIplKIHMMYcwLbMwSprNz5Lv1jvayiWOvvfi8jk2nxYjDFSx21mpOyjXD4ZH8CYEes5xje14dYwFZxE8g2B+XWdsM/zQ9iK03tiPcRkJfKCIvI9AsYyHwB/DROvCXaaSAbWJmFLIuVwcOuAbOBuY8w9xph8Y0y5MWadMea7BAyoJmKVVF24DlverbHK+HrsvNX7gBUiclKoRMaYl40xM4wxbxtj1htjio0xhcaYucaYawgMj3TG9r4lBFWSlrURwta4jnuHibPBGFMVQx6CnVDswzdO1AHb5VIYYRvjxO0U5hoJm1jsEE+ZuI+/CZfY2OkBPjPzcGWaCKK1AnwtxGBL1T7OPtb7Goq7sLXjAdguwp0i8oqI3BGLdXASOOrso40rucfNEzn2FSuPYe/Hk8aYecm+mDGm2hhT5Gz7jDHzjTF3AtOdKDOAnyfqes44/EPO6SLs/MhwFZefAiOxtgp/TpQMQbjv8UHCKGxs167vXaiTkjTGlDrlXego4+ewlf/52N6yt4MaE7Hm+xesAwuAaYmq3KSbkvSZCMf6532D4tFqo5E+Bu6wVnGkj5RHPL4hjzH+cUi0eXw8ZdIqTJxQFIZIk2giKTg3wa0nXzdjbe5rDYwxC7AWwm9ilWVn7AT1B4FVIrJMRM4JKUxyDHd83Xm5Uf6TO3x/2FhJQEQuBs7BTov4RZToScXYqRCzndPbE5GniJyNtR7OwBqwnWPCGOGI9fJzL7ZFfZtJ0LzTELi7eReYMAYzxpg9WFsCgIRX8pyhJt8974i1So8HX3dtS6zhXJ1JNyXpm9wbay3Dp4QORokXaezFHVYYQ5za5OF7QRbVoittRpRrJYp4yqQwTJxIeQSXabTuQB9NokeJG999qc19PQZjzHJjzGVYK9rTsK6+ZmONQkYC74vIpSGSRupRiGULZdHs+8D1i/Kf+vpkSOJ4XLRr5wIHJITzamCyE6e36/dwrZ+64hu+6CIi4XpwYkJETsZ2z2djjUvONEEOHYLogm31CzAnTFnc54q/2fm9tvOi3b0h0b6TvvDWtbxGrLiHi0aEjRWZPa7jWrdGQ5FuStI30bm5iMTSTeebohCtK3JIhDC354dwYwIDJbI3f18eBjvPyYdPrqEi0pTUIp4yyXcdh50y44y1DAqRBgKGJdG6BZM5PSHf2cd6XyPijJ18boz5nTFmCvYDsBf7AbwvYuLEsdjZd49i1OAbY16SZHnSAXdFLNbK2zE401n+je1GLgDOMMbsrKNsiSKfQGuyQ4R47vBDSZIlEeXtti9IiJzppiTnuI4vjhRRREYQGO/6Ikq+oWrzPi5z9tXYOYihaIGdRxctj28c604fH7nSTye1iKdM5hFws3V5hPTnE1CCc4PCfB+PTiLSLlRiERlMoNWRDHwyxXpfa4UxZjUBa7xjFG2SDHfedR2HnJ8qIqMAnxeiSFaGyeJ5rM/TSJtP2e90/fZ/SZLHN2/vMHF2PYvIUOwcwNZYZXSmMSY/hqTriF4W7jm+5zu/1aqb0hkPfds5HRduLqRYl3i+iu3SUHESwKmu441hY0XGN15aSMDuoW7EMk8kVTZsTWMbgTl2IefsYMcsPyYw3ynUfL8ZxDYn8ChJmieJbUmsdML2hJIhKH4fgjxRuGTIS0D5JqJMfPMki4HjQ4S3wRoF+e5h8DzJwS4Zjplj6DwDH7jizIpwXyKWCbYWfcy8Quo4TxKrXHtGubbPA86Oenx/fA7OdwDtQzyL/3HC43ZwHua6tZonGSWvPOo4TxJbEThm7mxQnO+65H46zuv0wa5aYrCtmlEJvp8zQz1/ceRzAvY7aQjjzB142nWtKXFcY0iU8HZYAyWDtSHpHxTeCmgdJY9fuGT8R8LKOZE3rT42rNcWX0Fsx3p0GYTtf+6Jrd1/7YrzhzD5zHDF2ex8OG7ANte7Osc7nfAy4LgQefg+xgVY44wF2GkdHZwX8V7nd4N1UXbMigDY2p9vcv5hbPfbKKzHnU7YrrmbsDX7SoImHZM8JRlvmQzEKliD7VK8xbkvnbDzD1e6rhFy5QPgSye8BDs3rDt2MP9M7JheKYGPz6wI9yVimRBGSTph7vUL54e5r5sI8ZHCfhwrsDX0G4HhjvydsSb07g/On+rx3ZlEwAXZCqc8O2I/kq+7ZArphs35XxEVHrbFNCFo86X5d9DvtVYaxKgkXff2mHhY5bIZO03gNOwyWW2c5+wc4AWXzHuBHnFcozN2WoNxntdzsGPY4bZjKmIxlMXMUM9fhPchbDysVyFfnL9hjXPaYeerPu8KC+mMIto1sN+uN7HfkGHOc9ce68zhTuwwVNhvtvOMHsRaP1+EfQ/bYb9NZxOonPsqgQlzAlEvL2eiN6egS1yFEm77C7Et4DmO8L5Gy4DLozwYeViv/PH6bj2JwEc/0lYJtAsnQwLKtc5l4uQTi+/WsJ5onJconC/bUmyXUh5JVJJOeCTfrSsJ47uVmsok0vYx0KKe353/IvKiy49FSOv+X8eUuxNnSoz/PaRyiUH+vFjSEl1JxiLfN0T27RvpGjNqUQ7xloX7f/SJEG9WtHjYHppXosj4Po7f2NpeI8YyqMQ6NJAQ6U+IMY/VhKi812VLtzFJAIz1dtIPWxP8GvtBrcTONVyNrW2cYIz5kYk8z82X3wLsPMSnsDWacuy6ai8Ao40xr0dI7svjcWxr4z1s12kZtl/9z9gXbV2EtF9hW8N3YD+cu7E1/hJsjfdt4P8BnY0x0SzQEkJdysQY8zn2//we22Ipwiq3TU5+JxhjwnpSMXbMbiy2xVWALYudzrXHGWNeruv/iwVjzE+wtdZPsUq/GGsN+FtsSyjcvdiKbbXd56TdiO2iLsdWht7BKvqzjDFHw+SRFIwxzxAoW9993Y39AF5ojLmtPuVJBo4RnM8aNZRP1EexFe2nsd3pu7DPWBH2Xr2KXQj4BGPMyqQLnHx6Ovt8wswdNsZUGmOmY20J3ifwDdqLHd6YDpxv4vcbeyo134dCJ/992Hv0B6xyu8c4WjGIb7G9O09hx0R3YL+xJdjn2NdKHWWMCTtHOx4ktDwNHxGZgX1JMMbE5WVE7DJN/wXMNtZqUVEUjxGR07Af43LsWNhmj0XyDMcQ5yB2zvi1xpgXPBYp7UjLlqSiKEoEfP6NH2nMCtJhMlZBLiZgUa3UAlWSiqI0NM7Edo//j9eCpAC+KUx3henGVKKgSlJRlAaFMWaMMaadsU7sGzXGmJ8YO3f2M69lSVdUSSqKoihKGFRJKoqiKEoYGq11q6IoiqJEQ1uSiqIoihIGVZKKoiiKEgZVkoqiKIoShpRRkiIyw7Wg6BSv5WloiMhMp2zzvZYlHXA/j17LkmhEpIWI3CMiS0XksIgccY7vEZHmCbzOdSLymYjsFZESEdkgIg9GWwtWRHqKyPdF5HUnTbGIlIrIFhF5RUTOS4BsQ0TkxyLyvIgsE5EdIlIuIoUiskpEHhWRkXW9jut6J4vIyyKyXUTKnP3LIjIpxvQniMjfRWStiBQ5su4SkQ9F5GYRyUqgrONF5AkRWe9c67CIrBORl0Tkljrk20lEzheRX4vIByKyz/XNn1mLfLqKyG9FZKGIHBKRChE5ICLzROTeui6QfQyJdARbl42aDoGneC1PQ9sIOEPO91qWdNjcz6PXsiT4f/XCrlUYzkH0OqIs8xXDNbKw/mnDXeMw1m9tqLRXEFi2KdL2JtCsDjI+EMM1qoBfJ6DM7yH84gdVwN11SO/bllPHlS+wTs4fjVb+dcg/L0K+M2PM42wiL55gsL68T03UO5MyLUlFUZKL09p4F+t8vgz4CVZp9nKOy5ywd+vYMvkbcKFz/CRwHHbpqMuxDt5bA6+KyIAQaVti17YswDq9Pg27hFUnrPeYPCfeJcAzdZDxCHZ5sDuxK5cMwi7fdDx2LcmN2J62e0Xk1ngvIiJXAr9z8poDnAzkOvs5zu/3i0jIRddF5DJX+i3YpdcGYcvzJOBfTtQRQNyO/0VEgOeA27Dl/yp2wYZu2LIfj3VQHu9iyG6OYv/7P2spYy/sPWvj5HEfMNKRbyTwa+wiBO2BtxLWokyUtk1AbWsG2pJMZvnORFuStSkv//PotSwJ/E+3ud6xa0OEX+sKvzXOawwj0Op5MkT4QALrp74UIvxs7Pqp4Za4y6DmotvjklRWbbGK2gCb48yjKYF1Eldy7ILpTQksNLwlONyJM9cJLyRoIWJXnCdc5TEyTllvduVxR5LK9Ezs2qqZznkfatGSxLoZ9MUPtxbt1a44YZfjq82mLUlFaTzc7uxXGmOeDw50fvMtDfW9OK9xG1aRVQK/CnGNDcA/nNNpwbV9Y8yHxph/mjBL3BljqoFfun46N045I2KMOYRttQD0EZEOcWRzIYFlqu4zxpQFXaMMu4A32Nb8+SHyOMHZf2WMCdeKc7eoh9RWSBHJwbbaAd41xjxU2zxiwRjzsTFmZbh7GwO+sigmcG+CeQW7fBbEURahaFBKUkSGi8g/RGSjYyhwxBmU/52IdAyTZq4zcPxkmPBPXYPLF4cIb+4MohsRuTZMHt1E5A+OLIccI4RNIvKUiBwX4f/kOfnOcs7PFZF3HCODShF5K6aCCZ33SMdowWdIsNUZrO8ZQ9o+jgGGz4jgqIisEZG/RTLKEJFZzv/Ji5J/frjB/BBlcoqIvOUYMZSJyGYReUhEOsfwP24QkS+d5+SIiCwWkR+ISGYMaTs6xgOLHMOGChHZLdbo41mxRitNouVTX4hIX2wrD+yHJBy+sOFOmtri62adbYzZHeUaGYRWDNFY7TruFkf6WKlwHZeFjRUeX1mUYNeZDcV7BD7qF4UIL3X21RGu4w7bG7N0Aa7AdlEC/F8c6esL3z3wtRRD4Q6LpyxC5JiEZnWcTfEZrj84JY70PyXy4PYBQgzmYhfQNcC3IcKyCXQNGeCvYboQfOHdQ4RfFZRH8FYJ3BzmP+U5cWZhV+wOTvtWLcpnppMmH/vyloSR5zAwKUI+V2Ff3HD/pwSYFibtLCdOXhRZ8wnTBRNUJj+KcM+3hLofTh6Z2PGbcP/hU+y4VMjuVuwY2+4I6X1bR6/fK5fMV7jkOiNCvDNc8S6r5TU6utL+T4R4Oc5zb4AH4/gvvVzX+d8klVcOsMG5xjdx5uHrSp0bJZ6vS3VFiLCPXO9ljzDp/+rE2Qe0jkPOFwgYvIjr9wzCdHsnqIz7uO7jzBji3+OKf1GYOJe44oT9jtVKzmQVQBwFNsP156bUMq27H3oVtkaWi+3quA2rIA12sL5fUNrTXWl7BoWd6vxe7uyXh7i2T3mtDxF2AQFLsbnODeyOrbVNAt5ywqoJYe1HQCFsd/bvYAf8OwL9gdNrUUYznTwOOtt64FKnnHoDP3DKx/ey5IbI42QCSmkrdgyrG9DVOfaNv1QCE0Okn0XilOQmp9zedMqyA9AX+I2rzF8Ik797bOMDV/phWKOTaif/cEpyjhO2B7gVGOzc0/7OM/MrYA1BShJrENGyjluTON+vX7r+c78I8fq74t1Ty2tMcqW9KUrcbU68j+L4Lz9yXeeSeMojTL4ZzvN8CbCAwLsZ8oMcQ15lTh7PRon7LydeKS4lFeKdWwNcBnQBmjvP60NOWAVwdZz/21cZ+BBr4fojbLd7hXPtrcDfgYGJKmvnun1c9/GYdz1E/DYEKqcHsd+sPtgKTR9H7sNO+MMJkzORf7qOBTbDVWBTapGuqavg1gBtQsQZRaD180ZQWDPXw3x9UNi9BFotpc4LE/zh+8qJ80TQ7zkuuT4AMsLI/6wTZ2WIsDxXmbwU/ALVsnxnuvLaTmglOIWAgnkoRPgyAsrhmFottoa/14mzJET4LBKnJA3w9zDpH3TCywiqWWMVuq/S8wEhasqu+36MksRaZvrCLq7lPejjzjfObUac9/8vrjxaRojXyhXvT7W8xsWutBdEibvYibe4ltdo73rG8oHseN8JV56LwpT1ZuJUwtgPui+fB6LE/ZMrbqsQ4RdhW4nhnol/A6fU4f/7vo3PAbMjXKcEuKKu5R3mfZgZY5rBWAUeTsZl8b4j4baGMCZ5IbY1BPBzY8zh4AjGmKVYCzCAi9zGAsaYEmC+czo1KKnv/APga2xLYLIvUERaACc6p3lBaa925KrG3rRwYwo+I4TjJfzk5Srgx8Z5ShLA/xhj9gT/aIzJIzAgfr17bE5ExmLNrH3pt4dIvxXbsgYYJSKjEyRvKIqBu8KEPe3sswnI7ONa7Dw+sGUayojg98DOMHm7xysLYpAzVWjhOi4NGyswPga25ZqMa7ivE/M1RCQD2+ry2Rf82BhTHrt4teIItrI1O8708ZQFhCgPY8w7wDRsiy4UPbE9ALXGMdpp6pxOw/aEzMW2YJthp1d8B9tyywGeE5ETQmRVLxhj1mFb+uHuS2egv4g0DRNeaxqCkjzZ2RcD70eI96qzz8TOL3LzubOf4vvBKeQJzmmeK45bkZ6M7Z7wxXFzhrNfDhwVkZahNuzD5xtgHhtG9mXGmB1hwuIhksHPG86+DXbOmI+TXcevRUj/quv4lFrKVRu+NtYCMRTrXMddgsJ8/2OtMWZNqMTGmArsfMJQYQex450Aj9SmImCMyTd2Ady6bLNivV4QEme6eK8RrUIXjzx/AHzedh43xrwRKXItOAXbgm6DnYN4G7bb7s/AIhEZHEeeCSkLEWkqIi8BvkWTZ2B7bDoA47AVwuHA0yLylzjkdOuAbGxL7AxjzJfGmFJjzD5jzFNYA6tqrEL9dRzXSQgi8mPsUNE47LDGUGzvwhBsg6ON8/vHzve1zjQEJdnb2a83xlRGiOe2iOsdFJbn7Pu6rDMnYmtO3xhrpRdKSfqO1xljglsevhdrFHaOU6TN17INN/l1U5jf4+GQMWZXhHC34ugd4vhQJIXttDB9rfngck4kkWQodp0Gu1nr4+zXRsk/pAJ18I2JjQMWO9a4z4p1DxaPRWjcOB/RkBWwIOvaItdxToQsm4VJEwvu+M3CxqopQ0zXcD6OP3NO3wPuqJ1o4THGlBhjiowxR4wxG4wxjwOjse9dP+DtWCyeg4inLILTge0BuxI7xDHRGPOMMWabMeaAMWahMeYm7Bg7wA9FpFbWws674u7lut8ETVVx4s0j0Ag522mB1isiMgPbNZ2BHSf+nTFmrTHmoDFmnTHmfgIWwqdgnQ3UmYagJFs5+2gvW2GIND7mETAvnhq0z3P2X2O7RY5zTS/wxfEpUDdtosgTinAPXnGY3+MhWjm5w1uFOI7lo+aLE1zOiSTWuVbBtXRf7bI25VADY8yb2Hv/iSNHb+B6rHHDJhH5QkTGHSOIJZxCi3ULnlbyBOErX9e54u1zHecSHnfY/gjxQhHrNdzhUa8hIjdh3ciBfR+nRakQ1xljzD6s5TvYCu8ZEaKHohA79g2xl0UZrudORLpjnyuwhijhKob3Yz3QgHXEUFvc92BOhHhfOPumQChvScnmbmf/mTHmk1ARnN993+MbRaTOPSgNQUn6lF+0prU73K0wMcaUYpUgBLpcffvPnTjlWGUKMEVEWmFrm3BsVysEHvbXatGVNjPKf0gE8ZZTrOXsjlMY9HusY6rJnF/ouy+1KYdjMMbMNsacie32Ohdbm1/oBJ8CzAmhKHsTvVch2nYd8eHugu4XIZ67JRyttR3XNZyhjK6xXENEpmErH4K1OL3QeV/rg/mu4xG1SejYIGxwTiOVNwTKfH2Q3cE4At/oRRGuVUKgpyzsvOsIuHtNDkaI5w5rHcd14kZE2mG7wiFCWTj43sMORK+gRKUhKMl8Zz8oyuTtYa7j/BDh/u5UpythPPajPjtUHOyHMNx4JAS6SEdFkMkL2kaZaD/UdbzFdZzvSt+VMDi1X18rOj8o2PdxC9v9JNZnaEjHDwki39lH88YxNEo4AMaYw8aY/xhj/tsYMw5buSrBju/cE6+QsWKMmRHj+OVi1/H4CFlOcB0vraUs+wgYl0S6xokEDKCWhIskIucCzztxVwHnGmNq2wW/oQZgAAAgAElEQVRcF9zfk3iM5nxlPlrC+MJ1fvdVtoPLwt2zFK1F5PuWR3I6EI6FruNInoXcYeHsAZJFPGUB8ZVH2MzSlbnOvjlwToR4Vzj7KgItQjd5zr4XtrbeFFhljHF7bXArySnO8RoT2rPIR86+v4gk04AlHi6NEHaZsz+M/TD5mOs6vjxC+itcx3ODwnzjtgMdS8VQTCVgbZcMfDINEZGQitL5cF0YKiwaxpjZwMfO6dCgMM8Md4wxmwm0NqZFiOoLW+mkqS0+g6fJIhKuFu+7RjV2+sIxiMipWEvrLOBb4ExjzIE45KkLp7qO43Hs7SuLZoT3LHQBgUrjO0FhbjuHMeEuInZ5M18Lcku4eBFwG/JNDhsr8M07SqCVXF/sI+ABKWxZOPgMIIuo/ZDBsZgEziepy0Zi5kmuJvQ8o5EE5gK9HiEfn2ecfGf/YFCcLOwD4o7zSJj8WrjkWgd0jvI/Bof4Lc9JPysB5TvTVb7bgU4h4kwh8jzJpU7YLkIsywP0wBoYhJz/hnVe7ZPhmDmGTpktc8WZGW+ZuPKYEfR78DzJY+avEnmeZEegQ4TrZgArnLRf1df7E+Mz4HZwfszEc2o65YjXwfnxBCa/PxEivL/rHTrGwbkTZwyBSeHbgN4JLocWhPFe44rTG2scZrDTQY75rsRwHbeD8xUEzenE9jb4npVjHJxjW0+FrneuS5jruJ1j3BmHnEJg3upqoHmIOFNd34ZZCboPfSK96yHif+LErQZOCxPH7QHtjYTImciHr44FNsP1576H7faJtPV3pb3GlXY5tnbWCfvRvoXARNywnvSdfD5zfxyBS0PE+SgoTkgXbE7c81wfjJ3Aj7Hdvu2w83nGOv/1U+BIiPR5iXooOdbjjm++USds6/lOaudxZzP2o9oVO83iaudFN4T3uNOEQOViP7bFnuuUxSXOvdvnyJcUJemEBXvcOQlrRn4c1sVXWI872IpEMdaV19XYbtv2WE8tU6m5jmJSVlOowzOQ5ZSxwVYaf+i8Iz2cY19FchmQFSaPvFDlEhTnUVcZPO6UUa5zj31K4zAwIETaIQScBRzAKsxIHohCrilJzUrhlKCwPtgu8eeA6QQ8JnXEdn3+0nk+I1YYIl3DFedKV5zZzrPW0dm7J+6HW9Xiv11xNmMNeXpgvyFjgadc4VuAFiHymOKKc8w75cSZRKDyuBA4C9u9Gurb0DvOa3Si5jf8UleafwSFHRci/WQC35+jWEOewdgVWwZjhzd8DZ1yYHSUb0NeTO+N1y+uS/AZLuFj2WYFpY/Ld2uEB7IaaB8izt1BcY5pkQXFv4jARz/Stj9E2rxQ/zXO8p3p5JXvyBTO/2o0361XR0hriOC71Uk/lfB+Yw85L0J+uJct1jJx5TkjRFgTrJPtcP/hM8L4bqXmxyDS9i+S6PeyDs9BLIsu94qQPi9UuQTFqcuiyzMjpAu15cWQz5SgsD4x5l1MhIpOpGsExYt70WVsz8TjMci6CRgWJg/3M3vMOxX0bkfyM70bmBDvNajdNz7cfb2JyN8fg+1mjfQNiniN4K0hjEkCYIx5AGsk809sjasUW1grsCbSg4wxX4TPAag5lWOFCT0G4o7zjak5ZhlKrnew1m13Y02o92FbWr5+/ZewD2efKLIlDEemiVgn3zuwta5t2AVyhxtjvoyQ9kXsWNtD2A9qsbOtw3ooGWKMeTVC+s+xNcXXsF2z5QR8Q55g7JheUjHGVBpjpmNf2nnY56QI24L6KbYWHc6Ty1fY6QC/x5rL52OVfplz/DJwjjHmehP/kkBJw1ivSL7W0jICVrPLnN9GO3Hqco0KY8xFwA1Ypbof+z5uBB7Grnn4UfgcEoJvNZsj1BxbBzvccBaBe7gZ+wyXYxVBHrbCPMgkYNkoY+fvTcY62vC9bzuc88nGmN9HSFttjLkVOz76DHYifTH2G7IP+z36ITDCGLM6TDbulX2+inCtF7FDU49ix4F939ClWAcCQ40xX4dLXx8YY/6J7Y17AGvodARb0TiC7TL+A7YVGvIbJCI9XKdhy6JGGkezKoqiNBhEZCtWOfzSUVKNFhF5FttN+7Ex5iyv5fESZ87tU9gKRn9jzJFoaRpMS1JRFAXAsVruifWtG4+rtobGGdihoXC+jhsTvkrCb2NRkKBKUlGUhseZzv5eYyfaN1pEZDjWuO55Y8wyr+XxEsf7zunYbv/HYk6n3a2KoiiKEhptSSqKoihKGJLpI7NB0bFjR9OnTx+vxVAURUkbFi9evM8YE251o7RAlWSM9OnTh0WLovnVVRRFUXyISDxu8lIK7W5VFEVRlDA0aCUpIoNF5Aci8pyIrBWRahExInJF9NSKoihKY6ehd7feBvzAayEURVGU9KRBtySx7qj+D+tkeAA114ZUFEVRlIg06JakMeYf7nM7l1RRFEVRYqOhtyQVRVEUJW4adEtSUQCqqg37j5ax+3AZGRkwtEtrMjK0V0FRlOioklQaFPuKyvjXvC2s21XIriOl7D5Syt7CMiqrA+4XO7VqypnHdeacYV2Y0K8D2U20Q0VRlNCokoyAiHwXu/guvXr18lgaJRKHSyr4x5xNPDV3M8XlkZdx3FtYxgvzt/LC/K20ymnCGUM7c/awLpw+NJesTFWYiqIEUCUZAWPM37GLATN27Fj1BJ+ClJRXMeurfB6fvZHDJRVh47VtnkXnVjnsKypj/9HAesqFpZW8ubSAN5cWcHz31jx09Wj6dmxRH6IripIGqJJU0pLKqmpeXLCVBz/7lr2FZTXChnRpxU0n96VPhxZ0aZ1Dbuum5GRlAnZ8clH+AT5cvZsPV++i4FBgJaVVBUe44ME5/O7S4Vwyqnu9/h9FUVITVZJK2lFcXsltzy1h9vq9NX7v3aE5Pz5zEBeO6BbWMCczQxjfrwPj+3Xgvy8YyuodR3h3xQ6enptPeVU1R8ur+OHLy5j77T5+fdEwWjTVV0RRGjP6BVDSisPFFdz0zEIWbzno/61L6xzuPH0g08b2qNWYoohwfPc2HN+9DReO6MYdLy5l876jALy2eDtLth7koatHMaxbm4T/D0VR0gO1UlDShj2FpVz593k1FOStk/uT97MpXDO+V52Mbo7v3oZ37ziZS13drJv2HuXSR77ixQVb6yS3oijpiypJJS3YdqCY6Y/PY+2uQv9v915wHL84d4h/vLGutGzahL9ceQJ/mjaS5tk2z/Kqau5+YyVvLNmekGsoipJeNGglKSKjReRr3waMdoLuD/pdSWE27C7kise/In9/MWDHFR+YNpKbTu6blOtdPqYH795xMkO7tvb/dtdrK5izYW+EVIqiNEQatJIEWgPjXVsr5/eBQb8rKcqK7YeY/sQ8dh+xFqzZmRk8eu1orhjTI6nX7d+pJS99dwKDO9tHprLacNtzS1i943BSr6soSmrRoJWkMSbPGCPRNq/lVEKz63ApNz69kIPFdv5ji+xMZt14ImcP61Iv12/TLIunbzyRLq1zACgqq+TGpxey/WBxvVxfURTvadBKUklfKqqquePFJf6J/22bZ/H8zRM4aUDHepWjW9tmzLrpRFo5U0H2FJYx4+mFHCouj5JSUZSGgCpJJSV54MN1LMy3VqwZAo9dO4YTerb1RJYhXVrzxA1jyHasZ7/dU8R3n11MaUVk93eKoqQ/qiSVlOOj1bt44otN/vOfnDWYif07eCgRnNS/Iw9MH+k/X5B/gB+/sozqavVWqCgNGVWSSkqxdX8xP3l1uf986uBO3Da5v4cSBbhoZDfuOW+I//z9lbt4dl6+Z/IoipJ8VEkqKUNpRRXfe2ExhaWVAHRv24w/Tz8hpdZ+vPmUfvzXxN7+8z/+Zx1b9h/1UCJFUZKJKkklZfjte9+wquAIAFmZwiPXjqZdi2yPpaqJiHDP+UP9U0NKKqr42asrtNtVURooqiSVlODtZQU8Pz/g/u1X5x/nmaFONJo2yeSBaSPJdFq4C/IPMOurfG+FUhQlKaiSVDyn4FAJd7+x0n9+/oiu3ODq0kxFhvdow/emBMZK//fDtX7n6IqiNBxUSSqe8z/vfUNxuZ1O0a9jC/54+QhEUmccMhx3nDaQIV1st2tpRTU/e3U5VdrtqigNClWSiqfMXr+XD1bt8p//8YoRtEyTNRyzm2TwwLSRNHG6XRdtOcjTX272WCpFURKJKknFM8oqq7jv7VX+88tH9+DEPu09lKj2HN+9DbdPHeA//78P17Fpb5GHEimKkkhUSSqe8eQXm/wre7TKacIvzh0SJUVqcvvUAf4VQ8oqq/mpdrsqSoNBlaTiCdsOFPPw59/6z3929mA6tWrqoUTxk90kgz+5ul2XbD3Ec19v8VgqRVESgSpJxRN+8943lFZUAzCsW2uuHZ/a1qzROK5ba+44baD//K+frOdIaYWHEimKkghUSSr1zmdrd/PxN7v957+5+Hj/nMN05pbJ/ejethkAB4sreDxvo8cSKYpSV1RJKvVKaUUVM9/5xn8+fWwPxvRu56FEiSMnK5O7zhnsP39q7mZ2HCrxUCJFUeqKKkmlXnl89ka2HrDGOm2aZfHzc9LTWCccF47oxvDubQBrxPOnj9Z7LJGiKHVBlaRSb2w7UMyjri7In509mA4t09NYJxwZGcLdrpVC3li6nW92HPFQIkVR6oIqSaXe+NunGyivtMY6w7u34epxvTyWKDmc1L8jpw3JBcAY+P0HazyWSFGUeFElqdQLm/YW8caS7f7z/77guAZhrBOOu88dgu/vzdmwjy/W7/VWIEVR4kKVpFIv/O3TDfjm158ysCPj+qaXZ53aMrBzK648saf//P7316iDAUVJQ1RJKklnw+5C3lm+w3/+ozMHeShN/fGjMwbRLCsTgLW7Cmu0pBVFSQ9USSpJ56+fbMA4jaipgzsxulfDmPIRjdzWOdx8aj//+Z8+Wk+Js9qJoqQDP3hpKbO+3ExpReN9blVJKkllzc4j/HvlTv95Y2lF+rjl1H50dCx4dx0p5Z+6SoiSJizMP8Dby3Yw891vmPpAXqNVlKoklaTyl48D8wTPPK4zI3q09VCa+qdF0yb86MyAu7on52ziaFmlhxIpSmw84vKtfMrAjuQ4QweNDVWSStJYuf0wH7ncz/3ojMbVivQxfWxPerSz7uoOFVfw4oKtHkukKJFZVXCYvHXWIlsEbp3c32OJvEOVpJI0/vJJoBV53vAuHNettYfSeEdWZga3uD4yT87ZRFll4+y6UtKDR/MCrcjzhnelX6eWHkrjLaoklaSwZOtBPlu7B7A10R820lakj2ljeviXAtt9pIw3lhR4LJGihObbPYV8sGqX//z2KQMixG74qJJUkoJ7LPLCEd0Y1LmVh9J4T05WJjef0td//vjsjVRWVXsokaKE5rG8TX5r9NOG5DbaHiAfqiSVhLMw/wBzNuwDIEPgB2cMjJKicXDN+N60aZYFwJb9xTWsfhUlFdh2oJi3lgV6OW6f2rhbkaBKUkkCbqu4S0Z1p38jHs9w07JpE2ac1Md//ujnG6lWLzxKCvHEFxv9nqEm9GvfYJaxqwuqJJWEsn53YQ2ruO9rTbQGN07qQ/Nsa0q/bnchnzrjtoriNXuOlPLKooBXqO9P1R4gUCWpJJh/zNnkPz5zaOdGbRUXirbNs7luQm//+cOff4sx2ppUvOcfczf7V+kZ2aMNkwZ08Fii1ECVpJIw9hSW8tbSgI/W77pcsikBvnNyX7Iz7au3fNsh5m3c77FESmPnUHE5z329xX9++9QBiDTcVXpqgypJJWE8+9UWyh2LzVG92up4RhhyW+cwbWwP//kjrjlpiuIFT3+ZT7HjV3hQ55acMbSzxxKlDqoklYRQXF7Jv1w10e+e0k9rohG4dXJ//3qaX367n6VbD3oskdJYKSqrZNZX+f7z26cOIKMBr/VaW1RJKgnh1UXbOVxSAUCv9s05a1gXjyVKbXq2b87FI7v5zx/5fKOH0iiNmRfnb63x7p4/vKvHEqUWqiSVOlNVbXhqbmB1i/93cl9/K0kJz21TAq7qPlmzm837jnoojdIYqayqrtGKvHVyf5pkqlpwo6Wh1JmPVu9i64FiANo0y6ox3qaEZ2DnVpw2JNd//ozrY6Uo9cEna/ZQcKgEgHbNs7hsdHePJUo9VEkqdcIYwxNfBKZ9XD+hN82zm3goUXrhdi7w2uLtFJZWeCeM0uh42rW+6dXjejXa5bAioUpSqROLtxxk2bZDAGRnZnDDSb2jpFDcnDKwIwNy7VzSorJKXlu8PUoKRUkMq3ccZv7mAwBkZgjXT9R3NxSqJJU68aTLecAlo7qR2yrHQ2nSDxHhv1ytyWe+yldXdUq94O7eP/f4LnRt08w7YVIYVZJK3Gzed7TGosrfOUWdB8TD5aO70yrHdlHn7y8mb726qlOSy/6iMt5aFnD8ceOkPt4Jk+KoklTi5qm5gSV1pg7u1OiXw4qX5tlNuOrEnv7zp7/M904YpVHw4oKtfhd0I3q0YXQvdfwRDlWSSlwcKa2osXDwzdqKrBM3TOyDb9bMnA37+HZPobcCKQ2WiqrqGo4/bpzURx1/RECVpBIXbyzeXsON1cT+6gy5LvRs37yGK7BZOh1ESRIfrNrF7iNlAHRq1ZTzh3eLkqJxo0pSqTXGmBo10esnak00Edw4qa//+PXFBRwu1ukgSuJxT/u4dnwvspuoGoiElo5Sa+Zt3M/GvdY7TMumTbh0lE5ATgQT+rVnSBc7rltSUcUri7Z5LJHS0Fi27RBLtwambF07Xqd9REOVpFJrnp0XaEVeNro7LZuq84BEICI1rAyfmZfvXyVeURLBLFcr8oKRXenUqqmH0qQHqiSVWrHzcAkfrwlM+7h+gtZEE8nFJ3SnXfMsALYfLOETV1krSl3Yc6SUf6/c6T+/8aS+EWIrPlRJKrXixflb/a2bCf3aM1CnfSSUnKxMrh7Xy3/uHj9SlLrw3PytVFTZd3ds73YM79HGY4nSA1WSSsyUV1bz4sLAONkNE/t4J0wD5roJvf2rqHy96QDrdul0EKVuVFRV8+KCrf5zt5GYEhlVkkrMfLh6F3sLrel459ZNOfM4Xb08GXRr24yzhwXK9oX5WyLEVpTofPLNbv+7m9uqKWcN03c3VlRJKjHjnvZx9bheZOm6c0nDbXX4xtICSpw5qYoSDy+4WpFXndhT391aoCWlxMTaXUdY4KwY0CRDaoybKYlnYr8O9OnQHIDC0kreXbEjSgpFCU3+vqPM2bAPgAyBK/XdrRWqJJWYeM7Vijx7WBc6t9bVPpJJRoZwzfjAx+z5+VsjxFaU8Ly4MPDsTB2cS/e2utpHbVAlqUSlsLSCN11+Wq/TaR/1whVjepLtdIst33aIVQWHPZZISTfKKqt4dVFgjVJ3xUuJDVWSSlTeXFrAUWdMbGBuSyb0a++xRI2D9i2yOef4Lv5z97iSosTCh6t3c+BoOQDd2uQwZXCuxxKlH6oklYgYY/jXPLef1t7qp7UeudZV8397aQFFZZUeSqOkG8+7hkmuGtfLP7VIiR1VkkpEFm05yIY9RQC0yM5UP631zLi+7RmQ2xKAo+VVvLNMDXiU2Ph2TxHzHWO7zAzhSteapUrsqJJUIuKegHzRCd1olZPloTSNDxHhmnFuA54tGKP+XJXovOAy9jpjaK4a28VJXJ6pRaQDMBUYBXQG2gIHgT3AEiDPGLM/UUIq3nC4uIJ/rwj4etRpH95w+ege/PE/aymrrGb1jiOs2H6YkT3bei2WksKUVlTx+hK3wY4a28VLzEpSRJoA04DvARMBcbZgDGBE5CvgUeA1Y4wOpKQhby0roKyyGoDjurZmeHf19egFbZpnccGIbv6P3vPzt6iSVCLy7xU7OVxi1yPt2b4Zpwzo6LFE6UtM3a0icj2wGXgOmATsBd4G7gd+CnzX2f8eeMcJPxl4HtgkItclXHIlqRhjanS1Xj2upxrseIjbdP/d5Ts5UqoLMivheaHGu9uLDDXYiZuoLUkRmQ+MBXYDfwKeMcasjiHd8cAM4BrgGRH5vjFmQt3EVeqL5dsPs9ZxrJ2TlcHFarDjKaN7tWVIl1as3VVISUUVby0tUAfzSkjW7jrC4i0HAcjKFKaNUYOduhBLS7IncCfQ2xhzVywKEsAYs8oY81OgN/ADQAe00oiXXDXR84d3o7Ua7HiKiNSYDvL811vVgEcJidtg56xhXXRh5ToSi5Lsb4x5xBgTV/+OMabCGPMw0D+e9Er9U1RWyTvLA1MNrh6nNdFU4OJR3WmWlQnAut2FLNl60GOJlFSjpLyqhnesa9XDTp2JqiSNMSXucxHJjOdCwfkoqcs7y3ZQ7HjYGZDbkjG923kskQLQOieLi0Z285+/tGBbhNhKY+T9lTspdBxO9O3Ygon9OngsUfoTzzzJt0VE2+8NmJcW1hz0V4Od1OEqV6v+vRU7KVQDHsXFy65F0aePVWO7RBCPkjwP+I+ItEy0MIr3rN5xmBXbrSPt7MwMLlODnZTihJ5tGdy5FQAlFVW855rHqjRuNu4tYkF+wMPO5WP03U0E8SjJF4HJwKciEtbTtYhMcuZKKmmEuwvvnOO70K5FtofSKMGICNNd7sVeWqhdrorllUWBZ+H0IbnktlIPO4mg1krSGHMt1knAicBsEeniDheRASLyGvAFMD4hUir1Qkl5FW8tCwz6X6UGOynJpaO611hCa+2uIx5LpHhNRVU1ry8OeNhRP62JIy63dMaY74vIAeBXwFwROQMoBO4DbgGygMPAHxMlqJJE/m8gHN1DM2AlgFMBNW/kws82eCiYEor2LbI5c1hnv8vAlxdu474Lh3ksleIln67Zw74iuyRW59ZNmTyok8cSNRzidnBujLkX+BHQF5gHfAt8H6gCHgD6GWP+kAghlSRzdE/InyXM74r3XOVqKby5tICyyioPpVG85mWXsd20MT1pkqlrVySKupbkdmA/1sl5a6xLukGO0wGdxKUoSWJS/450b9sMgEPFFXy0erfHEilesfNwCbPX7/WfTx+rXa2JJC4lKSKnOe7qXgE6Aquxzs5HA80TJ56iKKHIyJAaH8OX1YCn0fLaou1UO86XTurfgV4d9BOcSGqtJEXkQ+BjrOHOOuBiY8xw4IdAd2COiIxKqJSKohzDtLE98E2Dm/vtPrYdKPZWIKXeqa42vOyyalWDncQTT0vyTOwqH7cDw40x7wIYYx4EbgLaA5+JyKkJk1JRlGPo1rZZDQONVxdpa7KxMW/TfrYftM7M2jTL4uxhXaKkUGpLPEry98AAY8xjxpga1gLGmGeA6Vj7yP+IyAUJkFFJMoczwrida5Fbv4IoteZKV5frq4u3U1WtTs8bE+55speO6k5OVlxeQ5UI1HoKiDHml1HC3xSRC4G3gNfwTyhQUpFdh0s5qeQR/5jGFz+bqmMaacTpQzvToUU2+4+Ws/NwKV9s2MvUwVq5aQwcPFrOh6t2+c+1qzU5xDVPMhrGmE+cuZP/Tkb+SuJ4fUlg0H9iPx30Tzeym2SQ0fvXtDLWleCdXwNf27AOOR3IuzLPM9mU5LD+5FOo2rcPgLddv2fO7Qhz53gjVAMmaZNpjDFfY93XKSlKdbWp4cpq+ok9PJRGiZdSR0EGs790fz1LotQHPgUZ6+9K3UjqjFNjzKpk5h8rInKNiMwRkcMiUiQii0TkdhFp1DNuF+QfYMt+axHZKqcJ5x7f1WOJFEVRUouoSkJE7heRNnW5iIi0EZH765JHHa79CPA8MBaYg52+Mgh4GHgt3vUxGwKvuAb9Lz6hmw76K4qiBBFLS+rnwGYRuU9EarXMtYj0EpGZwCbgrjjkqxMicjnwPWAXMMIYc4Ex5lJgILAGuBTrSq/RcaS0gvdXBZZZunKsrmCuKIoSTCxKchLWL+t9wCYR+URE7haRKSLSWUSaAIhIlnM+VUTuEZHPsMrxXmADcFKy/kQE7nb2PzfG+D11G2N2A7c5p79ojN2u7yzbQWlFNQBDu7bm+O6tPZZIURQl9Yhq3eoY4IwTkWuwXnVOA6a644hIGdDU/ZOz/xr4mzHm5cSIGzsi0gMYA5QDrwaHG2Nmi0gB1kvQBKBRrX3pnng+fWwPXcE8jemQ0yGkkU77nA4eSKMkm6LmrWlZfOzyaJkdO3ogTcMn5ikgxpgXgBdEZCxwCTAFOAHrq9U3F/IosAT4HHjLGLMsodLWDp9rvNXGmJIwcRZileQoGpGSXLvrCMu3W4vI7MwMLjlBVzBPZ3zTPIwxnPmXL/h2TxEA/33FCA+lUpJB/r6jTDvrXgAyM4R5vziN3NY6FT2ZxONMYBGwyHcuIs2BNsChCMrIC/o6+y0R4vjWl+kbIU7DwVk3cgiQ736vHtV1IxsCIsL0sT24//21gDXM0hUhGhbuKVtTBnVSBVkP1HkszhhTbIzZmWIKEqClsz8aIU6Rs28VKlBEvutMF1m0d+/eUFHSi3DrQ+q6kQ2GS0f1oEmG7TpftOUgG/cWRUmhpAuVVdW8vmS7/3y6etipFxqywYpvkC1uZ5bGmL8bY8YaY8Z26qQrfSupT6dWTTltSMAt3Svq9LzB8MWGvew+UgZAx5bZNe6zkjzqpCRFJFNEcp2pHiG3RAkaB4XOvmWEOL6wwghxFCWtcPvwfH1xARVV1R5KoyQK95qhl43uQVZmQ27jpA7xLro83llXshDYCWwOs21KkJzxkO/se0eI4/ua5EeIoyhpxeRBnchtZY3N9xWVkbeuAQwVNHL2FZXx6ZrAsIiONdcf8Sy6PAnIw64rmQMcwhrAhNq87OtZ6uyHiUizMHFODIqrKGlPk8wMLh8T8MPrboEo6cmbSwqodFYiGNO7HQNyI3WQKYkknpbkr7FzIp8EOhtjOhhj+obbEitu7BhjtmGno2QD04LDRWQy0APrjWde/UpX/1RXG/bTNnSgrhvZ4HC3ND5ft4c9haUeSqPUBWOCFiIYqwsR1CfxLJU1DnRkEZUAAB1fSURBVFhjjLkl0cIkgd9jHQn8UUS+MsZ8CyAiucCjTpw/GGMa/KDNlxv3cX2p/cvtmmfx9T2n07SJ+mptqPTt2IJxfdqzIP8AVdWGN5YUcOvk/l6LpcTB0m2H2ODMfW2encn5I7p5LFHjIh4lKcCKRAuSDIwxr4nIY1gXdCtF5BOgAjgdaI1dGPphD0WsN9xdbpeM6q4KshGwteXPaTX0IACP5NsNdJ3JdMG3bmQz4APX7zs+68ggXTey3ohHSa4EuiRakGRhjPmeiMwFbseub5kJrAX+CTzWGFqRB4+W89Hq3f5zXcG8cXC06mDI33WdyfRA141MDeJRkn8DnheREzx2OxczPpd6XsvhFW8uLaDcmQYwskcbhnRRZ+aKoiixUGvDHcdZ+e+Aj0XkNo/nQipRCB70v/JEvV2KoiixUuuWpIhUuU4fBh6OsIKEMcbE01pVEsSK7YdZu8v6SmiWlcmFI7t6LJGiKEr6EK/hTjLiKkngZVcr8rzhXWmVk+WhNIqiKOlFPN2tGbXZkiG0EhvF5ZW8s2yH/1wNdhoXHcKsJ9kmu309S6LUlrLKKg7lhFx3QdeNrGe0K7QB8/7KXRSVVQLQr2MLTuzTzmOJlPrEPc3jzheX8s5yW2G6bGIkT41KKvDJN3u4/Zz7AOjWJoc5Pz+NzAztmPMCbek1YF5xzY2cNrYnEcaOlQbOVa5ehDeXFlBaURUhtuI1Ly3c6j+eNranKkgPidqSdFmvFhhjqmprzWqM2Ro9lpJoNu0tYkH+AcCuYH75mO4eS6R4yYR+HejdoTlb9hdzpLSS/6zaxSWj9JlIRbYdKGbut3YupAhMUzd0nhJLSzIfu5pHf9d5uFU/UmkVkEbNK4sCi7OeNiSX3Fa6gnljJiNDavhzfXGB1l1TlVcXbcM4q+CeOrATPdo191agRk4sY5JbsQsXVwSdKylKeWU1ry12zY3UZXUUYNqYHvz54/VUVRvmbz7Apr1F9Oukq0mkElXVpkYF9yo1tvOcqErSGNMn0rmSenyyZjf7isoB6NI6hymDO3kskZIK5LbO4bQhuXz8jXVR+Mqi7fzi3CEeS6W4+WL9XnYdsSu2dGiRzelDO3sskaKGOw0Qd1fa9BN70kRXMFcc3C2T1xZvp6KqwbsuTivcBjuXj+lBdhN9d70moXdARAaKyOUiMjaR+Sqxs3V/MXM2BAb9dW6k4mbyoE50bt0UOHa1e8Vb9hSW1rgf03WYJCWotZIUkctE5H0RGR/0+6+ANcArwHwReS5BMiq14EVXTXTKoE50b9vMQ2mUVKNJZkaNj+/LC9WAJ1V4fXEBldXW3GNcn/YMyNXx4lQgnpbkdcCp2CWzABCR44HfANXAl8Ah4GoRuSwRQiqxUV5ZzasuN3RXj1Nn5sqxuJXk7PV72XGoxENpFLALEbgrLNoDlDrEoyRHAcuNMcWu367DWrx+xxhzKnAi1hr25rqLqMTKpy6Dnc6tm3LakFyPJVJSkZ7tm3PyAOvarNrAqy5rSsUb5m8+QP5++0lt1bQJ5w3XhQhShXiUZAegIOi3yUARzpqNxphNwFxgaJ2kU2rFCy6DnSvHqsGOEh53S+WVRduoqtZZXV7iNra7eFQ3mmVneiiN4iaer2hTXKt7iEg2cAIwzxhT6Yq3C1D75Xpi24GaBjvTtbtGicBZwzrTvkU2AAWHSpi9Xg14vGJ/URkfrNzlP79K13xNKeJRkjuB41znp2IV55dB8VoCR+KUS6klbtPxyYPUS4cSmaZNMpk2JuDu7Lmv1YDHK15ZtJ1yZyrOCT3bcnz3Nh5LpLiJR0nOBoaIyF0iMgL4LXY88j9B8Y4HdLCjHqioqq7hpUMNdpRYuGZ84Dn5fN0eth0ojhBbSQbV1YYXFmzxn183QVdoSTXiUZK/w44//h5YCowHPjXGLPRFEJFBQD9gfiKEVCLz6Zrd7C0sAyC3lRrsKLHRu0MLTh1kvTEZo/5cveCLDXvZdsBaF7dplsUFI9RgJ9WIZ9Hl9cAk4BngA2AmcHFQtNOB5cB7dZRPiYEXFgSmfUwf25MsNdhRYuRaV2vylUXbKK9UDzz1ibub+4oxPcjJUoOdVCOuRZeNMauAmyKEPwY8Fq9QSuxYg529gHrYUWrP6UNy6domh52HS9lXVM6Hq3dx4chuXovVKNhxqITP1u72n7srLErqoE2ONOflhTWX1enZXg12lNhpkplRw5ryua+3RIitJJKXFmzFN/Nm0oAOuiJLiqJKMo0pr6zmpYXqYUepG1eNC6x8P3/zATbsLvRYooZPRVXNd/fa8Wqwk6qokkxjPli1k31F1mCnc+umnD5UDXaU2tO5dQ5nHReY0vz8fDXgSTYff7ObPS5juzOP0ynlqYoqyTTmma/y/cfXju+tBjtK3LinHry+eDvF5ZURYit15fn5gW7tq05UY7tURu9MmrJy+2GWbD0EQFamcNU4NdhR4uek/h3o17EFAIVllbyzbIfHEjVcNu0t4stv9wOQIXCVDpOkNKok05Rn5uX7j88f3pXcVjmeyaKkPyJSw7nAc/O3YIz6c00G7u7s04Z0ppsuZ5fSqJJMQw4cLeed5YGa/g0n9fFOGKXBcMWYHjRtYj8JqwqOsHz7YY8laniUVlTx2uKAd6zrJmgrMtVRJZmGvLRwq3/S94gebRjVs63HEikNgbbNs7lgRGCOpE4HSTzvrdjJ4ZIKAHq1b86pAzt5LJESDVWSaUZlVTXPu7x03DCxDyISIYWixI67ZfPu8h0cKi73UJqGhTGGf83L959fM74XGRn67qY6qiTTjE/X7qHAWUm+fYts9fWoJBS7CkVrAMoqq3nR5fJQqRuLtxz0d2FnN8mosQqLkrqokkwz3NM+rjqxp/p6VBKKiDDjpL7+82e+yqeiSv25JoJ/frnZf3zJCd3o0LKph9IosaJKMo3YsLuQrzYGTMev1WV1lCRw4ciudHQ+4LuOlPL+yp0eS5T+bDtQzH9WBRZWvunkvhFiK6mEKsk0wj3t46zjutBdTceVJNC0SSY3TAxUwJ6au1mng9SRZ77K9/tpPXlAR4Z0ae2tQErMqJJME46UVvDGkgL/+Q0naStSSR7Xju9FtjMdZMX2wyzactBjidKXorJKXnb5af1/2opMK1RJpgmvLdpOcXkVAIM6t2Rivw4eS6Q0ZDq0bMplo7r7z5+aszlCbCUSryzcRmGZdfPXr1MLJg/SaR/phCrJNKC62vAv15w1nfah1AfucbOPvtnFtgPFHkqTnlRVG57+KlDBuGlSX532kWaokkwDPl6zm837jgLQqmkTLnXV8BUlWQzq3IpTBnYEoNrA01/meytQGvLxN7vZdsBO2WrbPIvLR+u0j3RDlWSKY4zh8dkb/efXjO9Fi6ZNPJRIaUy4x89eWbSNwtIKD6VJP9zTPq4Z14tm2TplK91QJZniLMw/yFJntY/szAw1HVfqlcmDOjEgtyVwrAGKEplVBYdZsPkAAE0yhBsm9vFWICUuVEmmOO5W5KWjutO5ta72odQfIsJNkwIVs6e/zKdSnQvExFNzA63I80d0pUsbfXfTEVWSKcy6XYV8tnYPACLw3cn9PJZIaYxcNro77ZpnAVBwqISPvtntsUSpz+4jpbzrWqlHp32kL6okU5gnXK3Is47rTP9OLT2URmms5GRlcu34ms4FlMg8Oy+fSsd7wIl92jGih67Uk66okkxRCg6V1Fgz8tbJ/T2URmns3DCxN1mZdurC4i0HWbpVnQuE42hZZY2FlbUVmd6okkxRnpqz2V8THd+3PaN6tfNYIqUxk9s6hwtda00+8vm3HkqT2jz39RYOFVsr4J7tm3HmcV08lkipC6okU5BDxeW8tDBQE711irYiFe9xP4efrNnDqoLDHkqTmpSUV/H3Lzb5z2+fMoBMdR6Q1qiSTEGenbfF74JuSJdWTFE3VkoKMKhzK84bHmgVPfTZBg+lSU2en7+F/UftQtXd2zbjMnUekPaokkwxSsqrmOVaM/KWyf3UBZ2SMtxx2kD/8Yerd7Nm5xEPpUktSiuqeMLVirx1Sn+/k3glfdE7mGK8ungbB1w10Qtc40CK4jVDu7bm7GGd/efamgzw0oKt7C0sA6BL6xymj9VWZENAlWQKUVlVzZNzAjXR75zSl6xMvUVKauFuTb6/chfrdhV6KE1qUFZZxeOzXa3Iyf1o2kRd0DUE9AucQry5tMDvDLld8yyuPLGnxxIpyrEc370NZwzN9Z8/rJauvLpoO7uOlALQqVVTrhrXy2OJlEShSjJFKKus4q+fBLqubpzUl+bZ6shcSU3uPD3QmnxvxQ6+3VPkoTTeUl5ZzWN5Accft5zaj5wsbUU2FFRJpggvzN9KwSHbiuzQIlsdmSspzYgebZk62FpdGwMPN+KxyTeWbPe/ux1bZtfwTqSkP6okU4Ciskoe/izQZXX71AG01OWwlBTH3Zp8Z/kONu1tfK3JiqpqHskLvLs3n9JPl8NqYKiSTAH+OXdzjblV107Q8Qwl9RnVqx2nOnN4qw088vnGKCkaHm8F2RFcN0FbkQ0NVZIec+BoeQ0PHT88Y6BaxSlpww9OH+A/fmtZAVv2H/VQmvqlsqq6hnu+75zSTxdEb4CokvSYx/K+paisEoABuS3VQ4eSVozp3Z5JAzoAUFVt+MvH6z2WqP54aeE28vcXA9A6pwk3TNRWZENElaSH7DxcwjPztvjPf3rWIPXzqKQdPzxjkP/4rWU7WNIIVgg5XFLBn10Vglsm96dVTpaHEinJQpWkh/ztkw2UV9pV3kf2aMPZw3S1ACX9OLFPe849PvDs/vrdb6h2VrBpqDz46YYanrF0OayGiypJj9i0t4hXF2/3n991zhD10aqkLfecN9Tvp3T5tkO8ubTAY4mSx8a9RTzj8q98z3lDdV5kA0aVpEf86eP1VDm17UkDOjBpQEePJVKU+OnZvjk3nxJoTf3xP2s56oy1NzTu//ca/1qv4/q0r7EyitLwUCXpASu3H+b/t3fn4VXVdx7H39+QENBAIMgiuxgWCRg2V0aE4l6VKuNoW612gVasllrFcaMVKjqOOmqtWu0oWrWitdoBrY9VrGXELQqCAgURJDKARAk7JITv/HFObkKaGxpM7rnL5/U89zn3d89Jni/3Cfdzzzm/5YVF62LtKacOiLAakaYxaXQhndrkAvD51t3c99f0m67ub8s38uqyzwEwg6lnDdQVoDSnkEywqr3O9c8vjrVPK+pCcY92EVYk0jQOzs1mymk1X/gemreK0i93RFhR09pTtZfpc5bE2ucN786gbvkRViSJoJBMsJnzV7Pos2BF95bZWUw5rX/EFYk0nXOHdqO4exAcFXv2MuPFpRFX1HSeeHsNK8I5avNys7nqVP3fzQQKyQT6bNMO7nj577H2FV8rpE/HvAgrEmlaWVnG1LOKYu0/f7ieN1d+EWFFTaN8RwX/9UrNkI/LxhTSqU2rCCuSRFFIJoi7c8PzH7KjogqA/p3bMHHU4RFXJdL0hvdqzzeG1CwWPm3OklgntVR11ysrKN9RCUCPgtZ8d2TvaAuShFFIJsjsRev46983AsEN/xnnDo51mRdJN9ecPoDW4bCIpeu28NS7ayKu6MAt37CV371VM+nH9RrykVH0KZ0A5TsqmDb7o1j7omN7MbxX+wgrEmleh+a35tLRNVdKbn1xWUp24tm9p4rJTy2MnQkf26dAk35kGIVkAsx4cSll24LZObq0bcXVuuEvGWDiqD706nAQAFt37+Gnsxayp2pvxFU1zp0vL2fJui1A0NFu2rhBGvKRYRSSzWz+yjKeLqmZWWfauCLN8SgZoVVOC+46f0hsPuKSTzel1HJab3xcxm9qrdBz7ekD6Ne5TYQVSRQUks1oV2UV1z/3Yax9WlEXTtGlGskgQ3u2Z3KtxZnvmbuC9z5N/gnQN22v4GdPfxBrn9ivI5cc3zu6giQyCslmdO/cj1lVFqyv1yY3m5vGFe3nJ0TSz6QxhRzduwAIJtOYPGsBW3dVRlxVfO7Odc8tZv2WXQAUHNyS/zzvSF1mzVAKyWZStm03D86ruVRzzekD6NxW46ok87TIMu48v5g2rYIFiUu/3MnP//TRfn4qOs+UfMafP1wfa982/kiNicxgCslmckheLk//8DgGdGnDiF7t+dbRPaMuSSQy3dsfxM3nDI61/7hgLX9amHwrhawq284vavVE//YxPTlpYOcIK5KoKSSb0ZAe7Zh9+b9w34XDyNJiypLhzi7uyrnDusXaNzz3YVINC6ms2svkpxbEJvzo0/Fgbvj6wIirkqgpJJtZTossXaoRCU0bN4ieBTXDQi7//QJ2VES/pJa7c9Psj/ggnFc5p4VxzwVDad1SkwZkOoWkiCRMXm42d19QMyxkYWk5P3i0hF2VVZHV5O7MeHEpj79VMyvQVaf01wofAigkRSTBhvZsz41fPyLWnr/yCyY8Fl1Q3vmX5Tw0b1WsfVZxVyac0CeSWiT5KCRFJOEuGXnYPsvEzVtRxqQn3qdiT2Jn5Ll37gp+NbdmcehTizpz578Vqw+BxCgkRSQSk0YX8tOT+sXac5d9zo+ffJ/KBE1d99t5n3D7yzXLX43p35F7vjmUnBb6WJQa+msQkchcMbaQy8bUTIT+8pINTE7AHK+PvbmaX75QsyD0yMIO3H/hcHKz1VFH9pW2IWlmB5vZt83sLjN7w8x2mJmb2ZyoaxORgJlx1Sn9mXDCYbHXXli0jsmzFjbLrDxVe50HXl/J1FqTGRzdu4CHvjNCy19JvbKjLqAZ9QUej7oIEWmYmXHdGUdQWeXMnL8agDmL1lGyehO/OLuI0wY1zXzHH/3fZq7942IWhcM8IBjL/PB3j+Kglun8UShfRTr/ZWwFHgZKgPeAocADkVYkIvUyM35+1kD27N0bG4qxfssufvT4e5x0RGduGldEt3atD+h376yo4q5Xl/Pbeati60ICFHfP59HvHU1ebjp/DMpXlbZ/He6+Evh+ddvMNHWGSBIzM6aPG8RRvQuYPmdJbA3WV5ZuYP7KMq48uR+XHN+b7EZ0rPnb8o1c//xiSr/cGXutZXYWV3ytkImjDqdldtrecZImkrYhKSKpx8wYN6Qbo/t14taXlvH7d4Kzyh0VVfzyhaU8+c4ajuvTgeLu7TiyRz59O7WJTUzg7qwt38mCNeUsLC3n/TWbWLCmfJ/ff2yfAmacM5g+HfMS/m+T1KSQFJGkk39QDrecO5jxw7px3XOLWb5hGwCfbNzOJxu388TbQXi2zmnBoG5tyW+dw8LSzZRt213/72udw/VnHMF5I7pryStpFIWkiCStEb0LmHP5CTw07xN+NXcFuyr3HRqys7KKd1c3vIjz2cVdufHMgXRsk9ucpUqaUkg2wMwmAhMBevbUUlciUWiZncVlYwq56LhefFBazqLPNse21QsjV8vLzaa4Rz5De7RnSI92DOnZjkPyFI5y4JIyJM3sNuDsA/jRse7eZIvUufuDwIMAI0aM8P0cLiLNqG2rHE7o25ET+naMvbZhyy4WfbaZbbsrKeqaz+Ed82L3KEWaQlKGJNAV6L/fo/5RTlMXIiLJq3PbVpw8UEvRSfNJyv7P7n6hu9sBPFZHXbuIiKSPpAxJERGRZKCQFBERiUMhKSIiEkeydtxpEmb2HHBo2KzuEjfSzN6qddh0d38hsZWJiEgqSOuQJJjUvFed19oBx9Rqd0RERKQeaR2S7t476hpERCR1mbvGyP8zzGwj8GnUdTSxQ4CyqItIIXq/GkfvV+Ok4/vVy91T+mqdQjKDmVmJu4+Iuo5UofercfR+NY7er+Sk3q0iIiJxKCRFRETiUEhmtgejLiDF6P1qHL1fjaP3KwnpnqSIiEgcOpMUERGJQyEpIiISh0Iyw5jZt8xsnpltNrNtZlZiZpeZmf4WajGzHDMba2Z3mNlbZrbOzCrMbK2Z/cHMRkddY7Izsxlm5uHjqqjrSVZm1trMppjZu2ZWbmY7zGyVmT1jZiOjri/TpfWMO7IvM/s1MAnYBbwKVAJjgXuBsWZ2nrtXRVhiMjkR+Ev4fD3wHrAdGAiMB8ab2XR3nxpRfUnNzI4CpgAOWMTlJC0zOwx4GSgEPgdeB3YDvYFxwAfAG1HVJwrJjGFm4wkCcj0wyt1XhK93Bl4DzgF+DNwdWZHJZS/wLHC3u8+rvcPMzgeeAG40s9fc/bUoCkxWZpYLzAQ2AO8A34i0oCRlZgcTfBE7HJhOsNhCZa39HYAOEZUnIV1iyxzXhttrqgMSwN03AJeGzX/XZdeAu89193+tG5DhvlkEIQBwYUILSw3TCM64fwRsjriWZHYDQUA+5u5TawckgLt/4e7LoylNqukDMQOYWXdgOFABPFN3v7u/DqwFugDHJra6lLUg3HaPtIokY2bHAD8DnnT32VHXk6zMrCUwIWzeGmUt0jBdbs0MQ8PtR+6+M84x7wLdwmPnJ6Sq1NY33K6LtIokYmatgEeBL4GfRFxOshtOcCm11N2XmtnxwJnha+uBl9z9zSgLlIBCMjMcFm4bWsVkTZ1jJQ4z6wJcEjafjbCUZHMz0B+4wN3TbTWLpjY43K4ws5nAxXX2TzWzZ4GLGvhiKwmgy62ZIS/cbm/gmG3htk0z15LSzCwbeBzIB17VJcVAeCY0GXg+vGcrDSsIt6OA7wC3E/RwbU/Qq3UtQS/qX0dSncQoJDNDdRd8zUH41T1AMGymFHXaAYJxfsAjwBaCHtSyf9WfvdnAf7v71e6+0t3L3f1/CHoEO3CxmfWJrEpRSGaIreE2r4FjqvdtbeCYjGZmdwPfJ7hnNNbd10dcUrKYAfQDrnR33aP959T+f/ZQ3Z3uXkIwNjcLGJ2gmqQeuieZGVaH214NHNOjzrFSi5ndAVwBbCQIyBX7+ZFMcg7BuNKLzazuvbUB4fZSMzsT+Njdf5DQ6pLT6lrPV8U5ZhUwgqDXuUREIZkZqocrFJlZ6zgdAY6qc6yEzOw24ErgC+Bkd18ScUnJKItglqJ4+oSPdokpJ+m9X+t5B4IvX3UdEm631bNPEkSXWzOAu5cS/KdsCZxXd7+ZnUgw3m89oG7ntZjZrcDVwCaCgPwg4pKSjrv3dner70EwJATg6vC1IVHWmizcfS3wdtgcW3e/mbUHhoXNkkTVJf9IIZk5bgm3/2FmhdUvmlkn4L6weau77014ZUnKzKYD1wDlBAGps2xpSjeH26lmFvvyEI43vZ+gB/V76ItrpHS5NUO4+x/M7H6CKegWm9kr1Exw3hZ4nmCicwHM7GyCacMAPgYuN6t3nu5l7q4ZU6TR3H22md0OXAW8bWZvE1zSPxroSjAM5Jvurl7pEVJIZhB3n2Rm/wtcRnD/qAWwDHgYuF9nkfsoqPV8RPioz+toWjE5QO5+tZnNBy4nmO3qIIKJPe4kuLJT371KSSDTlxQREZH66Z6kiIhIHApJERGROBSSIiIicSgkRURE4lBIioiIxKGQFBERiUMhKSIiEodCUkREJA6FpIiISBwKSRERkTgUkiIiInEoJEVSiJn9xszczF6yepYlMbOZ4f7Z9e0XkcbRBOciKSRca/AtoBi4zt1vqbXvYmAmUAoMcfcvIylSJI0oJEVSjJn1I1iMtxUw2t3fMLMjCFawb1n9WpQ1iqQLXW4VSTHuvhz4IcF6sE+ZWQ/gGYK1CG9QQIo0HZ1JiqQoM3sQmABsBvKBl4AztJK9SNNRSIqkqPD+5DKgF/A5UOTuZdFWJZJedLlVJHWNAnqGzwuAvhHWIpKWFJIiKcjMDgV+BxjwCDX3J9tHWphImlFIiqQYM8sCngA6AXe7+/eAxwjOKh+JsjaRdKOQFEk9U4ExBEM+poSvTSK4PznOzH4SVWEi6UYdd0RSiJmNAV4BtgHD3H1lrX2DgXcIvvyOdPeSaKoUSR86kxRJEWbWieAyaxYwoXZAArj7YmAywYQCs8wsP/FViqQXnUmKiIjEoTNJERGROBSSIiIicSgkRURE4lBIioiIxKGQFBERiUMhKSIiEodCUkREJA6FpIiISBwKSRERkTj+H83PA9GgnrpPAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mn=-1\n", + "mx=7\n", + "x=np.linspace(mn,mx)\n", + "plt.plot(x,np.sin(x))\n", + "\n", + "xb = incsearch(lambda x: np.sin(x),mn,mx,ns=50)\n", + "\n", + "plt.plot(xb,np.sin(xb),'s')\n", + "plt.ylabel('$\\sin(x)$')\n", + "plt.xlabel('x')\n", + "plt.title('Upper bounds={:.2f},{:.2f},{:.2f}\\nLower bounds={:.2f},{:.2f},{:.2f},'.format(*xb[0,:],*xb[1,:]));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Success - incsearch works\n", + "\n", + "You should see that `incsearch` returns intervals in the correct locations near x=0, x=$\\pi/2$ and x=$\\pi.$ Now, let's apply it to the freefall problem and discover what mass is necessary to reach 36 m/s at t=4 sec of freefall.\n", + "\n", + "Depending upon what `ns` you choose, you should see that a mass of 142-143 kg will reach 36 m/s in 4 seconds of freefall. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of brackets: 1\n", + "\n", + "Upper bound on mass = 143.94 kg\n", + "Lower bound on mass = 142.42 kg\n" + ] + } + ], + "source": [ + "xb = incsearch(f_m,50,200,ns=100)\n", + "\n", + "print('Upper bound on mass = {:.2f} kg'.format(*xb[0,:]))\n", + "print('Lower bound on mass = {:.2f} kg'.format(*xb[1,:]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise \n", + "\n", + "Use the `incsearch` function to find the number of times $cos(x)=0$ in the interval $x=0...8$.\n", + "\n", + "Plot x-vs-cos(x)\n", + "\n", + "and \n", + "\n", + "plot the values of `xb` and `np.cos(xb)` as $\\circ$-markers (`'o'`)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Bisection method" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "The `incsearch` function will always return a set of upper and lower bounds on the zeros of a function, but if you want to increase the accuracy of your solutions, you have to calculate $f(x)$ __a lot__. The error in the solution is always \n", + "\n", + "$error = \\frac{x_{max}-x_{min}}{ns}$\n", + "\n", + "We can reduce the number of times we have to evaluate the function with more insight. \n", + "\n", + "Let's divide interval in half until, then evaluate $f(x_{max})$, $f(x_{min})$, and $\\frac{x_{max}+x_{min}}{2}$. Now, we can look for a sign change between these three locations. We focus our attention on the bisected bracket. Look at the figure below that illustrates choosing the region of interest on the right vs left side of the interval." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "![Using the bisection method to reduce search to half of interval](../images/bisection.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Let's use the same interval we started with to illustrate a few steps in the right direction. \n", + "\n", + "$x_{max}=200$ kg\n", + "\n", + "$x_{min}=50$ kg\n", + "\n", + "$x_{mid}=125$ kg" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f(xmin) = 4.58, f(xmid) = 0.41, f(xmax)=-0.86\n" + ] + } + ], + "source": [ + "x=np.array([50,125,200])\n", + "fx=f_m(x)\n", + "\n", + "print('f(xmin) = {:.2f}, f(xmid) = {:.2f}, f(xmax)={:.2f}'.format(*fx))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we have reduced our region of interest to just 125-200 kg. \n", + "\n", + "## Exercise\n", + "\n", + "Divide the region 125-200 kg into two, and repeat the above step. Is the solution in the upper (163-200 kg)? or lower (125-163 kg) region? What are the values of f_m(m)?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Bisect Function" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "We can automate this process with a `bisect` function. Its a much better root locator because we can reduce the error without evaluating the function a lot of times [1, 2]. \n", + "\n", + "_Note the use of the function `break`:_\n", + "\n", + "We can use an `if`-statement to check a condition and `break` the loop if that condition is met. These break statements are often used in `while`-loops so that you can have some stopping criteria. In our case, we use the specified error, `es`, as a stopping criteria. If our relative error, \n", + "\n", + "$e_{relative} = \\frac{|x_{new}-x_{old}|}{x_{new}}$\n", + "\n", + "is less than our specified error, the loop is broken and the number of iterations halts at that point. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "## Discussion\n", + "\n", + "What is another stopping criteria that you could use?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "def bisect(func,xl,xu,es=0.0001,maxit=50):\n", + " '''bisect: root location zeroes\n", + " root,fx,ea,iter=bisect(func,xl,xu,es,maxit,p1,p2,...):\n", + " uses bisection method to find the root of func\n", + " arguments:\n", + " ------\n", + " func = name of function\n", + " xl, xu = lower and upper guesses\n", + " es = desired relative error (default = 0.0001 )\n", + " maxit = maximum allowable iterations (default = 50)\n", + " p1,p2,... = additional parameters used by func\n", + " returns:\n", + " -------\n", + " root = real root\n", + " and a list of [fx, ea, iter]\n", + " fx = function value at root\n", + " ea = approximate relative error ( )\n", + " iter = number of iterations'''\n", + " xr = xl\n", + " ea = 100\n", + " for iter in range(0,maxit):\n", + " xrold = xr\n", + " xr = (xl + xu)/2\n", + " if xr != 0:\n", + " ea = abs((xr - xrold)/xr) * 100\n", + " else:\n", + " ea = abs((xr - xrold)/1) * 100\n", + " test = func(xl)*func(xr)\n", + " if test < 0:\n", + " xu = xr;\n", + " elif test > 0:\n", + " xl = xr;\n", + " else:\n", + " ea = 0;\n", + " if ea <= es:\n", + " break\n", + "\n", + " root = xr\n", + " fx = func(xr);\n", + " return root,[fx,ea,iter]\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The best estimate for the mass is 142.73769855499268 kg\n", + "We reached a relative error of 5.0109798921069224e-05 with 20 iterations\n" + ] + } + ], + "source": [ + "Mass_at_36ms,out=bisect(f_m,50,200)\n", + "print('The best estimate for the mass is {} kg'.format(Mass_at_36ms))\n", + "print('We reached a relative error of {} with {} iterations'.format(out[1],out[2]))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Recursive functions\n", + "\n", + "The `bisection` function and the next two open root solvers (`newtraph` and `modsecant`) make use of a recursive function. \n", + "\n", + "Definition:\n", + "\n", + "__recursive: for a definition of recursive, see recursive.__\n", + "\n", + "Recursive functions work by updating an initial assignment each time the function is called. In the bisection method, the initial solution is assumed to be halfway between the upper and lower bound\n", + "\n", + "$x_{r} = \\frac{x_u+x_l}{2},$\n", + "\n", + "but once the upper or lower bound is updated, the value of $x_r$ is updated as well. This is why the first step in the loop is to temporarily save $x_r$ as `xrold`. With the `xrold` variable, we can track the progress of our solution. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Newton-Raphson: Open method\n", + "\n", + "Bracketing methods are great, but they are burdened by slow convergence rates. In the bisection method, we reduce our error by 50\\% with each region of interest selection, but this is rather slow. \n", + "\n", + "One of the fastest root-finding methods is the __Newton-Raphson__ method, it is an __open method__ so it does not require an upper- and lower-bound [1,2]. \n", + "\n", + "The __Newton-Raphson__ works by creating a Taylor series expansion around your initial guess of the function, \n", + "\n", + "$f(x_{0}+\\Delta x) = f(x_{0}) +\\frac{df}{dx}\\Delta x +...$\n", + "\n", + "We want to determine what step, $\\Delta x$, to take in order for $f(x_{0}+\\Delta x)=0$. So we set our right hand side to 0 and ignore the $...$ -higher order terms. \n", + "\n", + "$0 = f(x_{0}) +\\frac{df}{dx}\\Delta x$\n", + "\n", + "So our best guess for a solution is then\n", + "\n", + "$x_{solution} = x_{0}+ \\Delta x$\n", + "\n", + "where \n", + "\n", + "$\\Delta x = -f(x) \\left({\\frac{df}{dx}}\\right)^{-1}.$\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Newton-Raphson example\n", + "\n", + "Let's use the __Newton-Raphson__ method to solve an engineering problem. Consider a spherical tank of water that can be filled to a height, $h$, and has radius, $R$. \n", + "\n", + "The volume of water, $V$, in the tank is \n", + "\n", + "$V= \\pi h^2\\frac{3R-h}{3}.$\n", + "\n", + "If your tank has a radius of $R=2~m$ and you need a volume of 29 $m^3$, what height should you fill it to?\n", + "\n", + "To answer this question with the Newton-Raphson method, we first define a new function, $f(h,parameters)$\n", + "\n", + "$f(h,parameters) = V-\\pi h^2\\frac{3R-h}{3}.$\n", + "\n", + "Now we can plug in our known parameters\n", + "\n", + "$f(h) = 29-\\pi h^2\\frac{6-h}{3},$\n", + "\n", + "and calculate the derivative, \n", + "\n", + "$\\frac{d}{dh}(f(h)) = -\\pi \\frac{12h-3h^2}{3}$" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "def f_h(h,V=29,R=2):\n", + " return V-np.pi*h**2*(3*R-h)/3\n", + "\n", + "def dfdh(h,V=29,R=2):\n", + " return -np.pi*(6*R*h-3*h**2)/3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use the definitions of `f_h` and `dfdh` to calculate the height, $h$ to fill the tank." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.974413341499149\n" + ] + } + ], + "source": [ + "xguess = 2\n", + "deltax = -f_h(xguess)/dfdh(xguess)\n", + "print(xguess+deltax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discussion\n", + "\n", + "Try changing the value of `xguess`. Is there any way to choose the best `xguess` value? Are there any `xguess` values that return an Python error? Why?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create a Newton-Raphson function\n", + "\n", + "In the same way that we created bracketing method functions, we can create the Newton-Raphson method function to update our `xguess` until a desired tolerance is achieved. " + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "def newtraph(func,dfunc,x0,es=0.0001,maxit=50):\n", + " '''newtraph: Newton-Raphson root location zeroes\n", + " root,[ea,iter]=newtraph(func,dfunc,x0,es,maxit,p1,p2,...):\n", + " uses Newton-Raphson method to find the root of func\n", + " arguments:\n", + " ----------\n", + " func = name of function\n", + " dfunc = name of derivative of function\n", + " x0 = initial guess\n", + " es = desired relative error (default = 0.0001 )\n", + " maxit = maximum allowable iterations (default = 50)\n", + " returns:\n", + " ----------\n", + " root = real root\n", + " ea = approximate relative error (%)\n", + " iter = number of iterations'''\n", + " xr = x0\n", + " ea=1\n", + " for iter in range(1,maxit):\n", + " xrold = xr\n", + " dx = -func(xr)/dfunc(xr)\n", + " xr = xrold+dx\n", + " if xr!=0:\n", + " ea= np.abs((xr-xrold)/xr)*100 # relative error in %\n", + " if ea < es:\n", + " break\n", + " return xr,[func(xr),ea,iter]\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0791382579723865\n" + ] + } + ], + "source": [ + "hr, out = newtraph(f_h,dfdh,1)\n", + "print(hr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare techniques\n", + "\n", + "Let's compare the relative error in finding the height, $h$, in the previous example as a function of the number of iterations in the bisection (`bisect`) method and the Newton-Raphson (`newtraph`). \n", + "\n", + "What we should see is that as we increase the number of iterations, the relative error decreases. We can compare the rate that the error decreases, $\\frac{\\Delta error}{\\# iterations},$ for our two root locators.\n", + "\n", + "We are going to set the maximum iterations, `maxit=n[i]`, to the desired value in the loop, but we want as low of an error as possible. We set our specified error to `es=0`." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n=np.arange(3,30)\n", + "\n", + "err_bisect = np.zeros(len(n))\n", + "err_newtraph=np.zeros(len(n))\n", + "\n", + "for i in range(0,len(n)):\n", + " root,out = bisect(f_h,0,4,es=0,maxit=n[i])\n", + " err_bisect[i] = out[1]\n", + " \n", + " root,out = newtraph(f_h,dfdh,1,es=0,maxit=n[i])\n", + " \n", + " err_newtraph[i] =out[1]\n", + "\n", + "plt.semilogy(n,err_bisect,label = 'bisection')\n", + "plt.semilogy(n,err_newtraph, label = 'Newton-Raphson')\n", + "plt.xlabel('number of iterations')\n", + "plt.ylabel('relative error (%)')\n", + "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discussion\n", + "\n", + "There is a drastic difference between the `bisection` function and the `newtraph` function. How many iterations are necessary for the bisection method to reach an error of $10^{-3}$ \\%? How many iterations are necessary for the Newton-Raphson method to reach an error of $10^{-3}$ \\%? \n", + "\n", + "Are there any benefits to the bisection method? When would the Newton-Raphson method not work? or not be appropriate?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Secant Methods" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "The key to the Newton-Raphson method is its evaluation of the derivative of the function, but we can't always evaluate the derivative. Many numerical functions, such as the solution to differential equations that we worked on in notebooks [01](./01_Catch_Motion.ipynb), [02](./02_Step_Future.ipynb), and [03](03_Get_Oscillations.ipynb) do not have analytical derivatives. Instead, we will approximate the derivative with a modified secant method.\n", + "\n", + "Approximation of derivative:\n", + "\n", + "$f'(x) \\approx \\frac{f(x+\\delta x)-f(x)}{\\delta x}$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Modified Secant method" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Change the x evaluations to a perturbation $\\delta$ [1,2]. \n", + "\n", + "$x_{i+1}=x_{i}-\\frac{f(x_{i})(\\delta x_{i})}{f(x_{i}+\\delta x_{i})-f(x_{i})}$" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "def mod_secant(func,dx,x0,es=0.0001,maxit=50):\n", + " '''mod_secant: Modified secant root location zeroes\n", + " root,[fx,ea,iter]=mod_secant(func,dfunc,xr,es,maxit,p1,p2,...):\n", + " uses modified secant method to find the root of func\n", + " arguments:\n", + " ----------\n", + " func = name of function\n", + " dx = perturbation fraction\n", + " xr = initial guess\n", + " es = desired relative error (default = 0.0001 )\n", + " maxit = maximum allowable iterations (default = 50)\n", + " p1,p2,... = additional parameters used by function\n", + " returns:\n", + " --------\n", + " root = real root\n", + " fx = func evaluated at root\n", + " ea = approximate relative error ( )\n", + " iter = number of iterations'''\n", + "\n", + " iter = 0;\n", + " xr=x0\n", + " for iter in range(0,maxit):\n", + " xrold = xr;\n", + " dfunc=(func(xr+dx)-func(xr))/dx;\n", + " xr = xr - func(xr)/dfunc;\n", + " if xr != 0:\n", + " ea = abs((xr - xrold)/xr) * 100;\n", + " else:\n", + " ea = abs((xr - xrold)/1) * 100;\n", + " if ea <= es:\n", + " break\n", + " return xr,[func(xr),ea,iter]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n=np.arange(3,30)\n", + "\n", + "err_bisect = np.zeros(len(n))\n", + "err_newtraph=np.zeros(len(n))\n", + "err_modsec=np.zeros(len(n))\n", + "\n", + "for i in range(0,len(n)):\n", + " root,out = bisect(f_h,0,4,es=0,maxit=n[i])\n", + " err_bisect[i] = out[1]\n", + " \n", + " root,out = newtraph(f_h,dfdh,1,es=0,maxit=n[i])\n", + " err_newtraph[i] =out[1]\n", + " \n", + " root,out = mod_secant(f_h,0.001,1,es=0,maxit=n[i])\n", + " err_modsec[i] =out[1]\n", + "\n", + "plt.semilogy(n,err_bisect,label = 'bisection')\n", + "plt.semilogy(n,err_newtraph, label = 'Newton-Raphson')\n", + "plt.semilogy(n,err_modsec, label = 'modified secant')\n", + "plt.title('Convergence rates of solvers')\n", + "plt.xlabel('number of iterations')\n", + "plt.ylabel('relative error (%)')\n", + "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The modified secant can converge as quick as the Newton-Raphson method, but there is no universal $\\delta x$ that works well for every problem. Typically, it is set as a small number and then varied based upon the conergence rate for the problem. \n", + "\n", + "# Shooting method\n", + "\n", + "Now, we have multiple solving methods to revisit our __Initial Value Problems__. In notebooks [01](./01_Catch_Motion.ipynb) and [02](02_Step_Future.ipynb) we measured the displacement of a ball as a function of time. We _assumed_ the initial velocity was 0 in the case of the dropped object, or we approximated the velocity based upon the first two measured displacements and a finite difference approximation. \n", + "\n", + "Consider the case of the tennis ball that was dropped in the ['data/fallingtennisball02.txt file'](../data/fallingtennisball02.txt). After it strikes the ground, we don't really _know_ the velocity. What we _do know_ is that the position was $\\approx 0$ at t=0.58 s and it was $\\approx 0$ m at t=1.43 s. Solving our differential equation without an initial velocity is known as a \"shooting\" method." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![The shooting method imagined as a catapult aiming at a target](../images/shooting.png)\n", + "\n", + "Solving this type of problem where the __boundaries__ are known is referred to as a _Boundary value problem_. Typically, boudary value problems happen over a distance, rather than points in time, but we will come back to those in the fifth module on boundary value problems. \n", + "\n", + "For now, let's reframe our engineering problem into a root-finding problem. We have a length of time of interest:\n", + "\n", + "t=0.58 - 1.43 sec\n", + "\n", + "in this time, the ball had just struck the ground and is traveling upwards. What is the initial velocity necessary to keep it in the air for $\\Delta t = 0.85~s$ ?\n", + "\n", + "We know that the ball is acted upon by gravity and the force of drag, but we do not an analytical solution for the position as a function of time. First, let's look at the data we have. " + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "at time t=0.58 s, y=-0.0152 m\n", + "at time t=1.42 s, y=-0.0110 m\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "filename = '../data/fallingtennisball02.txt'\n", + "t, y = np.loadtxt(filename, usecols=[0,1], unpack=True)\n", + "tbounce = t[580:1425]\n", + "ybounce = y[580:1425]\n", + "\n", + "print('at time t={:.2f} s, y={:.4f} m'.format(tbounce[0],ybounce[0]))\n", + "print('at time t={:.2f} s, y={:.4f} m'.format(tbounce[-1],ybounce[-1]))\n", + "plt.plot(t,y)\n", + "plt.plot(tbounce,ybounce,'s',label='after bounce 1')\n", + "plt.legend()\n", + "plt.title('Time between bounce 1 and 2')\n", + "plt.xlabel('time (s)')\n", + "plt.ylabel('height y(t) (m)');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's look at the `fall_drag` function we created that described the motion of the tennis ball. Remember, this function returns the derivative of the state. So if we input\n", + "\n", + "state = $[x,~v]$\n", + "\n", + "it will return\n", + "\n", + "d(state)/dt = $\\left[v,~-9.81+\\frac{F_{D}}{m}\\right]$" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [], + "source": [ + "def fall_drag(state,C_d=0.47,m=0.0577,R = 0.0661/2):\n", + " '''Computes the right-hand side of the differential equation\n", + " for the fall of a ball, with drag, in SI units.\n", + " \n", + " Arguments\n", + " ---------- \n", + " state : array of two dependent variables [y v]^T\n", + " m : mass in kilograms default set to 0.0577 kg\n", + " C_d : drag coefficient for a sphere default set to 0.47 (no units)\n", + " R : radius of ball default in meters is 0.0661/2 m (tennis ball)\n", + " Returns\n", + " -------\n", + " derivs: array of two derivatives [v (-g+a_drag)]^T\n", + " '''\n", + " \n", + " rho = 1.22 # air density kg/m^3\n", + " pi = np.pi\n", + " \n", + " a_drag = -1/(2*m) * pi * R**2 * rho * C_d * (state[1])**2*np.sign(state[1])\n", + " \n", + " derivs = np.array([state[1], -9.81 + a_drag])\n", + " return derivs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get the position as a function of time, we can use any of the integration methods that we defined in [03_Get_Oscillations](./03_Get_Oscillations.ipynb). Here we copy in the second-order Runge-Kutta explicit method. " + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": {}, + "outputs": [], + "source": [ + "def rk2_step(state, rhs, dt):\n", + " '''Update a state to the next time increment using modified Euler's method.\n", + " \n", + " Arguments\n", + " ---------\n", + " state : array of dependent variables\n", + " rhs : function that computes the RHS of the DiffEq\n", + " dt : float, time increment\n", + " \n", + " Returns\n", + " -------\n", + " next_state : array, updated after one time increment'''\n", + " \n", + " mid_state = state + rhs(state) * dt*0.5 \n", + " next_state = state + rhs(mid_state)*dt\n", + " \n", + " return next_state" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining our problem for Python \n", + "\n", + "Now, we can finally ask our engineering question in a Python way. \n", + "\n", + "We need a function, $f(v_0)$, such that when we input the correct velocity for the initial condition, $f(v_0^{correct})=0$\n", + "\n", + "So we define a new function with `def`" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": {}, + "outputs": [], + "source": [ + "def f_v(v0,y0=ybounce[0],yT=ybounce[-1],T=(tbounce[0],tbounce[-1]),N=50):\n", + " ''' define a function f(v) that returns \n", + " ymeasured(T)-ypredicted(T)\n", + " here, the time span is based upon the tbounce variable defined above from \n", + " the first bounce to the second bounce\n", + " \n", + " arguments:\n", + " ---------\n", + " v0: the unknown initial vy velocity component\n", + " y0: the known initial position\n", + " yT: the known final position\n", + " T: a list of two times (beginning time, end time)\n", + " N: the number of time steps to integrate the RK2 method default = 50\n", + " \n", + " returns:\n", + " --------\n", + " error: the difference between vmeasured(T) and vpredicted(T)\n", + " when f_v(v0)= 0, the correct initial velocity was chosen\n", + " '''\n", + " \n", + " \n", + " # initialize array\n", + " t_sol=np.linspace(T[0],T[1],N)\n", + " dt=t_sol[1]-t_sol[0]\n", + " num_sol_drag = np.zeros([N,2])\n", + "\n", + " # Set intial conditions\n", + " num_sol_drag[0,0] = y0\n", + " num_sol_drag[0,1] = v0\n", + "\n", + " for i in range(N-1):\n", + " num_sol_drag[i+1] = rk2_step(num_sol_drag[i], fall_drag, dt)\n", + " error = num_sol_drag[-1,0]-yT\n", + " #plt.plot(t_sol,num_sol_drag[:,0])\n", + " return error" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Take a look at the pieces of this function:\n", + "\n", + "1. Create an array of time `t_sol`\n", + "\n", + "2. Set initial conditions to `y0` and `v0` <- __here `v0` is our unknown value__\n", + "\n", + "3. Use Runge-Kutta second order to integrate the function for `t_sol[0]` to `t_sol[-1]`\n", + "\n", + "4. Create an output, `error` of the difference between the measured y(T), `yT`, and the current solution for y(T), `num_sol_drag[-1,0]`\n", + "\n", + "When `error` is 0, we have chosen the correct initial velocity, `v0`.\n", + "\n", + "To see what the output looks like, below we can take out the integration part and plot the results for a guess of `v0`." + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize array\n", + "N=50\n", + "T=(tbounce[0],tbounce[-1])\n", + "t_sol=np.linspace(T[0],T[1],N)\n", + "dt=t_sol[1]-t_sol[0]\n", + "num_sol_drag = np.zeros([N,2])\n", + "num_sol_drag[0,0] = ybounce[0]\n", + "num_sol_drag[0,1] = 3\n", + "\n", + "for i in range(N-1):\n", + " num_sol_drag[i+1] = rk2_step(num_sol_drag[i], fall_drag, dt)" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t,y)\n", + "plt.plot(t_sol,num_sol_drag[:,0],'s')\n", + "plt.title('Predicted motion after bounce')\n", + "plt.xlabel('time (s)')\n", + "plt.ylabel('height y(t) (m)');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "Enter your best guess for `v0`. What is the error between the measured `yT` and your predicted y(T)? _Hint: use our function, `f_v`, and plot the results._" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solving the engineering problem\n", + "\n", + "Now, we have all the components we need for this \"shooting\" problem. We can't evaluate a derivative easily and the bisection method is too slow. Therefore, we will use the `mod_secant` function to find the correct initial velocity. \n", + "\n", + "Below is the solution. _Just one line of code!_" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.175915400675785 m/s is the correct initial velocity to match the height at beginning and end of bounce\n", + "the solve took 3 iterations\n" + ] + } + ], + "source": [ + "v0,out = mod_secant(f_v,0.0001,7,es=0.000001) # <-- solution line\n", + "print(v0, 'm/s is the correct initial velocity to match the height at beginning and end of bounce')\n", + "print('the solve took ',out[2],' iterations')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "Change the value of the `dx` and `x0`. Does it change the final result? Does it change the time it took to arrive at the solution or the number of iterations?" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mmod_secant\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.0001\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmaxit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "mod_secant: Modified secant root location zeroes\n", + "root,[fx,ea,iter]=mod_secant(func,dfunc,xr,es,maxit,p1,p2,...):\n", + "uses modified secant method to find the root of func\n", + "arguments:\n", + "----------\n", + "func = name of function\n", + "dx = perturbation fraction\n", + "xr = initial guess\n", + "es = desired relative error (default = 0.0001 )\n", + "maxit = maximum allowable iterations (default = 50)\n", + "p1,p2,... = additional parameters used by function\n", + "returns:\n", + "--------\n", + "root = real root\n", + "fx = func evaluated at root\n", + "ea = approximate relative error ( )\n", + "iter = number of iterations\n", + "\u001b[0;31mFile:\u001b[0m ~/Documents/UConn/ME3255/ME3255-CompMech/CompMech03-IVPs/notebooks/\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mod_secant?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What we've learned\n", + "\n", + "* How to find the 0 of a function, aka root-finding\n", + "* The difference between a bracketing and an open methods for finding roots\n", + "* Two bracketing methods: incremental search and bisection methods\n", + "* Two open methods: Newton-Raphson and modified secant methods\n", + "* How to measure relative error\n", + "* How to compare root-finding methods\n", + "* How to frame an engineering problem as a root-finding problem\n", + "* Solve an initial value problem with missing initial conditions (the shooting method)\n", + "\n", + "* _Bonus: In the Problems you'll consider stability of bracketing and open methods._\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# References\n", + "\n", + "1. Chapra, Steven _Applied Numerical Methods with Matlab for Engineers._ McGraw Hill. \n", + "\n", + "2. _Computational Physics with Python_, lecture notes by Eric Ayars, California State University, Chico. Available online on the author's website: https://physics.csuchico.edu/ayars/312/handouts/comp-phys-python.pdf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problems\n", + "\n", + "1. One of the main benefits of a bracketing method is the stability of solutions. Open methods are not always stable. Here is an example. One way engineers and data scientists model the probability of failure is with a [sigmoid function e.g. this Challenger O-ring case study](https://byuistats.github.io/M325_Hathaway/textbook/challengerLogisticReg.html)\n", + "\n", + "$$\\begin{equation}\n", + " \\sigma(T) = \\frac{e^{a_0-a_1 T}}{1+e^{a_0-a_1 T}}\n", + "\\end{equation}$$\n", + "\n", + "The Challenger explosion was a terrible incident that occurred due to the failure of an O-ring. The post-mortem data analysis showed that at low temperatures the O-rings were brittle and more likely to fail. We can use the function $\\sigma(T)$ to determine the point at which there is a 50\\% chance of O-ring failure. Using the pass-fail data, the two constants are\n", + "\n", + "$a_0 = 15.043$\n", + "\n", + "$a_1 = 0.232$\n", + "\n", + "a. Plot the function $\\sigma(T)$ for $T=0-100^{o}F$. Where do you see the function cross 50\\% (0.5)?\n", + "\n", + "b. Create two functions `f_T` and `dfdT` where `f_T`=$f(T)=\\sigma(T) - 0.5$ and `dfdT`=$\\frac{df}{dT}$\n", + "\n", + "c. Use the `incsearch` and `newtraph` functions to find the root of f(T). When does Newton-Raphson fail to converge? Why does it fail? _Hint: if you're stuck here, take a look at this [youtube video finding an interval of convergence for the Newton-Raphson method](https://youtu.be/zyXRo8Qjj0A). Look at the animation of how the method converges and diverges._" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. In the examples shown above, we determined the initial velocity after the first bounce by specifying the beginning y(0) and end y(T) for an object subject to gravity and drag. Repeat this analysis for the time period just after the second bounce and just before the third bounce. The indices are given below for t[1430:2051] = 1.43-2.05 seconds.\n", + "\n", + " a. What is the velocity just after the second bounce?\n", + "\n", + " b. What is the coefficient of restitution for the second bounce? _Hint: use the ratio of the last velocity from above to the initial velocity calculated here._\n" + ] + }, + { + "cell_type": "code", + "execution_count": 177, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4300000000009008 2.051000000004969\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 177, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "i0=1430\n", + "ie=2051\n", + "print(t[i0],t[ie])\n", + "plt.plot(t,y)\n", + "plt.plot(t[i0:ie],y[i0:ie],'s')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/.ipynb_checkpoints/06_roots-1-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/06_roots-1-checkpoint.ipynb deleted file mode 100644 index aa2b764..0000000 --- a/notebooks/.ipynb_checkpoints/06_roots-1-checkpoint.ipynb +++ /dev/null @@ -1,892 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true, - "scrolled": true, - "slideshow": { - "slide_type": "skip" - } - }, - "outputs": [], - "source": [ - "%plot --format svg" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Roots of Nonlinear functions\n", - "## Bracketing ch. 5" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "## Not always possible to solve for a given variable. \n", - "\n", - "### Freefall example:\n", - "If an object, with drag coefficient of 0.25 kg/m reaches a velocity of 36 m/s after 4 seconds of freefalling, what is its mass?\n", - "\n", - "$v(t)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)$\n", - "\n", - "Cannot solve for m \n", - "\n", - "Instead, solve the problem by creating a new function f(m) where\n", - "\n", - "$f(m)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)-v(t)$. \n", - "\n", - "When f(m) = 0, we have solved for m in terms of the other variables (e.g. for a given time, velocity, drag coefficient and acceleration due to gravity)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false, - "scrolled": true, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t-5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t60\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t80\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t100\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t120\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t140\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t160\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t180\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t200\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tgnuplot_plot_2a\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "setdefaults\n", - "g=9.81; % acceleration due to gravity\n", - "m=linspace(50, 200,100); % possible values for mass 50 to 200 kg\n", - "c_d=0.25; % drag coefficient\n", - "t=4; % at time = 4 seconds\n", - "v=36; % speed must be 36 m/s\n", - "f_m = @(m) sqrt(g*m/c_d).*tanh(sqrt(g*c_d./m)*t)-v; % anonymous function f_m\n", - "\n", - "plot(m,f_m(m),m,zeros(length(m),1))\n", - "axis([45 200 -5 1])" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false, - "scrolled": true, - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ans = 0.045626\r\n" - ] - } - ], - "source": [ - "f_m(145)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "Brute force method is plot f_m vs m and with smaller and smaller steps until f_m ~ 0\n", - "\n", - "Better methods are the \n", - "1. Bracketing methods\n", - "2. Open methods\n", - "\n", - "Both need an initial guess. \n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Incremental method (Brute force)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "You know that for one value, m_lower, f_m is negative and for another value, m_upper, f_m is positive. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "^C\r\n" - ] - } - ], - "source": [ - "function xb = incsearch(func,xmin,xmax,ns)\n", - "% incsearch: incremental search root locator\n", - "% xb = incsearch(func,xmin,xmax,ns):\n", - "% finds brackets of x that contain sign changes\n", - "% of a function on an interval\n", - "% input:\n", - "% func = name of function\n", - "% xmin, xmax = endpoints of interval\n", - "% ns = number of subintervals (default = 50)\n", - "% output:\n", - "% xb(k,1) is the lower bound of the kth sign change\n", - "% xb(k,2) is the upper bound of the kth sign change\n", - "% If no brackets found, xb = [].\n", - "if nargin < 3, error('at least 3 arguments required'), end\n", - "if nargin < 4, ns = 50; end %if ns blank set to 50\n", - "% Incremental search\n", - "x = linspace(xmin,xmax,ns);\n", - "f = func(x);\n", - "nb = 0; xb = []; %xb is null unless sign change detected\n", - "for k = 1:length(x)-1\n", - " if sign(f(k)) ~= sign(f(k+1)) %check for sign change\n", - " nb = nb + 1;\n", - " xb(nb,1) = x(k);\n", - " xb(nb,2) = x(k+1);\n", - " end\n", - "end\n", - "if isempty(xb) %display that no brackets were found\n", - " fprintf('no brackets found\\n')\n", - " fprintf('check interval or increase ns\\n')\n", - "else\n", - " fprintf('number of brackets: %i\\n',nb) %display number of brackets\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "number of brackets: 1\n", - "ans =\n", - "\n", - " 141.84 144.90\n", - "\n" - ] - } - ], - "source": [ - "incsearch(f_m,50,200)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false, - "scrolled": true, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "number of brackets: 1\n", - "ans =\n", - "\n", - " 142.73 142.83\n", - "\n" - ] - } - ], - "source": [ - "incsearch(f_m,140, 150,100)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true, - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Bisection method" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Divide interval in half until error is reduced to some level\n", - "\n", - "in previous example of freefall, choose x_l=50, x_u=200\n", - "\n", - "x_r = (50+200)/2 = 125\n", - "\n", - "f_m(125) = -0.408\n", - "\n", - "x_r= (125+200)/2 = 162.5\n", - "\n", - "f_m(162.5) = 0.3594\n", - "\n", - "x_r = (125+162.5)/2=143.75\n", - "\n", - "f_m(143.75)= 0.0206" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false, - "scrolled": true, - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x_r = 134.38\n", - "interval left f(x_l)= -0.4,f(x_r)= -0.2\n", - "interval right f(x_r)= -0.2,f(x_u)= 0.0\n", - "ans = -0.18060\n" - ] - } - ], - "source": [ - "x_l=125; x_u=143.75;\n", - "x_r=(x_l+x_u)/2\n", - "fprintf('interval left f(x_l)= %1.1f,f(x_r)= %1.1f\\n',f_m(x_l),f_m(x_r))\n", - "fprintf('interval right f(x_r)= %1.1f,f(x_u)= %1.1f\\n',f_m(x_r),f_m(x_u))\n", - "f_m(x_r)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Bisect Function" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Much better root locator, with 4 iterations, our function is already close to zero\n", - "\n", - "Automate this with a function:\n", - "`bisect.m`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "^C\r\n" - ] - } - ], - "source": [ - "function [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,varargin)\n", - "% bisect: root location zeroes\n", - "% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):\n", - "% uses bisection method to find the root of func\n", - "% input:\n", - "% func = name of function\n", - "% xl, xu = lower and upper guesses\n", - "% es = desired relative error (default = 0.0001%)\n", - "% maxit = maximum allowable iterations (default = 50)\n", - "% p1,p2,... = additional parameters used by func\n", - "% output:\n", - "% root = real root\n", - "% fx = function value at root\n", - "% ea = approximate relative error (%)\n", - "% iter = number of iterations\n", - "if nargin<3,error('at least 3 input arguments required'),end\n", - "test = func(xl,varargin{:})*func(xu,varargin{:});\n", - "if test>0,error('no sign change'),end\n", - "if nargin<4|isempty(es), es=0.0001;end\n", - "if nargin<5|isempty(maxit), maxit=50;end\n", - "iter = 0; xr = xl; ea = 100;\n", - "while (1)\n", - " xrold = xr;\n", - " xr = (xl + xu)/2;\n", - " iter = iter + 1;\n", - " if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end\n", - " test = func(xl,varargin{:})*func(xr,varargin{:});\n", - " if test < 0\n", - " xu = xr;\n", - " elseif test > 0\n", - " xl = xr;\n", - " else\n", - " ea = 0;\n", - " end\n", - " if ea <= es | iter >= maxit,break,end\n", - "end\n", - "root = xr; fx = func(xr, varargin{:});" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mass_at_36ms = 142.74\r\n" - ] - } - ], - "source": [ - "Mass_at_36ms=bisect(f_m,50,200)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Thanks" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## False position (linear interpolation)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Rather than bisecting each bracket (1/2 each time) we can calculate the slope between the two points and update the xr position in this manner\n", - "\n", - "$ x_{r} = x_{u} - \\frac{f(x_{u})(x_{l}-x_{u})}{f(x_{l})-f(x_{u})}$" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false, - "scrolled": true, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t-5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t50\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t100\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t150\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t200\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tgnuplot_plot_2a\n", - "\n", - "\t \n", - "\t\n", - "\n", - "\t\n", - "\tgnuplot_plot_3a\n", - "\n", - "\t \n", - "\t\n", - "\n", - "\t\n", - "\tgnuplot_plot_4a\n", - "\n", - "\t\t \n", - "\t\n", - "\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%xl=50; xu=200; \n", - "xu=xr;\n", - "xl=xl;\n", - "xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu));\n", - "plot(m,f_m(m),xl,f_m(xl),'s',xu,f_m(xu),'s',xr,0)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## False Position" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Much better root locator, with 4 iterations, our function is already close to zero\n", - "\n", - "Automate this with a function:\n", - "`falsepos.m`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "^C\r\n" - ] - } - ], - "source": [ - "function [root,fx,ea,iter]=falsepos(func,xl,xu,es,maxit,varargin)\n", - "% falsepos: root location zeroes\n", - "% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):\n", - "% uses false position method to find the root of func\n", - "% input:\n", - "% func = name of function\n", - "% xl, xu = lower and upper guesses\n", - "% es = desired relative error (default = 0.0001%)\n", - "% maxit = maximum allowable iterations (default = 50)\n", - "% p1,p2,... = additional parameters used by func\n", - "% output:\n", - "% root = real root\n", - "% fx = function value at root\n", - "% ea = approximate relative error (%)\n", - "% iter = number of iterations\n", - "if nargin<3,error('at least 3 input arguments required'),end\n", - "test = func(xl,varargin{:})*func(xu,varargin{:});\n", - "if test>0,error('no sign change'),end\n", - "if nargin<4|isempty(es), es=0.0001;end\n", - "if nargin<5|isempty(maxit), maxit=50;end\n", - "iter = 0; xr = xl; ea = 100;\n", - "while (1)\n", - " xrold = xr;\n", - " % xr = (xl + xu)/2; % bisect method\n", - " xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu)); % false position method\n", - " iter = iter + 1;\n", - " if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end\n", - " test = func(xl,varargin{:})*func(xr,varargin{:});\n", - " if test < 0\n", - " xu = xr;\n", - " elseif test > 0\n", - " xl = xr;\n", - " else\n", - " ea = 0;\n", - " end\n", - " if ea <= es | iter >= maxit,break,end\n", - "end\n", - "root = xr; fx = func(xr, varargin{:});" - ] - } - ], - "metadata": { - "celltoolbar": "Slideshow", - "kernelspec": { - "display_name": "Octave", - "language": "octave", - "name": "octave" - }, - "language_info": { - "file_extension": ".m", - "help_links": [ - { - "text": "MetaKernel Magics", - "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" - } - ], - "mimetype": "text/x-octave", - "name": "octave", - "version": "0.19.14" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebooks/03_Get_Oscillations.ipynb b/notebooks/03_Get_Oscillations.ipynb index 7b32bd6..5b4f145 100644 --- a/notebooks/03_Get_Oscillations.ipynb +++ b/notebooks/03_Get_Oscillations.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "###### Content under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License © 2017 L.A. Barba, N.C. Clementi" + "###### Content modified under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License © 2020 R.C. Cooper" ] }, { @@ -34,10 +34,11 @@ "metadata": {}, "outputs": [], "source": [ - "import numpy\n", - "from matplotlib import pyplot\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", - "pyplot.rc('font', family='serif', size='14')" + "plt.rcParams.update({'font.size': 22})\n", + "plt.rcParams['lines.linewidth'] = 3" ] }, { @@ -112,7 +113,7 @@ "\\dot{v} &=& -\\omega^2 x\n", "\\end{eqnarray}\n", "\n", - "Like we did in [Lesson 2](http://go.gwu.edu/engcomp3lesson2) of this module, we write the state of the system as a two-dimensional vector,\n", + "Like we did in [Lesson 2](./02_Step_Future.ipynb) of this module, we write the state of the system as a two-dimensional vector,\n", "\n", "\\begin{equation}\n", "\\mathbf{x} = \\begin{bmatrix}\n", @@ -135,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 423, "metadata": {}, "outputs": [], "source": [ @@ -149,10 +150,10 @@ " \n", " Returns \n", " -------\n", - " derivs: array of two derivatives [v - ω*ω*x]^T\n", + " derivs: array of two derivatives [v - w*w*x]^T\n", " '''\n", " \n", - " derivs = numpy.array([state[1], -ω**2*state[0]])\n", + " derivs = np.array([state[1], -w**2*state[0]])\n", " return derivs" ] }, @@ -165,17 +166,12 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 43, + "metadata": {}, "outputs": [], "source": [ - "ω = 2\n", - "period = 2*numpy.pi/ω\n", + "w = 2\n", + "period = 2*np.pi/w\n", "dt = period/20 # we choose 20 time intervals per period \n", "T = 3*period # solve for 3 periods\n", "N = round(T/dt)" @@ -183,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 44, "metadata": {}, "outputs": [ { @@ -209,27 +205,17 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 45, + "metadata": {}, "outputs": [], "source": [ - "t = numpy.linspace(0, T, N)" + "t = np.linspace(0, T, N)" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 46, + "metadata": {}, "outputs": [], "source": [ "x0 = 2 # initial position\n", @@ -238,28 +224,18 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 47, + "metadata": {}, "outputs": [], "source": [ "#initialize solution array\n", - "num_sol = numpy.zeros([N,2])" + "num_sol = np.zeros([N,2])" ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 48, + "metadata": {}, "outputs": [], "source": [ "#Set intial conditions\n", @@ -276,13 +252,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 49, + "metadata": {}, "outputs": [], "source": [ "for i in range(N-1):\n", @@ -298,43 +269,40 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 67, + "metadata": {}, "outputs": [], "source": [ - "x_an = x0*numpy.cos(ω * t)" + "x_an = x0*np.cos(w * t)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 68, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAE1CAYAAAA2zJNzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "# plot solution with Euler's method\n", - "fig = pyplot.figure(figsize=(6,4))\n", + "fig = plt.figure(figsize=(6,4))\n", "\n", - "pyplot.plot(t, num_sol[:, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", - "pyplot.plot(t, x_an, linewidth=1, linestyle='-', label='Analytical solution')\n", - "pyplot.xlabel('Time [s]')\n", - "pyplot.ylabel('$x$ [m]')\n", - "pyplot.title('Spring-mass system with Euler\\'s method (dashed line).\\n');" + "plt.plot(t, num_sol[:, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", + "plt.plot(t, x_an, linewidth=1, linestyle='-', label='Analytical solution')\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('$x$ [m]')\n", + "plt.title('Spring-mass system with Euler\\'s method (dashed line).\\n');" ] }, { @@ -374,6 +342,7 @@ "A graphical explanation can help here. Remember that the derivative of a function corresponds to the slope of the tangent at a point. Euler's method approximates the derivative using the slope at the initial point in an interval, and advances the numerical position with that initial velocity. The sketch below illustrates two consecutive Euler steps on a function with high curvature.\n", "\n", " \n", + "\n", "#### Sketch of two Euler steps on a curved function.\n", "\n", "Since Euler's method makes a linear approximation to project the solution into the future, assuming the value of the derivative at the start of the interval, it's not very good on oscillatory functions.\n", @@ -406,13 +375,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 69, + "metadata": {}, "outputs": [], "source": [ "def euler_cromer(state, rhs, dt):\n", @@ -431,7 +395,7 @@ " mid_state = state + rhs(state)*dt # Euler step\n", " mid_derivs = rhs(mid_state) # updated derivatives\n", " \n", - " next_state = numpy.array([mid_state[0], state[1] + mid_derivs[1]*dt])\n", + " next_state = np.array([mid_state[0], state[1] + mid_derivs[1]*dt])\n", " \n", " return next_state" ] @@ -445,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 70, "metadata": {}, "outputs": [ { @@ -458,8 +422,8 @@ } ], "source": [ - "ω = 2\n", - "period = 2*numpy.pi/ω\n", + "w = 2\n", + "period = 2*np.pi/w\n", "dt = period/200 # time intervals per period \n", "T = 800*period # simulation time, in number of periods\n", "N = round(T/dt)\n", @@ -468,13 +432,13 @@ "print('The time increment is {}'.format( dt ))\n", "\n", "# time array\n", - "t = numpy.linspace(0, T, N)\n", + "t = np.linspace(0, T, N)\n", "\n", "x0 = 2 # initial position\n", "v0 = 0 # initial velocity\n", "\n", "#initialize solution array\n", - "num_sol = numpy.zeros([N,2])\n", + "num_sol = np.zeros([N,2])\n", "\n", "#Set intial conditions\n", "num_sol[0,0] = x0\n", @@ -495,44 +459,41 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 71, + "metadata": {}, "outputs": [], "source": [ - "x_an = x0*numpy.cos(ω * t) # analytical solution" + "x_an = x0*np.cos(w * t) # analytical solution" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 72, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbYAAAE1CAYAAACLLcUGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n0zRN0yzl/wMU/309FRR0EwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "iend = 800 # in number of time steps\n", "\n", - "fig = pyplot.figure(figsize=(6,4))\n", + "fig = plt.figure(figsize=(6,4))\n", "\n", - "pyplot.plot(t[:iend], num_sol[:iend, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", - "pyplot.plot(t[:iend], x_an[:iend], linewidth=1, linestyle='-', label='Analytical solution')\n", - "pyplot.xlabel('Time [s]')\n", - "pyplot.ylabel('$x$ [m]')\n", - "pyplot.title('Spring-mass system, with Euler-Cromer method.\\n');" + "plt.plot(t[:iend], num_sol[:iend, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", + "plt.plot(t[:iend], x_an[:iend], linewidth=1, linestyle='-', label='Analytical solution')\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('$x$ [m]')\n", + "plt.title('Spring-mass system, with Euler-Cromer method.\\n');" ] }, { @@ -551,30 +512,32 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 73, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbgAAAE1CAYAAACV5PW1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "istart = 400\n", "\n", - "fig = pyplot.figure(figsize=(6,4))\n", + "fig = plt.figure(figsize=(6,4))\n", "\n", - "pyplot.plot(t[-istart:], num_sol[-istart:, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", - "pyplot.plot(t[-istart:], x_an[-istart:], linewidth=1, linestyle='-', label='Analytical solution')\n", - "pyplot.xlabel('Time [s]')\n", - "pyplot.ylabel('$x$ [m]')\n", - "pyplot.title('Spring-mass system, with Euler-Cromer method. \\n');" + "plt.plot(t[-istart:], num_sol[-istart:, 0], linewidth=2, linestyle='--', label='Numerical solution')\n", + "plt.plot(t[-istart:], x_an[-istart:], linewidth=1, linestyle='-', label='Analytical solution')\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('$x$ [m]')\n", + "plt.title('Spring-mass system, with Euler-Cromer method. \\n');" ] }, { @@ -622,28 +585,23 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 74, + "metadata": {}, "outputs": [], "source": [ - "dt_values = numpy.array([period/50, period/100, period/200, period/400])\n", + "dt_values = np.array([period/50, period/100, period/200, period/400])\n", "T = 1*period\n", "\n", - "num_sol_time = numpy.empty_like(dt_values, dtype=numpy.ndarray)\n", + "num_sol_time = np.empty_like(dt_values, dtype=np.ndarray)\n", "\n", "\n", "for j, dt in enumerate(dt_values):\n", "\n", " N = int(T/dt)\n", - " t = numpy.linspace(0, T, N)\n", + " t = np.linspace(0, T, N)\n", " \n", " #initialize solution array\n", - " num_sol = numpy.zeros([N,2])\n", + " num_sol = np.zeros([N,2])\n", " \n", " \n", " #Set intial conditions\n", @@ -665,20 +623,15 @@ }, { "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 75, + "metadata": {}, "outputs": [], "source": [ "def get_error(num_sol, T):\n", " \n", - " x_an = x0 * numpy.cos(ω * T) # analytical solution at final time\n", + " x_an = x0 * np.cos(w * T) # analytical solution at final time\n", " \n", - " error = numpy.abs(num_sol[-1,0] - x_an)\n", + " error = np.abs(num_sol[-1,0] - x_an)\n", " \n", " return error" ] @@ -692,16 +645,11 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 76, + "metadata": {}, "outputs": [], "source": [ - "error_values = numpy.empty_like(dt_values)\n", + "error_values = np.empty_like(dt_values)\n", "\n", "for j in range(len(dt_values)):\n", " \n", @@ -710,38 +658,40 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 77, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAGlCAYAAAArqoUwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\no2yAV00AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "# plot the solution errors with respect to the time incremetn\n", - "fig = pyplot.figure(figsize=(6,6))\n", - "\n", - "pyplot.loglog(dt_values, error_values, 'ko-') #log-log plot\n", - "pyplot.loglog(dt_values, 10*dt_values, 'k:')\n", - "pyplot.grid(True) #turn on grid lines\n", - "pyplot.axis('equal') #make axes scale equally\n", - "pyplot.xlabel('$\\Delta t$')\n", - "pyplot.ylabel('Error')\n", - "pyplot.title('Convergence of the Euler method (dotted line: slope 1)\\n');" + "fig = plt.figure(figsize=(6,6))\n", + "\n", + "plt.loglog(dt_values, error_values, 'ko-') #log-log plot\n", + "plt.loglog(dt_values, 10*dt_values, 'k:')\n", + "plt.grid(True) #turn on grid lines\n", + "plt.axis('equal') #make axes scale equally\n", + "plt.xlabel('$\\Delta t$')\n", + "plt.ylabel('Error')\n", + "plt.title('Convergence of the Euler method (dotted line: slope 1)\\n');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "What do you see in the plot of the error as a function of $\\Delta t$? It looks like a straight line, with a slope close to 1. On a log-log convergence plot, a slope of 1 indicates that we have a first-order method: the error scales as ${\\mathcal O}(\\Delta t)$—using the \"big-O\" notation. It means that the error is proportional to the time increment: $ e \\propto \\Delta t.$" + "What do you see in the plot of the error as a function of $\\Delta t$? It looks like a straight line, with a slope close to 1. On a log-log convergence plot, a slope of 1 indicates that we have a first-order method: the error scales as ${\\mathcal O}(\\Delta t)$—using the \"big-O\" notation. It means that the error is proportional to the time increment: $ error \\propto \\Delta t.$" ] }, { @@ -769,13 +719,8 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 221, + "metadata": {}, "outputs": [], "source": [ "def rk2_step(state, rhs, dt):\n", @@ -806,28 +751,23 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, + "execution_count": 405, + "metadata": {}, "outputs": [], "source": [ - "dt_values = numpy.array([period/50, period/100, period/200,period/400])\n", + "dt_values = np.array([period/50, period/100, period/200,period/400,period/1000])\n", "T = 1*period\n", "\n", - "num_sol_time = numpy.empty_like(dt_values, dtype=numpy.ndarray)\n", + "num_sol_time = np.empty_like(dt_values, dtype=np.ndarray)\n", "\n", "\n", "for j, dt in enumerate(dt_values):\n", "\n", " N = int(T/dt)\n", - " t = numpy.linspace(0, T, N)\n", + " t = np.linspace(0, T, N)\n", " \n", " #initialize solution array\n", - " num_sol = numpy.zeros([N,2])\n", + " num_sol = np.zeros([N,2])\n", " \n", " \n", " #Set intial conditions\n", @@ -842,49 +782,79 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true + "execution_count": 406, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 406, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } - }, + ], + "source": [ + "plt.plot(t,num_sol[:,0],'s')\n", + "plt.plot(t,x0*np.cos(w*t))" + ] + }, + { + "cell_type": "code", + "execution_count": 407, + "metadata": {}, "outputs": [], "source": [ - "error_values = numpy.empty_like(dt_values)\n", + "error_values = np.empty_like(dt_values)\n", "\n", "for j, dt in enumerate(dt_values):\n", " \n", - " error_values[j] = get_error(num_sol_time[j], dt)" + " error_values[j] = get_error(num_sol_time[j], T)" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 408, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiAAAAGlCAYAAADDHE3qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nnQABANoJEACg3Te5vvRQXIymOQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "# plot of convergence for modified Euler's\n", - "fig = pyplot.figure(figsize=(6,6))\n", - "\n", - "pyplot.loglog(dt_values, error_values, 'ko-')\n", - "pyplot.loglog(dt_values, 5*dt_values**2, 'k:')\n", - "pyplot.grid(True)\n", - "pyplot.axis('equal')\n", - "pyplot.xlabel('$\\Delta t$')\n", - "pyplot.ylabel('Error')\n", - "pyplot.title('Convergence of modified Euler\\'s method (dotted line: slope 2)\\n');" + "fig = plt.figure(figsize=(6,6))\n", + "\n", + "plt.loglog(dt_values, error_values, 'ko-')\n", + "plt.loglog(dt_values, 5*dt_values**2, 'k:')\n", + "plt.grid(True)\n", + "plt.axis('equal')\n", + "plt.xlabel('$\\Delta t$')\n", + "plt.ylabel('Error')\n", + "plt.title('Convergence of modified Euler\\'s method (dotted line: slope 2)\\n');" ] }, { @@ -907,22 +877,18 @@ } }, "source": [ - "# Heun's Method: An implicit integration approach\n", - "\n", - "Increase accuracy with *predictor-corrector approach*\n", + "# An implicit integration approach\n", "\n", - "$y_{i+1}=y_{i}^{m}+f(t_{i},y_{i})h$\n", + "In the Modified Euler's method, which is a type of second order Runge-Kutta method, we increased the accuracy of the method by approximating the average slope over the time step. The Euler method assumes the slope is constant during each time step. We can increase accuracy the accuracy of our average slope with an _implicit_ *predictor-corrector approach*. \n", "\n", - "$y_{i+1}^{j}=y_{i}^{m}+\n", - "\\frac{f(t_{i},y_{i}^{m})+f(t_{i+1},y_{i+1}^{i-1})}{2}h$\n", + "Heun's method is an integration method that uses the same second order Runge Kutta method, but with one important distinction. It uses the actual derivative at the next state as part of its correction. \n", "\n", - "This is analagous to the trapezoidal rule\n", + "$y_{i+1}=y_{i}+f(t_{i},y_{i}) \\Delta t$\n", "\n", - "$\\int_{t_{i}}^{t_{i+1}}f(t,y)dt=\\frac{f(t_{i},y_{i})+f(t_{i+1},y_{i+1})}{2}h$\n", + "$y_{i+1}=y_{i}+\n", + "\\frac{f(t_{i},y_{i})+f(t_{i+1},y_{i+1})}{2} \\Delta t$\n", "\n", - "therefore the error is\n", - "\n", - "$E_{t}=\\frac{-f''(\\xi)}{12}h^3$" + "The error is $ error \\propto \\Delta t^2.$ This is the same convergence as the Modified Euler's method. Let's compare the two methods. " ] }, { @@ -933,18 +899,69 @@ } }, "source": [ - "### Example with Heun's method\n", + "## Using Heun's method\n", + "\n", + "The problem with an _implicit_ method is that our unknown $\\mathbf{y}_{i+1}$ is on both sides of the equation. In an _explicit_ method (such as the Euler and Modified Euler) we estimate the next state, with an equation that is only based upon the current state as such\n", + "\n", + "$\\mathbf{y}_{i+1} = f(\\mathbf{y_{i}}),$\n", + "\n", + "but with an implicit method we have a nonlinear function where\n", "\n", - "Problem Statement. Use Heun’s method with iteration to integrate \n", + "$\\mathbf{y}_{i+1} = g(\\mathbf{y}_{i},\\mathbf{y}_{i+1}). $\n", "\n", - "$y' = 4e^{0.8t} − 0.5y$\n", + "This extra step introduces the topic of solving a nonlinear problem with a computer. How can we solve an equation if the value we want is also part of our function? We'll take a look at methods to solve this next module, but for now lets set a tolerance `etol` for the _implicit_ Heun method and see what the resulting solution is. \n", "\n", - "from t = 0 to 4 with a step size of 1. The initial condition at t = 0 is y = 2. Employ a stopping criterion of 0.00001% to terminate the corrector iterations." + "\n" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 416, + "metadata": {}, + "outputs": [], + "source": [ + "def heun_step(state,rhs,dt,etol=0.000001,maxiters = 100):\n", + " '''Update a state to the next time increment using the implicit Heun's method.\n", + " \n", + " Arguments\n", + " ---------\n", + " state : array of dependent variables\n", + " rhs : function that computes the RHS of the DiffEq\n", + " dt : float, time increment\n", + " etol : tolerance in error for each time step corrector\n", + " maxiters: maximum number of iterations each time step can take\n", + " \n", + " Returns\n", + " -------\n", + " next_state : array, updated after one time increment'''\n", + " e=1\n", + " eps=np.finfo('float64').eps\n", + " next_state = state + rhs(state)*dt\n", + " ################### New iterative correction #########################\n", + " for n in range(0,maxiters):\n", + " next_state_old = next_state\n", + " next_state = state + (rhs(state)+rhs(next_state))/2*dt\n", + " e=np.sum(np.abs(next_state-next_state_old)/np.abs(next_state+eps))\n", + " if e" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "% improve estimate for y(2)\n", - "dy_corr(1)=(dy(1)+yp(t(2),y(2)))/2\n", - "y(2)=y(1)+dy_corr(1)*(t(2)-t(1))" + "plt.plot(t,num_heun[:,0],'o-',label='implicit Heun')\n", + "plt.plot(t,num_rk2[:,0],'s-',label='explicit RK2')\n", + "plt.plot(t,x0*np.cos(w*t))\n", + "plt.ylim(-8,8)\n", + "plt.legend();\n", + "#plt.xlim(np.max(t)-5,np.max(t))\n", + "#plt.xlim(np.max(t)-period,np.max(t))" ] }, { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "metadata": {}, "source": [ - "### This process can be iterated until a desired tolerance is achieved" + "## Discussion\n", + "\n", + "Change the number of steps per time period in the above solutions for the second order Runge Kutta and the implicit Heun's method. Why do you think the implicit method does not have an increasing magnitude of oscillation? " ] }, { "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "fragment" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], - "source": [ - "yp=@(t,y) 4*exp(0.8*t)-0.5*y;\n", - "t=linspace(0,4,5)';\n", - "y=zeros(size(t));\n", - "dy=zeros(size(t));\n", - "dy_corr=zeros(size(t));\n", - "y(1)=2;\n", - "for i=1:length(t)-1\n", - " dy(i)=yp(t(i),y(i));\n", - " dy_corr(i)=yp(t(i),y(i));\n", - " y(i+1)=y(i)+dy_corr(i)*(t(i+1)-t(i));\n", - " n=0;\n", - " e=10;\n", - " while (1)\n", - " n=n+1;\n", - " yold=y(i+1);\n", - " dy_corr(i)=(dy(i)+yp(t(i+1),y(i+1)))/2;\n", - " y(i+1)=y(i)+dy_corr(i)*(t(i+1)-t(i));\n", - " e=abs(y(i+1)-yold)/y(i+1)*100;\n", - " if e<= 0.00001 | n>100, break, end\n", - " end\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "y_an =\n", - "\n", - "@(t) 4 / 1.3 * exp (0.8 * t) - 1.0769 * exp (-t / 2)\n", - "\n", - "dy_an =\n", - "\n", - "@(t) 0.8 * 4 / 1.3 * exp (0.8 * t) + 1.0769 / 2 * exp (-t / 2)\n", - "\n" - ] - } - ], - "source": [ - "\n", - "y_euler=zeros(size(t));\n", - "for i=1:length(t)-1\n", - " dy(i)=yp(t(i),y(i));\n", - " y_euler(i+1)=y_euler(i)+dy(i)*(t(i+1)-t(i));\n", - "end\n", - "\n", - "y_an =@(t) 4/1.3*exp(0.8*t)-1.0769*exp(-t/2)\n", - "dy_an=@(t) 0.8*4/1.3*exp(0.8*t)+1.0769/2*exp(-t/2)\n" - ] + "source": [] }, { "cell_type": "markdown", @@ -1130,7 +1067,10 @@ "* the Euler-Cromer method fixes the amplitude growth (while still being first order)\n", "* Euler-Cromer does show a phase lag after a long simulation\n", "* a convergence plot confirms the first-order accuracy of Euler's method\n", - "* a convergence plot shows that modified Euler's method, using the derivatives evaluated at the midpoint of the time interval, is a second-order method" + "* a convergence plot shows that modified Euler's method, using the derivatives evaluated at the midpoint of the time interval, is a second-order method\n", + "* How to create an implicit integration method\n", + "* The difference between _implicit_ and _explicit_ integration\n", + "* The difference between stable and unstable methods" ] }, { @@ -1141,8 +1081,97 @@ "\n", "1. Linge S., Langtangen H.P. (2016) Solving Ordinary Differential Equations. In: Programming for Computations - Python. Texts in Computational Science and Engineering, vol 15. Springer, Cham, https://doi.org/10.1007/978-3-319-32428-9_4, open access and reusable under [CC-BY-NC](http://creativecommons.org/licenses/by-nc/4.0/) license.\n", "\n", - "2. Cromer, A. (1981). Stable solutions using the Euler approximation. _American Journal of Physics_, 49(5), 455-459. https://doi.org/10.1119/1.12478\n" + "2. Cromer, A. (1981). Stable solutions using the Euler approximation. _American Journal of Physics_, 49(5), 455-459. https://doi.org/10.1119/1.12478\n", + "\n", + "3. Chapra, Steven, _Applied Numerical Methods with MATLAB for Engineers and Scientists_ 4th edition. ch. 22.3 Improvements to Euler's method\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problems\n", + "\n", + "1. Show that the implicit Heun's method has the same second order convergence as the Modified Euler's method. _Hint: you can use the same code from above to create the log-log plot to get the error between $2\\cos(\\omega t)$ and the `heun_step` integration. Use the same initial conditions x(0) = 2 m and v(0)=0m/s and the same RHS function, `springmass`._" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. In the image above, we have a spring, mass, _and damper_. A damper is designed to slow down a moving object. These devices are typical in automobiles, mountain bikes, doors, any place where oscillations may not be desired, but motion is required. The new differential equation, if F(t)=0, that results from this addition is\n", + "\n", + "$\\ddot{x} = -\\frac{b}{m}\\dot{x} -\\frac{k}{m}x$\n", + "\n", + "or keeping our _natural frequency_ above, \n", + "\n", + "$\\ddot{x} = -\\zeta\\omega\\dot{x} -\\omega^2x$\n", + "\n", + "where $\\zeta$ is a new constant called the __damping ratio__ of a system. When $\\zeta\\gt 1$, there are no oscillations and when $0<\\zeta<1$ the system oscillates, but decays to v=0 m/s eventually. \n", + "\n", + "Create the system of equations that returns the right hand side (RHS) of the state equations, e.g. $\\mathbf{\\dot{y}} = f(\\mathbf{y}) = RHS$\n", + "\n", + "Use $\\omega = 2$ rad/s and $\\zeta = 0.2$." ] + }, + { + "cell_type": "code", + "execution_count": 425, + "metadata": {}, + "outputs": [], + "source": [ + "def smd(state):\n", + " '''Computes the right-hand side of the spring-mass-damper\n", + " differential equation, without friction.\n", + " \n", + " Arguments\n", + " --------- \n", + " state : array of two dependent variables [x, v]^T\n", + " \n", + " Returns \n", + " -------\n", + " derivs: array of two derivatives [v, zeta*w*v - w*w*x]^T\n", + " '''\n", + " ## your work here ##\n", + " \n", + " return derivs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Use three methods to integrate your `smd` function for 3 time periods of oscillation ( $t=0...6\\pi$ ) and initial conditions x(0)=2 m and v(0)=0 m/s. Plot the three solutions on one graph with labels. \n", + "\n", + "a. Euler integration\n", + "\n", + "b. second order Runge Kutta method (modified Euler method)\n", + "\n", + "c. the implicit Heun's method\n", + "\n", + "How many time steps does each method need to converge to the same results? _Remember that each method has a certain convergence rate_" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/notebooks/04_Getting_to_the_root.ipynb b/notebooks/04_Getting_to_the_root.ipynb new file mode 100644 index 0000000..3a721c1 --- /dev/null +++ b/notebooks/04_Getting_to_the_root.ipynb @@ -0,0 +1,1515 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Roots of Nonlinear functions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## It's not always possible to analytically solve for a given variable. \n", + "\n", + "In the last [Module 03](./03_Get_Oscillations.ipynb), we created an _implicit_ Heun's method that created the following problem: How can we solve for a value of $y$, a dependent variable, when the function is a function of $y$, in an equation format it becomes\n", + "\n", + "$y=f(y,parameters)$\n", + "\n", + "where $parameters$ are known inputs to the equation, but the variable $y$ is not separable from the function $f$. We can rewrite the problem as \n", + "\n", + "$0=y-f(y,parameters).$\n", + "\n", + "Many times, we may have a deeper problem such as wanting to know when two functions are equal to each other:\n", + "\n", + "$0 = g(y,parameters) -f(y,parameters)$\n", + "\n", + "where $g(y,parameters)$ in the previous equation was $g(y)=y$. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "# Getting to the root of a problem\n", + "\n", + "This is a very common problem in engineering designs. You may have mathematical models for designs, but you can't explicitly solve for the variables you can control or see [1]. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Freefall example:\n", + "Consider an observation of an object, with a known shape, so its drag coefficient c=0.25 kg/m. If the object reaches a velocity of 36 m/s after 4 seconds of freefalling, what is its mass?\n", + "\n", + "$v(t)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)$\n", + "\n", + "We can plug in the known parameters, $t=4~s$, $v=36~m/s$, $c_d=0.25$ kg/s, and $g=9.81~m/s^2$, but we cannot separate $m$ from the $\\tanh$ and $\\sqrt{}$.\n", + "\n", + "$36 = \\sqrt{\\frac{9.81m}{0.25}}\\tanh(\\sqrt{\\frac{9.81*0.25}{m}}4)$\n", + "\n", + "Instead, we can use computational methods to solve the problem by creating a new function f(m) where\n", + "\n", + "$f(m)=36 - \\sqrt{\\frac{9.81m}{0.25}}\\tanh(\\sqrt{\\frac{9.81*0.25}{m}}4)$. \n", + "\n", + "When f(m) = 0, we have solved for m in terms of the other variables (e.g. for a given time, velocity, drag coefficient and acceleration due to gravity)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "plt.rcParams.update({'font.size': 22})\n", + "plt.rcParams['lines.linewidth'] = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "g=9.81 # acceleration due to gravity\n", + "\n", + "def f_m(m,v=36,t=4,c_d=0.25,):\n", + " ''' define a function f(m) that returns \n", + " v(t)-sqrt(mg/cd)*tanh(sqrt(gcd/m)*t)\n", + " \n", + " arguments:\n", + " ---------\n", + " m: mass of object\n", + " c_d: drag coefficient default=0.25 kg/m # drag coefficient\n", + " t: time of velocity measure default=4 seconds\n", + " v: velocity measure at time, t default=36 m/s\n", + " \n", + " returns:\n", + " --------\n", + " f_m: the difference between v(t) and sqrt(mg/cd)*tanh(sqrt(gcd/m)*t)\n", + " if f_m ==0, then mass is correctly chosen\n", + " '''\n", + " \n", + " f_m = v-np.sqrt(g*m/c_d)*np.tanh(np.sqrt(g*c_d/m)*t)\n", + " return f_m\n", + "\n", + "m=np.linspace(60, 200,100); # possible values for mass 50 to 200 kg\n", + "plt.plot(m,f_m(m))\n", + "plt.plot(m,np.zeros(len(m)))\n", + "plt.xlabel('mass, m (kg)')\n", + "plt.ylabel('f(m)');" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true, + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.12322824302261637" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f_m(149)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "The Brute force method is plot f_m vs m and with smaller and smaller steps until f_m ~ 0, but we can do much better. \n", + "\n", + "We will look at two classes of methods, most numerical solutions use a combination of these two types of solvers:\n", + "\n", + "1. Bracketing methods\n", + "2. Open methods\n", + "\n", + "In __Bracketing__ methods, we choose an upper and lower bound and find the best solution in that range.\n", + "\n", + "In __Open__ methods, we choose an initial guess, then we have a function that brings us closer to the solution with every iteration.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "## Incremental searching ( a smarter brute force approach)\n", + "\n", + "If you consider a range of possible masses, e.g. 50 kg - 200 kg, then we can evaluate our function $f(m)$ at evenly-spaced intervals and look for x-axis crossings. If the value of $f(m_{i})$ is positive, and the value of $f(m_{i+1})$ is negative, then the correct mass is somewhere between $m_i$ and $m_{i+1}$. \n", + "\n", + "Take a look at the implementation we have below of the `incsearch` function. \n", + "\n", + "There are a few key lines to look at:\n", + "\n", + "```python\n", + " x = np.linspace(xmin,xmax,ns)\n", + " f = func(x)\n", + "```\n", + "\n", + "In these two lines, we are dividing the interval into `ns`-equally-spaced values (our default is ns=50). Then, we evaluate our function ($f(m)$) `ns` times for each value. \n", + "\n", + "```python\n", + " sign_f = np.sign(f)\n", + " delta_sign_f = sign_f[1:]-sign_f[0:-1]\n", + " i_zeros = np.nonzero(delta_sign_f!=0)\n", + "```\n", + "\n", + "On these three lines, we are looking for sign-changes in the array `f`. First, we get just the sign of each array value with `np.sign`. Then, we look at the changes in sign with the difference between f[i] and f[i-1] for i=1...len(f). Finally, we get the indices sign changes by looking for nonzero elements in `delta_sign_f`. \n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discussion\n", + "\n", + "Why can't we just consider cases where `delta_sign_f>0`? Why do we care about all nonzero sign changes?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "def incsearch(func,xmin,xmax,ns=50):\n", + " '''incsearch: incremental search root locator\n", + " xb = incsearch(func,xmin,xmax,ns):\n", + " finds brackets of x that contain sign changes\n", + " of a function on an interval\n", + " arguments:\n", + " ---------\n", + " func = name of function\n", + " xmin, xmax = endpoints of interval\n", + " ns = number of subintervals (default = 50)\n", + " returns:\n", + " ---------\n", + " xb(k,1) is the lower bound of the kth sign change\n", + " xb(k,2) is the upper bound of the kth sign change\n", + " If no brackets found, xb = [].'''\n", + " x = np.linspace(xmin,xmax,ns)\n", + " f = func(x)\n", + " sign_f = np.sign(f)\n", + " delta_sign_f = sign_f[1:]-sign_f[0:-1]\n", + " i_zeros = np.nonzero(delta_sign_f!=0)\n", + " nb = len(i_zeros[0])\n", + " xb = np.block([[ x[i_zeros[0]+1]],[x[i_zeros[0]] ]] )\n", + "\n", + " \n", + " if nb==0:\n", + " print('no brackets found\\n')\n", + " print('check interval or increase ns\\n')\n", + " else:\n", + " print('number of brackets: {}\\n'.format(nb))\n", + " return xb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test our function\n", + "\n", + "To test our `incsearch` function on a known function, let's try finding all the times that $sin(x)$ crosses the x-axis from $x=-1...7$. Our function should return values at $x=0,~x=\\pi/2,~x=\\pi.$\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of brackets: 3\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mn=-1\n", + "mx=7\n", + "x=np.linspace(mn,mx)\n", + "plt.plot(x,np.sin(x))\n", + "\n", + "xb = incsearch(lambda x: np.sin(x),mn,mx,ns=50)\n", + "\n", + "plt.plot(xb,np.sin(xb),'s')\n", + "plt.ylabel('$\\sin(x)$')\n", + "plt.xlabel('x')\n", + "plt.title('Upper bounds={:.2f},{:.2f},{:.2f}\\nLower bounds={:.2f},{:.2f},{:.2f},'.format(*xb[0,:],*xb[1,:]));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Success - incsearch works\n", + "\n", + "You should see that `incsearch` returns intervals in the correct locations near x=0, x=$\\pi/2$ and x=$\\pi.$ Now, let's apply it to the freefall problem and discover what mass is necessary to reach 36 m/s at t=4 sec of freefall.\n", + "\n", + "Depending upon what `ns` you choose, you should see that a mass of 142-143 kg will reach 36 m/s in 4 seconds of freefall. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of brackets: 1\n", + "\n", + "Upper bound on mass = 143.94 kg\n", + "Lower bound on mass = 142.42 kg\n" + ] + } + ], + "source": [ + "xb = incsearch(f_m,50,200,ns=100)\n", + "\n", + "print('Upper bound on mass = {:.2f} kg'.format(*xb[0,:]))\n", + "print('Lower bound on mass = {:.2f} kg'.format(*xb[1,:]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise \n", + "\n", + "Use the `incsearch` function to find the number of times $cos(x)=0$ in the interval $x=0...8$.\n", + "\n", + "Plot x-vs-cos(x)\n", + "\n", + "and \n", + "\n", + "plot the values of `xb` and `np.cos(xb)` as $\\circ$-markers (`'o'`)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Bisection method" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "The `incsearch` function will always return a set of upper and lower bounds on the zeros of a function, but if you want to increase the accuracy of your solutions, you have to calculate $f(x)$ __a lot__. The error in the solution is always \n", + "\n", + "$error = \\frac{x_{max}-x_{min}}{ns}$\n", + "\n", + "We can reduce the number of times we have to evaluate the function with more insight. \n", + "\n", + "Let's divide interval in half until, then evaluate $f(x_{max})$, $f(x_{min})$, and $\\frac{x_{max}+x_{min}}{2}$. Now, we can look for a sign change between these three locations. We focus our attention on the bisected bracket. Look at the figure below that illustrates choosing the region of interest on the right vs left side of the interval." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "![Using the bisection method to reduce search to half of interval](../images/bisection.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Let's use the same interval we started with to illustrate a few steps in the right direction. \n", + "\n", + "$x_{max}=200$ kg\n", + "\n", + "$x_{min}=50$ kg\n", + "\n", + "$x_{mid}=125$ kg" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f(xmin) = 4.58, f(xmid) = 0.41, f(xmax)=-0.86\n" + ] + } + ], + "source": [ + "x=np.array([50,125,200])\n", + "fx=f_m(x)\n", + "\n", + "print('f(xmin) = {:.2f}, f(xmid) = {:.2f}, f(xmax)={:.2f}'.format(*fx))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we have reduced our region of interest to just 125-200 kg. \n", + "\n", + "## Exercise\n", + "\n", + "Divide the region 125-200 kg into two, and repeat the above step. Is the solution in the upper (163-200 kg)? or lower (125-163 kg) region? What are the values of f_m(m)?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Bisect Function" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "We can automate this process with a `bisect` function. Its a much better root locator because we can reduce the error without evaluating the function a lot of times [1, 2]. \n", + "\n", + "_Note the use of the function `break`:_\n", + "\n", + "We can use an `if`-statement to check a condition and `break` the loop if that condition is met. These break statements are often used in `while`-loops so that you can have some stopping criteria. In our case, we use the specified error, `es`, as a stopping criteria. If our relative error, \n", + "\n", + "$e_{relative} = \\frac{|x_{new}-x_{old}|}{x_{new}}$\n", + "\n", + "is less than our specified error, the loop is broken and the number of iterations halts at that point. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "## Discussion\n", + "\n", + "What is another stopping criteria that you could use?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "def bisect(func,xl,xu,es=0.0001,maxit=50):\n", + " '''bisect: root location zeroes\n", + " root,fx,ea,iter=bisect(func,xl,xu,es,maxit,p1,p2,...):\n", + " uses bisection method to find the root of func\n", + " arguments:\n", + " ------\n", + " func = name of function\n", + " xl, xu = lower and upper guesses\n", + " es = desired relative error (default = 0.0001 )\n", + " maxit = maximum allowable iterations (default = 50)\n", + " p1,p2,... = additional parameters used by func\n", + " returns:\n", + " -------\n", + " root = real root\n", + " and a list of [fx, ea, iter]\n", + " fx = function value at root\n", + " ea = approximate relative error ( )\n", + " iter = number of iterations'''\n", + " xr = xl\n", + " ea = 100\n", + " for iter in range(0,maxit):\n", + " xrold = xr\n", + " xr = (xl + xu)/2\n", + " if xr != 0:\n", + " ea = abs((xr - xrold)/xr) * 100\n", + " else:\n", + " ea = abs((xr - xrold)/1) * 100\n", + " test = func(xl)*func(xr)\n", + " if test < 0:\n", + " xu = xr;\n", + " elif test > 0:\n", + " xl = xr;\n", + " else:\n", + " ea = 0;\n", + " if ea <= es:\n", + " break\n", + "\n", + " root = xr\n", + " fx = func(xr);\n", + " return root,[fx,ea,iter]\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The best estimate for the mass is 142.73769855499268 kg\n", + "We reached a relative error of 5.0109798921069224e-05 with 20 iterations\n" + ] + } + ], + "source": [ + "Mass_at_36ms,out=bisect(f_m,50,200)\n", + "print('The best estimate for the mass is {} kg'.format(Mass_at_36ms))\n", + "print('We reached a relative error of {} with {} iterations'.format(out[1],out[2]))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Recursive functions\n", + "\n", + "The `bisection` function and the next two open root solvers (`newtraph` and `modsecant`) make use of a recursive function. \n", + "\n", + "Definition:\n", + "\n", + "__recursive: for a definition of recursive, see recursive.__\n", + "\n", + "Recursive functions work by updating an initial assignment each time the function is called. In the bisection method, the initial solution is assumed to be halfway between the upper and lower bound\n", + "\n", + "$x_{r} = \\frac{x_u+x_l}{2},$\n", + "\n", + "but once the upper or lower bound is updated, the value of $x_r$ is updated as well. This is why the first step in the loop is to temporarily save $x_r$ as `xrold`. With the `xrold` variable, we can track the progress of our solution. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Newton-Raphson: Open method\n", + "\n", + "Bracketing methods are great, but they are burdened by slow convergence rates. In the bisection method, we reduce our error by 50\\% with each region of interest selection, but this is rather slow. \n", + "\n", + "One of the fastest root-finding methods is the __Newton-Raphson__ method, it is an __open method__ so it does not require an upper- and lower-bound [1,2]. \n", + "\n", + "The __Newton-Raphson__ works by creating a Taylor series expansion around your initial guess of the function, \n", + "\n", + "$f(x_{0}+\\Delta x) = f(x_{0}) +\\frac{df}{dx}\\Delta x +...$\n", + "\n", + "We want to determine what step, $\\Delta x$, to take in order for $f(x_{0}+\\Delta x)=0$. So we set our right hand side to 0 and ignore the $...$ -higher order terms. \n", + "\n", + "$0 = f(x_{0}) +\\frac{df}{dx}\\Delta x$\n", + "\n", + "So our best guess for a solution is then\n", + "\n", + "$x_{solution} = x_{0}+ \\Delta x$\n", + "\n", + "where \n", + "\n", + "$\\Delta x = -f(x) \\left({\\frac{df}{dx}}\\right)^{-1}.$\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Newton-Raphson example\n", + "\n", + "Let's use the __Newton-Raphson__ method to solve an engineering problem. Consider a spherical tank of water that can be filled to a height, $h$, and has radius, $R$. \n", + "\n", + "The volume of water, $V$, in the tank is \n", + "\n", + "$V= \\pi h^2\\frac{3R-h}{3}.$\n", + "\n", + "If your tank has a radius of $R=2~m$ and you need a volume of 29 $m^3$, what height should you fill it to?\n", + "\n", + "To answer this question with the Newton-Raphson method, we first define a new function, $f(h,parameters)$\n", + "\n", + "$f(h,parameters) = V-\\pi h^2\\frac{3R-h}{3}.$\n", + "\n", + "Now we can plug in our known parameters\n", + "\n", + "$f(h) = 29-\\pi h^2\\frac{6-h}{3},$\n", + "\n", + "and calculate the derivative, \n", + "\n", + "$\\frac{d}{dh}(f(h)) = -\\pi \\frac{12h-3h^2}{3}$" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "def f_h(h,V=29,R=2):\n", + " return V-np.pi*h**2*(3*R-h)/3\n", + "\n", + "def dfdh(h,V=29,R=2):\n", + " return -np.pi*(6*R*h-3*h**2)/3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use the definitions of `f_h` and `dfdh` to calculate the height, $h$ to fill the tank." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.974413341499149\n" + ] + } + ], + "source": [ + "xguess = 2\n", + "deltax = -f_h(xguess)/dfdh(xguess)\n", + "print(xguess+deltax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discussion\n", + "\n", + "Try changing the value of `xguess`. Is there any way to choose the best `xguess` value? Are there any `xguess` values that return an Python error? Why?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create a Newton-Raphson function\n", + "\n", + "In the same way that we created bracketing method functions, we can create the Newton-Raphson method function to update our `xguess` until a desired tolerance is achieved. " + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "def newtraph(func,dfunc,x0,es=0.0001,maxit=50):\n", + " '''newtraph: Newton-Raphson root location zeroes\n", + " root,[ea,iter]=newtraph(func,dfunc,x0,es,maxit,p1,p2,...):\n", + " uses Newton-Raphson method to find the root of func\n", + " arguments:\n", + " ----------\n", + " func = name of function\n", + " dfunc = name of derivative of function\n", + " x0 = initial guess\n", + " es = desired relative error (default = 0.0001 )\n", + " maxit = maximum allowable iterations (default = 50)\n", + " returns:\n", + " ----------\n", + " root = real root\n", + " ea = approximate relative error (%)\n", + " iter = number of iterations'''\n", + " xr = x0\n", + " ea=1\n", + " for iter in range(1,maxit):\n", + " xrold = xr\n", + " dx = -func(xr)/dfunc(xr)\n", + " xr = xrold+dx\n", + " if xr!=0:\n", + " ea= np.abs((xr-xrold)/xr)*100 # relative error in %\n", + " if ea < es:\n", + " break\n", + " return xr,[func(xr),ea,iter]\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0791382579723865\n" + ] + } + ], + "source": [ + "hr, out = newtraph(f_h,dfdh,1)\n", + "print(hr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare techniques\n", + "\n", + "Let's compare the relative error in finding the height, $h$, in the previous example as a function of the number of iterations in the bisection (`bisect`) method and the Newton-Raphson (`newtraph`). \n", + "\n", + "What we should see is that as we increase the number of iterations, the relative error decreases. We can compare the rate that the error decreases, $\\frac{\\Delta error}{\\# iterations},$ for our two root locators.\n", + "\n", + "We are going to set the maximum iterations, `maxit=n[i]`, to the desired value in the loop, but we want as low of an error as possible. We set our specified error to `es=0`." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n=np.arange(3,30)\n", + "\n", + "err_bisect = np.zeros(len(n))\n", + "err_newtraph=np.zeros(len(n))\n", + "\n", + "for i in range(0,len(n)):\n", + " root,out = bisect(f_h,0,4,es=0,maxit=n[i])\n", + " err_bisect[i] = out[1]\n", + " \n", + " root,out = newtraph(f_h,dfdh,1,es=0,maxit=n[i])\n", + " \n", + " err_newtraph[i] =out[1]\n", + "\n", + "plt.semilogy(n,err_bisect,label = 'bisection')\n", + "plt.semilogy(n,err_newtraph, label = 'Newton-Raphson')\n", + "plt.xlabel('number of iterations')\n", + "plt.ylabel('relative error (%)')\n", + "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discussion\n", + "\n", + "There is a drastic difference between the `bisection` function and the `newtraph` function. How many iterations are necessary for the bisection method to reach an error of $10^{-3}$ \\%? How many iterations are necessary for the Newton-Raphson method to reach an error of $10^{-3}$ \\%? \n", + "\n", + "Are there any benefits to the bisection method? When would the Newton-Raphson method not work? or not be appropriate?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Secant Methods" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "The key to the Newton-Raphson method is its evaluation of the derivative of the function, but we can't always evaluate the derivative. Many numerical functions, such as the solution to differential equations that we worked on in notebooks [01](./01_Catch_Motion.ipynb), [02](./02_Step_Future.ipynb), and [03](03_Get_Oscillations.ipynb) do not have analytical derivatives. Instead, we will approximate the derivative with a modified secant method.\n", + "\n", + "Approximation of derivative:\n", + "\n", + "$f'(x) \\approx \\frac{f(x+\\delta x)-f(x)}{\\delta x}$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Modified Secant method" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Change the x evaluations to a perturbation $\\delta$ [1,2]. \n", + "\n", + "$x_{i+1}=x_{i}-\\frac{f(x_{i})(\\delta x_{i})}{f(x_{i}+\\delta x_{i})-f(x_{i})}$" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "def mod_secant(func,dx,x0,es=0.0001,maxit=50):\n", + " '''mod_secant: Modified secant root location zeroes\n", + " root,[fx,ea,iter]=mod_secant(func,dfunc,xr,es,maxit,p1,p2,...):\n", + " uses modified secant method to find the root of func\n", + " arguments:\n", + " ----------\n", + " func = name of function\n", + " dx = perturbation fraction\n", + " xr = initial guess\n", + " es = desired relative error (default = 0.0001 )\n", + " maxit = maximum allowable iterations (default = 50)\n", + " p1,p2,... = additional parameters used by function\n", + " returns:\n", + " --------\n", + " root = real root\n", + " fx = func evaluated at root\n", + " ea = approximate relative error ( )\n", + " iter = number of iterations'''\n", + "\n", + " iter = 0;\n", + " xr=x0\n", + " for iter in range(0,maxit):\n", + " xrold = xr;\n", + " dfunc=(func(xr+dx)-func(xr))/dx;\n", + " xr = xr - func(xr)/dfunc;\n", + " if xr != 0:\n", + " ea = abs((xr - xrold)/xr) * 100;\n", + " else:\n", + " ea = abs((xr - xrold)/1) * 100;\n", + " if ea <= es:\n", + " break\n", + " return xr,[func(xr),ea,iter]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs8AAAE0CAYAAADTz97wAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAIABJREFUeJzsnXd4FWXWwH8njSQkAUISSEIJht5CCSiKoIKiQIIF196xd9dd61q+ta7uuuiuDcW6ttUVKSId7NJDJwQJLQQSAiQhIfX9/pi55Cbce9Mr5/c889yZec/7zpm5c+8998x5zxFjDIqiKIqiKIqiVI5XYyugKIqiKIqiKM0FNZ4VRVEURVEUpYqo8awoiqIoiqIoVUSNZ0VRFEVRFEWpImo8K4qiKIqiKEoVUeNZURRFURRFUaqIGs+1REQ6icjDIrJIRHaJSL6IHBWRnSLyjYjcJSLtG1tPRVGaJiIyRES+EJG9IlIkIsZe2ja2bp4QkadsPVMbWxdFUZSGxKexFWiuiIgP8AxwL+DvQqSLvSQCfxORV4wxjzWgiorSZBGRs4Al9mY3Y0xq42nTeIjIEOAnXH+HKIqiKE0Q9TzXABEJAOYAD2H96O0E/gzEA5FAB2AI8CCQBAQAjzaKsoqiNGUexPoO2Q+MAcKAYCDYGHO4MRVTFEVRXKOe55rxGnCevf4BcKsxpqCCzAFgjYj8A7gaeL0B9VMUpXkQZ79+ZoxZ3KiaKIqiKFVCjedqYj9uvsnenA/cYDzUOLfbPhKRVQ2gnqIozYtA+1W9zIqiKM0EDduoPn+2Xw1whyfD2RljzCZX+0XES0SuEZHvROSAiBTar9+JyFUiIu7GdJpYdL29fZ2I/Cgih0QkT0SSROTPIuLnou8Xdt8tlekuIk/YsvkiEuKi3UdEbrR1TrfPIUNE5ns6BxG53nEO9nZnEZkqIsm2/idMmhKRbiLyjojsFpEC+/UjEelvt6fa/Z7ycD4BInKfiCyz9Sy09Z4hIuM99Cs3QUpEYkTkDfuYBSKyX0S+FJHBVbim/iJyh32N0u3++0RkuYg86zgfN317ishrIrJJRHLsa7VVRF4VkS6VHbsa59fXvtY7bP0OO8mKiAwXkWdE5GcROWhPdjskIitE5GlxM1HWfr+XOO3a4XQvH78fXPSLEpEXRGStiBwWkWMi8ruIvCsifSs5t/Ei8j+n+ybX7rtMRJ4UkT7VvmBlY4eLyHP25y3b/pxsF5FpItLPhXyM03nG2LufrHANrq+mDqeLyMf2OeXb98ROEfnFvmbDPPQdYL/P2+2+2fY1flZEwqqjhz1es/tuEZH+IvK2iGwRa8L3MRHZIyIr7X5jqnsdFEVpwRhjdKniAgQBRViG86I6GK8tsMwez92yCAhx098hcxPwXw9jzAO8KvRNcGofVomeW225z120dQHWVnIO3wKtXfS93knmNCDLRd+2TvJnA7lujpEHjAdS7e2n3JzLQCcZd8t0wNtF36fs9lRgNJa30FX/Y8BYD9czDthRiQ5r3fT9o9M96Go5Ckys4f3ofH6TgPwKYx92kp1Uif4G2AcM8nDful1c9Lncfo/d9SkGbnZzXq9V4Zj/quE1O9vDfeDQ674KfWKqoM/11dDhwSqMN9tD3xIP/bKAUZXdL835u8W+tzx9pgywoSb3hy666NIyl0ZXoDktwFinL9MnazmWYBm1jvHeAQYDofbru1X44XO0b7d/pF8A+gPtsAy0/znJ3FKhry+QYbdN9aDnMKcxEiq0hQApdlsm8ADQG+tPQQ/gYcoMno9djO38A7cH2AVcC3TCmnQ5EfC3ZaMoM1IOAXfYP64RWIbcFuCg3WZwYTzb8gft9p3ALUCsfb36AS/a19EAz7jo/5TT8TOxJoNeBHS09b3W6fi7AB8XY3Rz+iHPA55zet+jgHOBfwKLXfS90+l6zcKKu++ANcnsXOB7uy0fGFCDe9JxfkeAbGADcLF9ftHAJCfZicBi4C7gdOAUoL19HW+hzCj63fEeOvUNAi5wOpe+9r7jSwX5iUCpLfsjcKGtTyhwBjDDbisFzqvQd4zTcb7A+tPTCQi3r/ul9v6XanC9elD2Z+4gcLvTPZlgXz/HsS+t8Nl3nOtOu/25CtfghHvHjQ49ne7ZhcA4W4f2wACsbD/vAf9x0fcKJ/022LIRQGf7XBz3aTZwiof7JbW5frfY4+XYcquwPs/d7HurL3A+1p+vEz6Puuiiy8m7NLoCzWkBbnb6Qr6slmNd6DTWc25k/uYkk+ii3dkzcpWLdi9gjd3+q4v2f9lt+3HhabVl/mnLZAC+Fdpedfpx7eWmv/MfjvgKbc4/cJlAJw/X6y3KPHmnumgPA3Y7jfeUC5mZTj+m4W6Oc5MtUwBEVWh7ymn8Nbj2eF3sJHO+i/bvKDNwR3g4X58K25FYHm0DvOWuD1Y4hNs/XJXck87ntxVoU4v7O4gy4+cGF+1nOR0rxsM4jkwUBphLhScoTnIf2jLrK+z/u71/NSA1PR83x3QY7flAnIv2tpT9idgH+LmQSXV3v1ZRh7udPsMnjO+hXyun67rZ1XuN9efCcc/9z8P9kuqirVl8t1DmJS8GQuvy/tBFF11a7qIxz9Uj1Gm9thN8ptiv6Vg/Qq74C1bWDmd5V/xijPlPxZ3GmFIsowJgsFi5qZ352H6NwPJclkNEvLEeaYL1WLXIqa01ZRMn/88Ys9WVYsaYhVgeSoCrPJzDS8aYPa4abL2vsDc/Ncb85uI4mcBf3Q0uIqdgeZvAeoye4UZ0OpYn3w/LK+mOh4wxR13sn4HlfQbLs+asQy8szyDA34wxv7gb3BhTXGHXbVgGz0HgHg99nrA3x0vtimw8YYw5UtPOxphcrCcf4OLeqgZXYN2fpVihDKVu5Bw51PuLSJzTfsc9n2aMMbXQoxwi4vAuA7xhjEmqKGOsVHMP25sdKbv/6hLH+WUYYwqr0S8B67qCdS+f8F4bY9Zg/WkFSBSR8GqM3yy+Wyi7fnnopE1FUaqIGs+NgD3J5Qx7c6a7Hz1jpb+bZW+O9DDkXA9tjh8eP6zwBOfxfwW22ZtXu+g7FusRJ5T9GDo4nbJMActEJMjdAqyz5eI96DnHQ9sArNy3YHmP3THDQ9sYrMflpcDPHnRtjRWO4UnfAspPeDuObdyl2JsdXejg4H0PurpirP36A+DrQX/HJC0BhlbzGA4cXl6P2JO5rhORmWJV13RMxHJM1PqTLdqrhnpA2XknAUc9nPchLA8mlH/f1tivF4jI/bZsXXA6Zd+f//UgNxvLMw1wZh0d2xnH+fWzJwZWtZqp4/skDytu2B2Oc/PGOucq0Yy+W5Kw7vdg4F0R6eRBVlEUBdBUddUly2m9Nl69EKf+LrNwOLHRfm0nIiHGmGwXMmke+uc5rQe6aP8Pluf7QhFpXcGb6vjRS7F/DJ1xNoiWezi+M548V797aItxWnfphQIwxhwQKyOEq/fGoa8XsNfDsZxxp2+Gs6fMBY5rXvF6x9qv2caYHVXUwYFD/wuxYjSrQnU8hc5kurnPjmN7Ib/DKgZUGW1qqAeUnfdganbeH2PFxw8D/gE8LyK/YsVOfw8srabH1kFXp3W3n2FjTJGIbMOaqNrVnVxNMcYsFZEZWPfFQ8CDIrKSsvNb5OYJiUOXZBdPOZzZ6LReXf2b/HeLMeZ3EZkK3IcV6nGdiKzD+pP6A7DQGJPlrr+iKCcn6nmuHs4GT+9ajBPstJ5biayzwRDsRqakisd1ldbJ4fVpjTVZxhIUCcT6QXaWcaYmBpHbEsTGmDx3bbZuDlwZAs64u551qW9Nr7cjFVdVjUBn6vR6V4Kn98LBh1iGczFWfOq5WBOt2mNXyMOawAq1+5Neq/O2DcNzgGew4o5bYU0afAxrwu5+sdLqnZDOsRJq8hl29/mtLX/A8vL/juUhPhUrK8s3wAGx0hpWTAPn0KUuvn/c0Ry+W8CajDgFWI/1mY3Dmgj7OZAuVgrAyBropChKC0WN5+rxK5axADCqFuM4/yBV9hjZub0mRpdHjDHbAUfsrfPj1Qudjn1CPDXlf3SDjTFShSWmhmo6G8yt3UpZuLueDn0zq6irGGPOqqG+7qiNEeXQ/+Vq6P9+3ahdHjt+/Hx7825jzL3GmIXGmFRjTJYxJteOeXb1pKO6OM77y2qc91POA9j6/AUrQ8cArGwg/8GKcW2LFSf+eTX1qslnuM4/v2B5t40xLxtjYrEyUVyLlb0nHes9uAtYVGHOg0OXevv+aSbfLRiLd40xA7EyjVyGNeExFStzyFXALyJSmycoiqK0INR4rga2QbDA3jxbRGI9yXsgm7JJZR6LO2Cl/gLIquxRei34yH4dKyKOOETHBJxfjTEpLvo4PwodVE96OdjptN7TnZA9ictdOI1D37BGjGt0XMcQEelWzb4O/SstwNIAOL/fn3qQG1AHx6qz87aNpA3GmGnGmKuxjOkv7eYLRaQ693Gq07rbz7BtsDru2VR3cnWFMSbFGPORMeZmLEPwVbspnvITFh269HQxkdgZ5yIvqe6EPNDUv1vKYYzZY4z5whhzN1b6RUfcflfghobURVGUposaz9XnJftVgH+7q3BVEXGqgGbP+v/J3kwQEV83ffwom9H/kyuZOuJzrCIB3sDldjzreXabq8eqYBV3KbDX6/tHZT1lXq9ED3KTPLQtcFpvrB/BhU7r11Wz73z7dXQNDO+6ppXTurcrAbEqHXp6OuMcM+5yDBvHeceKSJ1OuLMf5z/ntKs6VQZ/wZp8CnCJB7kJQIC9/mM1xq81dsjKU067nM/PoUsgZU8RXDHZfi2hzItcHZr6d4tb7D9bL2PlPYfq3R+KorRg1HiuJsaYJVhFB8BKOzZdRFq5kxeLa7BCPpx5136NpCy9WEWepmxG+rSaaVw59oQYx4z7q7EeW/pg/ei5fJxte8Ed53C9iHgyIBCRkJrGDdqT8z6zN68QF6WG7SwDj3sYYwtl5/iIiHjMHCAiESLSzpNMdTHGJGNNsgN4SESGezh+RW/gv7EMCh/go8qyRthp8eoLZ8/gCX9Y7D+D0/BsFB90Wo/yIPcxZeka33HyXrqk4nlX4To4Pz066FaqAsaYA5RlwrlDXJRTtx/zv2hvpmNl3qhTRKSHiHj6Hnd3frMpu64visgJoUR2yr/b7c1vjPv0jm5p6t8tItLNU7y7fb85rk2V7w9FUVo4pgkkm25uC5a3ZiFlSfhTscrcDsbKaxphrz+AU3nZCmMIZQUzDFY+1UFYuaTjsIwPR9scN3o42q/3oOtZTnIxHuQmO8ntsF9nVnId2mClRjNYXrh3sSZjdcBKi9cDyyv3Dpb3ZnKF/te7ujZujhVtj2Gwsp7cTlmluASsjAdZeK4w2JmywhAFWAU0TsMqsNIey7N0JVYoQj4nFl54yvF+V6LrUlvufRdtzhUGj2Llpna875FY5Z5fxkX5d6xcz473KAW4FSskoK3d93SsiWK/UaFYSBXv66qenzdWLmxHEYt7sIy0cCwv5s9220Z342EZUI73c459Hv72/ooFYsZTVkJ6H9bnqp99j3XACkm4A6uUfbaL92ID1h+r0ViGejusjA53O90ve6lQCbEK18u5wmCG/X50tq/DRKwnJo736w9uxkh1d79WUYf3sT6vz2NN2uxs3w+xWF7bXfb4uUBkhb5XOumXZOscjvW5uhWruIjBeuoTW4v7pcl+t9jnkA5MxXpKEGNfvxisPO+OKpEluCg1r4suupycS6Mr0FwXrIkkL1FWgcvTkuvqx9H+kl5WSd/FQIgbHerSeG5FmSHh8Qe/Qr9IrEfAlV0DQ4UqiVX9gXOSH4tlcLoaO9/+8XOUO37czRi9sQztynQtpULVOOrAeLbbB1Fm1Lhb1rrpe0sV77lVNbinq3R+tuwoysoju1peqmw8rJAJl/1dyCa6uD9dLQfdvBeelkw8VHus5DqcTVnZeFdLMXCvh/6p1N54ruz88oAL3fR/kLI/Jq6WLGBUbe4XmvB3C+Wranp6D++oyfujiy66tMxFwzZqiLFmuP8JywPyGNaP9F4swyYfyziaCdwJdDYVMgDYYxzG+vG9Fiu2MwPrizrD3r4GGGPqb6Kgsy4FlC/2kI3ngiSOfvuwij9cZPffhXUNCrG8hEuwqqz1MMZUOl4lx1qIlS/3PaxrXWi/fopVsnsOlWQ2MFb4xkCsmONZWDmyC7E80buxngbcg/WenVA1ri4wxqzFMuLvx8rFexDrMXYaltf4GcoqKlbs+zbWRKZnsXLgZmEZPzlYfwrexwqlOMNV/zo8h++B4VjhNAds/R2hCRPtz0ZlPI6VCeJXLO+hu+qB2PfOKcAjWNcsE+uzchSrGMdnWNcspkLX64Cb7fb1dr8SLIP3N+BJrPLPNYnnxVhhXD2xPL/rsP4oH8MKbXkXy1s5tSZjV5GHsL4n3sd6yrUf67rkYBVQeQnobYxxWUDIWDG9g7Eqa+6wdc+1z+U5oKf9XteYJv7d8k8sD/ObwEqsz2AR1n21EStcaqAx5vUajq8oSgtEjDGNrYOi1Al2jLKjoMFkY8xXjamPoiiKoigtD/U8Ky2JBKf1VY2mhaIoiqIoLRY1npVmg4iEemgLx5p8B7DCGJPaIEopiqIoinJSUZuyuYrS0DwrIl2xSkM74n1DscovPw50seX+0jjqKYqiKIrS0lHjWWlOCHCBvbjCAH80xsxrOJUURVEURTmZ0AmDTYywsDATExPT2Go0SfLz88nKyiInJ4fCwkKKi4sREXx9fQkODiY8PJzAwMDGVlNRlEZg1apVmcaY8MbWQ1GUlo96npsYMTExrFy5srHVUBRFaVaIyM7G1kFRlJMDnTCoKIqiKIqiKFVEjWdFURRFURRFqSJqPCuKoiiKoihKFVHjWVEURVEURVGqiBrPiqIoiqIoilJF1HhWFEVRFEVRlCqixnNLYekLsH1xY2uhKIqiKIrSotE8zy2B5Hmw9HlrfcRdMOYJ8GnVuDopiqIoiqK0QNTz3NwpLaV0wZNl27/8C94ZAxlbG08nRVEURVGUFooaz80dLy9+G/keS0riyvalr6f0rdGw4l3Q8uuKoiiKoih1hhrPLYBvd5RwQ9GfebLoOgqMLwBexfkw5wG2v5bI1u07MGpEK4qiKIqi1Bo1nlsAPTsEMSC6LR+UjCOx8K9sKe18vC0263vafXgW9z//Ck/N3MjPKZkUlZQ2nrKKoiiKoijNGFGPZNMiPj7erFy5skZ99x3JZ+Gm/SzZsIvRu/7Ndd7flWufVjyel4ovIyAgkHN6RzCuXwdG94wgwM+7LlRXFEVpNERklTEmvrH1UBSl5aPGcxOjNsazM9nHiti87Cv6LH+YkJJDx/dvKu3KPUV3kmI6ARDg683ZvcO5oH8kZ/eOIKiVJmBRFKX5ocazoigNhRrPTYyaGs+FJYVsydrCwPCB5RtyD1A64w68UhYc33XM+PJM8dV8XDIWkOP7/Xy8GN0znPEDOjKmTwdC/H1rehqKoigNihrPiqI0FNU2nkXEC4gFOgBtgUPAASDFqCVea2piPG8+uJnHfnqMPTl7+CrxKzoHdy4vYAwsnwbzH4eSguO7v/cZwQ25d1DCiWEbvt7CyO5hXDAgkvP6dqBtoF+NzkdRFKUhUONZUZSGokrGs4gEAFcCk4BRQLALsWzgB2AG8KkxJr8O9WxWiEgP4DVgJJAPfAY8ZIzJq6xvdY1nYwyXzrqUrYesvM5DOwxl+rjpeImLuaD7N8FXN8GBTcd3ZZ76MJ/4Tebb9fvYkp7j8hg+XsKI2PaMHxDJuH4dCW2thrSiKE0LNZ4VRWkoPBrPItIWeBSYArTBesZvgH1AFpbBHAK0Bzo6tR8BpgHPG2MO16P+TQ77mm0AdgJ/BSKAfwALjTGXV9a/Jp7nDZkbuPrbqykxJQA8PPxhrupzlWvhomMw98+w+gNr28sXbl0GHfqxI/MoczfsY+76dNbvPeKyu7eXcHpsexIGRnFeP/VIK4rSNFDjWVGUhsKt8SwidwBPYxnG6cB/gIXAr8aYEywr22g8DTgXuALLmD4IPGmMeb1etG+CiMhDwBNAV2NMpr3vSqzr198Ys9FT/5rGPL+6+lWmrZ8GgL+3P18mfknXkK6uhUuKYfp5sHeVtd1xINy8GLzLYpx3Z+Xx3YZ0vt2wjzW7XP//8fESRvYIY8KASM7r25E2gRojrShK46DGs6IoDYUn47kUWAn8H/CtMabKyYHtuOiJwF+AIcaYkyYXmogsA44YYxKd9rXC8sY/box52VP/mhrPRSVFXD7ncpIPJQMwKHwQ75//Pt5ebi59xlZ488yyGOizHoGzHnYpmnY4n+82pDNn/T5W7TzkUsbXWzizRzgTBkRybj+dbKgoSsOixrOiKA2FJ+P5ImPM17U+gMiFxpgZtR2nljr0As4HhgHxQE+sEJNLjTFfVtL3SuB2YCDgDWwB3gPecPWHQkQOANONMQ9X2L8R+MUYM8XT8WqTqm7zwc1cOedKik0xAA/GP8h1/a5z3+Hn16xJhABePjBlEUQN8niMtMP5fLt+H7PX7WPtbtceaT9vL0b1DCNxUDRj+0QQ6Kfp7xRFqV/UeFYUpaE4KVLVicg/gXtdNHk0nkXk38AdwDFgEVAEjMGaMPm13b+kQp8i4C/GmBcq7P8ROGCMudiTrrXN8/zG2jd4PcmKkvHz8uO/if/llDanuBYuLYH3xsPuX63tiL5wy1LwaVWlY+3OymPuhn3MWbePpD2uY6QD/bw5t28HJg2K4swe4fh6a1FLRVHqHjWeFUVpKE4WS2YD8BJwGdAdWFZZBxG5BMtwTgcGGmMmGmMuAnoAm4GLgLvcdHf1j0Tc7K9TpgycQp/QPgAUlhby+I+PU1xa7FrYyxsufB18AqztA5tg2YtVPlbn0EBuGRXLN3eN5Ic/n83DF/RmQHSbcjJ5hSV8szaNG99fyfBnF/LY1+tZviOL0tKW/6dNURRFUZSWR609z3Zatjgsw3CNMeb3ulCsPhGRpcBoPHieRWQlMBS4zhjzYYW20cBSLMM62jl8ozHDNhwkH0rmstmXHTea7x1yL1MGeDjsb29ZGTgAxAtuWgidhtb4+KmZR5mVlMaMtXvZnnHUpUxUG38SBkUxKS6aPpHBiIhLOUVRlKqgnmdFURqKGhvPIhIIfARcWKHpM+B6Y0xRLXWrNyoznkWkE7AbKATauspZLSJ7gGjgDGPMz077lwGHjTGTnPbV+4TBikxbN41X17wKgK+XL59P/Jwe7Xq4Fi4thQ8TIfUHazusJ9z6PfgG1EoHYwyb9mUzc20as5LSSDtyzKVcj4ggEuOiSIiLIiasda2OqSjKyYkaz4qiNBS1Cdt4BatoyifA3cDDwDrgcuCZ2qvWqAy2Xzd6KPayooKsg2+BMSLS3mnfRUAru61BuKH/DfRr3w+AotIiHv/pcYpK3fyf8fKCSf8CvyBrOzMZljxbax1EhH5RbXhkfB9+fOgcvrh1BFed2oW2FVLabTuQy98XJHPWy0tJeO1H3v5+O3sPn7Q1dhRFURRFacLUxvOcDfzTGPOE0z4/YD3Q2hjTqW5UrHuq4Hm+B5gKzLDjnF2NMRW4B/i7MeZBp/2OIimplC+SsshdkRQRuQW4BaBLly5Dd+7cWeNzc2b74e38YdYfKCwtBOCuQXdxa9yt7jusnA6z73doBTd+B11OqxNdnCksLuXHlAy+WZvG/I37yS8qcSkX37UdCXFRjB8QSXhw1SYxKopycqKeZ0VRGgq3nmcR+VhEwty0BQBBwHLn/caYQizj2WW/ZoTtgsV1wK5Frv1arlS5XVHxHLv9f1ge+s+BG90NZIx52xgTb4yJDw8Pr7HSFYltG8tdg8vmNL657k22Zm1132HoDRB7jkMrmHE7FHq6BDXDz8eLc3p3YOrlg1n1l7FMvXwQY/t0wNe7fNzzyp2HeHLmRk59biFXv/Mbn6/YxeG8wjrXR1EURVEUpap4CtuYBGwRkRsqNtihDPuAq+2CKACISBcsj26TnzRYCQ4rrkZueWNMsjHmfGNMa2NMmDHmLmNMXh3qV2Wu7XstA8MHAlBcWsxjPz5GUYmb8A0RSHwNWoVY21m/w8Kn61W/QD8fJg2K5p3r4ln52Ln8bfJAzuwRhrdXmSFdauDHlEwe+mo9w55dyI3vr2DGmr0cLXCTRURRFEVRFKWe8GQ89wF+BN4VkSUi0rNC+8vAH4AUEflcRGYBm7DKeb9SL9o2HDn2a5AHGUdbjgeZRsfby5tnzniGVt5W2MPWQ1t5e/3b7ju06QTnP1+2vfwt2PFDPWtpHzrQlz/Ed+ajm07lt0fH8NcL+zO8WyjOiTiKSgyLtxzgvs/XMvSZBdz5yWq+25DOMTehH4qiKIqiKHWJW+PZGLPHGHMhcAkQCySJyBMi4mu3vwL8EfAHLgUmAPuxMm1Mq3fN65dU+7WrB5nOFWSbLN3adOOewfcc3562bhqbDm5y32HQVdDz/LLtb+6Agob9jxAW1IprTuvKF7eO4OeHz+HxCX2I69y2nMyxolLmrNvHbR+vYtizC3nwv0l8n5xBcUmVK8kriqIoiqJUiypNGBSRIOA5rKIhycCtxpgfnNojgDxjTK6bIZoUVZgw2BnYhedUdbuBTsBIY8xPdaVbXaWqq0ipKeWG725g9YHVAHRv253PJ36On7ef6w7Z++D10+CYXYJ76A2Q8M8616u67DqYx6x1acxcm8bW/a4N+rAgP8YPiCQxLoohXdrh5aU5pBWlpaMTBhVFaSiqlW1DROKBt7GKokwH/myMOVRPutUbVSySsgoYQjWLpNSW+jKeAXZl72LyrMnkF1v/BaYMmMK9Q1xVLbdZ9wX87+ay7av/B93H1ItuNWFreg4zk/YyMymN3VmuU9tFtw1gYpxlSPeNDNFiLIrSQlHjWVGUhqLaqersCYL3AU9jZaO43xjzaT3oVm9U0XieDPwXy0A+0xiTYu+PAJYAfYH7jDFT61K3+jSeAT7Z/AnPL7dimr3Ei9kXzaZzcGfXwsbA51fDltnWdmgs3L0KmpgBaoxh7e7DzExKY/a6fWTkFLiUiw1vTUJcFIlxUZwS7imcXVGU5oYaz4qiNBSVGs+qlAitAAAgAElEQVQi4o01edAf2GGMOWjv7wL8C5gIzAduM8ak1qu2NUREhgCvO+3qi5VibhuQ5dhpjDmtQr/XgduBY8BCoAgYA4QAM4DJxpg6nalW38ZzxfCNewbfw80Db3bfITcDXhsCBdnW9pTFtSrdXd+UlBp++/0gM5PSmLshnSP5rjOL9IsKITEuiolxUUS3rV0lRUVRGh81nhVFaSg8Gs8i8iDwKNDGafcvwN3GmDW2zCXAP4FQLG/03+vaoKwtInIWlrfYI8aYE1yqInIlcCcwAPAGtmCFrLxRl+EaDurbeAaY8/scHv7hYQB6tevFl4kune9lzLgT1n5srZ92J5z/XL3qV1cUFpfyfXIGs9alsWDTfvIKtRiLorRU1HhWFKWhcGs8i8i9WCnnMoGvsTy0fbCyahwFBhhjdtuywcDzwG1Y1fVuMcYsdzWu4pmGMJ6PFh1l1GejjlcenHnhTLq16ea+Q8oi+Phiaz04Eu7fZJX0bkbkFRazeMsBZq5NY+nWDApdZOTwEjg9NozEuCjG9etImwplxBVFabqo8awoSkPhyXhOAfyAwY5QDXv/ZOAL4AljzDMV+gwH3sIyrH3qTesWTEMYzwD3LbmPRbsWAVUo211SDH/vCXn2bXD9txBzRr3rWF9kHyti3oZ0Zq3bx08pmZSUnvgZ8PP2YlTPcBIHRTG2TwSBfno7K0pTRo1nRVEaCk/uw07AcmfD2eY7p/Zy2N7meOChulFPqS/O63re8fV5O+d5Fvb2gb4Xlm1v+KqetGoYQvx9uTS+Mx/eOLysGEtMaDmZwpJSFm7ezz2frmHoXxdy96drmL8xnYLiJhWRpCiKoihKA+PJ87wZq1rgcOeJgCJyFzAVeMQY87eGUPJkoqE8z0eLjjL689EUlFiZKb658BtOaXOK+w6pP8H74631wPbwx2TLqG5B7DuSz+ykfcxal8a6PUdcyoT4+3B+/44kxEUx4pT2+Hg3r/AVRWmpqOdZUZSGwpPxfC3wPlamiWXAIaA3MAg4APQ3xmQ2jJonDw1lPAPcv+R+Fu5aCMCdg+7ktrjb3AuXlsIrfSFnn7XdxHI+1zU7Mo8yOymNmUlpbDvguvaPFmNRlKaDGs+KojQUnspzfwhchJXO7VzgcqAnVrzzCDWcmz/jYsYdX5+XWknohpcX9Lu4bHvD/+pJq6ZBt7DW3D2mB/PvH8Xce8/kjrNi6dSufEq7zNxCPvxlJ5Pf/IUz/7aE57/dzIa9R6hu7nRFURRFUZoPVS3P7YtVpjqj/lU6uWlIz3NeUR6jPx/NsZJjAMyYNIPYtrHuO+xZBe+cY623agN/2gY+J09qt6oWYzklzCrGkhAXRfcILcaiKA2Bep4VRWkoqhSwaYwpUsO55RHoG8iZnc48vj0/db7nDtFDoG1Xa73giJXC7iRCRBjcpR1PJvTj10fG8MnNp3LF8M60CSif0u73zKNMXbSNsf9YxvipP/DG0u3sOZTXSForiqIoilKX6Gynk5xqhW6IQP9LyrabedaN2uDtJZweG8bzFw9kxWNjmX59PBcNjqa1n3c5uU37snnxuy2MfHEJl7zxM+//tMOtx1pRFEVRlKaPpwmDnwCPG2N+r/HgIrHAX40xV9Z0jJONhgzbgBNDN75O/Jru7bq775C+Ad60czz7BsKfUsCvdQNo2jzILyxh8ZYDzEpKY/HWAxQWuy7GMiK2PYlxUZzfL1KLsShKHaBhG4qiNBSePM8XAZtF5D0RqVZFDBE5U0TeBzYBibXQT6lnAn0DGdVp1PHt+TsrCd3o0A/CelnrRXmQXIm3+iQjwM+bCQMjefOaoax8fCx/vzSO0T3D8XbKxFFq4KeUgzz01Xrin13AlA9W8M3aveQVFjei5oqiKIqiVAVPnueuwN+BiwED7AAWAb8Am4GDQDYQgpUPui8wAhgDxAACfAk8aIzZVZ8n0ZJoaM8zWLHOf1z2RwBOaXMKMybNQMRD2rWlL8LS56z13hPh8v80gJbNm6yjhXy7fh8zk9JYkZqFq49dgK83Y/t2IGFgJKN7hdPKx/tEIUVRXKKeZ0VRGopKs23YXuf7gEmAD5Yh7VYcKAK+AqYaY36rIz1PGhrDeM4vzmf056PJL84H4H+J/6NHux7uO2Rug3/Zv1HeraysG/5tGkDTlsG+I/nMWWcZ0u6KsQT7+3B+v44kDtJiLIpSFdR4VhSloahSqjoAEYkEJgBnYRVKiQDaAIexiqasBpYA3xpjDtSHsicDjWE8A/xp2Z/4LtWqvH7rwFu5a/Bdnju8eSakr7PWL3wTBl1Rzxq2TLQYi6LUDWo8K4rSUFTZeFYahsYynhfuXMj9S+8HICYkhpkXzvQcuvHjP2Hhk9Z693Ph6i8bQMuWizGGLek5zLIN6T2H8l3KRbcNYGJcJAkDo+gXFeL5PVKUkwg1nhVFaSjUeG5iNJbxfKz4GKM+H3U8dOPLhC/pFdrLfYdDO2HqQGvdywf+mAyt2zeApi0fYwxrdh9m5to05qz3UIwlvDWJdjGW2HAtxqKc3KjxrChKQ6GBlAoA/j7+nNX5rOPblWbdaNcVOg231kuLYfPM+lPuJENEGNKlHU8l2sVYprgpxpJxlH8u3MaYvy9jwqs/8Nay7ew97NpjrSiKoihK3aDGs3KccV3LCqbMT51PpU8ltGBKvePtJZzevawYy7vXxXPhoCgCKxRj2ZiWzfNzt3DGC4uZ/MbPfPhLqhZjURRFUZR6QMM2mhiNFbYBVujG6M9Hk1dslZKuNHQjJx3+3hsrAYvAH7dAcMcG0fVkJ7+whEVb9jMrKY0lWzIoLHFdjOWM7mEkxEUxrl/HEzzXitKS0LANRVEaCvU8K8epGLpRabnu4I4QM9LeMLBxRr3pppQnwM+biQOjeOuaeFb+ZSwvTR7ImT3CTijG8sO2TP785TqGPbOQmz9cyaykNC3GoiiKoii1QD3PTYzG9DwDLN61mHuX3AtAl+AuzL5otueMDivfg9n3WeudhsOUBQ2gpeKOzNwC5m5IZ9baNJanZrmUCfTzZmyfDiTGRTGqZzh+PvofWmn+qOdZUZSGQo3nJkZjG88FJQWM/nw0R4uOAvDFxC/o076P+w5HD8Lfe1qTBgHuXWdNJlQanbTDZcVY1u91XYwlxN+HC/pHkjgoitNOaV/Oc60ozYnqGs+rVq1q5+XldZ23t/dVxpgwrCJfiqKcxIhIrjHmh+Li4v8CS4YOHerSSK5OkZQQwBhjcupQT6UCjW08AzzywyPM/n02ADf1v4n7ht7nucPHkyHF9jiPfRpGViKvNDg7Mo8ezyGd4rYYSysmDowkIS6KIV3aag5ppVlRHeN51apVfj4+Pv8NDQ0dEBYWluvv71+o97uinNwYYyguLvbOzs4OysjIkPz8/HdKS0tfdGVAV+d57WFgYd2pqTRVxsU4Zd3YqVk3WgLdwlpzz5geLLh/FHPvPZM7zoqlU7uAcjKZuQW8/3Mql7zxMyNfXMILc7ewKS278vdfUZofV4SEhAzo1KlTVkBAgBrOiqIgIvj6+pa0b9/+SPfu3bMDAgKmAGe7kvWpxrg5wLY60VBp0pwedTpBvkHkFuWyO2c3m7M207d9X/cdeo8H71ZQUmCV7M7cBmE9Gk5hpcqICH0iQ+gTGcKfxvVyW4xl7+F83ly2nTeXbSc2vDWJcdEkDoqiW1jrRtReUeoGX1/f8aGhoWo0K4riEh8fn9Lw8HAKCgouBRZXbK+O53kz0KnONFOaLH7efpzduezPVqVZN/zbQI9zy7Y3/K+eNFPqElfFWC4fdmIxlu0ZR3llYTJnv7yUia/9wNvfbydNi7EozZuBrVu3zmtsJRRFabqEhITkisiZrtqqYzxPA0aKyNC6UUtpyjiHbsxLnVfN0I0vQR/1NyscxVheuKSsGMskF8VYNuzN5rlvt3D6C4u59M2f+eiXVDJztRiL0rwwxgR4e3ufmBxdURTFxsfHp9gYE+SyraqDGGPeFZE4YIGIvAh8Dew0xugvZwtkRNQIgn2DySnKYW/uXjYd3ES/sH7uO/QcB76toegoZCbD/o3QsX/DKazUGX4+Xozp04ExfTocL8Yyc20aS7eWL8ayIvUQK1IP8dSsTZwe216LsSjNCg3ZUBTFE56+I6rseRaREuBOoA3wHFYYR56IlLhYtApDM8fP24+zu1QjdMOvNfS6oGxbJw62CBzFWN6+tqwYy6ie4eVS2pWUGpfFWPILSxpRc0VRFEWpH6oTtiHVWLTqQgug1lk3NHSjRRHi78ul8Z358Mbh/PboGP46qR/DYtqVkyksKWXBpv3c/ekahj6zgHs+XcPCTfspLNYn5IqiKErLoDphG2oQn2SMiBxBsF8wOYVW6MbGgxvpH+YhFKP7GGjVBgqOwOGdsHc1dNIQ+ZZIWFArrhkRwzUjYkg7nM/sdVYO6Q17s4/L5BWWMNPOLa3FWBRFUZSWghrEilt8vX05p/M5x7crDd3waQV9Esq2N2rWjZOBqLYB3DIqltl3n8niP47m/rE9iQ0vn9Iu+1gxn6/czVXv/Mapzy3iqZkbWbXzkOaQVpQmiIgMrUlygOjo6AEiMnTr1q1+9aFXQ9PSzkepO9R4VjziHLqxYOeCyo2d3uPL1tPW1JNWSlPllPAg7h3bg4UPjObbe87kttGxRLfVYiyKojQtHnjggSgRGfrAAw9ENbYuSvOjOkVSABARX2AycBYQbe/eCywFvjTGFNWVckrjc1rkaQT6BJJXnMfe3L3syd1D5+DO7jt0HFC2fmCTFfess9pPOkSEvlEh9I0K4aHze7F612FmJaUxe92+cqntnIuxdI8IImFglBZjUZRmyvz585MLCwslJiamRdgBLe18lLqjWsaz/Rjnv0BXrImBzkwBnhGRS40xq+tIP6WR8fX2ZUiHIfy490cAVqSv8Gw8t+kMfkFQmAv5hyB3PwR3bCBtlaaIiDC0azuGdm3H4xP68NuOLGauTWPuhn1kHytLzJNyIJdXFibzysJk+keHkBgXxcSBUURV8FwritI06devX4tKXdvSzkepO6qTqq4TMA+IAfYALwA3A7cAzwO7gG7APBGJdjOM0gwZ3nH48fXl6cs9C4tARJ+y7QOb6kkrpTni4+3FGd3DeHHyQFY8PpZ3ro0nMS6KAF/3xVj+8OYvfPRLKge1GIuiNDgvv/xyWJ8+ffoGBAQMbtu27aDzzjsvdsWKFf6uZN3FCGdmZnrfdddd0d27d+8XEBAw2N/ff0iHDh0GDh8+vNcjjzzi0ruSkpLie8MNN3SOiYnp7+/vPyQoKGjwkCFDer/66qvtS0tdZ+8pLS3lnXfeaTdq1KgeoaGhcb6+vkMiIiIGjhgxoudzzz0X7pATkaGvvPJKJMArr7wS6YjxrhjG4SnmOTs72+uhhx7q2KtXr76BgYGDAwICBvfu3bvvww8/3DEnJ+cE22r27NnBIjJ0+PDhvQoKCuShhx7q2K1bt36tWrUaEhoaGjdp0qRu27Zt09jqZkJ1PM8PA6HAq8CfKoZniMiTwEvAvbbs3XWlpNK4OBvPK/atwBjjucBARB/Ys8JaP7AZYs9xL6uctLTy8WZs3w6M7duBvMJiFm0+wMykNJZVKMayPDWL5alZPDVrE2d0DyNhYCTj+nckxF+LsShKfXLTTTd1fv/99yOGDh2aO3bs2MPr169vvWDBgrY//PBDyIwZM7aNGzcut7IxcnJyvE477bTe27dv9w8NDS0eMWJETuvWrUv279/vl5KS4p+UlNT6+eefT3fuM2vWrOArr7wyNjc317tLly4FZ5555pGjR496JSUlBd17770xS5YsCf76669TnfscO3ZMJkyYcMrixYvbent7ExcXlxsVFVWYmZnpm5ycHPDYY48FP/rooxkAF1988cGNGzcGbt26NaBXr175/fr1O16qffDgwZWWbd+3b5/P6NGje27bti0gJCSk5IwzzsgWEX799dfgF198MXrGjBmhy5Yt29qhQ4cTkt0XFxfL2Wef3SMpKan18OHDc7p3735szZo1QTNnzgxdvnx50Pr16zeFhYVpkvwmTnWM5/OB34H7jYuZPcaYYhH5I5AAjEeN5xZD79Dex6sNHsg/wM7sncS0iXHfIaJv2bp6npUqEOjnQ0JcFAlxURzJL2LehnRmrUvjp5RMSu1vm5JSw/fJGXyfnMFjMzZwVs9wEgdFMaZ3BwIqlBFXlJoS8/CcZptfM/WFCavqcrxPPvkkbPbs2VsvuOCCXLA8u3fffXf066+/3vH666/vtn379g2BgYEeZ/p+8MEH7bZv3+5/1llnHZk/f36Kr2/Zn97i4mK+/fbbYGf5nTt3+l599dWx+fn53q+++mrqnXfeedDLy3LkpqSk+CYkJPSYMWNG+1dffTXnnnvuOejod/vtt3davHhx265duxZ8/fXXKYMHDz7mfJzPP/+8jWP7q6++Sn3ggQeitm7dGjB+/PjD//jHP9Kqc11uuummLtu2bQsYOnRo7nfffZfiMHYzMjK8x40b12PNmjWtp0yZ0mXWrFk7KvZds2ZN6379+uUlJyevj46OLgY4ePCg96hRo3pu2rQp8KWXXgp/8cUX0yv2U5oW1cm2EQ0sd2U4OzDGlALLAZ292oLw9vJmaIey35NKQzfKhW1srietlJZKmwBf/jCsMx/ddCq/PTqWpxP7Ed+1QjGW4lLmb9rPXZ+sIf6ZBdz32RoWbdZiLIpSl1xzzTUZDsMZwMvLi6lTp+7t1KlTQXp6ut8HH3zQzlN/gP379/sAnH322dnOhjOAj48PiYmJOc77XnjhhYjs7Gzvm2++Of3uu+8+bjgDdO/eveitt95KBXjrrbciHPv37t3r8/HHH4d7eXnx5ZdfljOcHce56qqrjlTr5N2QnJzs991337Xz8vJi2rRpO529xOHh4SXTpk1L9fLy4ttvvw1NSUk54fGYiDB9+vRUh+EM0L59+5L7778/HWDZsmUhdaGnUr9Ux3jOxwrbqIx2tqzSghjWcdjx9RXpKzwLl/M8bwE38WmKUhnhwa247vQYvrz9dH586GweuaA3/aLK/7YcLSxhxto0bvpgJcOfW8gj/1vHzymZlJRq6jtFqQ3XX3/9wYr7fHx8uOiii7IAli1bFnxir/KcdtppRwFee+21jq+//npoZmamx8dEixYtagNwxRVXHHLVPnLkyLzAwMDSLVu2BObl5QnAnDlzgouLi2XQoEG58fHxx1z1qysWLlwYZIwhLi7uaEUjHWDo0KHHBgwYcLS0tJQFCxaccH0iIyMLhw8ffoKNNGDAgGMA+/fv13i0ZkB1wjbWAWeJSG9jzBZXAiLSCzgb+LUulFOaDsMjneKe0yuJe24dDoHtIe8gFB2FI7ugXUzDKKq0WDq1C+TW0bHcOjqWlAO5zEpKY1ZSGr9nHj0ucziviE+X7+bT5buJCG7FhIGRJMRFMbhzW89x+opiU9ehD82ZXr16FbraHxMTUwiQlpZW6QS3CRMm5N52223pb7/9dsc777yz21133UW3bt2ODR8+PHfy5MmHLrnkkmxn+d27d7cCGD16dB/XI5axf/9+n27duhXt3LmzFUD37t3r1XAG2Lt3rx9A586d3c5g7tq1a0FSUlLrvXv3nmAIR0ZGurymbdu2LQEoLCzU+hvNgOoYz+8Co4DFIvI48LExphCO536+Gvgr4AtMq2tFlcalZ7uetGnVhiMFRzh47CC/H/md2LaxroVFLO9z6g/W9oHNajwrdUr3iCDuP7cn943twca0bGatS2N20j72Hi5z6BzIKeC9n1J576dUOocGkDDQiqnu3TFYDWlFqQNEpEqPd95444299957b8YXX3zR9ueffw5atWpV0GeffRb22WefhZ1xxhnZS5Ys2eYI6SgtLRWACRMmHGrVqpXHx5b+/v4N/njJEbnq6TvEU8En5zAUpflSZePZGPORiJwPXIFlHL8lIvsAgxXj7IWV+/kTY8x/6kNZpfHwEi/iO8SzaNciwIp7dms8gxX3fNx43gS9LmgALZWTDRGhf3Qb+ke34aFxvVm96xCzktKYs34fmbllDp7dWfm8vnQ7ry/dTo+IIBLtyYkxWoxFUdySnJzsN2LEiBNCDFJTU/0AOnbsWOXiIb179y584oknDgAHAObNmxd03XXXnfLTTz+FTJ06NezBBx/MtMcs3LVrV6unnnoqraohGF27di0ASElJcZlCry7p1KlTIcCuXbtauZNxeM+jo6O1uEoLpVp/gYwxVwF3AamAN9AJ6Gyv7wDuMsZcXcc6Kk2E6sU966RBpWHx8hLiY0J5elJ/fn1kDB/dNJw/xHci2L+8j2DbgVz+viCZs15eSuK/fuSdH34n/Ui9P+1VlGbHBx980L7ivuLiYr755ptQgNGjR+ec2KtqjBs3Lveyyy7LBEhKSgp07D/77LOPAHzyySdVmWMFwIQJE3J8fHzM2rVrg1avXl0lA9rPz68UrPOpDmPHjs0VEZKSklqvW7fuBAN69erV/uvWrWvt5eXFueeeW+ProzRtqv38wBjzujEmFstoPg0YAXQ2xnQ3xrxe1woqTQdn43ll+kpKjYcnauUmDarxrDQsPt5enNkjnL9NjmPl42N5+5qhJLgoxrJuzxGembOZES8s4g9v/cLHv+4k66jLkERFOen48MMPw+fNmxfk2C4tLeWBBx6I2rVrV6uIiIiia6+91uWkvgpjtJ07d25QSUn51MW5ubniyCzh8BwDPP744+lBQUElr732Wsfnn38+vKjoROftokWLWk+fPv14po/o6Ojiq666KqO0tJRLL700tqJRW1xczCeffNLGeZ/DK7x169ZqlTDt2bNn4bhx4w6VlpZy8803dz148ODxL5XMzEzvW265pWtpaSnjx4/P6t69u3qeWyhVDtsQkXuAPGPMOwDGmL3A3vpSTGl6dG/bnXat2nGo4BCHCg6RcjiFnu16uhYO7122npkMJUXgrZOIlYanlY835/XryHn9OpJXWMzCzQeYuTaNZckHKCqxYhONgeU7sli+I4snZ25kZPcwEuOiOK9fB4K1GItyknLFFVdkjh8/vld8fHxORERE0YYNGwJTU1P9/f39S6dPn/57UFBQpTHHS5cuDX7vvfci2rVrV9y3b9+89u3bF+fk5HivXr066MiRI97dunU7dv/992c65Lt37170ySefbL/mmmtiH3300S6vvPJKZPfu3fNDQ0NL0tPTfXft2tUqIyPDd8KECYduvPHG48b7G2+8sSc1NbXVsmXL2gwZMqTfoEGDjkZGRhYePHjQd+vWrQFZWVk+V1555fHJoJMmTTry5z//uXT+/Plt4+Pje8XExBR4e3ubxMTEw5WltZs+ffqu0aNH+y9fvjw4NjZ2wKmnnpoD8OuvvwZnZ2d79+rVK/+dd97ZVbOrrjQHqjNh8B/AXOCdetJFaeJ4iRfxHeNZsHMBYIVuuDWeA9pCSDRk74WSQsj6HcJ7NaC2inIigX4+JMZFkRgXxZG8IuZtTGdmUho/by9fjGVZcgbLkjPw+9qLc3pFkDgoinN6R+Dvq8VYlJOHadOm7e7Ro8ex9957L3zdunWt/fz8zNixYw8/++yzaa7SrbliypQpmf7+/qW//fZbUHJycsDhw4d9goODS7p06XJs8uTJWXfffXdmu3btyj3GTEhIyFm3bt2Gl156qcOCBQvaJCUlBRUXF0tYWFhRTExMwZQpUw5cddVV5bzeAQEBZtGiRSlvvfVW6EcffRS2adOmwKSkpNahoaHFvXr1yktMTDzsLN+lS5fiL774IuWZZ56J3LRpU+Dq1auDjDFER0cXVWY8R0ZGFq9YsWLLs88+22HGjBntvv/++xB7zILbb78969FHHz0QEhKiOVpbMOJpVmg5QWty4BJjzJX1q9LJTXx8vFm5cmVjq+GWz7Z8xrO/PQvAOZ3PYeo5U90Lf3wJpCy01i99H/pdVP8KKkoNOJBzjLnrLUN61U7XT6Jb+1ke7MS4KEb2CMPXW2fNNyVEZJUxJr4qsklJSalxcXGZlUsqinIyk5SUFBYXFxdTcX91PM8/AsMqlTrJEZHrgfdcNP3bGHNXA6tT5wzvWJbveeV+K+7ZS9wYERF9yoznA5vVeFaaLBHB/lx3egzXnR7DnkN5zF63j5lr09i0rywF7dHCEr5es5ev1+ylbaAvF/SPJDEuiuHdQvH20tR3iqIoJwvVMZ6fBlaIyNPAU57KdCsAnA84P/ppEbXqu7XpRlhAGJn5mWQXZrM1ayt92rvJZV9u0uCmhlFQUWpJp3aB3DY6ltsqLcayi0+X76JDSCsmDIgicVAUcZ3aaA5pRVGUFk51jOchwEfA48BkEfkG2ImbUtzGmA9rr16zZpUxpsU9FhQRhnUYxtzUuYCV79m98azp6pTmzQnFWGxDOs0ptd3+7AKm/7SD6T/toEtoIAlxkSTGRdOrY6WVixVFUZRmSHWM5/exCqII0Afo7VEaTnbjucUyLLLMeF6RvoLr+l3nWjCsF9btYqwJg0X54FutrECK0iQoV4zlfKsYy8ykNL6tUIxlV1Ye/16ynX8v2U7PDmXFWLq212IsiqIoLYXqGM8fYhnPjYqI9MIKiRgGxAM9sSy0S40xX1bS90rgdmAgVmGXLVjxyW8Y4ylpcY3YICLhwC6sPx7PGmOql429ieIc97xq/yqKS4vx8XJxK/kFQmg3y3A2pVbKusi4BtRUUeoeRzGW+JhQnpjYl19+P8jMtWl8tzGdnGNlH/Hk/bm8PD+Zl+cnE9epDQlxUUwcGEXHNvVeBE1RFEWpR6pTnvv6etSjOtwO3FvdTiLyb+AO4BiwCCgCxgD/AsaIyKXGmBIPQ1SVfcCTwHKgBLgA+AvQDbi+DsZvdLoEdyEiMIIDeQfILcplS9YW+of1dy0c0dcynsEK3VDjWWlBOIqxnNkjnGcu6s+yrRnMTBfZt/sAACAASURBVEpj4eb9HCsq+z+etOcISXuO8Oy3mxkeE0pCXBTjB0QS2tqvEbVXFEVRakJ1iqQkAkXGmLn1qE9V2AC8BKwEVgHvAqM9dRCRS7AM53RglDFmm72/A7AEuAir7PjUCv3aAJFV0GmXMSYPwBgzD5jn1LZARI4AT4nIX40x26swXpNGRBjWcRhzfp8DWHHP7o3nPrBltrWukwaVFoxzMZajBcUs3LyfWUlpLEvOKFeM5bcdWfy2I4unZm5kZI8wEgZqMRZFUZTmRHXCNr4GFmIVSmk0HBUOHVRxZvsj9utDDsPZHmu/iNwOLAUeFpHXKoRvXITrtHMVORfr2rjjC+AprEmXzd54Bit0w9l4vrH/ja4FddKgchLSupUPkwZFM2lQNIfzCo8XY/ll+8HjxViKSw1Lt2awdGsGrb724pzeESTEaTEWRVGUpk51jOcsoNlljxCRTsBQoBD4b8V2Y8wyEdkLRAOnAT87tb2PFa9cazXqYIwmxbCOZSm/V+9fTVFpEb5eLjxn5dLVqfGsnHy0DfTjsmFduGxYFw7kHOPbdfuYmZTG6l1lBc8KikuZuyGduRvStRiLoihKE6c6xvNywM2z+SbNYPt1ozHGXTnRFVjG82CcjOc65DKsyZarXDWKyC3ALQBdunSph8PXPZ2COhHZOpJ9R/eRX5zPpoObiAt3Ec8cGgtevlBaBEd2w7Fs8A9peIUVpQkQEezP9Wd04/ozurE7yy7GkpTGZi3GoiiK0myojkvjRaCfiNxUX8rUE93s150eZHZVkK0xIjJPRB4SkQkicoGIvAo8BrxrjPndVR9jzNvGmHhjTHx4eHhtVWgQHHHPDlakr3At6OMHYT3KtjO21LNmitI86BwayO1nxTL33jNZ+MAo7hnTg25h5VPaOYqxXDHtV05/YRH/N2sTa3cfRmtUKYqiNB7V8TwDvAm8LSKTsWKgPRVJ+b6WutUVQfbrUQ8yufZrXVQ12AzcCHTCur7bgIeAf9bB2E2K4R2HM3P7TACW71vOlAFTXAtG9C2bLHhgE3Qe7lpOUU5SukcE88C5wdw/tgcb9mYza51VjGWfm2IsXdsHkjDQyiGtxVgURVEaluoYz0spK5IyDjjPg6yp5tj1ieM5Z4O4aowx9wH3NcSxGhvnfM9rM9ZSVFKEr7eruGedNKgoVUFEGNCpDQM6teHh83uzcuchZtnFWA4eLSvGsvNgHv9aksK/lqTQq0MwiYOiSBgYRZf2gY2ovaIoyslBdQzc72kCRVJqQI79GuRBxtGW40FGqUBkUCSdgjqxJ3cP+cX5rM9cz5AOQ04ULDdpUNPVKUpV8PIShncLZXi3UJ5M6MtP261iLPM3ppNTUFaMZev+HF6at5WX5m0lrnNbEuOimDgwkg4hWoxFURSlPqhOkZSz6lGP+iTVfu3qQaZzBVmligyPHM6ebXsAK2Wda+NZPc+KUht8vL0Y3TOc0T3DOVbUn6VbM5hlF2MpKHYqxrL7MEm7D/PMnE2c2i2UxLhoLujfkXZajEWpBtHR0QPS0tL8AD799NOUyy+//IgruR49evRLSUnxnzVrVvLEiRPV+VQDnK+1Az8/PxMaGlo0ePDgo3feeeeBCRMm5Lrr31DMnj07OCEhoeewYcNyly9fvrWx9WlsToYcSGvs134iEuBGZlgFWaWKVGnSYNuu4Gs/Tj6aAbkZDaCZorRM/H29Ob9/R/591RBW/eVc/nnZIMb0jsDHKROHMfDr71k8+vV6hj27kBveW87Xa/aQ6+SxVpSq8MQTT0SXlNRF8d2GQUSGisjQxtajuowcOTL74osvPnjxxRcfHDly5BGAuXPntps4cWKvp59+OqKx9VPKU+O4ZBHxA9oDBcaYrLpTqW4xxuwWkdVYBUouBT50bheR0ViT+9KBXxpew+bNsA5lxvPaA2spKCmglXer8kJeXhDeG9JWW9sZmyGoeWQVUZSmTFArHy4cHM2Fg61iLHP/n707j4uqXv8A/nlmgGFfZF9kkc0FRQHRcsW9xTZss8wWM9NWf5bavd1b91pp17LM0tyyMku9mpp6XcOlTEFAXHEHEUEQQfaBmfn+/jgzOAwDziirPO/Xa14z55zvOfOcOSgP33nO93s8F7+lXcFfFwog9CZjSTidj4TT+VBYHMPQLh54KNIHg8N5MhbWMGtra83Zs2dtFi1a1GHKlCmt9vf83WD69Om5+r33SqWSXnrppY4//fST+0cffeT37LPPFgYHB1e3ZIzsJrN7nonoOSJKgjR6xWUAc/W2jSGiVUR0x0O+NbJPtM9ziChEt5KIPAB8o12cbTC7IDOBp50nAhylipgqTRWO5h813pAnS2GsSTnbWuHpWH+serkvDs0cin882BW9/J1rtVGqNNh6LBeTVqYgZtYuTF1zBHtO56Fazf/1sbpefPHFPAD45JNPfCsrK3mQ8WakUCjEokWLsuzs7DTV1dX022+/8QQJrYhZyTMRrYA0XXU0pCHqDP8xZQF4CsCYxgiunhiiiOig7gGpRxkAPjZYX0MI8V8ACwF4AThGRL8R0XpIw8h1BbABwIKmivlup1+6kZibaLxRrbpnvmmQsabk4WiNF/sH4dfJ/bD/3Ti8MzIcnQ2GtCtVqrA+JRvPf5eEPh/vxt9+PYZDFwqg0bTF+8JZU3jyyScLu3fvXpadnW01d+5cs74uXLduneOQIUNCXF1dIy0tLaPc3d17jB49OigxMbFW+WROTo6FTCaLdnNzqzPL1qxZszx0ZRgpKSm17oBNTk62JqLo8PDwrgAwdepUH/1yDd1+xso4NBoNvv766w6xsbHhjo6OPRUKRVTHjh0jxo0b53/u3DkjQ0bVLgdZsmSJS8+ePTvb2tr2srOz63XPPfeEbd++vaFBCW6Lvb29CAwMrASAq1ev1onrzJkzVjNnzvTq06dPmJeXVw8rK6soJyennn369AlbtGhRB2PH3Lx5swMRRcfGxoYXFxfLJk+e7Ovn59fdysoqysvLq8f48eM75ubmNviVlFKppOnTp3sFBQV1UygUUR06dIh8+OGHg86ePWv05or169c7Dh48OKRDhw6RFhYWUU5OTj2DgoK6Pf7444F//PFHnSGCiouLZdOnT/cKDw/vamtr28vGxqZX586du86YMcOrpKSkTt6qf07mxna7TE6eiWg8gOcApAGIAeBk2EYIcQjAFQD3NVaARjgC6KP30P1GCDVYbxjbZADPAEgBMAjScHvnALwGIF4I0XaKuloZ/SHrEnNMSJ6vcvLMWHPp2MEWU+JCsO2tgdj59kC8PiQEAQZD2l0vq8JPhy7hycUHce/s3zFr80kcvcyTsTDgo48+ygaAefPmed+4ccOknOGFF17oOGbMmNB9+/Y5+vv7K4cPH17k7u5evXnz5g4DBw7ssnr16pr8wdvbWxUeHl5RUFBgYZhYJyQk1PzF97///a9Wz+u2bdscAWDAgAHFANCrV6/yxx57rEC3XVc/rHvo1ms0GjzyyCNBr732WlBqaqpd9+7dy4YPH14khKCVK1e6x8TEdNu7d2+9Yz6+9dZbPpMmTepkaWkp4uLibnh6elYdPHjQYfTo0WG7du2yq2+/21VSUiIHAE9PzzolG0uXLnWdPXu2b05OjlWnTp0qRowYURQSElKRnJzs8Oqrrwa98MILHeseUVJdXU0DBgwIW7FihUdYWFjFkCFDipRKJf3www8effv27ZKVlWW0rFelUlFcXFzoggULvAMDA5UDBw68IZPJsGnTpg4DBw4Mv3btWq3Ee/78+a7x8fGh+/fvdwoICFDed999hdHR0aUKhUKsW7fOdevWrbWua05OjkVMTEznTz/91Dc3N9eqX79+xQMGDCi+cuWK1Zw5c3x79+7d+erVq0aTe3NjuxPm1Dy/DGkot9FCiGxAGpPUiPMAAu84snoIIfagbo+3qfuuArCqUQNitXqej147igpVBWwsDO7NNCzbEAIw/vPDGGsioZ4O+L8R4Zg6PAzHsm9g05Er2Hw0B7nFNydjyS2uxNI/LmLpHxcR6GqL0ZE+eCjSB6Ge7WQylg+c2tzNZjU+uJHc2IccPXp0Sb9+/Yr//PNPx3/961+en332WU5D7T/99FP3FStWeISEhFSuWbPmfK9evWp+uH788UfnF154odPLL78cNGTIkGPu7u5qQEqA09PTbbZt2+YQGxtbAQAqlQqJiYkOwcHBlRkZGYrff//d4W9/+1ue7li6xHrYsGElADBu3LiicePGFRGRKwCsW7cuo774fvvttw6urq6qbdu2nY6JianUvd+ECRM6fv/99x5jx44NPnfu3HEbG5s6fz2uWLHCY8+ePacGDBhQDgBqtRrPPvtswC+//OL2j3/8w2fYsGFnzfqAG3D48GHr7OxshYWFhRg9enSx4fYHHnjgxhNPPFGoOwedY8eOKUaMGBG2YsUKj3Hjxl0fMmRInUnijhw5YhcQEKA8ceLE8aCgoGoAKCwslD3wwAMhf/31l8Mrr7ziv3Xr1jqzIqemptp169at/MyZM8d8fX1VAFBQUCAfOHBg2MmTJ23/85//uM+ZMydX1/7TTz/1AYBt27alDx8+vFYc58+ftywqKqqV0L700kv+Z8+etYmOji7dtm3bOTc3NzUA5Ofny0eOHBmamppqN2HCBP/ffvvt4p3GdifMKdvoDuCgLnFuwBVI5RGsnXCzcUMnp04AAJVGhSN5R+o2cvACrLX1l1UlwI3LzRghY0wfEaGHnzP+/mBXHJgxBKsn9sUzffzhYlv7m+GMgnJ89fs5DJ+3D6O+2IevE84h63p5C0XNWsrs2bOziQjffvut15UrV+rtdFOpVJg7d643APzyyy+1EmdASnDHjh17raSkRL548WJX3fphw4YVA0BCQkJNL+S+ffvsSktL5aNGjSqKiIgoT0xMdFCpVDXvk5iY6CCXy8V9991n1hB5X3/9tScAzJw5M1s/6bSwsMCiRYsue3l5VV25csVqxYoVLsb2f/fdd7N1iTMAyOVyzJ07NxsAkpOTHZRK5R33CuXn58vXrFnjOGbMmBCNRoNZs2ZlGbtZcNCgQeWGiTMAdO/eXTlt2rQcAFi9erXR8wCATz75JEuXOAOAi4uLZvHixZlyuRzbt293MVbCQkRYvnx5hi45BQBXV1f122+/nQsAe/furdWTXFBQYOHg4KA2TJwBIDg4uDo6Orom/jNnzlht27bNRSaTYcmSJZm6xBkA3N3d1UuWLMmQyWTYunVrh8aI7U6Ykzxb4uY01g1xBcB3hLYztxyyjohvGmSsFZLJCH06ueKjR7sj8W/DsOKF3ngsyhf2ito5UnquNBnLgE8T8MjXf2L5HxeRV1zn9za7C/Xv37/8/vvvLywrK5P9/e9/966v3V9//WWbn59vGRISUqmfFOkbPHhwCQAcPHiwpsRh1KhRpRYWFiIpKcmhulpKH3bs2OEAACNGjCgeNGhQcWlpqXzPnj12ALB//37bkpISeWRkZJmTk5PJd7ueP3/e8vLlywqZTIZXX321wHC7tbW1eOyxx64DwN69e41+1RIfH19nzGtfX1+Vo6OjuqqqiuorKbiV0aNHh+nqqj08PHo++eSToTk5OVZr1649O3369HrHdy0vL6eVK1c6v/HGGz5jx44NiI+PD4yPjw/89ddfXQDg3LlzCmP7OTg4qJ9++uk65xIREaGMjIws1Wg02LlzZ53PwNvbu0r37YC+7t27G63N7tGjR1lJSYn80UcfDfzzzz9tNJr6L9euXbvshRCIjIwsM/zDCwCio6Mru3fvXtZYsd0Jc8o2LgGIaKgBEckBdINUusHakVivWKw+vRrALW4avHRAep13EghraIZ3xlhzs5TLMDjcA4PDPVBZrcae03nYlHYFu0/l1ZqM5UhWEY5kFeHfW06ib5ArHurpg/sivOBsexdMxtIEpQ93g9mzZ2dv27bN+aeffnKfMWPG1bCwsCrDNmfPnlUAwLlz56xvNdZyQUFBTf7h6OioiYyMLEtOTrZPSEiwGzFiRNnevXsdFQqFGD58eKlcLhfz58/33r59u+OwYcPKduzY4QgAAwcONKvXOTMz0woA3Nzcqm1tbY0W9AcHBysBICcnx2iiFRISUue8AcDe3l5dXFwsr6ioqOmUnDhxop/+eQKAq6uravHixXW+eu3fv3+xh4dHtRACeXl5locPH3ZQKpU0ceLEoPDw8PSIiAil4T67du2ye/bZZ4MbSgpLS0uNJvO+vr5GzwMA/Pz8qlJSUnD58uU6/6C9vb2N7ufs7KwGgKqqqlqdsgsXLrz00EMPhW7YsMF1w4YNrvb29uoePXqUDRkypPjll18u8Pf3r+klzs7OtgKAjh071jlXnYCAAGVaWppddnZ2nXM2N7Y7YU7yvB3Aa0T0rBBiZT1tXgHgDWD5HUfG2hT9nucT106gvLoctpYG91zwTIOMtRnSZCzeGBXhjVKlCjtP5mLTkSvYf/YaVNoROYQA/rpQgL8uFOD9DccxMMwdD0X6YHhXT9gpbnsaAdYKRUREKJ988slrq1atcp8xY4bP+vXrMwzb6MoqPDw8qvv371+nRldfeHh4rZ7FQYMGFScnJ9vv2LHDsX///uWpqan2UVFRJTY2NmLo0KFl1tbWmj179jgCyNF9/T5y5MgG38OQ7gbYeu7XqtWmPnK56R3LW7ZscTGcPdDHx6cK0jC/tRiO85yZmWk5fPjw0LNnz9qMHTs26MiRI+ky2c3cr6SkRPbUU0+FFBQUWDzxxBPXXnvttfyuXbsqnZ2d1XK5HOvXr3eMj48PFULcdhkJEdX5MPRjMEVUVFTl+fPnj69fv95x9+7dDomJifaHDh1yOHDggOPcuXN9fvzxx/NjxowpBu78+pgb250w53+3/wAYD2A5EXUF8F/temsi6gJpApL3ABQA+KpRo2Stnou1C0JdQnG28CxUQoXUvFT08+1Xu1Gtsg0ecYOxtsJeYYFHe/nh0V5+KCy7ORnLwYu1J2P5PT0Pv6fnwdpShqGdPTE60geDw915Mpa7xMcff5yzfv16140bN7omJSXVufEqMDCwCgDc3d2r67thrz4jR44s/vzzz3327NnjuHPnzlKlUklxcXElgFROERMTU3ro0CGH3NxceUpKir2NjY0mLi6uTh1tQ3Tx5efnW1ZUVJCxGwIvXryoAABvb+87Lj/Nzs4+drv7BgQEVK9evfpCbGxs12PHjtktWrSow+TJk2smqtm+fbt9QUGBRbdu3cpXr16dabj/mTNnjJZr6MVW79dEuh5nHx+fRinBVSgU4umnn76hKxPJz8+XT58+3ee7777zmDx5cuCYMWOOAlKPNwBcunSp3tizsrIUAODr69ui5cEmp+lCiMsAHoVU9zwdQBIAAeBJAMcBfACgEsAYIURePYdhd7FaQ9YZK93Q73nOPw1oeHRAxtoaFzsrjO3jj58n9sXBmUPx/oNd0bNj7clYKqs12HIsB5NWJqP3rF34vzVp2HsmHyqejKVNCwgIqH7ppZfyNBoNpk+f7me4fdCgQeXOzs6q9PR02+PHjzeYvBmKi4srs7W11aSlpdlt2LDBGajdszx48ODi6upq+uc//+mtVCopJiamVKFQ1El+LSwsBADoaqf1BQcHV/v5+Sk1Gg0WLVrkarhdqVTSr7/+2kF7LmaVhDSFXr16VY4bNy4fAGbPnu2jf07Xrl2zAOovVVi7dq3RcZ51SkpK5PpDBuqcPHnSKi0tzZ6IMHz4cFPuczObu7u7euHChZdlMhny8/MtdTehDhs2rJSIkJaWZnf06NE6Pz8pKSnWR48etZPJZBg+fHiLXh+z+riFEAmQJhWZC+AEpIlSqiDVOH8FIEIIsbexg2Rtg/5U3UZvGrTtANhrB2JRK4HrdUaaYYy1IZ6O1nipfxA2TOmHfe8Yn4ylRKnCupTLGL88EbEf78bfNxxD4sXrPBlLG/Xhhx/mOjk5qRMSEpwMa2IVCoWYOnVqjlqtxqOPPhqSkJBgdAKMb7/9toPhpCeWlpbo3bt3iUqlop9//tnd0dFR3a9fv5pRLUaNGlUMAN9//70HAMTFxRkt2fDw8KgGgNTUVBtj2ydPnnwVAD755BOf1NTUmhhUKhUmT57sd+XKFSsfH5+q559/vtDUz6QpzZo1K8fOzk6TlZWl+Oabb2oS/oiIiEoAOHjwoIP+eajVakybNs07JSXllpO2zJw50y8zM7OmdvjGjRuyiRMnBqjVagwfPrwoNDS03rpoU5SUlMg++OADT2MjtKxZs8ZJo9HA3t5e7erqqgaAsLCwqpEjRxZqNBq8/PLLAQUFBTVfWV27dk0+ceLEAI1Gg/vvv/96SEhIi/Y8m12UJoTIhdTzPL3xw2FtWYxXDAgEAYGTBSdRWlUKeyuDf78eXYBS7bd9eScBt5C6B2KMtTn+rtJkLFPiQnDmagl+S7uCTWlXkFlwc2i762VVWHnwElYevARvJ2s82MMbD0X6IsLXscE6R9Z6uLq6ql9//fWcWbNm+VVWVtbpgHv//ffzMjMzrZYtW+Y5ZMiQLmFhYRUBAQFKjUaDnJwcqwsXLlhXVlbK1q5dezYqKqpW3XNcXFzx3r17nZRKJQ0aNKhEv774nnvuqXB2dlYVFRVZAPXXO993332Fy5Yt8xw1alTYvffeW2JnZ6cGAF1pw/Tp0/MPHDhgv3nz5g59+vTp2qdPnxJnZ2fVkSNH7C5fvqxwdHRUr1q16ryxko6W4OPjo5o0aVLuZ5995jN37lzvyZMnF1haWqJ///7lcXFxNxISEpz69u3btU+fPiWOjo7qtLQ025ycHKtJkyblLlq0qN5hg3v27FmmVqvRtWvXiL59+xZbWVmJQ4cOORQWFlp07NhRuWTJkjqlIOZSKpX04Ycf+s2aNcsvNDS0IigoqFImkyEjI0Nx4sQJWwB4//33s/W/QVi+fPmlQYMGWWvH+O7ep08f3egsDsXFxfLw8PCKpUuXXrrT2O5U81VXs7uek8IJ4R3CAQBqoUZKXkrdRjxcHWN3vTDtZCx7pg3Gptf6YUL/IHg51upoRM6NSizZfxGjF/yBIZ/txec7TuNcXot/U85MMHPmzDxjM97pLF269PLWrVtPP/jgg9eLi4vle/bscTp06JBDRUWFbOjQoTcWLlx4ccSIEXVKAkaNGlXzAzBkyJBaybFMJsM999xTAgDOzs6qvn371hmSDAC++OKL7AkTJly1tbXVbN++3XnNmjVua9ascdM/zsaNGy8uWLDgYo8ePcqOHDlit337dheNRkPPPPNMfnJy8olBgwa1qsHM33///auurq6qy5cvKxYsWFBzLlu3bj3/3nvvZfv7+ysTExMd/vzzT4fQ0NDKHTt2nH7ggQcavJnS0tJS/PHHH2eeeeaZ/PT0dNvdu3c7W1painHjxuUfOnQoXX8UjNvl5OSknjNnzqVRo0YVVlZW0v79+x13797tVFJSIh89evT13bt3p7/77ru1huHz9vZWJSUlpb/zzjtXPDw8qvbt2+e4b98+Ry8vr6rp06dnJyYmpnt6erZ4zSfx9KutS0xMjDh8+HBLh3HbPk36FD+e/BEAML7reEzrPa12g5QfgU2vSa+7PgI88X0zR8gYawkajUBixnX8lnYFW4/loLDceO6VMG0wgtzMn+WYiJKFEDGmtE1LS8uIjIy8ZvabMNbGbd682WH06NFhvXv3Lk1MTDzd0vG0dmlpaW6RkZGBhuu555k1qlvfNMg9z4y1RzIZoa/eZCzfvdAbj/WqPRlLZy+H20qcGWOsOfFAnKxRRXtGQ0YyaIQG6dfTcUN5A04KvRt63cNvvi44B6iUgIVZN2Uzxto4S7kMceEeiNNOxpKQnoffjl5BlH+9MwkzxlirwT3PrFE5WDmgSwdpSDoBgeSrBpN1KewB5wDptVAD1842c4SMsdbE2lKO+7p745tnojFhQKeWDocxxm6Jk2fW6PRLN4wOWcelG4wxxlize/DBB0uEEMlc73xnOHlmjU5/qu5bTpbCMw0yxhhjrA3h5Jk1uijPKMhJGp/zTOEZFFYajDXPPc+MMcYYa6PMTp6JSEZEDxDRLCL6lohe1NvmTkRhRCRv6Bjs7mZnaYcIt4ia5cNXDYbe455nxhhjjLVRZiXPRBQFIB3AJgDvAZgAoL9ek4cAnAJwf2MFyNom/brnQzmHam90CwV0f18VZQLKOmPlM8YYY4y1SiYnz0QUAGAngBAAWwG8C8BwPtV1AKoBPNJYAbK2Sb/uuc5NgxYKwFVvWu58vm+BMcYYY22DOT3PfwPgAuA1IcRoIcRcwwZCiCJIPc+9Dbex9qWnR09YyKRhxC/cuIBrFQaTeXHpBmOMMcbaIHOS55EATgkhvrlFuywA3rcfErsb2FjYoIdbj5rlOr3PfNMgY4wxxtogc5JnTwDHTWhXCcDh9sJhd5NY7wam6uaeZ8YYY4y1QeYkzyWQEuhbCQJw7Zat2F2vwclSuOeZMcYYY22QOclzKoAYIqq3JIOIwgH0BGBkZgzW3vRw7wErmRUAILM4E1fLrt7c2CEIkCuk16W5QPn1FoiQMcYYY8w85iTPywHYAviJiFwNNxKRI4DF2mMub5zwWFumkCvQ06NnzXKt0g2ZHHAPv7nMvc+MMcbMcPr0aSsiivb19e1uuI2Iooko2th+27Zts7/33ntDHR0de8pksmgiiv7xxx+db7VfY5s/f74rEUXHx8cHNsf7scZjcvIshPgFwK8ABgO4QESbtJv6EtFqABcBDACwRgixubEDZW1Tg0PW1Srd4LpnxhhjTevixYuWjz/+eMjBgwcdw8PDKx5++OGCxx57rCAoKKiqpWNjpomPjw8kouj58+fX6chtLhZmtn8SwCwArwN4ULuus/ZRDeALSOM/MwZAqnv+Gl8DuNVNg9zzzBhjrHGkpKScMLZ+06ZNjqWlpfLRo0dfeAXRngAAIABJREFU37Rp00VT92NMn1nJsxBCBWAGEc0BEAegEwA5pOHpdgkh8ho/RNaWdXfrDhsLG1SoKpBdmo0rpVfgY+8jbeSbBhljjDWBXr16VRpbn5WVZQUAISEhSnP2Y0yfWdNz6wghCoUQ64UQc4UQc4QQqzhxZsZYyi3R072eumfD4eqEaMbIGGOMGaNf9zt//nzXiIiILjY2Nr3c3Nwin3jiiYArV65YAEB5eTm9/fbbPoGBgREKhSLK29u7++uvv+6rVCoNZx8GACiVSvr444/de/To0dne3r6XtbV1VKdOnbpNnjzZ9+rVq/L64tHVKNvb2/eys7PrFRUV1fmHH35wNvUcdOdBRNGfffaZDwDMmzfPW9cmNjY2vL79DOP/9NNP3aOjo8MdHR17KhSKqICAgIgJEyb46T4TQxqNBvPmzXPr2rVrF2tr6ygXF5fIYcOGBR86dMimofgbsnjxYpe+ffuGOTk59bSwsIhycXGJDAsL6zpu3Dj/EydOKBojbgBISUmxfvrppwP8/f0jrK2toxwdHXuGhYV1nThxot+ZM2es9NuuWLHC+fHHHw8MCQnp5uDg0FOhUET5+/tHjBs3zv/cuXOWxo4fGxsbTkTRmzdvdti/f7/tkCFDQpydnXtaW1tHhYeHd503b56bfntdjfv69etdAeDNN98M1F2v5i7jMLnnmYheBfCzdhZBxkwW6x2Lv3L+AiDVPT8Sop293ckPUDgCymKgsggoyQUceX4dxhhrDV599VXfZcuWefbu3btk4MCBxSkpKXZr1651S0tLs0tMTEyPi4sLO3/+vHVsbGxJQEBAZWJiosOCBQu8rl27ZvHzzz9n6h+rvLyc4uLiQhMTEx2sra01ffv2LbGxsdEkJSXZL1y40Gvjxo0ddu7cebpr1661ao8XL17s8uqrr3bSaDTo0qVLeXBwcGVmZqZi/PjxwS+99NJVmCg8PFz52GOPFZw4ccL29OnTNuHh4RXdunUr1267ZW/z9evXZcOHDw9NSUmxt7e3V0dERJQ7Ojqqjx8/brts2TLPrVu3uiQkJJwODw+vFf9zzz3n/9NPP7nL5XL07t27xM3NrfrIkSN2gwYN6jJmzBizh/WdOnWqz7x587wtLCxEr169yjw9PauKi4vlly9fVqxcudJ9wIABJd26davpVb/duBcsWOA6derUgOrqavLz81PGxcUVVVdXU2ZmpvWSJUs8IyIiKsLCwgp07SdMmBBsZWWlCQ4OruzXr19xVVWV7OTJk7YrV65037x5s8vevXvTe/ToYbS3f+vWrY5LlizxDAoKqhwwYMCN7OxsRWpqqt3UqVMDioqK5B9++OFVAHB0dNQ89thjBUlJSfZZWVmKqKio0sDAwJpjhoeHGz1+UzCnbONrAJ8T0UYAKwBsF4K7Ctmt6Y/3nJibCCEEiAggknqfsw5JG/NOcPLMGGtR3b/v3iwjLTSFY+OPJTfm8dauXet28ODBk1FRUZUAkJ+fL4+Nje185swZm969e3d2cHBQX7hw4Zirq6saAA4cOGAzcODALqtXr3b78MMPc8LCwmoSsqlTp/omJiY6BAUFVe7evftMUFBQNQCUlpZSfHx8px07djiPHTu205EjR9J1+2RkZFi+/fbbgRqNBnPmzLn07rvv5uu2LVmyxGXSpEmdTD2XkSNHlo4cObJ06tSpPqdPn7a5//77iz7//PMrpu7/3HPPBaakpNiPGjWq8Icffsh0d3dXA4BKpcLrr7/uu2jRIq9x48YFJSYmntbts2rVKqeffvrJ3d7eXr1p06YzcXFx5bp9JkyY0PH777/3MPX9AaCiooIWLlzoaWtrq/nrr79OGiajx44dU1haWtbKy24n7r1799q+9dZbAQDo888/z3zzzTevyWQ3CxVSUlKsDWNbtGjRhSeffPKGg4ODRreuuroa06ZN85k/f773a6+95r9v376zxs5r4cKFXvPmzct46623apLxb775psOUKVOCPv/8c+9p06blOzg4aLy9vVXr1q3LiI+PD8zKylKMHz/+2htvvFFg7JhNzZyyjfUACMATALYAuExEs4moS8O7sfauq2tX2FnaAQByy3KRVZJ1c6OT383X5YXNHBljjLH6zJgxI1uXOAOAu7u7+oUXXsgHgPPnz9ssWbIkU5c4A8C9995bMWjQoBtCCOzYsaNmpuHS0lL68ccf3QHgs88+y9IlzgBgb28vVqxYkWljY6NJS0uz27Fjh51u29dff+1WXl4u6927d6l+4gwAL7/8cuGwYcOa5Zvw5ORk6y1btrj4+PhUrV279qIuAQUACwsLLFiwIDssLKwiKSnJPjExsaYc46uvvvLUxpqnS5x1+yxcuPCyu7t7NcxQWFgor6yslHXs2FFprBe3e/fuys6dO9f8wXK7cf/73//2VqvVNHHixNy33367VuIMAFFRUZX6PxcAMGHChEL9xBkALC0t8eWXX15xd3ev/vPPPx0LCwuN5pwjR44s1E+cAWDy5MnXO3XqVFlaWir/448/bE38iJqNOUPVjQHgDeA1AMna1+8COE5EB4loEhE1WIPE2icLmQWiPKJqlmuPumG0NI4xxlgLe/jhh4sN14WGhioBwNvbu8owgQKA4OBgJQBcuXKlps71zz//tCsvL5e5u7tXP/roo3WO6e3trRo6dGgRAOzevdtBbz8HAHjqqaeM9i4+++yzzdLruGnTJicAGDp06A17e/s637jL5XLExsaWAsC+ffvsAKnXNSUlxR4AXnzxxTpx2tjYiAcffNCsHiMfHx+Vj49P1enTp21efvllv9TU1Do9wHcat0qlwoEDBxwBYPLkyWaVlRw9elQxa9Ysj+eff77j448/HhgfHx8YHx8fqFarSaPR4OTJk3XqsQHg/vvvv2FsfXBwcCUAZGVlGa2ZbknmjrZRCOAbAN8QUWcAzwN4BkAsgN4A5mnLOr4XQvyvkWNlbVisVyz2Z+8HICXPY8LGtHBEjDFWV2OXPrRlnTp1qjP2sa530cvLy+i4yPb29hoAqKysrOmcu3TpkiUAdOzYsd6a1KCgICUAZGdn19yIlpOTYwncTMgN1be+sV24cEEBAD/++KO7rge9Pvn5+RYAkJOTY1FVVUUymQyhoaFGPyv9el1TLVu27OLYsWODly5d6rl06VJPFxcXVc+ePcuGDx9+Y+LEidf1vwm43bgrKipkcrlcREREmBRfdXU1nnvuuYDVq1e7NVTNW1RUZPSm0MDAQKOfj4ODgxqo/bPUWpg7znMNIUQ6pGHrZgIYAWA8gIchlXWMuZNjs7tPb+/ak6XU1D0zxhhrleTyegfAgOFX+Q0x5fYoIUSr/YWgVkv5aLdu3crDw8MrGmobERHRpEPdjRo1qjQzM/PY6tWrnfbs2eNw+PBh+z179jglJCQ4ffrppz6bN28+069fv4rmjHvWrFmev/zyi5u7u3v1Rx99lBUXF1fq6+ursrGxEQDQq1evzkeOHLGr7xqb87PUWtxxgqu9aXA7EV0GUALgZfB38cxAZ5fOcLByQElVCa5VXMPF4ovo5GR4rwfff8oYY3ebgICAagC4fPmy0a/tASAjI8MKAHx9fWt6Ib28vKozMjKstT2oJYb7nD9/vt7jNaaOHTtWAUC/fv1Kvv3228um7OPt7a2ysrISVVVVdO7cOSv9ETB0MjIybit+BwcHzYQJEwonTJhQCACZmZmWU6ZM6bhlyxaX1157LSA1NTX9TuK2trbWVFZWyk6cOKEwFrehDRs2uADAl19+mfn000/XKcHIzMxsluvUnO4o3SciFyKaQkRJAI4CmKDd9OcdR8buKnKZHNGeN29iT8rRTtXNvc+MMXZX69evX5mtra0mLy/PcuPGjQ6G23Nzc+W///67MwAMHTq0RG+/EgBYvXp1B2PHXbVqldH1jW306NHFALBt2zbn6mrT7vGztLREr169SgHgu+++qxNnZWUlbdmyxaUx4gsICKieM2dONgCkp6fX3Ph3O3FbWFjg3nvvLQaAb775xu1W7QHgxo0bFoDx8otff/3VsbCwsFErEaysrAQAqFSqFksgzE6eiUhGRA8S0X8BXAEwH0A0gGwAnwAIE0IMbNww2d3AcMg6xhhjdz97e3vx7LPP5gPAtGnT/DMzM2tuACsvL6cXX3wxoLy8XBYZGVk2YsSIMt22KVOmXLOxsdEcOnTI4bPPPquVyH333XcuO3bsaJTk81b69+9fPmzYsKJLly4pHnjggeDz58/XuYEtMzPT8l//+peHfpI6ZcqUPAD49ttvPfft21czYoRarcaUKVP88vLyzLoR7syZM1aff/652/Xr1+vkbuvWrXMCAB8fn5oE9nbj/vvf/54jl8vx7bffehqbeCQ1NdVa/2bFTp06VQLAV1995a4rFQGAEydOKN544w1/c87RFLpzPHXqVIM3TDYlcyZJ6Q7pBsGxADwglWZUAvgF0rjPu3jcZ9YQ/eT58NXDUt1zC8bDGGOsecybNy/7yJEjtomJiQ5dunSJ0J8kJT8/39Lb27tq1apVF/T3CQoKqp47d27m66+/HjRt2rSA5cuXu3fq1KkyKytLkZaWZvfSSy9dXbZsmWdzxL969eqLo0aNCt25c6dzt27dnMLDw8v9/PyqSkpK5Dk5OVYXLlyw1mg0mDZtWr5urOVx48YV/e9//7v2888/uw0ZMqRzbGxsqaura3VaWppdXl6e1TPPPJP/008/NXgjn75r167J/+///i9gxowZ/p07dy739/ev0mg0OHv2rM25c+esLSwsxKxZs2qVZ9xO3HFxceVz587NmDZtWsCbb74ZOHfuXO/u3buXK5VKunTpkuLs2bM2X375ZYZuKvP33nsvZ//+/Y4///yz+4EDBxwjIiLKCwsL5UlJSQ49e/Ysc3d3V6WmptoZO6fbER8fX/TFF1/4LF++3PPUqVM2Pj4+VUSECRMmXBs+fHjZrY9w58zpeU4D8BYATwCHAEwC4CWEeEYIsZMTZ3YroS6hcFZIoxler7yOc0XnajfgHyHGGLsr2drain379p2dNWtWVnBwcOWhQ4ccdu3a5WxnZ6eeNGlSbkpKyknD2QUBabzfjRs3nrnnnntKMjIyrHXlHcuXL7/wzjvv5DVX/B06dNAcOHDg9IIFCy7GxMSUXLp0SbF9+3bn48eP28rlcjF27Nj8devWnbW1ta31i2zlypWZc+fOzQwNDa1MTk6237dvn1NISEjl77//fio2NtasRK9Lly7KDz/8MGvgwIE3bty4YfH777877du3z0mtVuPpp5++dvDgwZOGNce3G/dbb71VcODAgVPx8fEFKpWKdu7c6ZyUlOQgk8nwyiuvXL3vvvtqymuGDRtWtnfv3lODBw++UVpaKt+1a5dzbm6u1RtvvJGzd+/eMxYWFo36y/3ee++tWLp06YWIiIiy1NRU+7Vr17qtWbPGrTl7osnUnJeIsgH8AGCFEOL0rdqz2xMTEyMOHz7c0mE0mbcT3sauS7sAADNiZ+CZkwnAsbXSxkcXA5FPtmB0jLG2ioiShRAxprRNS0vLiIyMNHtqZMZY+5KWluYWGRkZaLjenJ7njkKImZw4szvR26v2kHU8MAtjjDHG2hJzZhjU3LoVYw0zrHvWcKkGY4wxxtqQem8YJCLdHZLZQgi13rJJhBCX7igydlcKdg5GB+sOuF55HTeUN3BGVo7OLR0UY4wxxpiJGhptIwOABkBXAGe0y6Z2E4pbHJu1U0SEWK9YbMvYBgBIVBfrJc/cC80YY4yx1q2hBPcSpGym2mCZsTvS26t3TfKcpC7Gcy0cD2OMMcaYqepNnoUQgQ0ttzdEFAJgGoC+ACIApAshIoy0CwXwFYD+ACogjYM9XQhR3ozhtmq16p7VxVCBv6ZgjDHGWNtwR9NztzPdADwA4ByAk8YaEJEzgAQADgDGAPg/AE8DWN5MMbYJAY4B8LDxAACUQo10K6sWjogx1t7w1ASMsYY09H+EyckzEf2DiB4yod1oIvqHqcdtQ34TQnQUQowBkFJPm1cAuAB4WAixTQjxA4A3ADxJRN2aK9DWjojQ2/vmkHWJNgrpBf8yY4w1AyKqUKvV3HnEGKuXSqWyIKJSY9vM+c/jAwCPmNDuIQD/NOO4bYKJQ/XdD2C3EEJ/8P11AJQA7muSwNoo/dKNROsWm56eMdY+HS0rK7Nt6SAYY61XcXGxvRBiv7FtTfGXtxy3cWMhEYUT0ZtEtJKI0olIQ0SCiMaYsO9YItpPRDeIqJSIDhPRFCJq7p6FLjAo6RBCKAGcB3hENn36k6WkWCtq7kpljLGmVl1dvfX69etWXLrBGDNGpVLJ8vPzoVKp1hrb3hTJZTCA4tvY71UAXwB4BkA4TJx6joi+BvATgBgA+wHsBBAGYAGA/xKR/DZiuV0uAIqMrC8E0KEZ42j1/Oz94G3nDQCokMlwQsF1z4yxZvNzcXHxsaysLNeKigpOohljEEKgurraoqCgwPncuXOOFRUVSyHdx1ZHg4McGKld7tlAPbMFpJ7X/gD2mBkzABwH8B8AhwEkA1gGYNAt4osHMBlALoCBQoiz2vWekE74UQCvAfjSYD8nAN4mxHTpNkbJMPa/MNWzvt0iIvT26o1N5zcBAJKsrdGzhWNijLUP0dHRVcnJyeMLCgqeKyoqGieEcIOJHTaMsbsXEZUKIXZqe5wToqOjjeZutxoh7ANISZ/uP5We2kdDygH8y4xYAQBCiKX6y0Qm/T82U/s8XZc4a491lYhehZTEzyCirwxqlh8F8J0Jxx8OYJcpgWgVQup9NuQM4JQZx2kXYr1ia5LnRBsFXua/LxhjzSQ6OroIwHztgzHGTHar5PlfuJk8/wPAEQAb62lbBSAbwHYhxNVGi7AeROQHIFr7vnVqUoQQe4koG4AvpLGZD+htWwFgRROEdQpS77t+nApIpSymJOvtiv5Ng0cUClRpVODiDcYYY4y1Zg0mz0KID3SvteUaR4QQHzZ1UCbqpX0+IYSoqKdNEqTkuRf0kucmtBXA+0TkKoQo0K57FIBCu43p8bb3hh9Z47KoRKVMhmPlOYhu6aAYY4wxxhpg8sRuQojWNiZmkPY5s4E2lwza3jYisoU0FB0ABABw1BsJJEkIkQngWwCvA9hIRP8G4AHgcwCrhRBGJ1bRHnsigIkA4O/vf6ehtil9LJxwuboSAHCoNIOTZ8YYY4y1aq0tITaHvfa5rIE2usGtHRrh/TwglYesBTAYQEe95TgAEEIUARiifd/1AOYBWA3gxYYOLIRYLISIEULEuLu7N0KobUeshVPN60MlGS0XCGOMMcaYCUzuedZHRF0gDQfniHruUNbOrteUdO/bLHeZCSEyYMLd2EKIMwBGNXlAd4lYuXPN66PlV1BeXQ5bS567gDHGGGOtk1nJMxHdC2AxDG6KM2wGKaFt6uS5RPts30Ab3baSBtqwFuQms0JIVRXOWVlBBQ1S8lLQ37d/S4fFGGOMMWaUyWUbRNQZwA4AXQH8BeCidtMvkMZmVmuXN6DpE2cAyNA+BzTQpqNBW9YK9a2orHl9KOdQC0bCGGOMMdYwc2qeZwCwBfCKEKI/pNn8IIR4RgjRB0AkpMlNwgC80diBGpGqfe5GRDb1tOlt0Ja1Qn0qlDWvOXlmjDHGWGtmTvI8GMBZIcQSYxuFEKcAPAjAH8D7dx5aw4QQWQBSAFgBeNxwOxENAuAHafbBv5o6Hnb7YiorIddOj5t+PR1FlcZmOGeMMcYYa3nmJM9ekKbQ1lEDNZOAAACEEHkA9kIa27g5fKJ9nkNEIbqVROQB4Bvt4myD2QVZa0IEeyHQTVkFABAQSMxNbOGgGGOMMcaMMyd5LkXt0SaKtc/eBu0qIE1MYhYiiiKig7oHgCjtpo8N1tcQQvwXwEJIif0xIvqNiNYDOAupNnsDgAXmxsKaX59KrntmjDHGWOtnzmgbl3HzBjwASNc+x0E79TQRWQLoAyD/NmJx1O5rKLShnYQQk4noDwBTAAwCINfGthzAQu51bhv6VlRiibM05vOhXE6eGWOMMdY6mZM8/wngBSJyFEIUA9gCqXRjHhFZQ0quX4ZUZ/yLuYEIIfbAhHGU69l3FYBVt7Mvax0ilUooyAJKoUJmcSZyy3LhZefV0mExxhhjjNViTtnGegDZkG4chBAiG1LNsSOk0ogNkG4YvAHgb40aJbuLSX8vKQTQy+5mtc/BnIP17cAYY4wx1mJMTp6FELuFEKFCiE166/4JaaSLNQB2AfgKQLR2Nj7GzNLH7uaQ3Vz3zBhjjLHW6Lam59YnhFgHYF0jxMLaub72AfjyqvQ6MScRQggQ3VYlD2OMMcZYkzCnbIOxJtXFxhMOlg4AgLyKPFwsvniLPRhjjDHGmhcnz6zVkBMhxiumZplLNxhjjDHW2tRbtkFEv9/BcYUQYugd7M/aC4OqjD7efZCQlQBASp6f7vx0CwTFGGOMMWZcQzXPg+/guOIO9mXtWF/vvjWvE3MTodaoIZfJWzAixhhjjLGbGkqe45otCsa0Ojl1gruNO/Ir8lFSVYL06+no5tatpcNijDHGGAPQQPIshNjbnIEwBu3oGrHesdhyYQsAabxnTp4ZY4wx1lrwDYOshdUdiq6P181Z2vmmQcYYY4y1Jrc1zjMRdQNwDwB3ACd0E6cQkQyAhRCiqvFCZO2Nft1zal4qqtRVsJJbtWBEjDHGGGMSs3qeichfOwrHUQDfApgF4BG9Jq8DqCAiHmmD3TZve2/4O/gDACrVlUjLT2vhiBhjjDHGJCYnz0TkBmAfpFE4jgFYiLrfua+BNNLGw40UH2tXbg7S0sf7ZunGwZyDLREMY4wxxlgd5vQ8zwTgD2AOgF5CiNcMGwghcgCcAtC/ccJjd716pt/WT54TcxKbKxrGGGOMsQaZkzyPBnARwHtCiIbGcc4C4HNHUbF2L9Yrtub18WvHUVZd1oLRMMYYY4xJzEmeOwJIuUXiDADFAFxuPyTGABdrF3Tu0BkAoBIqJF9NbuGIGGOMMcbMS54rADib0C4AQNHthcPYTfpD1nHdM2OMMcZaA3OS5+MAoonIqb4GROQLIBJAyp0Gxtohgy81Yr1vlm7weM+MMcYYaw3MSZ5XQep5/paI6gy6qx3jeT4ABYCVjRMeu/sZv2EQAGI8Y2BB0lDkZwrPoKCioLmCYowxxhgzypzkeSmAPwE8AeAUEc3Xro8gojmQRtl4FMBeSIk2Y3fE1tIW3d271ywn5Sa1YDSMMcYYY2Ykz0IIFYD7IY3lHARAN1RdDIB3AIQC2ADgYRNuKmTMJDzeM2OMMcZaE7NmGBRClAghngLQDcA0AN9Ammnw7wCihRCPCSFKGj9M1j7U/ZtL/6ZBrntmjDHGWEuzMLUhETkCENoE+hSkMg3G7kw9k6ToRLpHwsbCBhWqClwuvYzs0mz42vs2U3CMMcYYY7WZ0/NcBGBXUwXCmDGWcktEeUTVLHPvM2OMMcZakjnJcwmAs00VCGP10a975uSZMcYYYy3JnOT5FAC/pgqEsfroJ8+JuYng+1EZY4wx1lLMSZ6XAOhPRNFNFQxr5+pJijt36AwnhTQ3z7WKazhfdL45o2KMMcYYq2HOUHXLII2usZOIphNRGBEpmi401j40fMMgAMhIhlgvvdkGc7l0gzHGGGMtw+TkmYjUAKYAcALwMaQyjnIiUht5qJooXtZO6Q9Zx+M9M8YYY6ylmDxUHUzpIry9tozdkn7d8+Hcw1BpVLCQmfPjyxhjjDF258wp25CZ82jKoNndqv4bAQMcA+Bh6wEAKK0uxcmCk80VFGOMMcZYDU5yWcu6xSQpN5sR+nr3rVnmIesYY4wx1hI4eWZtBo/3zBhjjLGWxskzazP0bxpMzUtFtaa6BaNhjDHGWHvEyTNrMzztPGFnaQcAqNJUoVJV2cIRMcYYY6y94eSZtR4mzBxIPJALY4wxxloQJ8+shXEyzBhjjLG2g5NnxhhjjDHGTMTJM2uzRAPjQjPGGGOMNQVOnhljjDHGGDMRJ8+sZZk4SUpNc66RZowxxlgL4uSZMcYYY4wxE3HyzBhjjDHGmIk4eWathwnjPNduzjcMMsYYY6x5EScgrQsR5QPIbOk42jk3ANdaOgjWqPia3n0Mr2mAEMK9pYJhjLUfnDwzZoCIDgshYlo6DtZ4+JreffiaMsZaCpdtMMYYY4wxZiJOnhljjDHGGDMRJ8+M1bW4pQNgjY6v6d2HryljrEVwzTNjjDHGGGMm4p5nxhhjjDHGTMTJM2OMMcYYYybi5Jnd9YgonIjeJKKVRJRORBoiEkQ0xoR9xxLRfiK6QUSlRHSYiKYQEf/baUFEZElEQ4noMyI6SEQ5RFRFRNlE9F8iGnyL/fm6tkJE9DoRrSGiU0RUQETVRJRPRLuI6Fkionr2k2mv32Ht9byhvb5PN/c5MMbuflzzzO56RPQFgDeNbHpcCPHfBvb7GsBkAJUAdgOoBjAUgAOAX7X7qxs/YnYrRDQMwE7tYi6AZABlALoCiNCu/7cQ4h9G9uXr2koR0WUAHgCOA8iGdE0DAPQBQAA2AnhMCKHR20cOYD2AhwAUQ7qmCkjXVAHgKyHEG814Goyxuxwnz+yuR0QTAIQBOAwpyVoGYBAaSJ6JKB7AfyElZgOFEGe16z0BJADoAuAtIcSXTX8GzBARDYGUAH8phNhvsO1JAD8BkAMYIoRI0NvG17UVI6L+AFKFEGUG67tBSoo9AbwohPhOb9v/AZgL4CSk631Vuz4UwH7tPo8IITY2z1kwxu52nDyzdoeI9uDWyfNhANEAxgshfjDYNgjAHkgJmK9+LxhrHYhoKYCXACwXQrykt56vaxtFRO8D+BeAn4UQY7Xr5ACuQOqtHiSE2Gewz3gAKwAkCSFimzdixtjdiuv7GDNARH6QEqwqAGsNtwsh9kL6StkLQN/mjY6ZKFX77Kdbwde1zVNpnys25WZ3AAAOUUlEQVT11t0DKXG+bJg4a62FVJbTm4h8mzg+xlg7wckzY3X10j6fEEJU1NMmyaAta11Ctc85euv4urZRRBQEYJJ28Te9TbrrlAQjhBDlAE5oF3s2TXSMsfbGoqUDYKwVCtI+ZzbQ5pJBW9ZKEJEXgOe1i+v0NvF1bSOI6AVIpVWWkL49uBdSZ88nQohf9Zqaek17gq8pY6yRcPLMWF322ueyBtqUap8dmjgWZgYisgCwEoATgN1CCP1eSr6ubUc/AOP1llUA3gfwuUE7vqaMsWbHZRuM1aUbS5bvpm17FkEaoiwLwLMG2/i6thFCiAlCCAJgC6AbgC8AfADgIBH56DXla8oYa3acPDNWV4n22b6BNrptJQ20Yc2IiL6ENMJGLoChQohcgyZ8XdsYIUSFEOKkEOIdADMBRAJYoNeEryljrNlx8sxYXRna54AG2nQ0aMtaEBF9BuANAPmQEuezRpplaJ/5urZNurGdRxORpfZ1hvaZryljrNlw8sxYXbphzroRkU09bXobtGUthIg+BTAVQAGA4UKIk/U05evathVBqn22ANBBuy5F+9zb2A5EZIubM07yNWWMNQpOnhkzIITIgvRL2QrA44bbtZNp+EEqD/ireaNj+ohoNoB3ABRCSpzT6mvL17XNGwgpcS4CcE277i8AeQD8iGigkX0ehzRiR5IQIrtZomSM3fU4eWbMuE+0z3OIKES3kog8AHyjXZzNs9C1HCL6N4DpkJKp4UIIU3oW+bq2UkQ0gIieISKFkW39ACzTLi4TQqgBQPv8H+36hdrrqNsnFMBs7eJHTRc5Y6y94em52V2PiKJwMzECgK6Qhq06C+C6bqUQoq/Bft8AeBXSjGa7IM1UNhSAI4ANAMbofomz5kVEDwHYqF08jJsTYRhKF0LM1l/B17V1IqLnIdU1F0H6hiAX0r/TYEj/ZgFgC4DH9Se50U7R/SuA0QCKAeyG1Ns8DIA1gK+EEG80z1kwxtoDTp7ZXY+IBgNIuFU77dBYhvuOBTAFQHcAcgDpAJYDWMi9ky1HL9G6lb1CiMFG9ufr2spoZxF8AcAAACEA3CANRZcL6Q+klUKIDfXsKwMwWbt/ZwBqAEcBfCOEWNX00TPG2hNOnhljjDHGGDMR1zwzxhhjjDFmIk6eGWOMMcYYMxEnz4wxxhhjjJmIk2fGGGOMMcZMxMkzY4wxxhhjJuLkmTHGGGOMMRNx8swYY4wxxpiJOHlmzExEtIKIhHaijrsWEbkQ0UIiukRE1dpzNjpJhcF+7eLz0dGeKw+Yzxhj7QQnz4yx+iwBMAmACsB/AXwP4PfbPRgRPa9NNFc0TnhNr739IcAYY+zWLFo6AMZY60NElgAeBlAJoKcQotiM3WcCmA0gpylia4W6tHQAjDHGmg8nz4wxY7wh/f+QbWbiDCFEDtpP4gwhRHpLx8AYY6z5cNkGa1b69aFE9CQR/UVEpURUQkS7iai/kX0CtftlmHLcBt7veSI6TERlRJRLRMuIyF27zZqIPiSiM0RUqa3z/UjbA9vQ+fQkog1EdI2IyokomYheuMU+I4loExFdJaIqIsohop+JqHtD505EFkQ0jYjStOdQ1ND7GBwngIi+IaILRKQkokIiSiCiscY+MwCZ2sUA3WeofQSa8F51Sh201+477eJ4g2OuMNjfkogmEdF+bZyVRHSWiD7XXS+D9jXlIETkSkTzieii9rPdoNcunoiWE9EJIirSHvccEX1NRB0Njhmo/RzGa1d9ZxCz/rnVW/NMRG5ENIeI0omogoiKieggEU0mojqdFwbn4kBE/9Gei5KIskmqQe9Qz3s9RUS/E9F1kmrUrxHRMe35BRvbhzHGmPm455m1CCL6F4C/AfgDwBYAPQAMAdCfiAYLIf5q5PebA+AtAHsBbANwL4AXAcQQUT8A2yF9/b4XwDkAgwC8B8AdwMR6DtsHwEIA2QB2AvDQ7reciHoJId4wEseXAN6AVEecBOAygBAATwF4hIjihRBbjZ0CgHUARgHYB+AkAH8Tz72P9pydAVwE8CsAV22sg4loFIDxQghdAvg9AHsA8QDKINU765Sa8p5G/BdAXwD9AJyHdN11al4TkSOkn4f+AG4ASAZQBCAKwNsA4olokBAiw8h7uEH6TJ0A7AdwGECB3vbVkMpQTgLYBUABoCeAyQCeIKJ+Qogzeuf5vTaOYAB/Qvq50NF/bRQRhUCqEe8IIBfAbwBsAcQB+BrAo0T0oBBCaWR3J+17+kK63se1sUwCEEtEfYUQ1Xrv9QGAfwKoBnAAwBVI1ztQe377IX3ujDHG7pQQgh/8aLYHAKF9FACI1lsvA7BYu22nwT6B2vUZtzpuA++XC6CL3noXAOnabccgJRdOett7QkpENAACDI65Qu+4XwKQ623rA6BYu+1+g/0madcfB9DZYNsj2vcrBOBi5Nx1vcEhZn7e1gAuafefZxBrBICr2m2vmPuZN/Ceus/neYP1z2vXr2hg31+0bdYafA5yAHO02/bUc1wB6Y8gh3qO/QQAW4N1FgD+rd33f6aei4k/e4nabWsAWOut7wjgtHbbJw2cyxYA9nrbfPSu5TN66xUAygGUAAgzEkcogKA7/bfLD37wgx/8kB5ctsFayj+FEMm6BSGEBsDftYsDblUucRv+IYQ4pfd+hQAWaRe7ApgohLiht/0IgK2QenwH1XPMKwDeFUKo9fY7BClJBaSeUgAAEckB/EO7+IQwqJMVQmwA8C2k3sJn63m/mUKIW/Z4GngcUrKWaSTW4wA+0C5OM/O4jY6IugJ4ElKsz2mvEQBAG/dMAEcBDDJW4gLpj49XhBAlxo4vhFgjhCg3WKcSQrwP6VqOICKHRjqXAQB6Q0poJwkhKvXeMwvStyAAMIWIrI0cohTAS0KIUr39rgBYoF0cqtfWEYANgPPiZs859PY7K4S4eCfnwxhj7CZOnllL2Wy4QgiRB6nnVQGprKAxbTOyTpeIZuon1nrOap996jnmWmH8K/cftc/99epae0K6Ce+EEOJkPcfbq32+p57tv9azviG6xP8nofc1v57vIPVkhhCR720cvzHdp33eLISoMNyo/QNLV+Jh7DNKEcbLOWoQURgRvaGti16urS1eAakHWgaphKYx6D7334QQ1w03/n979xNaRxXFcfx7WqhibaW4Cq3WtiDVCrUGuxAkFdEQTagKtcRKFFopUsES1I0gWtEKKihoCQquXEjdVEWyki5ia6rWWiXgooq2/m12pYsqwnFx7uQ9X2bem5dM8oz9faBM38zLuzc3E3Lmzplz3X2UeKhyGdCd8/XH3f33nP3ZRdfUOenuk8CPwEYze9XM1s+m4yIi0pxynqVTThfsP0ekVOTNxs3Gzzn7zjc5Vn+8qC9Fs3mniXSPS4mLgD+AtenYhqKHy+pMeygOOJsXUJaQBcS5fXX3C2b2a3rfSiJ/u1OyMdpjZntavDdvjH7K2QdAuog5AOwi7iYUWd6i3bKajnvyA3FBlXfR0uz3A6afk0NETvwwMGxmk8A4kcbybv1dFRERmR0Fz9IRaRaxEmbW8g5Ki/Yq60te02m7OG1/IR5Wayav9NlMAmeoBYrNAvZmweR8ysboOJEX3sxEzr5mY/Q48AiRnjFMPFR3NrtzYGZHidnsqsZituPe1jnp7mOpEko/sIV4ILYfGACeNbM73f1EO58pIiL5FDzLQvBX2l5ecHz1fHWkwTUF+68mUgAuANkt+zNp+5u7Pzy33fqXbFZ9bd7BlG/blV52ctYZamN02N2frPizt6XtbnefljJEdekamabjnqxJ20rGPeVzH0z/MLMuIv9+O1Hd45Yq2hERudgp51kWgkkigL4yr84vcNc89yezzcyW5OzfkbZH3P3v9P/PiQojm1IJs/mS5VEP5tUVJuoYG3DK3ec6eM4ugoou2kfT9p6Cvs5GVhv5TOMBM7uD/DQQaN3nItm4D5jZipw2e4mLlvPETHvlPBareTq93DgXbYiIXIwUPMt/XnrQbSy93GdmU7e7LRZV2deRjkWu6kv1aSNmdjORFgBRxg6Y+h6eJ1ITDpnZ5sYPM7OlZjZoZlUu9/w+ETCuAfY39PV64Ln08pUK2yySBee535+7fwUcImaBD5rZqsb3mFmXme2dQXCdpcI82jAG66hVXWm7z0XcfYyoOb0MeNPMLqlrcyXwWnr5Rn0ljpmwWABnV6qR3WggbQvzwUVEpD1K25CF4hngVqJWco+ZTRDpGt3Ai9TK3M2nEWIBigEz+5KYvewhfq8OuPtH9W9299fNbDVRwu6YmX1DLFyxiCgnt55YRKMPyKv+0bb0QOD9xKzuE8TCHF8QM7FbgCVEdZC3qmivhXGi3vZNabwmiPJyR9x9avVB4EPgXqDPzE4Sgd9yYoyuI8ZrhFhopqz9xAIzu4HbzOwEMQY9wGepX3lpDR8Q595eM7uBSMdw4B13P9qizQeAw8Agcc5+Sm2RlKXAJ9RKBc7GCuBtIkj/mnhIcRFRgnEDMcZPVdCOiIigmWdZIFKgcjsRcFxFLVVjKNXp7YRjRMD1HdBLrJ73LfFg2mN5X+Duw0TA9h4R9NxNBLGXESvQ7aA2y14Jdx8nSuWNEDPf9xGLuYwTNaUfcvdWFUCq6MefRAD7MTET/iCwk7o62u5+jvg5DxEr661L/e0mguURoLfd2VqPFSs3p7avALYCq4AXiJ9dXhm/rN73dmIWOVuVcidwbYk2TwGbgJeJ9IytxM96gjg/+gpKHbbre+KCbJS4IOgnxnkxcVF0Y0Get4iIzIDNw99MEREREZH/Bc08i4iIiIiUpOBZRERERKQkBc8iIiIiIiUpeBYRERERKUnBs4iIiIhISQqeRURERERKUvAsIiIiIlKSgmcRERERkZIUPIuIiIiIlPQPwPOctaiaK6gAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n=np.arange(3,30)\n", + "\n", + "err_bisect = np.zeros(len(n))\n", + "err_newtraph=np.zeros(len(n))\n", + "err_modsec=np.zeros(len(n))\n", + "\n", + "for i in range(0,len(n)):\n", + " root,out = bisect(f_h,0,4,es=0,maxit=n[i])\n", + " err_bisect[i] = out[1]\n", + " \n", + " root,out = newtraph(f_h,dfdh,1,es=0,maxit=n[i])\n", + " err_newtraph[i] =out[1]\n", + " \n", + " root,out = mod_secant(f_h,0.001,1,es=0,maxit=n[i])\n", + " err_modsec[i] =out[1]\n", + "\n", + "plt.semilogy(n,err_bisect,label = 'bisection')\n", + "plt.semilogy(n,err_newtraph, label = 'Newton-Raphson')\n", + "plt.semilogy(n,err_modsec, label = 'modified secant')\n", + "plt.title('Convergence rates of solvers')\n", + "plt.xlabel('number of iterations')\n", + "plt.ylabel('relative error (%)')\n", + "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The modified secant can converge as quick as the Newton-Raphson method, but there is no universal $\\delta x$ that works well for every problem. Typically, it is set as a small number and then varied based upon the conergence rate for the problem. \n", + "\n", + "# Shooting method\n", + "\n", + "Now, we have multiple solving methods to revisit our __Initial Value Problems__. In notebooks [01](./01_Catch_Motion.ipynb) and [02](02_Step_Future.ipynb) we measured the displacement of a ball as a function of time. We _assumed_ the initial velocity was 0 in the case of the dropped object, or we approximated the velocity based upon the first two measured displacements and a finite difference approximation. \n", + "\n", + "Consider the case of the tennis ball that was dropped in the ['data/fallingtennisball02.txt file'](../data/fallingtennisball02.txt). After it strikes the ground, we don't really _know_ the velocity. What we _do know_ is that the position was $\\approx 0$ at t=0.58 s and it was $\\approx 0$ m at t=1.43 s. Solving our differential equation without an initial velocity is known as a \"shooting\" method." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![The shooting method imagined as a catapult aiming at a target](../images/shooting.png)\n", + "\n", + "Solving this type of problem where the __boundaries__ are known is referred to as a _Boundary value problem_. Typically, boudary value problems happen over a distance, rather than points in time, but we will come back to those in the fifth module on boundary value problems. \n", + "\n", + "For now, let's reframe our engineering problem into a root-finding problem. We have a length of time of interest:\n", + "\n", + "t=0.58 - 1.43 sec\n", + "\n", + "in this time, the ball had just struck the ground and is traveling upwards. What is the initial velocity necessary to keep it in the air for $\\Delta t = 0.85~s$ ?\n", + "\n", + "We know that the ball is acted upon by gravity and the force of drag, but we do not an analytical solution for the position as a function of time. First, let's look at the data we have. " + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "at time t=0.58 s, y=-0.0152 m\n", + "at time t=1.42 s, y=-0.0110 m\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "filename = '../data/fallingtennisball02.txt'\n", + "t, y = np.loadtxt(filename, usecols=[0,1], unpack=True)\n", + "tbounce = t[580:1425]\n", + "ybounce = y[580:1425]\n", + "\n", + "print('at time t={:.2f} s, y={:.4f} m'.format(tbounce[0],ybounce[0]))\n", + "print('at time t={:.2f} s, y={:.4f} m'.format(tbounce[-1],ybounce[-1]))\n", + "plt.plot(t,y)\n", + "plt.plot(tbounce,ybounce,'s',label='after bounce 1')\n", + "plt.legend()\n", + "plt.title('Time between bounce 1 and 2')\n", + "plt.xlabel('time (s)')\n", + "plt.ylabel('height y(t) (m)');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's look at the `fall_drag` function we created that described the motion of the tennis ball. Remember, this function returns the derivative of the state. So if we input\n", + "\n", + "state = $[x,~v]$\n", + "\n", + "it will return\n", + "\n", + "d(state)/dt = $\\left[v,~-9.81+\\frac{F_{D}}{m}\\right]$" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [], + "source": [ + "def fall_drag(state,C_d=0.47,m=0.0577,R = 0.0661/2):\n", + " '''Computes the right-hand side of the differential equation\n", + " for the fall of a ball, with drag, in SI units.\n", + " \n", + " Arguments\n", + " ---------- \n", + " state : array of two dependent variables [y v]^T\n", + " m : mass in kilograms default set to 0.0577 kg\n", + " C_d : drag coefficient for a sphere default set to 0.47 (no units)\n", + " R : radius of ball default in meters is 0.0661/2 m (tennis ball)\n", + " Returns\n", + " -------\n", + " derivs: array of two derivatives [v (-g+a_drag)]^T\n", + " '''\n", + " \n", + " rho = 1.22 # air density kg/m^3\n", + " pi = np.pi\n", + " \n", + " a_drag = -1/(2*m) * pi * R**2 * rho * C_d * (state[1])**2*np.sign(state[1])\n", + " \n", + " derivs = np.array([state[1], -9.81 + a_drag])\n", + " return derivs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get the position as a function of time, we can use any of the integration methods that we defined in [03_Get_Oscillations](./03_Get_Oscillations.ipynb). Here we copy in the second-order Runge-Kutta explicit method. " + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": {}, + "outputs": [], + "source": [ + "def rk2_step(state, rhs, dt):\n", + " '''Update a state to the next time increment using modified Euler's method.\n", + " \n", + " Arguments\n", + " ---------\n", + " state : array of dependent variables\n", + " rhs : function that computes the RHS of the DiffEq\n", + " dt : float, time increment\n", + " \n", + " Returns\n", + " -------\n", + " next_state : array, updated after one time increment'''\n", + " \n", + " mid_state = state + rhs(state) * dt*0.5 \n", + " next_state = state + rhs(mid_state)*dt\n", + " \n", + " return next_state" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining our problem for Python \n", + "\n", + "Now, we can finally ask our engineering question in a Python way. \n", + "\n", + "We need a function, $f(v_0)$, such that when we input the correct velocity for the initial condition, $f(v_0^{correct})=0$\n", + "\n", + "So we define a new function with `def`" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": {}, + "outputs": [], + "source": [ + "def f_v(v0,y0=ybounce[0],yT=ybounce[-1],T=(tbounce[0],tbounce[-1]),N=50):\n", + " ''' define a function f(v) that returns \n", + " ymeasured(T)-ypredicted(T)\n", + " here, the time span is based upon the tbounce variable defined above from \n", + " the first bounce to the second bounce\n", + " \n", + " arguments:\n", + " ---------\n", + " v0: the unknown initial vy velocity component\n", + " y0: the known initial position\n", + " yT: the known final position\n", + " T: a list of two times (beginning time, end time)\n", + " N: the number of time steps to integrate the RK2 method default = 50\n", + " \n", + " returns:\n", + " --------\n", + " error: the difference between vmeasured(T) and vpredicted(T)\n", + " when f_v(v0)= 0, the correct initial velocity was chosen\n", + " '''\n", + " \n", + " \n", + " # initialize array\n", + " t_sol=np.linspace(T[0],T[1],N)\n", + " dt=t_sol[1]-t_sol[0]\n", + " num_sol_drag = np.zeros([N,2])\n", + "\n", + " # Set intial conditions\n", + " num_sol_drag[0,0] = y0\n", + " num_sol_drag[0,1] = v0\n", + "\n", + " for i in range(N-1):\n", + " num_sol_drag[i+1] = rk2_step(num_sol_drag[i], fall_drag, dt)\n", + " error = num_sol_drag[-1,0]-yT\n", + " #plt.plot(t_sol,num_sol_drag[:,0])\n", + " return error" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Take a look at the pieces of this function:\n", + "\n", + "1. Create an array of time `t_sol`\n", + "\n", + "2. Set initial conditions to `y0` and `v0` <- __here `v0` is our unknown value__\n", + "\n", + "3. Use Runge-Kutta second order to integrate the function for `t_sol[0]` to `t_sol[-1]`\n", + "\n", + "4. Create an output, `error` of the difference between the measured y(T), `yT`, and the current solution for y(T), `num_sol_drag[-1,0]`\n", + "\n", + "When `error` is 0, we have chosen the correct initial velocity, `v0`.\n", + "\n", + "To see what the output looks like, below we can take out the integration part and plot the results for a guess of `v0`." + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize array\n", + "N=50\n", + "T=(tbounce[0],tbounce[-1])\n", + "t_sol=np.linspace(T[0],T[1],N)\n", + "dt=t_sol[1]-t_sol[0]\n", + "num_sol_drag = np.zeros([N,2])\n", + "num_sol_drag[0,0] = ybounce[0]\n", + "num_sol_drag[0,1] = 3\n", + "\n", + "for i in range(N-1):\n", + " num_sol_drag[i+1] = rk2_step(num_sol_drag[i], fall_drag, dt)" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t,y)\n", + "plt.plot(t_sol,num_sol_drag[:,0],'s')\n", + "plt.title('Predicted motion after bounce')\n", + "plt.xlabel('time (s)')\n", + "plt.ylabel('height y(t) (m)');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "Enter your best guess for `v0`. What is the error between the measured `yT` and your predicted y(T)? _Hint: use our function, `f_v`, and plot the results._" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solving the engineering problem\n", + "\n", + "Now, we have all the components we need for this \"shooting\" problem. We can't evaluate a derivative easily and the bisection method is too slow. Therefore, we will use the `mod_secant` function to find the correct initial velocity. \n", + "\n", + "Below is the solution. _Just one line of code!_" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.175915400675785 m/s is the correct initial velocity to match the height at beginning and end of bounce\n", + "the solve took 3 iterations\n" + ] + } + ], + "source": [ + "v0,out = mod_secant(f_v,0.0001,7,es=0.000001) # <-- solution line\n", + "print(v0, 'm/s is the correct initial velocity to match the height at beginning and end of bounce')\n", + "print('the solve took ',out[2],' iterations')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "Change the value of the `dx` and `x0`. Does it change the final result? Does it change the time it took to arrive at the solution or the number of iterations?" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mmod_secant\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.0001\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmaxit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "mod_secant: Modified secant root location zeroes\n", + "root,[fx,ea,iter]=mod_secant(func,dfunc,xr,es,maxit,p1,p2,...):\n", + "uses modified secant method to find the root of func\n", + "arguments:\n", + "----------\n", + "func = name of function\n", + "dx = perturbation fraction\n", + "xr = initial guess\n", + "es = desired relative error (default = 0.0001 )\n", + "maxit = maximum allowable iterations (default = 50)\n", + "p1,p2,... = additional parameters used by function\n", + "returns:\n", + "--------\n", + "root = real root\n", + "fx = func evaluated at root\n", + "ea = approximate relative error ( )\n", + "iter = number of iterations\n", + "\u001b[0;31mFile:\u001b[0m ~/Documents/UConn/ME3255/ME3255-CompMech/CompMech03-IVPs/notebooks/\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mod_secant?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What we've learned\n", + "\n", + "* How to find the 0 of a function, aka root-finding\n", + "* The difference between a bracketing and an open methods for finding roots\n", + "* Two bracketing methods: incremental search and bisection methods\n", + "* Two open methods: Newton-Raphson and modified secant methods\n", + "* How to measure relative error\n", + "* How to compare root-finding methods\n", + "* How to frame an engineering problem as a root-finding problem\n", + "* Solve an initial value problem with missing initial conditions (the shooting method)\n", + "\n", + "* _Bonus: In the Problems you'll consider stability of bracketing and open methods._\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# References\n", + "\n", + "1. Chapra, Steven _Applied Numerical Methods with Matlab for Engineers._ McGraw Hill. \n", + "\n", + "2. _Computational Physics with Python_, lecture notes by Eric Ayars, California State University, Chico. Available online on the author's website: https://physics.csuchico.edu/ayars/312/handouts/comp-phys-python.pdf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problems\n", + "\n", + "1. One of the main benefits of a bracketing method is the stability of solutions. Open methods are not always stable. Here is an example. One way engineers and data scientists model the probability of failure is with a [sigmoid function e.g. this Challenger O-ring case study](https://byuistats.github.io/M325_Hathaway/textbook/challengerLogisticReg.html)\n", + "\n", + "$$\\begin{equation}\n", + " \\sigma(T) = \\frac{e^{a_0-a_1 T}}{1+e^{a_0-a_1 T}}\n", + "\\end{equation}$$\n", + "\n", + "The Challenger explosion was a terrible incident that occurred due to the failure of an O-ring. The post-mortem data analysis showed that at low temperatures the O-rings were brittle and more likely to fail. We can use the function $\\sigma(T)$ to determine the point at which there is a 50\\% chance of O-ring failure. Using the pass-fail data, the two constants are\n", + "\n", + "$a_0 = 15.043$\n", + "\n", + "$a_1 = 0.232$\n", + "\n", + "a. Plot the function $\\sigma(T)$ for $T=0-100^{o}F$. Where do you see the function cross 50\\% (0.5)?\n", + "\n", + "b. Create two functions `f_T` and `dfdT` where `f_T`=$f(T)=\\sigma(T) - 0.5$ and `dfdT`=$\\frac{df}{dT}$\n", + "\n", + "c. Use the `incsearch` and `newtraph` functions to find the root of f(T). When does Newton-Raphson fail to converge? Why does it fail? _Hint: if you're stuck here, take a look at this [youtube video finding an interval of convergence for the Newton-Raphson method](https://youtu.be/zyXRo8Qjj0A). Look at the animation of how the method converges and diverges._" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. In the examples shown above, we determined the initial velocity after the first bounce by specifying the beginning y(0) and end y(T) for an object subject to gravity and drag. Repeat this analysis for the time period just after the second bounce and just before the third bounce. The indices are given below for t[1430:2051] = 1.43-2.05 seconds.\n", + "\n", + " a. What is the velocity just after the second bounce?\n", + "\n", + " b. What is the coefficient of restitution for the second bounce? _Hint: use the ratio of the last velocity from above to the initial velocity calculated here._\n" + ] + }, + { + "cell_type": "code", + "execution_count": 177, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4300000000009008 2.051000000004969\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 177, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "i0=1430\n", + "ie=2051\n", + "print(t[i0],t[ie])\n", + "plt.plot(t,y)\n", + "plt.plot(t[i0:ie],y[i0:ie],'s')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/06_roots-1.ipynb b/notebooks/06_roots-1.ipynb deleted file mode 100644 index 5a472ba..0000000 --- a/notebooks/06_roots-1.ipynb +++ /dev/null @@ -1,932 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "scrolled": true, - "slideshow": { - "slide_type": "skip" - } - }, - "outputs": [], - "source": [ - "%plot --format svg" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Roots of Nonlinear functions\n", - "## Bracketing ch. 5" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "## Not always possible to solve for a given variable. \n", - "\n", - "### Freefall example:\n", - "If an object, with drag coefficient of 0.25 kg/m reaches a velocity of 36 m/s after 4 seconds of freefalling, what is its mass?\n", - "\n", - "$v(t)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)$\n", - "\n", - "Cannot solve for m \n", - "\n", - "Instead, solve the problem by creating a new function f(m) where\n", - "\n", - "$f(m)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)-v(t)$. \n", - "\n", - "When f(m) = 0, we have solved for m in terms of the other variables (e.g. for a given time, velocity, drag coefficient and acceleration due to gravity)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "scrolled": true, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t-5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t60\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t80\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t100\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t120\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t140\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t160\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t180\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t200\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tgnuplot_plot_2a\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "setdefaults\n", - "g=9.81; % acceleration due to gravity\n", - "m=linspace(50, 200,100); % possible values for mass 50 to 200 kg\n", - "c_d=0.25; % drag coefficient\n", - "t=4; % at time = 4 seconds\n", - "v=36; % speed must be 36 m/s\n", - "f_m = @(m) sqrt(g*m/c_d).*tanh(sqrt(g*c_d./m)*t)-v; % anonymous function f_m\n", - "\n", - "plot(m,f_m(m),m,zeros(length(m),1))\n", - "axis([45 200 -5 1])" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "scrolled": true, - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ans = 0.045626\n" - ] - } - ], - "source": [ - "f_m(145)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "Brute force method is plot f_m vs m and with smaller and smaller steps until f_m ~ 0\n", - "\n", - "Better methods are the \n", - "1. Bracketing methods\n", - "2. Open methods\n", - "\n", - "Both need an initial guess. \n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Incremental method (Brute force)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "You know that for one value, m_lower, f_m is negative and for another value, m_upper, f_m is positive. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "^C\n" - ] - } - ], - "source": [ - "function xb = incsearch(func,xmin,xmax,ns)\n", - "% incsearch: incremental search root locator\n", - "% xb = incsearch(func,xmin,xmax,ns):\n", - "% finds brackets of x that contain sign changes\n", - "% of a function on an interval\n", - "% input:\n", - "% func = name of function\n", - "% xmin, xmax = endpoints of interval\n", - "% ns = number of subintervals (default = 50)\n", - "% output:\n", - "% xb(k,1) is the lower bound of the kth sign change\n", - "% xb(k,2) is the upper bound of the kth sign change\n", - "% If no brackets found, xb = [].\n", - "if nargin < 3, error('at least 3 arguments required'), end\n", - "if nargin < 4, ns = 50; end %if ns blank set to 50\n", - "% Incremental search\n", - "x = linspace(xmin,xmax,ns);\n", - "f = func(x);\n", - "nb = 0; xb = []; %xb is null unless sign change detected\n", - "for k = 1:length(x)-1\n", - " if sign(f(k)) ~= sign(f(k+1)) %check for sign change\n", - " nb = nb + 1;\n", - " xb(nb,1) = x(k);\n", - " xb(nb,2) = x(k+1);\n", - " end\n", - "end\n", - "if isempty(xb) %display that no brackets were found\n", - " fprintf('no brackets found\\n')\n", - " fprintf('check interval or increase ns\\n')\n", - "else\n", - " fprintf('number of brackets: %i\\n',nb) %display number of brackets\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "number of brackets: 1\n", - "ans =\n", - "\n", - " 141.84 144.90\n", - "\n" - ] - } - ], - "source": [ - "incsearch(f_m,50,200)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "scrolled": true, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "number of brackets: 1\n", - "ans =\n", - "\n", - " 142.73 142.83\n", - "\n" - ] - } - ], - "source": [ - "incsearch(f_m,140, 150,100)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Bisection method" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Divide interval in half until error is reduced to some level\n", - "\n", - "in previous example of freefall, choose x_l=50, x_u=200\n", - "\n", - "x_r = (50+200)/2 = 125\n", - "\n", - "f_m(125) = -0.408\n", - "\n", - "x_r= (125+200)/2 = 162.5\n", - "\n", - "f_m(162.5) = 0.3594\n", - "\n", - "x_r = (125+162.5)/2=143.75\n", - "\n", - "f_m(143.75)= 0.0206" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "scrolled": true, - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x_r = 134.38\n", - "interval left f(x_l)= -0.4,f(x_r)= -0.2\n", - "interval right f(x_r)= -0.2,f(x_u)= 0.0\n", - "ans = -0.18060\n" - ] - } - ], - "source": [ - "x_l=125; x_u=143.75;\n", - "x_r=(x_l+x_u)/2\n", - "fprintf('interval left f(x_l)= %1.1f,f(x_r)= %1.1f\\n',f_m(x_l),f_m(x_r))\n", - "fprintf('interval right f(x_r)= %1.1f,f(x_u)= %1.1f\\n',f_m(x_r),f_m(x_u))\n", - "f_m(x_r)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Bisect Function" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Much better root locator, with 4 iterations, our function is already close to zero\n", - "\n", - "Automate this with a function:\n", - "`bisect.m`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "^C\n" - ] - } - ], - "source": [ - "function [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,varargin)\n", - "% bisect: root location zeroes\n", - "% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):\n", - "% uses bisection method to find the root of func\n", - "% input:\n", - "% func = name of function\n", - "% xl, xu = lower and upper guesses\n", - "% es = desired relative error (default = 0.0001%)\n", - "% maxit = maximum allowable iterations (default = 50)\n", - "% p1,p2,... = additional parameters used by func\n", - "% output:\n", - "% root = real root\n", - "% fx = function value at root\n", - "% ea = approximate relative error (%)\n", - "% iter = number of iterations\n", - "if nargin<3,error('at least 3 input arguments required'),end\n", - "test = func(xl,varargin{:})*func(xu,varargin{:});\n", - "if test>0,error('no sign change'),end\n", - "if nargin<4|isempty(es), es=0.0001;end\n", - "if nargin<5|isempty(maxit), maxit=50;end\n", - "iter = 0; xr = xl; ea = 100;\n", - "while (1)\n", - " xrold = xr;\n", - " xr = (xl + xu)/2;\n", - " iter = iter + 1;\n", - " if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end\n", - " test = func(xl,varargin{:})*func(xr,varargin{:});\n", - " if test < 0\n", - " xu = xr;\n", - " elseif test > 0\n", - " xl = xr;\n", - " else\n", - " ea = 0;\n", - " end\n", - " if ea <= es | iter >= maxit,break,end\n", - "end\n", - "root = xr; fx = func(xr, varargin{:});" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mass_at_36ms = 142.74\n" - ] - } - ], - "source": [ - "Mass_at_36ms=bisect(f_m,50,200)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Thanks" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## False position (linear interpolation)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Rather than bisecting each bracket (1/2 each time) we can calculate the slope between the two points and update the xr position in this manner\n", - "\n", - "$ x_{r} = x_{u} - \\frac{f(x_{u})(x_{l}-x_{u})}{f(x_{l})-f(x_{u})}$" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "scrolled": true, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t-5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t-1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t50\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t100\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t150\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t200\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tgnuplot_plot_2a\n", - "\n", - "\t \n", - "\t\n", - "\n", - "\t\n", - "\tgnuplot_plot_3a\n", - "\n", - "\t \n", - "\t\n", - "\n", - "\t\n", - "\tgnuplot_plot_4a\n", - "\n", - "\t\t \n", - "\t\n", - "\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%xl=50; xu=200; \n", - "xu=xr;\n", - "xl=xl;\n", - "xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu));\n", - "plot(m,f_m(m),xl,f_m(xl),'s',xu,f_m(xu),'s',xr,0)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## False Position" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Much better root locator, with 4 iterations, our function is already close to zero\n", - "\n", - "Automate this with a function:\n", - "`falsepos.m`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "^C\n" - ] - } - ], - "source": [ - "function [root,fx,ea,iter]=falsepos(func,xl,xu,es,maxit,varargin)\n", - "% falsepos: root location zeroes\n", - "% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):\n", - "% uses false position method to find the root of func\n", - "% input:\n", - "% func = name of function\n", - "% xl, xu = lower and upper guesses\n", - "% es = desired relative error (default = 0.0001%)\n", - "% maxit = maximum allowable iterations (default = 50)\n", - "% p1,p2,... = additional parameters used by func\n", - "% output:\n", - "% root = real root\n", - "% fx = function value at root\n", - "% ea = approximate relative error (%)\n", - "% iter = number of iterations\n", - "if nargin<3,error('at least 3 input arguments required'),end\n", - "test = func(xl,varargin{:})*func(xu,varargin{:});\n", - "if test>0,error('no sign change'),end\n", - "if nargin<4|isempty(es), es=0.0001;end\n", - "if nargin<5|isempty(maxit), maxit=50;end\n", - "iter = 0; xr = xl; ea = 100;\n", - "while (1)\n", - " xrold = xr;\n", - " % xr = (xl + xu)/2; % bisect method\n", - " xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu)); % false position method\n", - " iter = iter + 1;\n", - " if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end\n", - " test = func(xl,varargin{:})*func(xr,varargin{:});\n", - " if test < 0\n", - " xu = xr;\n", - " elseif test > 0\n", - " xl = xr;\n", - " else\n", - " ea = 0;\n", - " end\n", - " if ea <= es | iter >= maxit,break,end\n", - "end\n", - "root = xr; fx = func(xr, varargin{:});" - ] - } - ], - "metadata": { - "celltoolbar": "Slideshow", - "kernelspec": { - "display_name": "Octave", - "language": "octave", - "name": "octave" - }, - "language_info": { - "file_extension": ".m", - "help_links": [ - { - "text": "GNU Octave", - "url": "https://www.gnu.org/software/octave/support.html" - }, - { - "text": "Octave Kernel", - "url": "https://github.com/Calysto/octave_kernel" - }, - { - "text": "MetaKernel Magics", - "url": "https://metakernel.readthedocs.io/en/latest/source/README.html" - } - ], - "mimetype": "text/x-octave", - "name": "octave", - "version": "5.1.0" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/07_roots_and_optimization-2.ipynb b/notebooks/07_roots_and_optimization-2.ipynb deleted file mode 100644 index 9c69bfe..0000000 --- a/notebooks/07_roots_and_optimization-2.ipynb +++ /dev/null @@ -1,1589 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "slideshow": { - "slide_type": "skip" - } - }, - "outputs": [], - "source": [ - "%plot --format svg" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "slideshow": { - "slide_type": "skip" - } - }, - "outputs": [], - "source": [ - "setdefaults" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Roots: Open methods\n", - "## Newton-Raphson" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "First-order approximation for the location of the root (i.e. assume the slope at the given point is constant, what is the solution when f(x)=0)\n", - "\n", - "$f'(x_{i})=\\frac{f(x_{i})-0}{x_{i}-x_{i+1}}$\n", - "\n", - "$x_{i+1}=x_{i}-\\frac{f(x_{i})}{f'(x_{i})}$\n", - "\n", - "Use Newton-Raphson to find solution when $e^{-x}=x$" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "Find x when $e^{-x}=x$" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x_r = 0.50000\n", - "error_approx = 1\n" - ] - } - ], - "source": [ - "f= @(x) exp(-x)-x;\n", - "df= @(x) -exp(-x)-1;\n", - "\n", - "x_i= 0;\n", - "x_r = x_i-f(x_i)/df(x_i)\n", - "error_approx = abs((x_r-x_i)/x_r)\n", - "x_i=x_r;\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x_r = 0.56714\n", - "error_approx = 0.0014673\n" - ] - } - ], - "source": [ - "x_r = x_i-f(x_i)/df(x_i)\n", - "error_approx = abs((x_r-x_i)/x_r)\n", - "x_i=x_r;" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x_r = 0.56714\n", - "error_approx = 2.2106e-07\n" - ] - } - ], - "source": [ - "x_r = x_i-f(x_i)/df(x_i)\n", - "error_approx = abs((x_r-x_i)/x_r)\n", - "x_i=x_r;" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x_r = 0.56714\n", - "error_approx = 5.0897e-15\n" - ] - } - ], - "source": [ - "x_r = x_i-f(x_i)/df(x_i)\n", - "error_approx = abs((x_r-x_i)/x_r)\n", - "x_i=x_r;" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Create function `newtraph.m`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "^C\n" - ] - } - ], - "source": [ - "function [root,ea,iter]=newtraph(func,dfunc,xr,es,maxit,varargin)\n", - "% newtraph: Newton-Raphson root location zeroes\n", - "% [root,ea,iter]=newtraph(func,dfunc,xr,es,maxit,p1,p2,...):\n", - "% uses Newton-Raphson method to find the root of func\n", - "% input:\n", - "% func = name of function\n", - "% dfunc = name of derivative of function\n", - "% xr = initial guess\n", - "% es = desired relative error (default = 0.0001%)\n", - "% maxit = maximum allowable iterations (default = 50)\n", - "% p1,p2,... = additional parameters used by function\n", - "% output:\n", - "% root = real root\n", - "% ea = approximate relative error (%)\n", - "% iter = number of iterations\n", - "if nargin<3,error('at least 3 input arguments required'),end\n", - "if nargin<4 || isempty(es),es=0.0001;end\n", - "if nargin<5 || isempty(maxit),maxit=50;end\n", - "iter = 0;\n", - "while (1)\n", - " xrold = xr;\n", - " xr = xr - func(xr)/dfunc(xr);\n", - " iter = iter + 1;\n", - " if xr ~= 0 \n", - " ea = abs((xr - xrold)/xr) * 100;\n", - " end\n", - " if ea <= es || iter >= maxit, break, end\n", - "end\n", - "root = xr;" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "In the freefall example, we created a function f(m) that when f(m)=0, then the mass had been chosen such that at t=4 s, the velocity is 36 m/s. \n", - "\n", - "$f(m)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)-v(t)$.\n", - "\n", - "to use the Newton-Raphson method, we need the derivative $\\frac{df}{dm}$\n", - "\n", - "$\\frac{df}{dm}=\\frac{1}{2}\\sqrt{\\frac{g}{mc_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)-\n", - "\\frac{g}{2m}\\mathrm{sech}^{2}(\\sqrt{\\frac{gc_{d}}{m}}t)$" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [], - "source": [ - "setdefaults\n", - "g=9.81; % acceleration due to gravity\n", - "m=linspace(50, 200,100); % possible values for mass 50 to 200 kg\n", - "c_d=0.25; % drag coefficient\n", - "t=4; % at time = 4 seconds\n", - "v=36; % speed must be 36 m/s\n", - "f_m = @(m) sqrt(g*m/c_d).*tanh(sqrt(g*c_d./m)*t)-v; % anonymous function f_m\n", - "df_m = @(m) 1/2*sqrt(g./m/c_d).*tanh(sqrt(g*c_d./m)*t)-g/2./m*sech(sqrt(g*c_d./m)*t).^2;" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "root = 142.74\n", - "ea = 1.8806e-04\n", - "iter = 50\n" - ] - } - ], - "source": [ - "[root,ea,iter]=newtraph(f_m,df_m,50,0.0001)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Thanks" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Secant Methods" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Not always able to evaluate the derivative. Approximation of derivative:\n", - "\n", - "$f'(x_{i})=\\frac{f(x_{i-1})-f(x_{i})}{x_{i-1}-x_{i}}$\n", - "\n", - "$x_{i+1}=x_{i}-\\frac{f(x_{i})}{f'(x_{i})}$\n", - "\n", - "$x_{i+1}=x_{i}-\\frac{f(x_{i})}{\\frac{f(x_{i-1})-f(x_{i})}{x_{i-1}-x_{i}}}=\n", - " x_{i}-\\frac{f(x_{i})(x_{i-1}-x_{i})}{f(x_{i-1})-f(x_{i})}$\n", - " \n", - "What values should $x_{i}$ and $x_{i-1}$ take?\n", - "\n", - "To reduce arbitrary selection of variables, use the" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Modified Secant method" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Change the x evaluations to a perturbation $\\delta$. \n", - "\n", - "$x_{i+1}=x_{i}-\\frac{f(x_{i})(\\delta x_{i})}{f(x_{i}+\\delta x_{i})-f(x_{i})}$" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "root = 142.74\n", - "ea = 3.0615e-07\n", - "iter = 7\n" - ] - } - ], - "source": [ - "[root,ea,iter]=mod_secant(f_m,1,50,0.00001)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ans = 1.1185e+04\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t10000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t15000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t20000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t25000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t30000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t5\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\t\tprinciple amount left ($)\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\ttime (years)\n", - "\t\n", - "\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "car_payments(400,30000,0.05,5,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Amt_numerical = 5467.0\n", - "ans = 3.9755e-04\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t100000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t200000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t300000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t400000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t500000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t600000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t700000\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t15\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t20\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t25\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t30\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\t\tprinciple amount left ($)\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\ttime (years)\n", - "\t\n", - "\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "Amt_numerical=mod_secant(@(A) car_payments(A,700000,0.0875,30,0),1e-6,50,0.001)\n", - "car_payments(Amt_numerical,700000,0.0875,30,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ans = 1.9681e+06\n" - ] - } - ], - "source": [ - "Amt_numerical*12*30" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Amortization\n", - "\n", - "Amortization calculation makes the same calculation for the monthly payment amount, A, paying off the principle amount, P, over n pay periods with monthly interest rate, r. " - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Amt = 566.14\n" - ] - } - ], - "source": [ - "% Amortization calculation\n", - "A = @(P,r,n) P*(r*(1+r)^n)./((1+r)^n-1);\n", - "Amt=A(30000,0.05/12,5*12)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Matlab's function\n", - "\n", - "Matlab and Octave combine bracketing and open methods in the `fzero` function. " - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "'fzero' is a function from the file /usr/share/octave/4.0.0/m/optimization/fzero.m\n", - "\n", - " -- Function File: fzero (FUN, X0)\n", - " -- Function File: fzero (FUN, X0, OPTIONS)\n", - " -- Function File: [X, FVAL, INFO, OUTPUT] = fzero (...)\n", - " Find a zero of a univariate function.\n", - "\n", - " FUN is a function handle, inline function, or string containing the\n", - " name of the function to evaluate.\n", - "\n", - " X0 should be a two-element vector specifying two points which\n", - " bracket a zero. In other words, there must be a change in sign of\n", - " the function between X0(1) and X0(2). More mathematically, the\n", - " following must hold\n", - "\n", - " sign (FUN(X0(1))) * sign (FUN(X0(2))) <= 0\n", - "\n", - " If X0 is a single scalar then several nearby and distant values are\n", - " probed in an attempt to obtain a valid bracketing. If this is not\n", - " successful, the function fails.\n", - "\n", - " OPTIONS is a structure specifying additional options. Currently,\n", - " 'fzero' recognizes these options: \"FunValCheck\", \"OutputFcn\",\n", - " \"TolX\", \"MaxIter\", \"MaxFunEvals\". For a description of these\n", - " options, see *note optimset: XREFoptimset.\n", - "\n", - " On exit, the function returns X, the approximate zero point and\n", - " FVAL, the function value thereof.\n", - "\n", - " INFO is an exit flag that can have these values:\n", - "\n", - " * 1 The algorithm converged to a solution.\n", - "\n", - " * 0 Maximum number of iterations or function evaluations has\n", - " been reached.\n", - "\n", - " * -1 The algorithm has been terminated from user output\n", - " function.\n", - "\n", - " * -5 The algorithm may have converged to a singular point.\n", - "\n", - " OUTPUT is a structure containing runtime information about the\n", - " 'fzero' algorithm. Fields in the structure are:\n", - "\n", - " * iterations Number of iterations through loop.\n", - "\n", - " * nfev Number of function evaluations.\n", - "\n", - " * bracketx A two-element vector with the final bracketing of the\n", - " zero along the x-axis.\n", - "\n", - " * brackety A two-element vector with the final bracketing of the\n", - " zero along the y-axis.\n", - "\n", - " See also: optimset, fsolve.\n", - "\n", - "Additional help for built-in functions and operators is\n", - "available in the online version of the manual. Use the command\n", - "'doc ' to search the manual index.\n", - "\n", - "Help and information about Octave is also available on the WWW\n", - "at http://www.octave.org and via the help@octave.org\n", - "mailing list.\n" - ] - } - ], - "source": [ - "help fzero" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ans = 563.79\n" - ] - } - ], - "source": [ - "fzero(@(A) car_payments(A,30000,0.05,5,0),500)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Comparison of Solvers\n", - "\n", - "It's helpful to compare to the convergence of different routines to see how quickly you find a solution. \n", - "\n", - "Comparing the freefall example\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "warning: axis: omitting non-positive data in log plot\n", - "warning: called from\n", - " __line__ at line 120 column 16\n", - " line at line 56 column 8\n", - " __plt__>__plt2vv__ at line 500 column 10\n", - " __plt__>__plt2__ at line 246 column 14\n", - " __plt__ at line 133 column 15\n", - " semilogy at line 60 column 10\n", - "warning: axis: omitting non-positive data in log plot\n", - "warning: axis: omitting non-positive data in log plot\n", - "warning: axis: omitting non-positive data in log plot\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-14\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-12\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-8\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-6\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t100\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t102\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t104\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t50\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t100\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t150\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t200\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t250\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t300\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t350\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t400\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\tnewton-raphson\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\tnewton-raphson\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tmod-secant\n", - "\n", - "\t\n", - "\t\tmod-secant\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tfalse point\n", - "\n", - "\t\n", - "\t\tfalse point\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tbisection\n", - "\n", - "\t\n", - "\t\tbisection\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "N=20;\n", - "iterations = linspace(1,400,N);\n", - "ea_nr=zeros(1,N); % appr error Newton-Raphson\n", - "ea_ms=zeros(1,N); % appr error Modified Secant\n", - "ea_fp=zeros(1,N); % appr error false point method\n", - "ea_bs=zeros(1,N); % appr error bisect method\n", - "for i=1:length(iterations)\n", - " [root_nr,ea_nr(i),iter_nr]=newtraph(f_m,df_m,300,0,iterations(i));\n", - " [root_ms,ea_ms(i),iter_ms]=mod_secant(f_m,1e-6,300,0,iterations(i));\n", - " [root_fp,ea_fp(i),iter_fp]=falsepos(f_m,1,300,0,iterations(i));\n", - " [root_bs,ea_bs(i),iter_bs]=bisect(f_m,1,300,0,iterations(i));\n", - "end\n", - "\n", - "setdefaults\n", - "semilogy(iterations,abs(ea_nr),iterations,abs(ea_ms),iterations,abs(ea_fp),iterations,abs(ea_bs))\n", - "legend('newton-raphson','mod-secant','false point','bisection')" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ea_nr =\n", - "\n", - " Columns 1 through 8:\n", - "\n", - " 6.36591 0.06436 0.00052 0.00000 0.00000 0.00000 0.00000 0.00000\n", - "\n", - " Columns 9 through 16:\n", - "\n", - " 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000\n", - "\n", - " Columns 17 through 20:\n", - "\n", - " 0.00000 0.00000 0.00000 0.00000\n", - "\n" - ] - } - ], - "source": [ - "ea_nr" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "warning: axis: omitting non-positive data in log plot\n", - "warning: called from\n", - " __line__ at line 120 column 16\n", - " line at line 56 column 8\n", - " __plt__>__plt2vv__ at line 500 column 10\n", - " __plt__>__plt2__ at line 246 column 14\n", - " __plt__ at line 133 column 15\n", - " semilogy at line 60 column 10\n", - "warning: axis: omitting non-positive data in log plot\n", - "warning: axis: omitting non-positive data in log plot\n", - "warning: axis: omitting non-positive data in log plot\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-14\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-12\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-8\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-6\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10-2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t100\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t102\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t104\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t20\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t30\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t40\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t50\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\tnewton-raphson\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\tnewton-raphson\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tmod-secant\n", - "\n", - "\t\n", - "\t\tmod-secant\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tfalse point\n", - "\n", - "\t\n", - "\t\tfalse point\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tbisection\n", - "\n", - "\t\n", - "\t\tbisection\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "N=20;\n", - "f= @(x) x^10-1;\n", - "df=@(x) 10*x^9;\n", - "iterations = linspace(1,50,N);\n", - "ea_nr=zeros(1,N); % appr error Newton-Raphson\n", - "ea_ms=zeros(1,N); % appr error Modified Secant\n", - "ea_fp=zeros(1,N); % appr error false point method\n", - "ea_bs=zeros(1,N); % appr error bisect method\n", - "for i=1:length(iterations)\n", - " [root_nr,ea_nr(i),iter_nr]=newtraph(f,df,0.5,0,iterations(i));\n", - " [root_ms,ea_ms(i),iter_ms]=mod_secant(f,1e-6,0.5,0,iterations(i));\n", - " [root_fp,ea_fp(i),iter_fp]=falsepos(f,0,5,0,iterations(i));\n", - " [root_bs,ea_bs(i),iter_bs]=bisect(f,0,5,0,iterations(i));\n", - "end\n", - " \n", - "semilogy(iterations,abs(ea_nr),iterations,abs(ea_ms),iterations,abs(ea_fp),iterations,abs(ea_bs))\n", - "legend('newton-raphson','mod-secant','false point','bisection')" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ea_nr =\n", - "\n", - " Columns 1 through 7:\n", - "\n", - " 99.03195 11.11111 11.11111 11.11111 11.11111 11.11111 11.11111\n", - "\n", - " Columns 8 through 14:\n", - "\n", - " 11.11111 11.11111 11.11111 11.11109 11.11052 11.10624 10.99684\n", - "\n", - " Columns 15 through 20:\n", - "\n", - " 8.76956 2.12993 0.00000 0.00000 0.00000 0.00000\n", - "\n", - "ans = 16.208\n" - ] - } - ], - "source": [ - "ea_nr\n", - "newtraph(f,df,0.5,0,12)" - ] - } - ], - "metadata": { - "celltoolbar": "Slideshow", - "kernelspec": { - "display_name": "Octave", - "language": "octave", - "name": "octave" - }, - "language_info": { - "file_extension": ".m", - "help_links": [ - { - "text": "GNU Octave", - "url": "https://www.gnu.org/software/octave/support.html" - }, - { - "text": "Octave Kernel", - "url": "https://github.com/Calysto/octave_kernel" - }, - { - "text": "MetaKernel Magics", - "url": "https://metakernel.readthedocs.io/en/latest/source/README.html" - } - ], - "mimetype": "text/x-octave", - "name": "octave", - "version": "5.1.0" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/18_initial_value_ode.ipynb b/notebooks/18_initial_value_ode.ipynb deleted file mode 100644 index 6c1eac5..0000000 --- a/notebooks/18_initial_value_ode.ipynb +++ /dev/null @@ -1,828 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "slideshow": { - "slide_type": "skip" - } - }, - "outputs": [], - "source": [ - "%plot --format svg" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "slideshow": { - "slide_type": "skip" - } - }, - "outputs": [], - "source": [ - "setdefaults" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Initial Value Problems (ODEs)\n", - "*Ch. 22*" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "## Euler's method \n", - "\n", - "$\\frac{dy}{dt}=f(t,y)$\n", - "\n", - "$y_{i+1}=y_{i}+\\int_{t_{i}}^{t_{i+1}}f(t,y)dt$\n", - "\n", - "$y_{i+1}\\approx y_{i}+f(t_{i},y_{i})h$\n", - "\n", - "The error of this method is:\n", - "\n", - "$E_{t}=\\frac{f'(t_i , y_i )}{2!}h^2 + \\cdots + O(h^{n+1})$\n", - "\n", - "or\n", - "\n", - "$E_{a}=O(h^2)$" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Example: Freefalling problem\n", - "\n", - "An object is falling and has a drag coefficient of 0.25 kg/m and mass of 60 kg\n", - "Define time from 0 to 12 seconds with `N` timesteps \n", - "function defined as `freefall`\n", - "\n", - "Using the Euler ODE solution results in a conditionally stable solution *(at some point the time steps are too large to solve the problem)*" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [], - "source": [ - "function [v_analytical,v_terminal,t]=freefall(N,tmax)\n", - " t=linspace(0,tmax,N)';\n", - " c=0.25; m=60; g=9.81; v_terminal=sqrt(m*g/c);\n", - "\n", - " v_analytical = v_terminal*tanh(g*t/v_terminal);\n", - " v_numerical=zeros(length(t),1);\n", - " delta_time =diff(t);\n", - " for i=1:length(t)-1\n", - " v_numerical(i+1)=v_numerical(i)+(g-c/m*v_numerical(i)^2)*delta_time(i);\n", - " end\n", - " % Print values near 0,2,4,6,8,10,12 seconds\n", - " indices = round(linspace(1,length(t),7));\n", - " fprintf('time (s)| error (m/s)\\n')\n", - " fprintf('-------------------------\\n')\n", - " M=[t(indices),abs(v_analytical(indices)-v_numerical(indices))];\n", - " fprintf('%7.1f | %10.2f\\n',M(:,1:2)');\n", - " plot(t,v_analytical,'-',t,v_numerical,'o-')\n", - " xlabel('time (s)')\n", - " ylabel('velocity (m/s)')\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "time (s)| error (m/s)\n", - "-------------------------\n", - " 0.0 | 0.00\n", - " 6.7 | 23.01\n", - " 6.7 | 23.01\n", - " 13.3 | 36.09\n", - " 13.3 | 36.09\n", - " 20.0 | 24.90\n", - " 20.0 | 24.90\n", - "\n", - "O(h^2)=44.44\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t20\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t30\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t40\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t50\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t60\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t70\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t80\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t15\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t20\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\t\tvelocity (m/s)\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\ttime (s)\n", - "\t\n", - "\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tgnuplot_plot_2a\n", - "\n", - "\t\t \n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "[v_an,v_t,t]=freefall(4,20);\n", - "fprintf('\\nO(h^2)=%1.2f',min(diff(t).^2))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Heun Method\n", - "\n", - "Increase accuracy with *predictor-corrector approach*\n", - "\n", - "$y_{i+1}=y_{i}^{m}+f(t_{i},y_{i})h$\n", - "\n", - "$y_{i+1}^{j}=y_{i}^{m}+\n", - "\\frac{f(t_{i},y_{i}^{m})+f(t_{i+1},y_{i+1}^{i-1})}{2}h$\n", - "\n", - "This is analagous to the trapezoidal rule\n", - "\n", - "$\\int_{t_{i}}^{t_{i+1}}f(t,y)dt=\\frac{f(t_{i},y_{i})+f(t_{i+1},y_{i+1})}{2}h$\n", - "\n", - "therefore the error is\n", - "\n", - "$E_{t}=\\frac{-f''(\\xi)}{12}h^3$" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "### Example with Heun's method\n", - "\n", - "Problem Statement. Use Heun’s method with iteration to integrate \n", - "\n", - "$y' = 4e^{0.8t} − 0.5y$\n", - "\n", - "from t = 0 to 4 with a step size of 1. The initial condition at t = 0 is y = 2. Employ a stopping criterion of 0.00001% to terminate the corrector iterations." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dy =\n", - "\n", - " 3\n", - " 0\n", - " 0\n", - " 0\n", - " 0\n", - "\n", - "y =\n", - "\n", - " 2\n", - " 5\n", - " 0\n", - " 0\n", - " 0\n", - "\n" - ] - } - ], - "source": [ - "yp=@(t,y) 4*exp(0.8*t)-0.5*y;\n", - "t=linspace(0,4,5)';\n", - "y=zeros(size(t));\n", - "dy=zeros(size(t));\n", - "dy_corr=zeros(size(t));\n", - "y(1)=2;\n", - "dy(1)=yp(t(1),y(1))\n", - "y(2)=y(1)+dy(1)*(t(2)-t(1))" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dy_corr =\n", - "\n", - " 4.70108\n", - " 0.00000\n", - " 0.00000\n", - " 0.00000\n", - " 0.00000\n", - "\n", - "y =\n", - "\n", - " 2.00000\n", - " 6.70108\n", - " 0.00000\n", - " 0.00000\n", - " 0.00000\n", - "\n" - ] - } - ], - "source": [ - "% improve estimate for y(2)\n", - "dy_corr(1)=(dy(1)+yp(t(2),y(2)))/2\n", - "y(2)=y(1)+dy_corr(1)*(t(2)-t(1))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### This process can be iterated until a desired tolerance is achieved" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [], - "source": [ - "yp=@(t,y) 4*exp(0.8*t)-0.5*y;\n", - "t=linspace(0,4,5)';\n", - "y=zeros(size(t));\n", - "dy=zeros(size(t));\n", - "dy_corr=zeros(size(t));\n", - "y(1)=2;\n", - "for i=1:length(t)-1\n", - " dy(i)=yp(t(i),y(i));\n", - " dy_corr(i)=yp(t(i),y(i));\n", - " y(i+1)=y(i)+dy_corr(i)*(t(i+1)-t(i));\n", - " n=0;\n", - " e=10;\n", - " while (1)\n", - " n=n+1;\n", - " yold=y(i+1);\n", - " dy_corr(i)=(dy(i)+yp(t(i+1),y(i+1)))/2;\n", - " y(i+1)=y(i)+dy_corr(i)*(t(i+1)-t(i));\n", - " e=abs(y(i+1)-yold)/y(i+1)*100;\n", - " if e<= 0.00001 | n>100, break, end\n", - " end\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "y_an =\n", - "\n", - "@(t) 4 / 1.3 * exp (0.8 * t) - 1.0769 * exp (-t / 2)\n", - "\n", - "dy_an =\n", - "\n", - "@(t) 0.8 * 4 / 1.3 * exp (0.8 * t) + 1.0769 / 2 * exp (-t / 2)\n", - "\n" - ] - } - ], - "source": [ - "\n", - "y_euler=zeros(size(t));\n", - "for i=1:length(t)-1\n", - " dy(i)=yp(t(i),y(i));\n", - " y_euler(i+1)=y_euler(i)+dy(i)*(t(i+1)-t(i));\n", - "end\n", - "\n", - "y_an =@(t) 4/1.3*exp(0.8*t)-1.0769*exp(-t/2)\n", - "dy_an=@(t) 0.8*4/1.3*exp(0.8*t)+1.0769/2*exp(-t/2)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t20\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t30\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t40\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t50\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t60\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t70\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t80\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\t\ty\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\ttime\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\tHeuns method\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\tHeuns method\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\n", - "\t\n", - "\tEuler\n", - "\n", - "\t\n", - "\t\tEuler\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\n", - "\t\n", - "\tanalytical\n", - "\n", - "\t\n", - "\t\tanalytical\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot(t,y,'o',t,y_euler,'s',linspace(min(t),max(t)),y_an(linspace(min(t),max(t))))\n", - "legend('Heuns method','Euler','analytical','Location','NorthWest')\n", - "xlabel('time')\n", - "ylabel('y')" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Thanks" - ] - } - ], - "metadata": { - "celltoolbar": "Slideshow", - "kernelspec": { - "display_name": "Octave", - "language": "octave", - "name": "octave" - }, - "language_info": { - "file_extension": ".m", - "help_links": [ - { - "text": "GNU Octave", - "url": "https://www.gnu.org/software/octave/support.html" - }, - { - "text": "Octave Kernel", - "url": "https://github.com/Calysto/octave_kernel" - }, - { - "text": "MetaKernel Magics", - "url": "https://metakernel.readthedocs.io/en/latest/source/README.html" - } - ], - "mimetype": "text/x-octave", - "name": "octave", - "version": "5.1.0" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/19_nonlinear_ivp.ipynb b/notebooks/19_nonlinear_ivp.ipynb deleted file mode 100644 index bd6e255..0000000 --- a/notebooks/19_nonlinear_ivp.ipynb +++ /dev/null @@ -1,3519 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "slideshow": { - "slide_type": "skip" - } - }, - "outputs": [], - "source": [ - "setdefaults" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "slideshow": { - "slide_type": "skip" - } - }, - "outputs": [], - "source": [ - "%plot --format svg" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "skip" - } - }, - "outputs": [], - "source": [ - "pkg load odepkg" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Initial Value Problems (continued)\n", - "*ch. 23 - Adaptive methods*" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Predator-Prey Models (Chaos Theory)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "source": [ - "Predator-prey models were developed independently in the early part of the twentieth\n", - "century by the Italian mathematician Vito Volterra and the American biologist Alfred\n", - "Lotka. These equations are commonly called Lotka-Volterra equations. The simplest version is the following pairs of ODEs:\n", - "\n", - "$\\frac{dx}{dt}=ax-bxy$\n", - "\n", - "$\\frac{dy}{dt}=-cy+dxy$\n", - "\n", - "where x and y = the number of prey and predators, respectively, a = the prey growth rate, c = the predator death rate, and b and d = the rates characterizing the effect of the predator-prey interactions on the prey death and the predator growth, respectively." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "```matlab\n", - "function yp=predprey(t,y,a,b,c,d)\n", - " % predator-prey model (Lotka-Volterra equations)\n", - " yp=zeros(1,2);\n", - " x=y(1); % population in thousands of prey\n", - " y=y(2); % population in thousands of predators\n", - " yp(1)=a.*x-b.*x.*y; % population change in thousands of prey/year\n", - " yp(2)=-c*y+d*x.*y; % population change in thousands of predators/year\n", - "end\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ans =\n", - "\n", - " 0\n", - " 19\n", - "\n" - ] - } - ], - "source": [ - "predprey(0,[20 1],1,1,1,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t6\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t15\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t20\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t25\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t30\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t35\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t40\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\t\tpopulation in thousands\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\ttime (years)\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\tEuler time plot\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\tprey\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\tprey\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tpredator\n", - "\n", - "\t\n", - "\t\tpredator\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "h=0.000625;tspan=[0 40];y0=[2 1];\n", - "a=1.2;b=0.6;c=0.8;d=0.3;\n", - "[t y] = eulode(@predprey,tspan,y0,h,a,b,c,d);\n", - "\n", - "plot(t,y(:,1),t,y(:,2),'--')\n", - "legend('prey','predator');\n", - "title('Euler time plot')\n", - "xlabel('time (years)')\n", - "ylabel('population in thousands')" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t0.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t6\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\t\tthousands of predators\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\tthousands of prey\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\tEuler phase plane plot\n", - "\t\n", - "\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot(y(:,1),y(:,2))\n", - "title('Euler phase plane plot')\n", - "xlabel('thousands of prey')\n", - "ylabel('thousands of predators')" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Fourth Order Runge-Kutte integration\n", - "\n", - "```matlab\n", - "function [tp,yp] = rk4sys(dydt,tspan,y0,h,varargin)\n", - "% rk4sys: fourth-order Runge-Kutta for a system of ODEs\n", - "% [t,y] = rk4sys(dydt,tspan,y0,h,p1,p2,...): integrates\n", - "% a system of ODEs with fourth-order RK method\n", - "% input:\n", - "% dydt = name of the M-file that evaluates the ODEs\n", - "% tspan = [ti, tf]; initial and final times with output\n", - "% generated at interval of h, or\n", - "% = [t0 t1 ... tf]; specific times where solution output\n", - "% y0 = initial values of dependent variables\n", - "% h = step size\n", - "% p1,p2,... = additional parameters used by dydt\n", - "% output:\n", - "% tp = vector of independent variable\n", - "% yp = vector of solution for dependent variables\n", - "if nargin<4,error('at least 4 input arguments required'), end\n", - "if any(diff(tspan)<=0),error('tspan not ascending order'), end\n", - "n = length(tspan);\n", - "ti = tspan(1);tf = tspan(n);\n", - "if n == 2\n", - " t = (ti:h:tf)'; n = length(t);\n", - " if t(n)h,hh = h;end\n", - " while(1)\n", - " if tt+hh>tend,hh = tend-tt;end\n", - " k1 = dydt(tt,y(i,:),varargin{:})';\n", - " ymid = y(i,:) + k1.*hh./2;\n", - " k2 = dydt(tt+hh/2,ymid,varargin{:})';\n", - " ymid = y(i,:) + k2*hh/2;\n", - " k3 = dydt(tt+hh/2,ymid,varargin{:})';\n", - " yend = y(i,:) + k3*hh;\n", - " k4 = dydt(tt+hh,yend,varargin{:})';\n", - " phi = (k1+2*(k2+k3)+k4)/6;\n", - " y(i+1,:) = y(i,:) + phi*hh;\n", - " tt = tt+hh;\n", - " i=i+1;\n", - " if tt>=tend,break,end\n", - " end\n", - " np = np+1; tp(np) = tt; yp(np,:) = y(i,:);\n", - " if tt>=tf,break,end\n", - "end\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t6\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t6\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t8\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\t\tpopulation in thousands\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\ttime (years)\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\tRK4 time plot\n", - "\t\n", - "\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tgnuplot_plot_2a\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "h=0.0625;tspan=[0 40];y0=[2 1];\n", - "a=1.2;b=0.6;c=0.8;d=0.3;\n", - "tspan=[0 10];\n", - "[t y] = rk4sys(@predprey,tspan,y0,h,a,b,c,d);\n", - "plot(t,y(:,1),t,y(:,2),'--')\n", - "title('RK4 time plot')\n", - "xlabel('time (years)')\n", - "ylabel('population in thousands')" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t0.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t6\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\t\tthousands of predators\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\tthousands of prey\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\tRK4 phase plane plot\n", - "\t\n", - "\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot(y(:,1),y(:,2))\n", - "title('RK4 phase plane plot')\n", - "xlabel('thousands of prey')\n", - "ylabel('thousands of predators')" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Adaptive Runge-Kutta Methods\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "'ode23' is a function from the file /home/ryan/octave/odepkg-0.8.5/ode23.m\n", - "\n", - " -- Function File: [] = ode23 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,\n", - " ...])\n", - " -- Command: [SOL] = ode23 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])\n", - " -- Command: [T, Y, [XE, YE, IE]] = ode23 (@FUN, SLOT, INIT, [OPT],\n", - " [PAR1, PAR2, ...])\n", - "\n", - " This function file can be used to solve a set of non-stiff ordinary\n", - " differential equations (non-stiff ODEs) or non-stiff differential\n", - " algebraic equations (non-stiff DAEs) with the well known explicit\n", - " Runge-Kutta method of order (2,3).\n", - "\n", - " If this function is called with no return argument then plot the\n", - " solution over time in a figure window while solving the set of ODEs\n", - " that are defined in a function and specified by the function handle\n", - " @FUN. The second input argument SLOT is a double vector that\n", - " defines the time slot, INIT is a double vector that defines the\n", - " initial values of the states, OPT can optionally be a structure\n", - " array that keeps the options created with the command 'odeset' and\n", - " PAR1, PAR2, ... can optionally be other input arguments of any type\n", - " that have to be passed to the function defined by @FUN.\n", - "\n", - " If this function is called with one return argument then return the\n", - " solution SOL of type structure array after solving the set of ODEs.\n", - " The solution SOL has the fields X of type double column vector for\n", - " the steps chosen by the solver, Y of type double column vector for\n", - " the solutions at each time step of X, SOLVER of type string for the\n", - " solver name and optionally the extended time stamp information XE,\n", - " the extended solution information YE and the extended index\n", - " information IE all of type double column vector that keep the\n", - " informations of the event function if an event function handle is\n", - " set in the option argument OPT.\n", - "\n", - " If this function is called with more than one return argument then\n", - " return the time stamps T, the solution values Y and optionally the\n", - " extended time stamp information XE, the extended solution\n", - " information YE and the extended index information IE all of type\n", - " double column vector.\n", - "\n", - " For example, solve an anonymous implementation of the Van der Pol\n", - " equation\n", - "\n", - " fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];\n", - "\n", - " vopt = odeset (\"RelTol\", 1e-3, \"AbsTol\", 1e-3, \\\n", - " \"NormControl\", \"on\", \"OutputFcn\", @odeplot);\n", - " ode23 (fvdb, [0 20], [2 0], vopt);\n", - "\n", - "See also: odepkg.\n", - "\n", - "Additional help for built-in functions and operators is\n", - "available in the online version of the manual. Use the command\n", - "'doc ' to search the manual index.\n", - "\n", - "Help and information about Octave is also available on the WWW\n", - "at http://www.octave.org and via the help@octave.org\n", - "mailing list.\n" - ] - } - ], - "source": [ - "help ode23" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t0.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3.5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t1\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t3\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t5\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t6\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\t\tthousands of predators\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\tthousands of prey\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\tPhase plot: ode23- vs ode45--\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\tode23\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\tode23\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\n", - "\t\n", - "\tode45\n", - "\n", - "\t\n", - "\t\tode45\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "h=0.00625;tspan=[0 40];y0=[2 1];\n", - "a=1.2;b=0.6;c=0.8;d=0.3;\n", - "\n", - "[t23 y23] = ode23(@(t,y) predprey(t,y,a,b,c,d),tspan,y0);\n", - "[t45,y45] = ode45(@(t,y) predprey(t,y,a,b,c,d),tspan,y0);\n", - "plot(y23(:,1),y23(:,2),'.',y45(:,1),y45(:,2),'k-')\n", - "title('Phase plot: ode23- vs ode45--')\n", - "xlabel('thousands of prey')\n", - "ylabel('thousands of predators')\n", - "legend('ode23','ode45')" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Thanks" - ] - } - ], - "metadata": { - "celltoolbar": "Slideshow", - "kernelspec": { - "display_name": "Octave", - "language": "octave", - "name": "octave" - }, - "language_info": { - "file_extension": ".m", - "help_links": [ - { - "text": "GNU Octave", - "url": "https://www.gnu.org/software/octave/support.html" - }, - { - "text": "Octave Kernel", - "url": "https://github.com/Calysto/octave_kernel" - }, - { - "text": "MetaKernel Magics", - "url": "https://metakernel.readthedocs.io/en/latest/source/README.html" - } - ], - "mimetype": "text/x-octave", - "name": "octave", - "version": "5.1.0" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/Projectile_Motion.mp4 b/notebooks/Projectile_Motion.mp4 deleted file mode 100644 index 5a910d6..0000000 Binary files a/notebooks/Projectile_Motion.mp4 and /dev/null differ diff --git a/notebooks/eulode.m b/notebooks/eulode.m deleted file mode 100644 index ceed97b..0000000 --- a/notebooks/eulode.m +++ /dev/null @@ -1,29 +0,0 @@ -function [t,y] = eulode(dydt,tspan,y0,h,varargin) -% eulode: Euler ODE solver -% [t,y] = eulode(dydt,tspan,y0,h,p1,p2,...): -% uses Euler's method to integrate an ODE -% input: -% dydt = name of the M-file that evaluates the ODE -% tspan = [ti, tf] where ti and tf = initial and -% final values of independent variable -% y0 = initial value of dependent variable -% h = step size -% p1,p2,... = additional parameters used by dydt -% output: -% t = vector of independent variable -% y = vector of solution for dependent variable -if nargin<4,error('at least 4 input arguments required'),end -ti = tspan(1);tf = tspan(2); -if ~(tf>ti),error('upper limit must be greater than lower'),end -t = (ti:h:tf)'; n = length(t); -% if necessary, add an additional value of t -% so that range goes from t = ti to tf -if t(n)h,hh = h;end - while(1) - if tt+hh>tend,hh = tend-tt;end - k1 = dydt(tt,y(i,:),varargin{:})'; - ymid = y(i,:) + k1.*hh./2; - k2 = dydt(tt+hh/2,ymid,varargin{:})'; - ymid = y(i,:) + k2*hh/2; - k3 = dydt(tt+hh/2,ymid,varargin{:})'; - yend = y(i,:) + k3*hh; - k4 = dydt(tt+hh,yend,varargin{:})'; - phi = (k1+2*(k2+k3)+k4)/6; - y(i+1,:) = y(i,:) + phi*hh; - tt = tt+hh; - i=i+1; - if tt>=tend,break,end - end - np = np+1; tp(np) = tt; yp(np,:) = y(i,:); - if tt>=tf,break,end -end \ No newline at end of file