Exercises 9.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.1: Demostrate the magic of inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Line:\n",
    "    def draw(self):\n",
    "        pass\n",
    "    \n",
    "class Parabola(Line):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'draw']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(Parabola)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.2: Make polynomial subclasses of parabolas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parabola(object):\n",
    "    def __init__(self, c0, c1, c2):\n",
    "        self.c0 = c0\n",
    "        self.c1 = c1\n",
    "        self.c2 = c2\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        print(\"in \")\n",
    "        return self.c2*x**2 + self.c1*x + self.c0\n",
    "    \n",
    "    def table(self, L, R, n):\n",
    "        \"\"\"Return a table with n points for L <= x <= R.\"\"\"\n",
    "        s = \"\"\n",
    "        import numpy as np\n",
    "        for x in np.linspace(L, R, n):\n",
    "            y = self(x)\n",
    "            s += \"%12g %12g\\n\" % (x, y)\n",
    "        return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cubic(Parabola):\n",
    "    def __init__(self, c0, c1, c2, c3):\n",
    "        super().__init__(c0, c1, c2)\n",
    "        self.c3 = c3\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        return super().__call__(x) + (self.c3 * x**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in \n",
      "in \n",
      "in \n",
      "in \n",
      "in \n",
      "in \n",
      "in \n",
      "in \n",
      "in \n",
      "in \n",
      "           0            1\n",
      "    0.555556      3.72291\n",
      "     1.11111      12.4129\n",
      "     1.66667      31.1852\n",
      "     2.22222       64.155\n",
      "     2.77778      115.438\n",
      "     3.33333      189.148\n",
      "     3.88889      289.402\n",
      "     4.44444      420.314\n",
      "           5          586\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(Cubic(1, 2, 3, 4).table(0, 5, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parabola(object):\n",
    "    def __init__(self, c0, c1, c2):\n",
    "        self.c0 = c0\n",
    "        self.c1 = c1\n",
    "        self.c2 = c2\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        print(\"Parabola.__call__\")\n",
    "        return self.c2*x**2 + self.c1*x + self.c0\n",
    "    \n",
    "    def table(self, L, R, n):\n",
    "        \"\"\"Return a table with n points for L <= x <= R.\"\"\"\n",
    "        s = \"\"\n",
    "        import numpy as np\n",
    "        for x in np.linspace(L, R, n):\n",
    "            y = self(x)\n",
    "            s += \"%12g %12g\\n\" % (x, y)\n",
    "        return sv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cubic(Parabola):\n",
    "    def __init__(self, c0, c1, c2, c3):\n",
    "        super().__init__(c0, c1, c2)\n",
    "        self.c3 = c3\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        print(\"Cubic.__call__\")\n",
    "        return super().__call__(x) + (self.c3 * x**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Poly4(Cubic):\n",
    "    def __init__(self, c0, c1, c2, c3, c4):\n",
    "        super().__init__(c0, c1, c2, c3)\n",
    "        self.c4 = c4\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        print(\"Poly4.__call__\")\n",
    "        return super().__call__(x) + (self.c4 * x**4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Poly4.__call__\n",
      "Cubic.__call__\n",
      "Parabola.__call__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2.6640000000000006"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Poly4(1, 2, 3, 4, 5)(0.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.3: Implement a class for a function as a subclass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class F(Parabola):\n",
    "    def __init__(self, A, omega, c0, c1, c2):\n",
    "        super().__init__(c0, c1, c2)\n",
    "        self.A, self.omega = A, omega\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        from math import sin\n",
    "        return self.A*sin(self.omega * x) + super().__call__(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parabola.__call__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2556.4056618765553"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = F(1, 2, 3, 4, 5)\n",
    "f(22.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "152 ns ± 2.3 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n",
      "1.59 µs ± 21.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "\n",
    "%timeit math.sin(2.415123452)\n",
    "%timeit np.sin(2.415123452)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.4: Create an alternative class hierarchy for polynomials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Polynomial(object):\n",
    "    def __init__(self, coefficients):\n",
    "        self.coeff = coefficients\n",
    "    \n",
    "    def __call__(self, x):\n",
    "        \"\"\"Evaluate the polynomial.\"\"\"\n",
    "        s=0\n",
    "        for i in range(len(self.coeff)):\n",
    "            s += self.coeff[i]*x**i\n",
    "        return s\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        \"\"\"Return self + other as Polynomial object.\"\"\"\n",
    "        if len(self.coeff) > len(other.coeff):\n",
    "            result_coeff = self.coeff[:]  # copy!\n",
    "            for i in range(len(other.coeff)):\n",
    "                result_coeff[i] += other.coeff[i]\n",
    "        else:\n",
    "            result_coeff = other.coeff[:] # copy!\n",
    "            for i in range(len(self.coeff)):\n",
    "                result_coeff[i] += self.coeff[i]\n",
    "        return Polynomial(result_coeff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parabola(Polynomial):\n",
    "    def __init__(self, a, b, c):\n",
    "        super().__init__([a, b, c])\n",
    "        \n",
    "class Line(Parabola):\n",
    "    def __init__(self, a, b):\n",
    "        super().__init__(a, b, 0)\n",
    "        del self.coeff[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(1, 2)(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.5: Make circle a subclass of an ellipse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ellipse:\n",
    "    from math import pi, sqrt\n",
    "    \n",
    "    def __init__(self, pos, a, b):\n",
    "        self.pos, self.a, self.b = pos, a, b\n",
    "\n",
    "    def area(self):\n",
    "        return pi * self.a * self.b\n",
    "    \n",
    "    def circumference(self):\n",
    "        return pi * (3/2*(a + b) - sqrt(a * b))\n",
    "    \n",
    "class Circle(Ellipse):\n",
    "    def __init__(self, pos, R):\n",
    "        super().__init__(pos, R, R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.6: Make super- and subclass for a point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x, self.y = x, y\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"%g, %g\" % (self.x, self.y)\n",
    "    \n",
    "class PolarPoint(Point):\n",
    "    from math import sin, cos\n",
    "    \n",
    "    def __init__(self, r, theta):\n",
    "        self.r, self.theta = r, theta\n",
    "        super().__init__(r * cos(theta), r * sin(theta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.7: Modify a function class by subclassing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import exp, sin\n",
    "class F:\n",
    "    def __init__(self, a, b):\n",
    "        self.a, self.b = a, b\n",
    "        \n",
    "    def __call__(self, t):\n",
    "        return exp(-self.a * t) * sin(self.b * t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fb(F):\n",
    "    def __init__(self, a, t):\n",
    "        self.a, self.t = a, t\n",
    "        \n",
    "    def __call__(self, b):\n",
    "        self.b = b\n",
    "        return super().__call__(self.t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.4482611891511404e-05"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Fb(t=2, a=4.5)(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.8: Explore the accuracy of difference formulas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from package.Diff2 import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu = 1\n",
    "v = lambda x: (1 - exp(x / mu)) / (1 - exp(1 / mu))\n",
    "dvdx = lambda x: exp(x / mu) / (mu * (exp(1 / mu) - 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.figure()\n",
    "\n",
    "x = np.linspace(-0.2, 1.005, 200)\n",
    "plt.plot(x, [v(x) for x in x], label=\"$\\mu = 1$\")\n",
    "mu = 0.01\n",
    "plt.plot(x, [v(x) for x in x], label=\"$\\mu = 0.01$\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+------+-----+-------------------------+\n",
      "|   Method  |  mu  |  x  |          Error          |\n",
      "+-----------+------+-----+-------------------------+\n",
      "| Backward1 |  1   |  0  |  2.909873501266702e-06  |\n",
      "| Backward1 |  1   | 0.9 |  7.157121372003417e-06  |\n",
      "| Backward1 | 0.01 |  0  |  1.859418130432611e-45  |\n",
      "| Backward1 | 0.01 | 0.9 |  2.269240054773858e-06  |\n",
      "|  Forward1 |  1   |  0  | -2.9098875877764385e-06 |\n",
      "|  Forward1 |  1   | 0.9 | -7.1571506179424205e-06 |\n",
      "|  Forward1 | 0.01 |  0  | -1.8606581558666612e-45 |\n",
      "|  Forward1 | 0.01 | 0.9 | -2.2707533000347266e-06 |\n",
      "|  Forward3 |  1   |  0  |  4.802269693016115e-12  |\n",
      "|  Forward3 |  1   | 0.9 |  2.4234836359937617e-11 |\n",
      "|  Forward3 | 0.01 |  0  |  3.1003034235195763e-52 |\n",
      "|  Forward3 | 0.01 | 0.9 |  4.3220895612483545e-13 |\n",
      "|  Central2 |  1   |  0  |  -7.043254868221993e-12 |\n",
      "|  Central2 |  1   | 0.9 | -1.4622969501942862e-11 |\n",
      "|  Central2 | 0.01 |  0  |  -6.200127167064711e-49 |\n",
      "|  Central2 | 0.01 | 0.9 |  -7.566226300007028e-10 |\n",
      "|  Central4 |  1   |  0  |  3.1870062144889744e-12 |\n",
      "|  Central4 |  1   | 0.9 |  1.3132606113686052e-11 |\n",
      "|  Central4 | 0.01 |  0  |  1.0068340878357098e-55 |\n",
      "|  Central4 | 0.01 | 0.9 |  5.3811989586538544e-14 |\n",
      "|  Central6 |  1   |  0  |  3.4023894812662547e-12 |\n",
      "|  Central6 |  1   | 0.9 |  1.5538015318838916e-11 |\n",
      "|  Central6 | 0.01 |  0  | -2.2940523520307313e-56 |\n",
      "|  Central6 | 0.01 | 0.9 |  5.795624397064714e-14  |\n",
      "+-----------+------+-----+-------------------------+\n"
     ]
    }
   ],
   "source": [
    "from prettytable import PrettyTable\n",
    "t = PrettyTable([\"Method\", \"mu\", \"x\", \"Error\"])\n",
    "for method in Backward1, Forward1, Forward3, Central2, Central4, Central6:\n",
    "    for mu in 1, 0.01:\n",
    "        for x in 0, 0.9:\n",
    "            t.add_row([method.__name__, mu, x, method(v, dfdx_exact=dvdx).error(x)])\n",
    "\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| Method    |   mu |   x |        Error |\n",
      "|-----------+------+-----+--------------|\n",
      "| Backward1 | 1    | 0   |  2.90987e-06 |\n",
      "| Backward1 | 1    | 0.9 |  7.15712e-06 |\n",
      "| Backward1 | 0.01 | 0   |  1.85942e-45 |\n",
      "| Backward1 | 0.01 | 0.9 |  2.26924e-06 |\n",
      "| Forward1  | 1    | 0   | -2.90989e-06 |\n",
      "| Forward1  | 1    | 0.9 | -7.15715e-06 |\n",
      "| Forward1  | 0.01 | 0   | -1.86066e-45 |\n",
      "| Forward1  | 0.01 | 0.9 | -2.27075e-06 |\n",
      "| Forward3  | 1    | 0   |  4.80227e-12 |\n",
      "| Forward3  | 1    | 0.9 |  2.42348e-11 |\n",
      "| Forward3  | 0.01 | 0   |  3.1003e-52  |\n",
      "| Forward3  | 0.01 | 0.9 |  4.32209e-13 |\n",
      "| Central2  | 1    | 0   | -7.04325e-12 |\n",
      "| Central2  | 1    | 0.9 | -1.4623e-11  |\n",
      "| Central2  | 0.01 | 0   | -6.20013e-49 |\n",
      "| Central2  | 0.01 | 0.9 | -7.56623e-10 |\n",
      "| Central4  | 1    | 0   |  3.18701e-12 |\n",
      "| Central4  | 1    | 0.9 |  1.31326e-11 |\n",
      "| Central4  | 0.01 | 0   |  1.00683e-55 |\n",
      "| Central4  | 0.01 | 0.9 |  5.3812e-14  |\n",
      "| Central6  | 1    | 0   |  3.40239e-12 |\n",
      "| Central6  | 1    | 0.9 |  1.5538e-11  |\n",
      "| Central6  | 0.01 | 0   | -2.29405e-56 |\n",
      "| Central6  | 0.01 | 0.9 |  5.79562e-14 |\n"
     ]
    }
   ],
   "source": [
    "from tabulate import tabulate\n",
    "t = []\n",
    "for method in Backward1, Forward1, Forward3, Central2, Central4, Central6:\n",
    "    for mu in 1, 0.01:\n",
    "        for x in 0, 0.9:\n",
    "            t.append([method.__name__, mu, x, method(v, dfdx_exact=dvdx).error(x)])\n",
    "\n",
    "print(tabulate(t, [\"Method\", \"mu\", \"x\", \"Error\"], tablefmt='orgtbl'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.9: Implement a subclass    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FuncWithDerivatives(object):\n",
    "    def __init__(self, h=1.0E-5):\n",
    "        self.h = h  # spacing for numerical derivatives\n",
    "\n",
    "    def __call__(self, x):\n",
    "        raise NotImplementedError\\\n",
    "        (\"___call__ missing in class %s\" % self.__class__.__name__)\n",
    "    \n",
    "    def df(self, x):\n",
    "        \"\"\"Return the 1st derivative of self.f.\"\"\"\n",
    "        # Compute first derivative by a finite difference\n",
    "        h = self.h\n",
    "        return (self(x+h) - self(x-h))/(2.0*h)\n",
    "    \n",
    "    def ddf(self, x):\n",
    "        \"\"\"Return the 2nd derivative of self.f.\"\"\"\n",
    "        # Compute second derivative by a finite difference:\n",
    "        h = self.h\n",
    "        return (self(x+h) - 2*self(x) + self(x-h))/(float(h)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sin\n",
    "class Sine1(FuncWithDerivatives):\n",
    "    def __call__(self, x):\n",
    "        return sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sin, cos\n",
    "class Sine2:\n",
    "    def __call__(self, x):\n",
    "        return sin(x)\n",
    "    \n",
    "    def df(self, x):\n",
    "        return cos(x)\n",
    "    \n",
    "    def ddf(self, x):\n",
    "        return -sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method       x        f(x)\n",
      "---------  ---  ----------\n",
      "Sine1      0.1   0.0998334\n",
      "Sine2      0.1   0.0998334\n",
      "Sine1.df   0.1   0.995004\n",
      "Sine2.df   0.1   0.995004\n",
      "Sine1.ddf  0.1  -0.0998333\n",
      "Sine2.ddf  0.1  -0.0998334\n",
      "Sine1      1.1   0.891207\n",
      "Sine2      1.1   0.891207\n",
      "Sine1.df   1.1   0.453596\n",
      "Sine2.df   1.1   0.453596\n",
      "Sine1.ddf  1.1  -0.891208\n",
      "Sine2.ddf  1.1  -0.891207\n"
     ]
    }
   ],
   "source": [
    "print(tabulate([\n",
    "    [\"Sine1\", 0.1, Sine1()(0.1)],\n",
    "    [\"Sine2\", 0.1, Sine2()(0.1)],\n",
    "    [\"Sine1.df\", 0.1, Sine1().df(0.1)],\n",
    "    [\"Sine2.df\", 0.1, Sine2().df(0.1)],\n",
    "    [\"Sine1.ddf\", 0.1, Sine1().ddf(0.1)],\n",
    "    [\"Sine2.ddf\", 0.1, Sine2().ddf(0.1)],\n",
    "    [\"Sine1\", 1.1, Sine1()(1.1)],\n",
    "    [\"Sine2\", 1.1, Sine2()(1.1)],\n",
    "    [\"Sine1.df\", 1.1, Sine1().df(1.1)],\n",
    "    [\"Sine2.df\", 1.1, Sine2().df(1.1)],\n",
    "    [\"Sine1.ddf\", 1.1, Sine1().ddf(1.1)],\n",
    "    [\"Sine2.ddf\", 1.1, Sine2().ddf(1.1)]\n",
    "], [\"Method\", \"x\", \"f(x)\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sine1.df', 0.1, 0.9950041652613538]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"Sine1.df\", 0.1, Sine1().df(0.1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.10: Make classes for numerical differentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Derivative:\n",
    "    def __init__(self, f, h=1e-6):\n",
    "        self.f, self.h = f, h\n",
    "\n",
    "class Central(Derivative):\n",
    "    def __call__(self, x):\n",
    "        f, h = self.f, self.h\n",
    "        return (f(x + h) - f(x - h)) / 2/h\n",
    "    \n",
    "    \n",
    "class Forward(Derivative):\n",
    "    def __call__(self, x):\n",
    "        f, h = self.f, self.h\n",
    "        return (f(x + h) - f(x)) / h\n",
    "    \n",
    "    \n",
    "class Backward(Derivative):\n",
    "    def __call__(self, x):\n",
    "        f, h = self.f, self.h\n",
    "        return (f(x) - f(x - h)) / h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.11: Implement a new subclass for differentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for (exp(-t))' at t=0:\n",
      "\n",
      "Method               h        Error\n",
      "---------  -----------  -----------\n",
      "Backward1  1            0.718282\n",
      "Backward2  1            0.757964\n",
      "Backward1  0.5          0.297443\n",
      "Backward2  0.5          0.123397\n",
      "Backward1  0.25         0.136102\n",
      "Backward2  0.25         0.0252392\n",
      "Backward1  0.125        0.0651876\n",
      "Backward2  0.125        0.00572642\n",
      "Backward1  0.0625       0.0319113\n",
      "Backward2  0.0625       0.00136494\n",
      "Backward1  0.03125      0.015789\n",
      "Backward2  0.03125      0.000333263\n",
      "Backward1  0.015625     0.00785335\n",
      "Backward2  0.015625     8.23409e-05\n",
      "Backward1  0.0078125    0.00391644\n",
      "Backward2  0.0078125    2.04647e-05\n",
      "Backward1  0.00390625   0.00195567\n",
      "Backward2  0.00390625   5.10119e-06\n",
      "Backward1  0.00195312   0.000977199\n",
      "Backward2  0.00195312   1.27343e-06\n",
      "Backward1  0.000976562  0.00048844\n",
      "Backward2  0.000976562  3.18124e-07\n",
      "Backward1  0.000488281  0.00024418\n",
      "Backward2  0.000488281  7.95017e-08\n",
      "Backward1  0.000244141  0.00012208\n",
      "Backward2  0.000244141  1.98725e-08\n",
      "Backward1  0.00012207   6.10376e-05\n",
      "Backward2  0.00012207   4.96948e-09\n",
      "Backward1  6.10352e-05  3.05182e-05\n",
      "Backward2  6.10352e-05  1.23691e-09\n"
     ]
    }
   ],
   "source": [
    "from itertools import chain\n",
    "\n",
    "class Backward2(Diff):\n",
    "    def __call__(self, x):\n",
    "        f, h = self.f, self.h\n",
    "        return (f(x - 2*h) - 4*f(x - h) + 3*f(x)) / (2 * h)\n",
    "    \n",
    "print(\"Accuracy for (exp(-t))' at t=0:\\n\")\n",
    "print(tabulate([(method.__name__, h, abs(-1 - method(lambda x: exp(-x), h=h)(0)))\n",
    "                for method, h in zip(15*[Backward1, Backward2], \n",
    "                                     chain.from_iterable((2**(-k), 2**(-k)) for k in range(15)))\n",
    "], [\"Method\", \"h\", \"Error\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.12: Understand if a class can be used recursively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48.00000397171544"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x: x**4\n",
    "ddf = Central2(Central2(f).__call__)(2)\n",
    "ddf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 * 2**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.13: Represent people by a class hierarchy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------  -------------\n",
      "name      Anthony\n",
      "birthday  1971-01-11\n",
      "company   Grocery Store\n",
      "area      Logistics\n",
      "--------  -------------\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, birthday=\"\", **kwargs):\n",
    "        self.name, self.birthday = name, birthday\n",
    "        \n",
    "class Worker(Person):\n",
    "    def __init__(self, name, company=\"\", **kwargs):\n",
    "        super().__init__(name, **kwargs)\n",
    "        self.company = company\n",
    "        \n",
    "class Scientist(Worker):\n",
    "    def __init__(self, name, area=\"\", **kwargs):\n",
    "        super().__init__(name, **kwargs)\n",
    "        self.area = area\n",
    "        \n",
    "s = Scientist(name=\"Anthony\", birthday=\"1971-01-11\", company=\"Grocery Store\", area=\"Logistics\")\n",
    "print(tabulate([(a, eval('s.' + a)) for a in s.__dir__()[:4]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.14: Add a new class in a class hierarchy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Integrator(object):\n",
    "    def __init__(self, a, b, n):\n",
    "        self.a, self.b, self.n = a, b, n\n",
    "        self.points, self.weights = self.construct_method()\n",
    "\n",
    "    def construct_method(self):\n",
    "        raise NotImplementedError('no rule in class %s' %\n",
    "                                  self.__class__.__name__)\n",
    "\n",
    "    def integrate(self, f):\n",
    "        s = 0\n",
    "        for i in range(len(self.weights)):\n",
    "            s += self.weights[i]*f(self.points[i])\n",
    "        return s\n",
    "\n",
    "    def vectorized_integrate(self, f):\n",
    "        return np.dot(self.weights, f(self.points))\n",
    "    \n",
    "    \n",
    "class MCint(Integrator):\n",
    "    def construct_method(self):\n",
    "        a, b, n = self.a, self.b, self.n\n",
    "        h = (b - a) / n\n",
    "        x = np.random.uniform(a, b, n)\n",
    "        w = n*[h]\n",
    "        return x, w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5488135  0.71518937 0.60276338]\n",
      "0.16145042469863546\n",
      "1.2445108309142587\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "i = MCint(0, 1, 3)\n",
    "print(i.points)\n",
    "print(sum(f(p)/3 for p in i.points))\n",
    "print(i.integrate(lambda x: 2*x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      n        Error\n",
      "-------  -----------\n",
      "      1  1.11041\n",
      "     10  0.21277\n",
      "    100  0.0293739\n",
      "   1000  0.0328792\n",
      "  10000  0.00193093\n",
      " 100000  0.0036776\n",
      "1000000  9.35153e-06\n"
     ]
    }
   ],
   "source": [
    "from math import sin, pi\n",
    "f = lambda x: sin(x)\n",
    "print(tabulate([\n",
    "    (n, abs(2 - MCint(0, pi, n).integrate(f))) for n in [1, 10, 100, 1000, 10000, 100000, 1000000]\n",
    "], [\"n\", \"Error\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.15: Compute convergence rates of numerical integration methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from package.integrate import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method          n          r         C\n",
      "-----------  ----  ---------  --------\n",
      "Midpoint        5   -2.02938  0.872319\n",
      "Midpoint        9   -2.00804  0.840112\n",
      "Midpoint       17   -2.00212  0.828246\n",
      "Midpoint       33   -2.00055  0.824255\n",
      "Midpoint       65   -2.00014  0.822998\n",
      "Midpoint      129   -2.00003  0.822621\n",
      "Midpoint      257   -2.00001  0.82251\n",
      "Midpoint      513   -2        0.822479\n",
      "Midpoint     1025   -2        0.82247\n",
      "Midpoint     2049   -2        0.822467\n",
      "Trapezoidal     5   -2.61526  6.99074\n",
      "Trapezoidal     9   -2.27413  3.81205\n",
      "Trapezoidal    17   -2.13058  2.69004\n",
      "Trapezoidal    33   -2.06384  2.18724\n",
      "Trapezoidal    65   -2.03158  1.93591\n",
      "Trapezoidal   129   -2.01571  1.80328\n",
      "Trapezoidal   257   -2.00783  1.73146\n",
      "Trapezoidal   513   -2.00391  1.69217\n",
      "Trapezoidal  1025   -2.00195  1.67063\n",
      "Trapezoidal  2049   -2.00097  1.65878\n",
      "Simpson         5  -13.5797\n",
      "Simpson         9   -9.89354\n",
      "Simpson        17   -8.83364\n",
      "Simpson        33   -8.39449\n",
      "Simpson        65   -8.19221\n",
      "Simpson       129   -8.09493\n",
      "Simpson       257   -8.04802\n",
      "Simpson       513   -8.00013\n",
      "Simpson      1025   -5.53038\n",
      "Simpson      2049   15.0074\n"
     ]
    }
   ],
   "source": [
    "from math import pi, sin, log\n",
    "\n",
    "t = []\n",
    "for Method in Midpoint, Trapezoidal:\n",
    "    for n in [2**k + 1 for k in range(2, 12)]:\n",
    "        E1 = abs(2 - Method(0, pi, n).integrate(sin))\n",
    "        E2 = abs(2 - Method(0, pi, n - 1).integrate(sin))\n",
    "        r = log(E2 / E1) / log((n - 1) / n)\n",
    "        C = E1 / n**r\n",
    "        t.append([Method.__name__, n, r, C])\n",
    "for Method in Simpson,:\n",
    "    for n in [2**k + 1 for k in range(2, 12)]:\n",
    "        E1 = abs(2 - Method(0, pi, n).integrate(sin))\n",
    "        E2 = abs(2 - Method(0, pi, n - 2).integrate(sin))\n",
    "        r = log(E2 / E1) / log((n - 1) / n)\n",
    "        C = E1 / n**r\n",
    "        t.append([Method.__name__, n, r])\n",
    "        \n",
    "print(tabulate(t, [\"Method\", \"n\", \"r\", \"C\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.16: Add common functionality in a class hierarchy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "\n",
    "class Integrator(object):\n",
    "    def __init__(self, a, b, n):\n",
    "        self.a, self.b, self.n = a, b, n\n",
    "        self.points, self.weights = self.construct_method()\n",
    "\n",
    "    def construct_method(self):\n",
    "        raise NotImplementedError('no rule in class %s' %\n",
    "                                  self.__class__.__name__)\n",
    "\n",
    "    def integrate(self, f):\n",
    "        s = 0\n",
    "        for i in range(len(self.weights)):\n",
    "            s += self.weights[i]*f(self.points[i])\n",
    "        return s\n",
    "\n",
    "    def vectorized_integrate(self, f):\n",
    "        return np.dot(self.weights, f(self.points))\n",
    "    \n",
    "    def int_function(self, f, x):\n",
    "        self.b = x\n",
    "        self.points, self.weights = self.construct_method()\n",
    "        return self.integrate(f)\n",
    "\n",
    "\n",
    "class Midpoint(Integrator):\n",
    "    def construct_method(self):\n",
    "        a, b, n = self.a, self.b, self.n  # quick forms\n",
    "        h = (b-a)/float(n)\n",
    "        x = np.linspace(a + 0.5*h, b - 0.5*h, n)\n",
    "        w = np.zeros(len(x)) + h\n",
    "        return x, w\n",
    "\n",
    "class Trapezoidal(Integrator):\n",
    "    def construct_method(self):\n",
    "        x = np.linspace(self.a, self.b, self.n)\n",
    "        h = (self.b - self.a)/float(self.n - 1)\n",
    "        w = np.zeros(len(x)) + h\n",
    "        w[0] /= 2\n",
    "        w[-1] /= 2\n",
    "        return x, w\n",
    "\n",
    "class Simpson(Integrator):\n",
    "    def construct_method(self):\n",
    "        if self.n % 2 != 1:\n",
    "            print('n=%d must be odd, 1 is added' % self.n)\n",
    "            self.n += 1\n",
    "        x = np.linspace(self.a, self.b, self.n)\n",
    "        h = (self.b - self.a)/float(self.n - 1)*2\n",
    "        w = np.zeros(len(x))\n",
    "        w[0:self.n:2] = h*1.0/3\n",
    "        w[1:self.n-1:2] = h*2.0/3\n",
    "        w[0] /= 2\n",
    "        w[-1] /= 2\n",
    "        return x, w\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "\n",
    "x = np.linspace(-3, 3)\n",
    "\n",
    "plt.plot(x, [Midpoint(0, 1, 50).int_function(sin, x) for x in x])\n",
    "plt.plot(x, [Trapezoidal(0, 1, 50).int_function(lambda x: x, x) for x in x])\n",
    "plt.plot(x, [Simpson(0, 1, 51).int_function(lambda x: 1, x) for x in x])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.17: Make a class hierarchy for root finding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rootfinder:\n",
    "    def __init__(self, f, dfdx=None):\n",
    "        self.f = f\n",
    "        self.df = dfdx if dfdx else Central2(f)\n",
    "        \n",
    "    def solve(self, start_values=[0], max_iter=100, tolerance=1e-6):\n",
    "        pass\n",
    "    \n",
    "\n",
    "class Newton(Rootfinder):\n",
    "    def solve(self, start_values=[0], max_iter=100, tolerance=1e-6):\n",
    "        f, x, dfdx, epsilon, N = self.f, start_values[0], self.df, tolerance, max_iter\n",
    "        f_value = f(x)\n",
    "        n = 0\n",
    "        info = [(x, f_value)]\n",
    "        \n",
    "        while abs(f_value) > epsilon and n <= N:\n",
    "            dfdx_value = float(dfdx(x))\n",
    "            \n",
    "            if abs(dfdx_value) < 1E-14:\n",
    "                raise ValueError(\"Newton: f'(%g)=%g\" % (x, dfdx_value))\n",
    "\n",
    "            x = x - f_value/dfdx_value\n",
    "\n",
    "            n += 1\n",
    "            f_value = f(x)\n",
    "            info.append((x, f_value))\n",
    "            \n",
    "        return x, f_value, f_value < tolerance, info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.5505102040816306,\n",
       " 2.603082140950619e-07,\n",
       " True,\n",
       " [(0, 3),\n",
       "  (0.49999999999672445, 0.250000000016378),\n",
       "  (0.5499999999992284, 0.002500000003780478),\n",
       "  (0.5505102040816306, 2.603082140950619e-07)])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Newton(lambda x: (x - 3)**2 - 6).solve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.18: Make a calculus calculator class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MinMax:\n",
    "    import numpy as np\n",
    "    \n",
    "    def __init__(self, f, a, b, n):\n",
    "        self.__dict__.update({k: v for k, v in locals().items() if k != 'self'})\n",
    "        self._find_extrema()\n",
    "        \n",
    "    def _find_extrema(self):\n",
    "        f, a, b = self.f, self.a, self.b\n",
    "        \n",
    "        self.Pmin, self.Pmax, self.Fmin, self.Fmax = Pmin, Pmax, Fmin, Fmax = [], [], [], []\n",
    "        \n",
    "        x = np.linspace(a, b, self.n)\n",
    "        for i, xi in enumerate(x[1:-1]):\n",
    "            if f(x[i]) < f(xi) > f(x[i + 2]):\n",
    "                Pmax.append(xi)\n",
    "                Fmax.append(f(xi))\n",
    "            elif f(x[i]) > f(xi) < f(x[i + 2]):\n",
    "                Pmin.append(xi)\n",
    "                Fmin.append(f(xi))\n",
    "                \n",
    "        if f(a) > f(x[1]):\n",
    "            Pmax.insert(1, a)\n",
    "            Fmax.insert(1, f(a))\n",
    "        elif f(a) < f(x[1]):\n",
    "            Pmin.insert(1, a)\n",
    "            Fmin.insert(1, f(a))\n",
    "        if f(b) > f(x[-2]):\n",
    "            Pmax.append(b)\n",
    "            Fmax.append(f(b))\n",
    "        elif f(b) < f(x[-2]):\n",
    "            Pmin.append(b)\n",
    "            Fmin.append(f(b))\n",
    "                    \n",
    "    def _refine_extrema(self):\n",
    "        f, a, b, n = self.f, self.a, self.b, self.n\n",
    "        Pmin, Pmax, Fmin, Fmax = self.Pmin, self.Pmax, self.Fmin, self.Fmax\n",
    "        for i, p in enumerate(Pmin):\n",
    "            if p != a and p != b:\n",
    "                df = Derivative(f, h= (b - a) / n**2 / 1000)\n",
    "                xmin, dfmin = p, df(p)\n",
    "                for x in np.linspace(p - (b - a)/n, p + (b - a)/n, n):    # just reuse `n` as precision basis\n",
    "                    if df(x) < dfmin:\n",
    "                        xmin, dfmin = x, df(x)\n",
    "                Pmin[i] = xmin\n",
    "                Fmin[i] = f(xmin)\n",
    "                \n",
    "        for i, p in enumerate(Pmax):\n",
    "            if p != a and p != b:\n",
    "                df = Derivative(f, h= (b - a) / n**2 / 1000)\n",
    "                xmax, dfmin = p, df(p)\n",
    "                for x in np.linspace(p - (b - a)/n, p + (b - a)/n, n):    # just reuse `n` as precision basis\n",
    "                    if df(x) < dfmin:\n",
    "                        xmax, dfmin = x, df(x)\n",
    "                Pmax[i] = xmax\n",
    "                Fmax[i] = f(xmax)\n",
    "                \n",
    "    \n",
    "    def get_global_minimum(self):\n",
    "        return min(self.get_all_minima(), key=lambda t: t[1])\n",
    "            \n",
    "    def get_global_maximum(self):\n",
    "        return max(self.get_all_maxima(), key=lambda t: t[1])\n",
    "    \n",
    "    def get_all_minima(self):\n",
    "        return [(x, y) for x, y in zip(self.Pmin, self.Fmin)]\n",
    "    \n",
    "    def get_all_maxima(self):\n",
    "        return [(x, y) for x, y in zip(self.Pmax, self.Fmax)]\n",
    "    \n",
    "    def __str__(self):\n",
    "        from textwrap import dedent as dd\n",
    "        return dd(f\"\"\"\n",
    "        All minima: {', '.join(f'{p:.4f}' for p, v in self.get_all_minima())}\n",
    "        All maxima: {', '.join(f'{p:.4f}' for p, v in self.get_all_maxima())}\n",
    "        Global minimum: {self.get_global_minimum()[0]}\n",
    "        Global maximum: {self.get_global_maximum()[0]}\n",
    "        \"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "class CalculusCalculator:\n",
    "    def __init__(self, f, a, b, resolution=100):\n",
    "        self.f, self.a, self.b, self.resolution = f, a, b, resolution\n",
    "        self.set_integration_method(Trapezoidal)\n",
    "        self.set_differentiation_method(Central2)\n",
    "        \n",
    "    def plot(self):\n",
    "        import matplotlib.pyplot as plt\n",
    "        plt.figure()\n",
    "        x = np.linspace(self.a, self.b, self.resolution)\n",
    "        plt.plot(x, [self.f(x) for x in x])\n",
    "        plt.show()\n",
    "        \n",
    "    def plot_derivative(self):\n",
    "        import matplotlib.pyplot as plt\n",
    "        plt.figure()\n",
    "        x = np.linspace(self.a, self.b, self.resolution)\n",
    "        plt.plot(x, [self.df(x) for x in x])\n",
    "        plt.show()\n",
    "        \n",
    "    def set_differentiation_method(self, method):\n",
    "        self.diff_method = method\n",
    "        \n",
    "    def set_integration_method(self, method):\n",
    "        self.int_method = Trapezoidal\n",
    "        self.integral = method(self.a, self.b, self.resolution).integrate(self.f)\n",
    "        \n",
    "    def df(self, x):\n",
    "        return self.diff_method(self.f)(x)\n",
    "    \n",
    "    def extreme_points(self):\n",
    "        print(MinMax(f=self.f, a=self.a, b=self.b, n=self.resolution))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c = CalculusCalculator(lambda x: x**2 * exp(-0.2 * x) * sin(2 * pi * x), 0, 6, 700)\n",
    "c.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c.plot_derivative()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "All minima: 0.8069, 0.0000, 1.7768, 2.7639, 3.7597, 4.7554, 5.7511\n",
      "All maxima: 0.3605, 1.2876, 2.2661, 3.2618, 4.2575, 5.2532, 6.0000\n",
      "Global minimum: 5.75107296137339\n",
      "Global maximum: 5.253218884120171\n",
      "\n"
     ]
    }
   ],
   "source": [
    "c.extreme_points()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.7349674573087768"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.integral"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-24.05698904775627"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.df(2.51)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.19: Compute inverse functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CalculusCalculator:\n",
    "    def __init__(self, f, a, b, resolution=100):\n",
    "        self.f, self.a, self.b, self.resolution = f, a, b, resolution\n",
    "        self.set_integration_method(Trapezoidal)\n",
    "        self.set_differentiation_method(Central2)\n",
    "        \n",
    "    def plot(self):\n",
    "        import matplotlib.pyplot as plt\n",
    "        plt.figure()\n",
    "        x = np.linspace(self.a, self.b, self.resolution)\n",
    "        plt.plot(x, [self.f(x) for x in x])\n",
    "        plt.show()\n",
    "        \n",
    "    def plot_derivative(self):\n",
    "        import matplotlib.pyplot as plt\n",
    "        plt.figure()\n",
    "        x = np.linspace(self.a, self.b, self.resolution)\n",
    "        plt.plot(x, [self.df(x) for x in x])\n",
    "        plt.show()\n",
    "        \n",
    "    def set_differentiation_method(self, method):\n",
    "        self.diff_method = method\n",
    "        \n",
    "    def set_integration_method(self, method):\n",
    "        self.int_method = Trapezoidal\n",
    "        self.integral = method(self.a, self.b, self.resolution).integrate(self.f)\n",
    "        \n",
    "    def df(self, x):\n",
    "        return self.diff_method(self.f)(x)\n",
    "    \n",
    "    def extreme_points(self):\n",
    "        print(MinMax(f=self.f, a=self.a, b=self.b, n=self.resolution))\n",
    "        \n",
    "    def inverse(self, x, h=1e-6):\n",
    "        def Newton(f, x, dfdx, epsilon=1.0E-7, N=100, store=False):\n",
    "            f_value = f(x)\n",
    "            n = 0\n",
    "            if store: info = [(x, f_value)]\n",
    "            while abs(f_value) > epsilon and n <= N:\n",
    "                dfdx_value = float(dfdx(x))\n",
    "                if abs(dfdx_value) < 1E-14:\n",
    "                    raise ValueError(\"Newton: f'(%g)=%g\" % (x, dfdx_value))\n",
    "\n",
    "                x = x - f_value/dfdx_value\n",
    "\n",
    "                n += 1\n",
    "                f_value = f(x)\n",
    "                if store: info.append((x, f_value))\n",
    "            if store:\n",
    "                return x, info\n",
    "            else:\n",
    "                return x, n, f_value\n",
    "\n",
    "        \n",
    "        def F(gamma):\n",
    "            return f(gamma) - xi\n",
    "\n",
    "        def dFdx(gamma):\n",
    "            return (F(gamma+h) - F(gamma-h))/(2*h)\n",
    "\n",
    "        g = np.zeros(len(x))\n",
    "\n",
    "        for i in range(len(x)):\n",
    "            xi = x[i]\n",
    "\n",
    "            # Compute start value (use last g[i-1] if possible)\n",
    "            if i == 0:\n",
    "                gamma0 = x[0]\n",
    "            else:\n",
    "                gamma0 = g[i-1]\n",
    "\n",
    "            gamma, n, F_value = Newton(F, gamma0, dFdx)\n",
    "            g[i] = gamma\n",
    "\n",
    "        return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x109799358>]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c = CalculusCalculator(lambda x: x**2 * exp(-0.2 * x), 0, 6, 700)\n",
    "c.plot()\n",
    "x = np.linspace(0, 6, 100)\n",
    "plt.plot(c.inverse(x), x)    # i don't know but this does not look right.."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 9.22: Animate a person with waving hands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(3, 6))\n",
    "plt.axis([-1.5, 1.5, -0.5, 5.5])\n",
    "ax.add_artist(plt.Circle((0, 4.5), 0.5, fill=False, lw=2))\n",
    "plt.plot([-1, 0, 1, 0, 0, 0, -1, 0, 1], [2, 3.5, 4, 3.5, 4, 1.5, 0, 1.5, 0], 'k', lw=2)\n",
    "ln, = plt.plot([1, 1.1], [4, 4.7], 'k', lw=2)\n",
    "\n",
    "from matplotlib.animation import FuncAnimation\n",
    "from math import sin, cos, sqrt, pi\n",
    "\n",
    "l = sqrt(2) / 2\n",
    "\n",
    "def draw(theta):\n",
    "    ln.set_data([1, 1 + l*cos(theta)], [4, 4 + l*sin(theta)])\n",
    "    return ln,\n",
    "\n",
    "a = FuncAnimation(fig, draw, np.r_[np.linspace(0.5*pi/2, 1.1*pi/2), np.linspace(1.1*pi/2, 0.5*pi/2)], interval=15, blit=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<video width=\"216\" height=\"432\" controls autoplay loop>\n",
       "  <source type=\"video/mp4\" src=\"data:video/mp4;base64,AAAAHGZ0eXBNNFYgAAACAGlzb21pc28yYXZjMQAAAAhmcmVlAAAgfm1kYXQAAAKvBgX//6vcRem9\n",
       "5tlIt5Ys2CDZI+7veDI2NCAtIGNvcmUgMTUyIHIyODU0IGU5YTU5MDMgLSBILjI2NC9NUEVHLTQg\n",
       "QVZDIGNvZGVjIC0gQ29weWxlZnQgMjAwMy0yMDE3IC0gaHR0cDovL3d3dy52aWRlb2xhbi5vcmcv\n",
       "eDI2NC5odG1sIC0gb3B0aW9uczogY2FiYWM9MSByZWY9MyBkZWJsb2NrPTE6MDowIGFuYWx5c2U9\n",
       "MHgzOjB4MTEzIG1lPWhleCBzdWJtZT03IHBzeT0xIHBzeV9yZD0xLjAwOjAuMDAgbWl4ZWRfcmVm\n",
       "PTEgbWVfcmFuZ2U9MTYgY2hyb21hX21lPTEgdHJlbGxpcz0xIDh4OGRjdD0xIGNxbT0wIGRlYWR6\n",
       "b25lPTIxLDExIGZhc3RfcHNraXA9MSBjaHJvbWFfcXBfb2Zmc2V0PS0yIHRocmVhZHM9MTIgbG9v\n",
       "a2FoZWFkX3RocmVhZHM9MiBzbGljZWRfdGhyZWFkcz0wIG5yPTAgZGVjaW1hdGU9MSBpbnRlcmxh\n",
       "Y2VkPTAgYmx1cmF5X2NvbXBhdD0wIGNvbnN0cmFpbmVkX2ludHJhPTAgYmZyYW1lcz0zIGJfcHly\n",
       "YW1pZD0yIGJfYWRhcHQ9MSBiX2JpYXM9MCBkaXJlY3Q9MSB3ZWlnaHRiPTEgb3Blbl9nb3A9MCB3\n",
       "ZWlnaHRwPTIga2V5aW50PTI1MCBrZXlpbnRfbWluPTI1IHNjZW5lY3V0PTQwIGludHJhX3JlZnJl\n",
       "c2g9MCByY19sb29rYWhlYWQ9NDAgcmM9Y3JmIG1idHJlZT0xIGNyZj0yMy4wIHFjb21wPTAuNjAg\n",
       "cXBtaW49MCBxcG1heD02OSBxcHN0ZXA9NCBpcF9yYXRpbz0xLjQwIGFxPTE6MS4wMACAAAALRmWI\n",
       "hAAr//72c3wKa0czlS4Fdvdmo+XQkuX7EGEjxB1tGiRfz7DKKAAAC7l9Mgo8zANgtqg+qophueA+\n",
       "x3nyamGXPbUO0QMTulTsL9vvp060lqAaOhGWXmS/z2s2CQ471T8A51OyQHgid1MBHlEu+qtyZP4b\n",
       "YhbuQggL8o+g/MA7+LD34qAqs8r4YBwvV7c/vklSpHJLKndN3/o2qX+LgpieuJzFHftyZVXfUXLe\n",
       "U/P81bW7TKn5STiyp4z9uiAMzBnCSndu9qcY6zrGdB/1t31prhKUnhgoCMsnN9d7UoIJhieSdaFt\n",
       "wjpTBsZDngxV67cGZ6tP+SXjUMBzu4LV3qf+8pmCioznu+KMyI8uBW4ZQDCgGieDINdmR9JfEKcX\n",
       "Rb0Mu39epnug+CM6uBJRahS8znpa9rxloOlUoW9snidoKL5mN4xtjgBfGpi7feS0lmNNxj3aWRRx\n",
       "NJIdc8MEWGXNPm+K41sMlCxcvyqJrbzlFqz/bSHK2tC36sKlHUnLYBzh5h7YlWoe8OyXmNuIlJL3\n",
       "HcyiMN4GaBsbtqoXpOJOmBEFSvPS6y/uLoJLZMK7MLirmpfcLkQKkwjIMjsP/C7+aA1bj0H54tsG\n",
       "792Yu6ElH1dGmOVEUXv0ko37Juh/8MsbHvWvY4+VVtqzUtTQVUVDcu2u7XRaTaUVCFhhE20s2n/q\n",
       "X1vNGn7Syii9hTpdbtO2kHDvPEycrdGHZp8pmRHulIw7MGkDq8pegQrBrl/sJ8ZktQqeP71byOOU\n",
       "Hb1H2/nN8KM/BTrN/038qfppF10lsAEejuVyfHlIq/0RJvwaTJIV5tdU26bMAuhw5D9hPvsmgB93\n",
       "GQEjQeIlXly1UHtA46OpanFWZLr8kF1ptuZreX8OZAUXd8aGIRMvx4VNGp4Gp/p29I3brQ903E3e\n",
       "4eUtQFb85O1vFd39F9en/m9SSHuIH9LJx9IHvHnpdebwv1sP3ty+ZS/uBlRGh0GzjFBS2Qqb+BAv\n",
       "QIvioXgjAS9Yth+s0SK5cNPdYRvb6Jm+C/XIjbbhrnClw8A7Sq24I8ET2Nlk2DobeXq5aU90W6ro\n",
       "/n5mauO3rP6sK8sWFFVcInmQ/Bk1WrwFSlZtzj67ROWe5Iqij4uXouihFZNML8nJ6KjpzlLIvChE\n",
       "ry8aj7sW7BuKk7hJXZkjI6BT5d4qT2DMVgODSCwXSkgWpXuuwz0df0ukYasNXD6mCxv/Q667RGqp\n",
       "ZU0zTxrub/DbuPjsvf/vXnmh44OXb27LcoBMztjMAyEAff2ZZD8+g3Gbm7E76dzRaoTLQfhDIwNx\n",
       "N4uRtKsY4gmnQGc59dXt0KD5qRDqRAmcYsaKAbjgX+pnyvTTSSDUTgDwrd5kZbqYAzwV4DoEsb0h\n",
       "sKoGGpJag3OOrZt3D5zkCEec9NvWDG6XL9jHaLRcp9AQ7bOOY15bsz0EwxQjYsTZrT3xjIR7PP+Q\n",
       "fn605P4TPdjYjlh6YkEJwIgE8R6azKZ4/9Gzk4Q4LAuTXfGbfRNFhSRDZMkLOrz2vPMvAzm0gxnu\n",
       "lJSnAUytQuvXVdyhdSNdGlBInPGGMpIglhv1VWwSTjENZWhQebkQ6iZBKErkmYm35ivU7Fwpwagc\n",
       "zqnyxJsOyyI2y/OGyKAMTuZVjsEo3u+U5XrxWdVwP1ur7olnZ1qIl1DEnpsmpdE2tCnY7MHr4dKl\n",
       "+vaAAtqGNsHIRTin38NNUpVqrTCPWOREdF60FjQRZc6h6x1ivyG6gXDD3dEA68/fcrpEBBmoQ8Wl\n",
       "1wNtf5+ZFd64HB2hwH0k7/yvBXEDJ0XHJpiKZKFzS7vfM/vU8fzb+cR/+fr+3tmdPbtH1GnGLslP\n",
       "8/KWMg1SDNSF/an+R8K5u+RsU+D1DYKOk7251uKdBnp6yjI9YU532sQVCUuA6wJ4sKLRPsUvGMfK\n",
       "jGWMtkltgerpygfCtzWrEO8vnE7HK4IUivks2VKsXMsz8nPy+xTL/vaiyRqo57LjoOFKuVDctEE2\n",
       "KWWry3KrOh4f0j/vArgb5B1SmAZg5AXDc7y5o/FBN1rwBtMkW/2FXrJkAz2a4Iuu2WBIvoy7quo+\n",
       "yyEVhe7RHKPRZvFMf98MVFBnDwYss957YOUIOSzPZCRhazsHciWzbKnLyTWN8PK/8SUEDJbVRvb4\n",
       "Qh4lzjcvmOKL2Zt+KqJT0frSIrCQOeKAs5yMnXCvhq2U5ELN1xDCEK45A54i27KuSn3mjX901DS8\n",
       "8HKf0jHploAvVCqu3URuygioZuYRFbT9q6RQ3pMd8I4K+NlEGgyL5J2JXf4YDS4OgSyr4PU8of17\n",
       "WQhkRlgqsRU9O0S2GINgfBrWezFCwVqn3jwRD1bD69yFwNbzdEJJ8Gu1CIB6fXHnP0/a+/XCVB2P\n",
       "N1Tpm4IL6tXik1NhUevYdShoSkeWdt6VocQTQwkTTyVBU1T/OIWU6GXFLtCRhwX4vJZNAr+4DZe/\n",
       "ptkZRp7c0ftHQiU5qEodbst2gVP34ywTEBFmG1t923k0VJRHY2r7yFUeRzaKsuYqtfTyirIEYdUd\n",
       "EATD1tqkeAPG5bD5ieztRK1pcF2woCfGfojKQEtbzZFKHHjEb5OXnDKMln3rIdOacp3c8L0QOlPm\n",
       "ziBET9ZU38f5PUAWI/DZxgTBvqAvl2ZjhMQxwxHY6+1jmajh35B2jJgj3i7g//jI+d419fpiawEo\n",
       "4rMNufEi2hnT97VwaPmR+Y+KQp6kEcH1X9evc8OpLIXD3UTd3QC5cDjN0+ECChX4dQ40e2pksP08\n",
       "Nv1wGfTuMmseopykZjQF+0xJ4tNSdJfjm1Sul39qqzW7DHpIWggitfBURGTT8WqaZzHbYIR4f94N\n",
       "JqiI4GOoP2DFyK22i02IjbqSeBr4vlpteV4I0WuRV3JzF+UDmbQiDUkAJYc2mi3Iy/mAl7hOid9X\n",
       "l5gBRGzP1a++aqh3/hU38CGOVz7jIeM8OF2g7ZRIfHLcieyq8OJOSNC/Fu8lEYoZ05f+AGSkMINB\n",
       "3WnT6d6qYYhDSha8eQtLKHg7+3tt8RPCWt2v553F0RCtOKqwAcPmw4yIz2piP/UDxl6VVyiqVB/2\n",
       "vxml0XLmmRJi4fo5Bj9TlJY4H87YfcF3OwBAXz3rL+UQrnLyQPxNXsrvqQ8nOvkdPkYPGtrHGC0i\n",
       "tiiFIeyeuhQ+KZtKwgqrAbwN8+S1qkCR2Ra0A9mAn84Mr3Z0Z4nkWTaeZBgvKTpbJRLt7FMHIQAC\n",
       "EF8iguJEDrCOAzZ74JghbmbqxPkClc68F1ZeWMhsAuyn19n8dqn8XjdHoetxEPpIyJdMV76C5vFW\n",
       "vK/OWeQCbrlId/hdA3DjN5n49agYYhDpAHnIc0m7L4uoeYBYLG/uYhl25ICk9neUQZaM0mZL4TkA\n",
       "KIwNClA9dGTp0JRiIin7csgfRB4dX3sUES2NIRNbkinmSjJikRSnbdkMwpqFDfRs2leYF3dcRZPn\n",
       "jBoSqgutjYTek8YGRyIsjIYwFyJr/Px98PsAKhnsCRqvc0PfggHPTzbwG3bfqP9LmI930imeeyVa\n",
       "b/wNIz//C4HN/MN585Z8VDM7X1KkeB0X6Kn+8JCFdP6o3Qjo8RIllMMTRjOyxicc3vzcX8kf3DFj\n",
       "irQqp/L7M0XjjUyCJzD8KQfkncEVfxi3SO/NmPRpBzKEwPfy0iUbf4U4KCl7StVmKiGo3M+mTyw4\n",
       "80yVzFxjEm8IHO3729pE+x2wYuqSrcfMroTD3xu4athQrCYXuxSE4ynxMGL7lk9+6nrynpyLigeP\n",
       "EXV/RxOlQwdcvvNFNshdxuKBZ7GUEe8NQQRCHVD7KMChK9ET0mXw4XV5Vc+MqfgRkNZWZjxm0tSt\n",
       "72RcVw9IOY3gtq2untM0MD5bwKAgDoeaK5n5U7IjXYADUwAAAK9BmiRsQr/+OEAcD0nuVmuxSztE\n",
       "CE7vbFMAH884StnjPowOGTVV3Rg5u2DGCa//QVWTRH/aeDLyYi55ftjsF2SvHdpPQe3pD8eakxYz\n",
       "ioyVxLYY/bUhExPHz688daUru1UewQcZIEHiL4ACA0YAIaZxfu3LQvC1DtXRjr1PISOQy+ZTVMI2\n",
       "r8OeSawOQpyWYepaX1+onXe6XmSGog9xoxxjqk52dU3VYsI548oqrF0QAAAALkGeQniP/wNb9xLI\n",
       "7YpVqQaHphkasTfzT8HCKLLT5szPyUAPMgbkaqV2xF3BvvEAAAAkAZ5hdEb/BCkJWDZ0SITs6YiV\n",
       "Si3TZxu4NOSoWGy/HPoXBj5gAAAAHAGeY2pG/wGt2NsJQAYYKcv3zP0zyFCNwS1A3zcAAABzQZpo\n",
       "SahBaJlMCFf//jhACefblSqSACpPN/9snCU7LMY/hzQgOcpIJB8sx/4LFrdrJw73U5sfjKHuy7ge\n",
       "eQVIQThrwJ0QdPLPxC+TIUFuK2m8T2TUAhOod805h0d2Pc3Fn7Wba6wgxhHNIWzpPwqvLbEcVQAA\n",
       "AClBnoZFESx/AVnLE66RWuShJJkkTJbVPSmMQCdXhz5oKzmopjHZ94NzYQAAABsBnqV0Rv8BrrRI\n",
       "W4DjwSPh43PY5mJjaiCZPYEAAAAWAZ6nakb/AaM01reCmMuW52PjhPTFgAAAAGZBmqtJqEFsmUwI\n",
       "V//+OEAJ5ZALBrH5YXdPEiguAAXrqAqzIeYQg+xCxctwJbEZghlOqS8xXWBcSEMlXzOOUmcTTUur\n",
       "TLWPZaZ0GmG2vK++ydbaqN/wZngOLY3Bv9sJPn2/gnFUq8AAAAAcQZ7JRRUsfwFOjgaY4OoXGvEV\n",
       "f5SSsw26kmynjQAAABgBnupqRv8BobLiX+TWor+urq5yjQjJCFAAAAAvQZrsSahBbJlMCFf//jhA\n",
       "Cj+1mXUf2aDoNQAtvbC9SzWSW38nX2Ag3cvNjf+u10AAAABZQZsQSeEKUmUwIV/+OEAJ8jZUv9q/\n",
       "eAAFLJX6htTMdNs9EKfnUWe51crpF3LyaLd91G+l4epeuSQweswKv1iRb9tPbBaI6huBDc5RGAGw\n",
       "GY86Qrv8o2cKDYEAAAAiQZ8uRTRMfwHWV/C6dEQxT8lehgau0Ra1lJ7Nc6cdgzih/wAAABUBn010\n",
       "Rv8CWDvkA7VWYh8Hu0CUh80AAAAaAZ9Pakb/Alfu+tH/cUUPKJwhLYrnwPyzCtgAAABpQZtUSahB\n",
       "aJlMCFf//jhACi6X4EQDVZk58YQKluWTTSNsM/4W597G9CmN0hGmboQPcH0cU52oey2C9oLwT/F8\n",
       "KW+CcsDHddhddGAxMx7VwmG/ghBJ2YWmfEId0h47i6onj2dn9w1KmihAAAAAHkGfckURLH8B1fdD\n",
       "MX4x/SU7ZiBA2jrUhcRrZ8JUwQAAABkBn5F0Rv8CVoY7BfBAL8qtMfx77JiBTGrAAAAAGAGfk2pG\n",
       "/wJX7vulW9ciiNiVVpD/a5jVgAAAAGRBm5hJqEFsmUwIT//98QAi/WcAUhL8S1lBQWrlgHFX1S8R\n",
       "M/v1slBQSb2ODWrwRr2ER7gsEUCKVUC9XlgSgOsfFmwF9Pm/+KOswl90g9te9O4KcoA4/pETH5IB\n",
       "++dWQ2n6kLKBAAAAI0GftkUVLH8B5n7+2xXcX0jOb9LSwEZQEdF1Lrs3pr5qAOjYAAAAIQGf1XRG\n",
       "/wJQejq5dtUFjnlYAIaHeLK5n5tqCkBWL6Y1YQAAABsBn9dqRv8CZ+rzN7KCoqf49vQDyGe5wXEE\n",
       "TMEAAAA/QZvZSahBbJlMCE///fEAIsDnuAoENS+lZm/+oc0w+azNGtmVuCcmYUz9IXBZmP3hP0Vl\n",
       "Jn18oDr3RcPovImAAAAANEGb+knhClJlMCE//fEAIvFsj9p9EAhT0O8AAlY08m1ny6DXgiZE340L\n",
       "lDUrvABHkdxEob0AAAA1QZobSeEOiZTAhP/98QAj/WcA1DrtbhH5M2eJZ0GoLbcE81cXgXZ6Gcq5\n",
       "EqRwVrteJqL2RlQAAAAxQZo8SeEPJlMCE//98QAjvN1HgP20Xpm2riQTlPXiDeMeMd/c9oyEiP9X\n",
       "pdIGREfZIwAAAC9Bml1J4Q8mUwIT//3xACO9Hr8Amt/uO3hYDLXIElcvbmiwksHNoRB9fnRF7duk\n",
       "zQAAADpBmn5J4Q8mUwIT//3xACO9Hr8AcwyoZZiOOL1mr7uTgLE0cTFxgK5BKduNxN2NJq3dIv2N\n",
       "epr+yMqAAAAAN0Gan0nhDyZTAhP//fEAI701ZwAtPmtsqJ+WKnHhcqEiZ9opAVN/8aCQCGIvfb2J\n",
       "IJUtQwoTAZUAAAAoQZqgSeEPJlMCE//98QAjvReDvanLV+vgDS1G0IALbBCVtVTX4qZMwQAAACZB\n",
       "msFJ4Q8mUwIT//3xACO9M9DvX5zmPZUEvG0ZkAJepZi5QzINmAAAACZBmuJJ4Q8mUwIT//3xACPd\n",
       "o+2Vd2js8xwEEiZ/UyAEuNEh3coZBwAAAD5BmwRJ4Q8mUwURPCf//fEAI9mbdh28AmW+clK+KRhC\n",
       "XiyfoiZxZv/IQV6y4uMg7kWTynInCm5MVbq5DQhQQAAAABEBnyNqRv8CZqaYY02TBSDGFQAAACVB\n",
       "myVJ4Q8mUwIT//3xACPUm0AUdSM/XPsMkKjzMATYS26T7JGBAAAAJUGbRknhDyZTAhX//jhADmaf\n",
       "TdTb2QYBXelqptvQBvnaWGSYoIEAAAAoQZtnSeEPJlMCFf/+OEAOanSm1TWPyXxYZV/5mvyW3oA3\n",
       "12UdgZBswQAAAEFBm4tJ4Q8mUwIV//44QA5mExlM7u+EqqoALh0E+KM086t0jmymehBAwKm+5tkY\n",
       "SwUYKmtXJMCWOqYHwYuHs0Ml3AAAABtBn6lFETx/AeRioCiwHHa6AFsPbLKmLgRpkW0AAAAWAZ/I\n",
       "dEb/AmgJyjjFqnKpgAIT7y4rYQAAAB4Bn8pqRv8CZ8/NP+xCABCWDwYuh3tLZ7AlSs+klFAAAABM\n",
       "QZvPSahBaJlMCFf//jhADmYTGRGB8satgAIf7PT+sVhqsvBlAEdI22500u770Cccc26gzIc32Kzz\n",
       "Q5bFGSA+pcdvadSTW0WPP2QbMAAAACJBn+1FESx/Aebi+7bAZ0p8caoS761Ey5/dNgAJ16K5XGVB\n",
       "AAAAFAGeDHRG/wJoCco6aetXbWWT2k3BAAAAGgGeDmpG/wJmpl039hahNIvllCWuQ25ZgJJxAAAA\n",
       "KUGaE0moQWyZTAhP//3xACO9OyiwT2dk/6+ANZh3l26rczAE1pPzTZMwAAAAHUGeMUUVLH8B8Whi\n",
       "M4xfc4f9PK2YeaFidEyCv56QAAAAEgGeUHRG/wJ4N7SRbJ1FHSKFgQAAABABnlJqRv8Cd+rzCHDD\n",
       "G8dMAAAAGEGaVEmoQWyZTAhP//3xACPI83tpOqrhvwAAACVBmnVJ4QpSZTAhP/3xACO9UoOrmFDT\n",
       "rPzDOezIASwolRZgMg2ZAAAAJEGalknhDomUwIV//jhADmaxTdh2uKcSdBRrdhgBxHck8iYoIAAA\n",
       "ACxBmrdJ4Q8mUwIV//44QA5ppZPAAHCiA7dScI6atHwPpcqUvIZp7BjCEQyDgQAAAD1BmttJ4Q8m\n",
       "UwIV//44QA5mFY3Dk+3pDZle38ANt6fnknoSq0+h7pFcr4EPw7miqvU7oQ1/ANp4eDf5MH+BAAAA\n",
       "IkGe+UURPH8B5q9+n0ebzGk+hj6dL4DQAl2Tm6t/q5omqHgAAAAVAZ8YdEb/AmgOimXKPCiHxyct\n",
       "5uVtAAAAEgGfGmpG/wJn0w1HsEERtNOVsAAAADtBmx1JqEFomUwU8K/+OEAOaY5jTezgUPgBMIYC\n",
       "/iRSf0kkkDRTawmPXCP2JNAouszb3yA1PzkSrSMUEQAAABQBnzxqRv8CZ9MnON/wWppZumaSMQAA\n",
       "AE5BmyFJ4QpSZTAhP/3xACO7ikUj+aJSl8AAjP6PO2OTvGgnlxHrv5v9oWK6Y2T+GxJKDlqwaMPZ\n",
       "Fem37Nc7p+C2wIjy/WSp6pwjszFpkHAAAAAiQZ9fRTRMfwHgqjzdvF31jQY4AJN8vI+6ZCNQfMEm\n",
       "Q7yCbgAAABQBn350Rv8CX5CrYVkbyMhhXSBFtQAAABkBn2BqRv8CZ9MjX0bcTWCKiwF3awK9vCbg\n",
       "AAAANUGbYkmoQWiZTAhX//44QA5msU2Ry0NeMQPcNxvKnPAC3j47n0m0HcElKEqqg0YKURlwCS7h\n",
       "AAAAOkGbhEnhClJlMFESwr/+OEAOaneDIK4HaKuqdCpxDgafJQS5/VCGCtCv3Gz8FLWzU0ZyrjEU\n",
       "HRZmjKgAAAAWAZ+jakb/Amae3o3TB8lKD3LOEp5oQQAAAEJBm6ZJ4Q6JlMFEwr/+OEAOZnbbpdyQ\n",
       "rHEAorC7yrOwdWy228SRUUvtijdE6hMqu58hW/7xHzEnWtYEB8xsGQARx60AAAAXAZ/Fakb/Ama1\n",
       "U1lKWgwKtn2DarvhpU0AAABWQZvKSeEPJlMCFf/+OEAOf6kPVUAOBn847UKkAFusFqUrjGiC0S6g\n",
       "br4Ae5M23/y2+7WZ/OsG8/zTx3lD0k0i50D6WykcWBdVLJRK/S5C67A65DvDSDkAAAAmQZ/oRRE8\n",
       "fwHmNt2fatVfD5QZPTHtIvEy7qjhZRR18UyPis4kciYAAAAaAZ4HdEb/AmZa73VJMgeq6xNzHdK3\n",
       "3OvJm1AAAAAaAZ4Jakb/AmbgsYnSgiGx6LHgt1SVYXRZnTEAAABBQZoMSahBaJlMFPCv/jhADiep\n",
       "GjfR23U4yrTKVpuADo+0z7HY7+fr3+aHGd8kO6+lzQHh7Vuu5gx2daRFL8jQ1IAAAAAZAZ4rakb/\n",
       "Aa2rwqJjjrnhsyOlTxr8ThIf4AAAAFZBmjBJ4QpSZTAhX/44QAosgS3Bfi+y8jqgAS2/R5+ra3jN\n",
       "iWT627SL68f5S5+mHcDRalr6SRUcRkt8N1Ibq9/9tA76avfa/5oib3mpxtmFpkfU+JjKgQAAACtB\n",
       "nk5FNEx/AduAu+RZ7pa8Pb+IaACX/ysuhSBvjftoeuJSZGgTzW0yKTHzAAAAIgGebXRG/wJYPv3V\n",
       "5a9d3za/ABOA6KGYOei7np+ozad4z4EAAAAeAZ5vakb/AliQ05GlU4/nf5+ABrQsnSoY5y1t3p6Q\n",
       "AAAARUGackmoQWiZTBTwr/44QAo/J9hAgYRY933gAfxZMC0N6unkZ7/BBobGQd3UEkLHD35B+vDX\n",
       "L9hmrk3pNtkAxmdNc4mMqAAAABYBnpFqRv8CUHo6rcxudpeWyfEJM8Z9AAAAOEGak0nhClJlMCFf\n",
       "/jhADib/0udY7/oGAB/DOykTAsyyykPfrODOMX5bX1YVvmZGEms1pjAIxjUgAAAAREGatknhDomU\n",
       "wIV//jhACe2Vq4ogTAAP53aed82VRhWMGKHqmjsSkuanT+KjpQcuIt+jHBfETK2kPWuX3nely8zO\n",
       "mxlwAAAAJkGe1EURPH8B2s98fbtX086qphABBQDWt0ML3EDVRzBZHGTGEz/BAAAAGQGe9WpG/wJW\n",
       "6bPb5luT9nBzfngzTCXSfS8AAABbQZr6SahBaJlMCFf//jhACeyYHEuVWOACdVNFguJs8Gypk9t3\n",
       "5azPZFiihOPR2NJ8QLzUe6dRL/j7tSqyOhWHfoxDIge/XIaqL5Z08WP5QLTrL2l/S8/6/FQ7oQAA\n",
       "ABtBnxhFESx/AVXjbpddAlYcSEOKA6HLhv5Wf4EAAAAUAZ83dEb/Aa2fnU3V+w1AVxvvz/AAAAAR\n",
       "AZ85akb/Aa6OmUvqW6qjR/kAAABJQZs8SahBbJlMFEwr//44QAnsmBny2XkAIUXgxkFVIry2iur9\n",
       "K4E102LWT25Z4AgksetH6vT4F5d92XLmJr8ZAGtuHJ0XB+yxUwAAABMBn1tqRv8BobL8KmHBUNr3\n",
       "imm5AAAAZkGbQEnhClJlMCE//fEAIcIy6AGue9ADeE2mbdcnpWqIAKQwxxcXUR9lzXkqAAuBwWoj\n",
       "/5F6CBSx1SR72mQhBTaq5vrYJfdSJsX3+62lenweopPEVE2DSSH6dcSZbOlEccKBM3jHgQAAAB9B\n",
       "n35FNEx/AU/HXKHftq03FfXdZYl5zNSSrtqjWOoIAAAAFAGfnXRG/wGiBfJ5+3YOqtdACabgAAAA\n",
       "FQGfn2pG/wGiARp0aGSG0ibzM/6J1wAAAD9Bm4NJqEFomUwI3/pYAScVLueHZ89gAEu8Ja2sXcrg\n",
       "vAvTVOs78/gAA4k3ayFkS/NdeG6c+fLECrcwrl1fVw8AAAAVQZ+hRREsfwFQ67V8+irkFD7PTpGx\n",
       "AAAAHAGfwmpG/wGktsrsEiAAl4xd5dhyMPiGvWRPNuAAAAdWbW9vdgAAAGxtdmhkAAAAAAAAAAAA\n",
       "AAAAAAAD6AAABdwAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAA\n",
       "AABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAABoB0cmFrAAAAXHRraGQAAAADAAAA\n",
       "AAAAAAAAAAABAAAAAAAABdwAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAA\n",
       "AAAAAAAAAABAAAAAANgAAAGwAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAAAXcAAABgAABAAAA\n",
       "AAX4bWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAAAyAAAASwBVxAAAAAAALWhkbHIAAAAAAAAAAHZp\n",
       "ZGUAAAAAAAAAAAAAAABWaWRlb0hhbmRsZXIAAAAFo21pbmYAAAAUdm1oZAAAAAEAAAAAAAAAAAAA\n",
       "ACRkaW5mAAAAHGRyZWYAAAAAAAAAAQAAAAx1cmwgAAAAAQAABWNzdGJsAAAAs3N0c2QAAAAAAAAA\n",
       "AQAAAKNhdmMxAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAANgBsABIAAAASAAAAAAAAAABAAAAAAAA\n",
       "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGP//AAAAMWF2Y0MBZAAe/+EAGGdkAB6s2UODfl4Q\n",
       "AAADADAAABkA8WLZYAEABmjr48siwAAAABx1dWlka2hA8l8kT8W6OaUbzwMj8wAAAAAAAAAYc3R0\n",
       "cwAAAAAAAAABAAAAZAAAAMAAAAAUc3RzcwAAAAAAAAABAAAAAQAAAqhjdHRzAAAAAAAAAFMAAAAB\n",
       "AAABgAAAAAEAAAPAAAAAAQAAAYAAAAABAAAAAAAAAAEAAADAAAAAAQAAA8AAAAABAAABgAAAAAEA\n",
       "AAAAAAAAAQAAAMAAAAABAAADAAAAAAIAAADAAAAAAQAAAYAAAAABAAADwAAAAAEAAAGAAAAAAQAA\n",
       "AAAAAAABAAAAwAAAAAEAAAPAAAAAAQAAAYAAAAABAAAAAAAAAAEAAADAAAAAAQAAA8AAAAABAAAB\n",
       "gAAAAAEAAAAAAAAAAQAAAMAAAAAKAAABgAAAAAEAAAJAAAAAAQAAAMAAAAADAAABgAAAAAEAAAPA\n",
       "AAAAAQAAAYAAAAABAAAAAAAAAAEAAADAAAAAAQAAA8AAAAABAAABgAAAAAEAAAAAAAAAAQAAAMAA\n",
       "AAABAAADwAAAAAEAAAGAAAAAAQAAAAAAAAABAAAAwAAAAAQAAAGAAAAAAQAAA8AAAAABAAABgAAA\n",
       "AAEAAAAAAAAAAQAAAMAAAAABAAACQAAAAAEAAADAAAAAAQAAA8AAAAABAAABgAAAAAEAAAAAAAAA\n",
       "AQAAAMAAAAABAAABgAAAAAEAAAJAAAAAAQAAAMAAAAABAAACQAAAAAEAAADAAAAAAQAAA8AAAAAB\n",
       "AAABgAAAAAEAAAAAAAAAAQAAAMAAAAABAAACQAAAAAEAAADAAAAAAQAAA8AAAAABAAABgAAAAAEA\n",
       "AAAAAAAAAQAAAMAAAAABAAACQAAAAAEAAADAAAAAAQAAAYAAAAABAAADAAAAAAIAAADAAAAAAQAA\n",
       "A8AAAAABAAABgAAAAAEAAAAAAAAAAQAAAMAAAAABAAACQAAAAAEAAADAAAAAAQAAA8AAAAABAAAB\n",
       "gAAAAAEAAAAAAAAAAQAAAMAAAAABAAADAAAAAAIAAADAAAAAHHN0c2MAAAAAAAAAAQAAAAEAAABk\n",
       "AAAAAQAAAaRzdHN6AAAAAAAAAAAAAABkAAAN/QAAALMAAAAyAAAAKAAAACAAAAB3AAAALQAAAB8A\n",
       "AAAaAAAAagAAACAAAAAcAAAAMwAAAF0AAAAmAAAAGQAAAB4AAABtAAAAIgAAAB0AAAAcAAAAaAAA\n",
       "ACcAAAAlAAAAHwAAAEMAAAA4AAAAOQAAADUAAAAzAAAAPgAAADsAAAAsAAAAKgAAACoAAABCAAAA\n",
       "FQAAACkAAAApAAAALAAAAEUAAAAfAAAAGgAAACIAAABQAAAAJgAAABgAAAAeAAAALQAAACEAAAAW\n",
       "AAAAFAAAABwAAAApAAAAKAAAADAAAABBAAAAJgAAABkAAAAWAAAAPwAAABgAAABSAAAAJgAAABgA\n",
       "AAAdAAAAOQAAAD4AAAAaAAAARgAAABsAAABaAAAAKgAAAB4AAAAeAAAARQAAAB0AAABaAAAALwAA\n",
       "ACYAAAAiAAAASQAAABoAAAA8AAAASAAAACoAAAAdAAAAXwAAAB8AAAAYAAAAFQAAAE0AAAAXAAAA\n",
       "agAAACMAAAAYAAAAGQAAAEMAAAAZAAAAIAAAABRzdGNvAAAAAAAAAAEAAAAsAAAAYnVkdGEAAABa\n",
       "bWV0YQAAAAAAAAAhaGRscgAAAAAAAAAAbWRpcmFwcGwAAAAAAAAAAAAAAAAtaWxzdAAAACWpdG9v\n",
       "AAAAHWRhdGEAAAABAAAAAExhdmY1Ny44My4xMDA=\n",
       "\">\n",
       "  Your browser does not support the video tag.\n",
       "</video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import HTML\n",
    "HTML(a.to_html5_video())"
   ]
  }
 ],
 "metadata": {
  "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}