Week04_Interpolation_I.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical Methods Week 4\n",
    "# Interpolation I\n",
    "## Based on Tim Sauer's \"Numerical Analysis\" (Chapter 3, 3.1-3.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importing required Python modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import Symbol, simplify, lambdify, Rational, Poly, poly, latex, factor, expr\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from functools import reduce\n",
    "import operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Data and Interpolating Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Definition*. The function $y = P(x)$ **interpolates** the data points $(x_1,y_1), \\ldots,(x_n,y_n)$ in the plane if $P(x_i) = y_i$ for each $1 \\leq i \\leq n$. \n",
    "\n",
    "Notice that all the $x_i$'s need to be distinct!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.1 Lagrange polynomial interpolation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given three points $(x_1,y_1), (x_2,y_2), (x_3,y_3)$ in the plane, the **Lagrange interpolating polynomial** of degree two is:\n",
    "\n",
    "$$P_2(x) = y_1\\frac{(x - x_2)(x - x_3)}{(x_1 - x_2)(x_1 - x_3)} +\n",
    "y_2\\frac{(x - x_1)(x - x_3)}{(x_2 - x_1)(x_2 - x_3)} +\n",
    "y_3\\frac{(x - x_1)(x - x_2)}{(x_3 - x_1)(x_3 - x_2)}$$\n",
    "\n",
    "In general, given $n$ points $(x_1,y_1), \\ldots, (x_n,y_n)$ in the plane, for each $k = 1, \\ldots, n - 1$, define the $n - 1 $ degree polynomial:\n",
    "\n",
    "$$L_k(x) = \\frac{(x - x_1) \\cdots (x - x_{k-1})(x - x_{k+1}) \\cdots (x - x_n)}\n",
    "{(x_k - x_1) \\cdots (x_k - x_{k-1})(x_k - x_{k+1}) \\cdots (x_k - x_n)}$$\n",
    "\n",
    "Notice that $L_k(x_k) = 1$, while $L_k(x_j) = 0$, where $x_j$ is any of the other data points. Then define the degree $n − 1$ polynomial:\n",
    "\n",
    "$$P_{n-1}(x) = y_1 L_1(x) + \\cdots + y_n L_n(x)$$\n",
    "\n",
    "*Theorem*. (**Main Theorem of Polynomial Interpolation**.) Let $(x_1,y_1), \\ldots, (x_n,y_n)$ be $n$ points in the plane with distinct $x_i$. Then there exists one and only one polynomial $P$ of degree $n − 1$ or less that satisfies $P(x_i) = y_i$, for $i = 1, \\ldots, n$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def interpolate_lagrange(x, x_values, y_values):\n",
    "    \"\"\"\n",
    "    x : value at which to evaluate y, should be between min and max x_values\n",
    "    x_values: list or numpy array containing values of x\n",
    "    y_values: list or numpy array contaning values of y\n",
    "    \"\"\"\n",
    "    def _basis(j):\n",
    "        p = [(x - x_values[m])/(x_values[j] - x_values[m]) for m in range(k) if m != j]\n",
    "        return reduce(operator.mul, p)\n",
    "    assert len(x_values) != 0 and (len(x_values) == len(y_values)), 'x and y cannot be empty and must have the same length'\n",
    "    k = len(x_values)\n",
    "    return sum(_basis(j)*y_values[j] for j in range(k)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#19bfc2\">EXAMPLE 3.1</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the interpolating polynomial for the data points $(0,1),(2,2),$ and $(3,4)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Lagrange polynomial is:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{2}(x) =  + \\frac{x^{2}}{2} - \\frac{x}{2} + 1$"
      ],
      "text/plain": [
       "P_{2}(x) =  + x**2/2 - x/2 + 1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points=[[0,1],[2,2],[3,4]]\n",
    "\n",
    "x=[p[0] for p in points]\n",
    "y=[p[1] for p in points]\n",
    "xs = Symbol('x')\n",
    "po = simplify(interpolate_lagrange(xs,x,y))\n",
    "\n",
    "d=len(x)-1\n",
    "\n",
    "print(\"The Lagrange polynomial is:\")\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "pol=px+po\n",
    "pol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x1 = np.linspace(min(x), max(x), 100)\n",
    "y1 = lambdify(xs, po)(x1)\n",
    "\n",
    "fig = plt.figure(figsize=(7,5))  \n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "# Move left y-axis and bottim x-axis to centre, passing through (0,0)\n",
    "ax.spines['left'].set_position('zero')  #'center')\n",
    "ax.spines['bottom'].set_position('zero')  #center')\n",
    "# Eliminate upper and right axes\n",
    "ax.spines['right'].set_color('none')\n",
    "ax.spines['top'].set_color('none')\n",
    "# Show ticks in the left and lower axes only\n",
    "ax.xaxis.set_ticks_position('bottom')\n",
    "ax.yaxis.set_ticks_position('left')\n",
    "plt.ylim([min(y)-1,max(y)+1])\n",
    "lti=\"$y = P_{%i}(x)$\" %d\n",
    "ax.plot(x1, y1,label=lti)\n",
    "ax.legend(loc='upper right')\n",
    "ax.scatter(x,y, c = 'r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#19bfc2\">EXAMPLE 3.2</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the interpolating polynomial for the data points $(0, 2), (1, 1), (2, 0)$, and $(3, −1)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Lagrange polynomial is:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{2}(x) =  - x + 2$"
      ],
      "text/plain": [
       "P_{2}(x) =  - x + 2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points=[[0,2],[1,1],[2,0],[3,-1]]\n",
    "\n",
    "x=[p[0] for p in points]\n",
    "y=[p[1] for p in points]\n",
    "xs = Symbol('x')\n",
    "po = simplify(interpolate_lagrange(xs,x,y))\n",
    "\n",
    "d=2  #len(x)-1\n",
    "\n",
    "print(\"The Lagrange polynomial is:\")\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "pol=px+po\n",
    "pol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZwAAAEoCAYAAABsGkdaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XtYlHXeP/D3DEdBQEVQBDnM4AFQRETAAwzk+ZCamVlUWhrC+svn97TtVj+3Z6ur1nafamvbFiS1bCPtrG5ulrVyUhTFI2qmwxlRDnI+DjPf3x+jlnkCvLmHGd6v6/LiYubmvj83dxdv5uY93xRCCBAREfU0pakHICKivoGBQ0REsmDgEBGRLBg4REQkCwYOERHJgoFDRESykDRwFAqFvUKhyFEoFMcVCsUphULxkpT7JyIi86WQ8n04CoVCAcBRCNGoUChsAGQB+C8hxAHJDkJERGbJWsqdCWN6NV751ObKP76zlIiIpP8bjkKhsFIoFMcAVADYI4Q4KPUxiIjI/HT1llqnN66trcV9992Hd955B2PGjLn2eEpKClJSUgAALS0tOHXqVFeOT0REvYui0xv2VOAAwMsvvwwHBwc888wzN30+LCwMhw8f7souiYiod+l04Eh6S62yshK1tbUAjK9e9uzZg9GjR0t5CCIiMlOSlgbKy8uxfPly6PV6GAwGLF26FPPnz5fyEEREZKYkDZzg4GAcPXpUyl0SEZGFkDRwiIh6M51Oh9LSUrS2tpp6FLNjb28PLy8v2NjYdHsfDBwi6jNKS0vh5OQEX19fGN+nTp0hhEB1dTVKS0vh5+fX7f1wLTUi6jNaW1vh6urKsOkihUIBV1fXu35lyMAhoj6FYdM9UnzfGDhERCQLBg4REcmCgUNEZKY2bNiAoUOHIiQkBCqVCh988MEtt21paYFGo4Fer7/lNu3t7YiOjkZHR0cPTMvAISIyWydPnsSLL76IY8eO4fPPP8dvf/vbW267efNmLF68GFZWVrfcxtbWFtOmTcMnn3zSE+MycIiI5JSXl4fJkydf+/zIkSOYNm1at/Z14sSJa8uHeXl53fbVS2pqKhYuXHjt89jYWOzZswcA8Ic//AFPPfUUAGDRokVITU3t1jx3wvfhEBHJKDAwEPn5+dDr9bCyssLTTz+NN99887ptoqKi0NDQcMPXvv7665g+ffq1z0+ePImAgAAIIfC3v/3tlkuJtbe3Iz8/H76+vtcee+mll/A///M/qKiowNGjR7Fz504AwJgxY3Do0CEJzvRGDBwi6pNe+tcpnL5QL+k+A4c544/3Bt12G6VSiaCgIJw6dQrnzp2Dj48PQkNDr9smMzPzjscqKSlBY2MjZs2aBRsbG4SHh+Pdd9/F9u3bsWvXLtTX12PlypWYOXMmqqqqMGDAgOu+Pjo6GkIIvPnmm0hLS7t2q83Kygq2trZoaGiAk5NTF78Dt8fAISKSWWRkJPbt24d//OMf2L179w3Pd+YVzsmTJzFt2rQbvn7RokVYtGgRampq8Mwzz2DmzJno16/fDW/aPHnyJMrLy+Hq6npDsLS1tcHe3v5uT/MGDBwi6pPu9EqkJ0VGRmLFihVYs2YNPD09b3i+M69wTpw4gXHjxt3y+VdeeQVr1qwBAAwcOBB6vR6tra2wt7dHeXk54uLisGPHDqxduxa7d+/G7NmzAQDV1dUYPHjwXa2ZdissDRARyWz06NGws7PDs88+2+19nDx5EsHBwTc8LoTAs88+izlz5lx3q27mzJnIyspCc3MzFi9ejDfeeAMBAQF44YUX8NJLL13bbu/evZg3b16357odvsIhIpLZ22+/jfXr18PR0bHb+7hVk+ydd97B999/j7q6Opw/fx4JCQkAgDVr1uCvf/0rpk+fjuzs7GvbR0dHX/f5xx9/jNdee63bc90OA4eISCZarRbz5s3DlClTsHz58h45xtq1a7F27dobHg8NDUVsbOy1dtzNtLe3Y9GiRRg5cmSPzKYQQnRl+y5tfCdhYWE4fPiwlLskIrqlM2fOICAgwNRjmK1bfP86vaon/4ZDRESyYOAQEZEsGDhERCQLBg4R9Sld/Ls1XSHF942BQ0R9hr29Paqrqxk6XSSEQHV19V2vPsBaNBH1GV5eXigtLUVlZaWpRzE79vb28PLyuqt9MHCIqM+wsbGBn5+fqcfos3hLjYiIZMHAISIiWTBwiIhIFgwcIiKSBQOHiIhkwcAhIiJZMHCIiEgWDBwiIpIFA4eIiGTBwCEiIlkwcIiISBYMHCIikgUDh4iIZMHAISIiWTBwiIhIFgwcIiKSBQOHiIhkwcAhIiJZMHCIiEgWDBwiIpIFA4eIiGTBwCEiIllIGjglJSWIjY1FYGAggoKC8Pbbb998w9RUwNcXyM01fkxNlXIMIiLqhRRCiK5sf9uNy8vLUV5ejtDQUDQ0NGDChAnYvn07AgMDf94oNRWIjweamxEG4DAAODgAKSlAXFw3ToGIiExI0dkNJX2F4+HhgdDQUACAk5MTAgICUFZWdv1G69YBzc2osXdCtYMLWqztgOZm4+NERGSxeuxvOIWFhTh69CgiIiKuezylqAhhAKJGTsIFZzdMSdyMtycvQ01FTU+NQkREvYCkt9SuamxshEajwbp167B48eLrn/T1BYqKAAABNvaYvOD3+ME/HA66NiyLGY1VUX4YNqBfV2YiIiLT6fQtNckDR6fTYf78+Zg1axaefvrpGze4yd9wznqNQvKa9dhZbwcFgEXjPZGgUcHf3akrsxERkfxMEzhCCCxfvhyDBg3CW2+9desNU1OBdesQVlSEwz4+wKuvAnFxKK1pxsbMAmw7VIxWnQEzAocgQaPGBJ+BXZmRiIjkY5rAycrKQlRUFMaOHQul0vjnoT/96U+YO3fuTbcPCwvD4cOHb3i8urENW7KL8GF2IWqbdQj3HYTEGDViRrlBoej0uRERUc8z3S21rrhV4FzV1NaBbYdKsCkzHxfqWjF6qBMSY9SYN9YD1lZ8zyoRUS9gGYFzlU5vwM5jF5CcrsW5ikZ4DeyH+GgVHpgwHP1sraQciYiIusayAucqg0Hghx8rkJyuRW5RDQY52mLFZF88NskHAxxspRyNiIg6xzID55cOFV5GUpoW//mxAg62Vngo3Burovzg4cJKNRGRjCw/cK768WI9NqTnY+fxC1AqgIUhrFQTEcmo7wTOVSWXm7Ep6+dK9czAIUiIUSPUm5VqIqIe1PcC56rqxjZs2V+ILdlFqGvRIcJvEBJi1IgZyUo1EVEP6LuBc1VTWwe25hRjU1YByutaEeDhjASNipVqIiJpMXCuau8wYMexMiSna6GtbMLwQf0QH6XCA2HDYW/DSjUR0V1i4PyawSCw58wlJKdrcbS4Fq6Otnh8ii8ejfSFi4ONLDMQEVkgBs6tCCGQU3AZSelapJ2thKOtFR6O8MbKqSoMdbGXdRYiIgvAwOmM0xfqsSFDi69PlEOpAO4b74n4aDX83fubbCYiIjPDwOmKksvNeC8zH58cKkG73lipTozxR8jwAaYejYiot2PgdEfV1Ur1/kLUt3YgUjUIiTH+iB4xmJVqIqKbY+Dcjca2DmzLKcbGzAJcrG9FoIczEmLUmDtmKCvVRETXY+BIob3DgO1XKtX5VyvV0Wo8MMGLlWoiIiMGjpSuVqqT0rQ4VlKLwf1t8fgUPzwS6QOXfqxUE1GfxsDpCUIIHMi/jOR0LdJ/qkR/O+srlWo/DHFmpZqI+iQGTk87daEOG9Lz8fWJC7BWKo2Vao0KajdWqomoT2HgyKW42lip/vSwsVI9K3AoEmPUGMdKNRH1DQwcuVU1tuGDfYX4MNtYqZ6kckVijBpRrFQTkWVj4JhKY1sHth4sxsasfFyqb0PQMGckaNSYO9YDVkoGDxFZHAaOqbV3GLD9aBmSM4yVah9XB8RHq3B/KCvVRGRRGDi9hcEg8N3pS0hK1+J4SS0G97fDE1N98UikD5ztWakmIrPHwOltrlaqk9K1yLhSqY6L9MbKKX5wZ6WaiMwXA6c3O3WhDsnp+dh1pVJ9/wTjKtV+gx1NPRoRUVcxcMxBcXUzUjK1+PRwKXR6A+aO8UCCRo2xXi6mHo2IqLMYOOaksqENH+wvwIfZRWho7cBU/8FI0Kgxxd+VlWoi6u0YOOaooVWHbTkleC8zHxUNbRjr6YIEjRqzxwxlpZqIeisGjjlr69DjqyNlSMnIR35VE3xdHRAfrcbiUE9Wqomot2HgWAK9QeC7UxeRlK7FidI6uDnZ4YkpfoiL9Galmoh6CwaOJRFCIFtbjaR0LTLPVcHJzhpxkT54Yqov3J1YqSYik2LgWKq8sjokp2vx75PlsLZS4v5QL6yOVsGXlWoiMg0GjqUrrGpCSmY+Ps8tRYfegDmsVBORaTBw+oqKhla8v68QH2UXoaGNlWoikh0Dp6+pb9Xh44PF2JRVgMqGNgR7GSvVs4JYqSaiHsXA6atadXp8eaQMGzK0KKpuht9gR8RHq3DfeFaqiahHMHD6Or1BYHfeRSSna3GyrA7uTnZYOdUPD0d4w4mVaiKSDgOHjIQQ2K+tRlKaFlnnq+Bkb41HI33w+BQ/uDnZmXo8IjJ/DBy60cnSK5XqvHLYWCmxZIIX4qNYqSaiu8LAoVsrqGpCSoYWX+SWocNgwNyxxkr1GE9Wqomoyxg4dGcV9a3YtK8AqQeK0djWgagRg5EYo8YkFSvVRNRpDBzqvLoWHVIPFmFzViGqGtswzssFiTFqzAhkpZqI7oiBQ13360q16mqlOtQTdtasVBPRTTFwqPv0BoFv8sqRnK5FXlk9K9VEdDsMHLp7Qghkna9CcroW+85Xw8neGo9N8sGKyaxUE9E1pgmcJ554Al9//TXc3d2Rl5d3x50xcMzH8ZJaJKdrsfvURdhaKfFAmBfio9TwdnUw9WhEZFqdDhyllEddsWIFdu/eLeUuqZcYN3wAkh6ZgB+e1uC+8Z749FApYl7fi7Vbj+L0hXogNRXw9QWUSuPH1FRTj0xEvYy1lDuLjo5GYWGhlLukXkbl1h+v3R+M/54xEpuyCvDxwWLsPH4B0UWFSDQ4I1IIKIqKgPh44xfExZl2YCLqNSR9hUN9xxBne/y/uQHY99w9+N3xHTg92AcPPbweix59A7tHTIKhuQVYt87UYxJRLyJ5aaCwsBDz58+/5d9wUlJSkJKSAgCorKxEUVFRV45PvZFSiVYrG3w+ZhpSwhejeKAHVNUlSMj5Eotyd8PWmr/XEFkw07XU7hQ4v8TSgIXw9QWu/OLQoVDim1FTkBS5BKeHqDHU2R6rovywLNwb/e0kvYNLRL2DaUoD1Ee9+irgYGyrWQsD7v0xE7s+fR5bfBvhN9gRr+w6g8nrf8Ab351FVWObiYclIlORNHAeeughTJo0CWfPnoWXlxc2bdok5e6pt4qLA1JSAB8fQKEAfHygSEmBJuFBbI2PxPY1UzBJ7Yq/7z2PKa/9By9sz0PJ5WZTT01EMuMbP0k22spGpKTn48ujpTAIYN6VVaoDhzmbejQi6j6uNEC918W6VmzeV4DUA0VoatdDM9INiTFqRPgN4irVROaHgUO9X12zDh8dLMLmrAJUN7VjvPcAJGjUmBEwBEquUk1kLhg4ZD5adXp8lluKlAwtSi63wN+9P1ZHq7AwxJOVaqLej4FD5qdDb8C/8y4iKU2LM+X18HCxx8qpfngo3BuOrFQT9VYMHDJfQgik/1SJ5HQtDuRfhks/Gyyf5IPlk33h2p+rVBP1MgwcsgxHi2uQnK7Fd6cvwc5aiaVhw/FklArDB3GVaqJegoFDluV8RSNSMrT46mgZDAK4N9gDqzVqBHiwUk1kYgwcskzldS3YfGWV6qZ2PWJHuSExxh8TfQeyUk1kGgwcsmx1zTp8mF2ID/YXorqpHaHeA5AY449po91ZqSaSFwOH+oaWdj0+yy1BSkY+SmtaMMK9P1Zr1Fgwbhgr1UTyYOBQ39KhN2DXyXIkpWnx48UGeLjYY1WUCssmDmelmqhnMXCobxJCIO2nSiSlaZFTcKVSPdkXKyb7YpCjranHI7JEDByi3CJjpXrP6Uuwt1Fi2URvrIryg9dAVqqJJMTAIbrq3KUGJKfnY8exMggAC8YNQ4JGjVFDnUw9GpElYOAQ/dqF2hZsyirA1pxiNLfrcc9odyTGqDHRd5CpRyMyZwwcolupaWrHPw8U4f19Bahp1mGCz0AkatS4h5Vqou5g4BDdSUu7Hp8eNlaqy2qNleoEjRoLQobBxoqVaqJOYuAQdZZOb8CuE8ZK9dlLDRh2tVIdPhwOtqxUE90BA4eoq4QQ2Hu2Aslp+cgpvIwBDjZYPslYqR7ISjXRrTBwiO5GbtFlJKXl4/szl9DPxgrLwodjVZQKngP6mXo0ot6GgUMkhZ8uNSA5XYudxy4AABaEGCvVI4ewUk10BQOHSEpltS3YmJmPbTklaNHpMT3AHQkaNcJYqSZi4BD1hJqmdmzJLsSW/YWoadYhzGcgEmPUiB3FSjX1WQwcop7U3N6BTw6VYGNmAcpqWzBqiBNWa1S4dxwr1dTnMHCI5KDTG/Cv4xeQnK7FT5ca4TmgH56M8sODE73Rz9bK1OMRyYGBQyQng8FYqU5K0+JwUQ0GOthgxWQ/PDbJh5VqsnQMHCJTOVR4GclpWvzwYwUr1dQXMHCITO3sxQZsSNdi53FjpXphiCcSNCqMYKWaLAsDh6i3KKttwXsZ+fjk0NVK9RAkxqgwwYeVarIIDByi3uZyUzu27C/EluxC1DbrEO47CIkxasSMcoNCwUo1mS0GDlFv1dzegW05JdiYmY8Lda0YPdQJCRo15gd7wJqVajI/DByi3k6nN2DnMWOl+lyFsVIdH63C0rDhrFSTOWHgEJkLg0HgPz9WICldi9yiGgxytMWKyb54bJIPBjiwUk29HgOHyBz9slLtYGuFh8K9sSrKDx4urFRTr8XAITJnP16sx4b0fOw8fgFKxc+Van93Vqqp12HgEFmCksvN2JRVgG2HitGqM2Bm4BAkxKgR6j3Q1KMRXcXAIbIk1Y1tVyrVRahr0SHCz1ip1oxkpZpMjoFDZIma2jqwNacYm7IKUF7XigAPZyRoVJg3lpVqMhkGDpEla+8wYMexMmzIyMf5ikYMH9QPT0ap8MAEVqpJdgwcor7AYBD4/swlJKdrcaS4Fq7XKtW+cHGwMfV41DcwcIj6EiEEDhXWICntPPaerYSjrRUejvDGyqkqDHWxN/V4ZNkYOER91ZnyeiSna/H1iXIoFcB94z0RH62Gv3t/U49GlomBQ9TXlVxuxsbMfGw7VIJ2/ZVKtUaN8axUk7QYOERkVHWlUv0hK9XUMxg4RHS9xrYObMspxsbMAlysZ6WaJNPpwJH8v7Ldu3dj1KhR8Pf3x2uvvSb17omom/rbWWNVlAoZv4/F/y4JRnuHHv+17Rhi30jDPw8UoVWnN/WIZOEkDRy9Xo81a9bgm2++wenTp7F161acPn1aykMQ0V2ytVbigbDh2PPfGmx4dAJcHe3wwvY8TP3zf/Du3vOoa9EBqamAry+gVBo/pqaaemyyANZS7iwnJwf+/v5QqVQAgGXLlmHHjh0IDAyU8jBEJAGlUoFZQUMxM3AIDhZcRlKaFv/77Vkk7fkRDx/OwMrqBgwRAigqAuLjjV8UF2faocmsSfoKp6ysDMOHD7/2uZeXF8rKyqQ8BBFJTKFQIFLlii1PhGPX2qm4p+AwNobMQ9TqTXh29lPQDvIEmpuBdetMPSqZuS6VBmbPni2qqqpu+XxNTQ3q6+vh4+MDAKiurkZTUxO8vb2vbVNZWYmr+2hra0NISEg3RzcvlZWVcHNzM/UYPY7naQFyc9FuZY0qh4G47OAMAQWc2xrh1lQDh+Axpp6uR1j09fwVqc81Nzf3WyHE7M5sK2lLLTs7Gy+++CK+/fZbAMD69esBAM8///xNt3d0dERTU1NXjm+2+kojj+dpAXx9jbfRAIQ6uCBuwr3YEjof9fb9MUnlisQYNaJGDLaoSrVFX89f6YFzNU1LbeLEiTh37hwKCgrQ3t6Obdu2YcGCBVIegoh62quvAg4OAABlcx1+m/kR9n/wG6wb2oL8qkY8tjkH89/Jwr+OX4DeIOk7JcjCSRo41tbW+Pvf/45Zs2YhICAAS5cuRVBQkJSHIKKeFhcHpKQAV26Nw8cH/d/9G578v0uQ8ftY/OX+YLTo9Hhq61Hc80YaUg+yUk2dI2lLDQDmzp2LuXPndmrbwYMHS334Xiv+asvHwvE8LURcHBAXh/iUlJ8bagDsrK2wdOJwLJnghe9OX0JS2nms+yoPf91zDo9P8cUjkT5w6Wd+q1Rb/PX8BVOeK1caIKJuE0IgO78aSWlaZJ6rQn87a8RFeOOJqX4Y4sxVqvsILm1DRPLKK6vDhox87DpxAdZKJRaHeiI+WgWVG1eptnCmW9rmZu603E1bWxsefPBB+Pv7IyIiAoWFhXKMJbk7necHH3wANzc3hISEICQkBBs3bjTBlHfviSeegLu7O8aMuXlFVgiBtWvXwt/fH8HBwThy5IjME0rjTueZlpYGFxeXa9fz5ZdflnlCaZSUlCA2NhaBgYEICgrC22+/fcM2nbmmYzxd8M5D47H3mRgsneiFL4+WYdqb6Uj8KBcnSmvlOJXb6sx5WsI1bW1tRXh4OMaNG4egoCD88Y9/vGEbk/3MFUJ05V+XdXR0CJVKJbRarWhraxPBwcHi1KlTQgghJkyYIIQQ4t133xWrV68WQgixdetWsXTp0u4cyqRud55Xvf/++2LNmjUmmlA66enpIjc3VwQFBd30+V27donZs2cLg8EgsrOzRXh4uMwTSuNO57l3714xb948maeS3oULF0Rubq4QQoj6+noxYsSIG/7b7c41rahvFX/ZfUaM+eNu4fPs1+Lh97JF5k+VwmAw9Mh53ElnztMSrqnBYBANDQ1CCCHa29tFeHi4yM7Ovm4biX/mdjpDevwVzi+Xu7G1tb223M0v7dixA8uXLwcALFmyBD/88ANE1271mVxnztNSREdHY9CgQbd8fseOHXjssceM72CPjERtbS3Ky8tlnFAadzpPS+Hh4YHQ0FAAgJOTEwICAm5YIaQ719TNyQ6/mzUa+5+7B8/PGY1zlxrxyKaDuPfvWfj6hPyV6s6cpyVQKBTo3994G1On00Gn093wnilT/czt8cDpzHI3v9zG2toaLi4uqK6u7unRJNXZZX2++OILBAcHY8mSJSgpKZFzRNn0pSWOsrOzMW7cOMyZMwenTp0y9Th3rbCwEEePHkVERMR1j9/NNXWyt8FqjRqZz8bitcVj0dSmx//5+CimmbBSfavzBCzjmur1eoSEhMDd3R0zZsy47fWU82cu/ycYMrr33ntRWFiIEydOYMaMGdd+wyDzFBoaiqKiIhw/fhxPPfUUFi1aZOqR7kpjYyPuv/9+vPXWW3B2dpZ8/3bWVlgW7o3vn9YgKS4ULv1ssO6rPEz98178I+086lt1kh/zZm53npZyTa2srHDs2DGUlpYiJycHeXl5ph4JgAyB4+nped1v8qWlpfD09LzlNh0dHairq4Orq2tPjyapzpynq6sr7OzsAACrVq1Cbm6urDPKpTPfC0vg7Ox87dbF3LlzodPpcLu1BnsznU6H+++/H3FxcVi8ePENz0t5Ta2UCswZ64Hta6bg41URCPBwwl92n8WU9f/B+m/OoKK+tdvncSd3Ok9LuqYAMGDAAMTGxmL37t3XPW6qn7k9HjidWe5mwYIF2LJlCwDg888/xz333GN26zR15jx/ec97586dCAgIkHtMWSxYsAAffvghhBA4cOAAXFxc4OHhYeqxJHfx4sVr971zcnJgMBjM7hclwFgcWrlyJQICAvD000/fdJueuKYKhQKT/Qfjnysj8PVTU6EZ5Yb3MvIx9c978fyXJ1FYJe06i505T0u4ppWVlaitNbYCW1pasGfPHowePfq6bUz2M7crDYPuVhh27dolRowYIVQqlXjllVeEEEK88MILQq1WCyGEaGlpEUuWLBFqtVpMnDhRaLXa7h7KpG51njt27BBCCPHcc8+JwMBAERwcLGJiYsSZM2dMOW63LVu2TAwdOlRYW1sLT09PsXHjRpGUlCSSkpKEEMaWzG9+8xuhUqnEmDFjxKFDh0w8cffc6Tzfeeeda9czIiJC7Nu3z8QTd09mZqYAIMaOHSvGjRsnxo0bJ3bt2mWSa1pQ2Sie//KEGLHu38L3ua/Fbz7KFSdKaiXZd2fO0xKu6fHjx0VISIgYO3asCAoKEi+99JIQ4vqfRRL/zO10hvCNn0TU61Q0tOL9fYX4KLsIDW0dmOo/GIkxakxWu5rd3Y8+gCsNEJH5q2/V4eODxdiUVYDKhjaM9XRBYowas4KGwkrJ4OklGDhEZDnaOvT48kgZUjLyUVDVBL/BjngySoXFoZ6wt7Ey9Xh9HQOHiCyP3iDw7amLSErT4mRZHdyc7LByqh/iIrzhZG9+q1RbCAYOEVkuIQT2a42rVGedr4KTnTUemeSDx6f4wt2Jq1TLjIFDRH3DydI6JKWfxzd5F2FjpcQDE7wQH62Cj6ujqUfrKxg4RNS3FFQ1ISUjH1/klqLDYMDcsR5I0KgxxtPF1KNZOgYOEfVNFfWt2LyvEKkHjJXqqBGDkahRYxIr1T2FgUNEfVt9qw6pB4qxeZ+xUh3s5YJEjRozWamWGgOHiAgAWnXGSvWGDC2KqpuhGuyI1RoVFo33hJ01K9USYOAQEf2S3iDwTV45ktO1yCurxxBnY6X6oXBWqu8SA4eI6GaEENh3vhpJ6eex73w1nOyt8WikDx6f4gc3JztTj2eOGDhERHdyvKQWGzK0rFTfHQYOEVFn5Vc24r3MfHyRW4YOgwHzgochQaNC0DBWqjuBgUNE1FUV9a3YtK8AqQeK0djWgeiRbkjUqBGpGsRK9a0xcIiIuquuRYePDhTh/X2FqGpsw7jhA4yV6sAhULJS/WsMHCKiu9Wq0+OLI6XYkJ6P4svNULk5IiFajUXjPWFr3eP/w2RzwcAhIpJKh96Ab/IuIjldi1MX6jHU2d5YqY7wRn87a1OPZ2oMHCIiqQkhkHmuCsnpWuwLp8fsAAAFxklEQVTXVsPZ3hqPTfLFiim+GNy/z1aqGThERD3peEktktO12H3qImytlFgaNhxPRqng7epg6tHkxsAhIpKDtrIR72Xk44sjpdAbBOYHD0OCRo3AYc6mHk0uDBwiIjldqm/F5qwCfHSgCE3tesSMckOCRo0IP4uvVDNwiIhMoa5Zh48OFmFzVgGqm9ox3nsAEjRqzAiw2Eo1A4eIyJRadXp8lluKlAwtSi63QO3miNWWWalm4BAR9QYdegP+nXcRyWlanC43VqpXRflhWbjFVKoZOEREvYkQAhnnqpCcpkV2vrFSvXyyL1ZM9oWreVeqGThERL3V0eIaJKdr8d3pS7CzVuLBsOFYFaXC8EFmWalm4BAR9XbnKxqRkqHFV0fLYBDA/GAPJGjUCPAwq0o1A4eIyFyU17VgU2YBtuYUX6tUJ2rUCDePSjUDh4jI3NQ16/DPA4V4f1/htUp1okaN6b27Us3AISIyV606PT49XIKUjHyU1rTA370/VkersDCkV1aqGThEROauQ2/ArpPlSErT4seLDfBwsceqKBWWTRwOx95TqWbgEBFZCiEE0n6qRHKaFgcLLmOAg41xlerJvhjkaGvq8Rg4RESW6EhxDZLStNhz+hLsbZRYNtEbq6L84DXQZJVqBg4RkSU7X9GADen52H7MWKleMG4YVmtUGD1U9ko1A4eIqC+4Wqn+OKcYze16xI5yQ2KMPyb6DpSrUt3pg0hWd/jss88QFBQEpVLJECEikomHSz/8YX4g9j93D347YySOl9Zh6YZsLEnOxvenL8FguPI6ITUV8PUFlErjx9RU2WeV7BXOmTNnoFQqsXr1arz++usICwu74874CoeISFot7T9XqstqWzDCvT9W217CwudXwaax4ecNHRyAlBQgLu5uDyn/K5yAgACMGjVKqt0REVE39LO1wvLJvkj7XQzeejAEVkoFnil1hObRt7F5wgI021xZKLS5GVi3TtbZZC9yp6SkICUlBQBQWVkp9+GJiPoEGyslFo33xMKQYUgbEY6kiCV4eXo8HHStWHbiO+NGxcWyztSlwJk+fTouXrx4w+OvvvoqFi5c2Kl9xMfHIz4+HgA6dduNiIi6T6FQILajErEfP4fcYaMRdEn785Pe3rLO0qXA+f7773tqDiIi6imvvgrEx2PChR9/fszBwfi4jHrdojxERCSxuDhjQcDHB1AojB+lKQx0iWQtta+++gpPPfUUKisrMWDAAISEhODbb7+97c7YUiMiMnt84ycREclC/lo0ERHR7TBwiIhIFgwcIiKSBQOHiIhkwcAhIiJZMHCIiEgWDBwiIpIFA4eIiGTBwCEiIlkwcIiISBYMHCIikgUDh4iIZMHAISIiWTBwiIhIFgwcIiKSBQOHiIhkwcAhIiJZMHCIiEgWDBwiIpIFA4eIiGTBwCEiIlkwcIiISBYMHCIikgUDh4iIZMHAISIiWTBwiIhIFgwcIiKSBQOHiIhkwcAhIiJZMHCIiEgWDBwiIpIFA4eIiGTBwCEiIlkwcIiISBYMHCIikgUDh4iIZMHAISIiWTBwiIhIFgwcIiKSBQOHiIhkwcAhIiJZMHCIiEgWDBwiIpIFA4eIiGTBwCEiIllIFji/+93vMHr0aAQHB+O+++5DbW2tVLsmIiILIFngzJgxA3l5eThx4gRGjhyJ9evXS7VrIiKyAJIFzsyZM2FtbQ0AiIyMRGlpqVS7JiIiC9Ajf8PZvHkz5syZ0xO7JiIiM6UQQnR+Y4XiewBDb/LUOiHEjivbrAMQBmCxuMnOFQpFPID4K5/aCyHGdHlqIiIyO10KnDvuTKFYAWA1gGlCiGbJdkxERGbPWqodKRSK2QB+D0DDsCEiol+T7BWOQqE4D8AOQPWVhw4IIRIk2TkREZk9SW+pERER3QpXGiAiIlkwcIiISBYMHCIikgUDh4iIZMHAISIiWTBwiIhIFgwcIiKSBQOHiIhk8f8B9sXsBChwqZ8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x1 = np.linspace(min(x), max(x), 100)\n",
    "y1 = lambdify(xs, po)(x1)\n",
    "\n",
    "fig = plt.figure(figsize=(7,5))  \n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "# Move left y-axis and bottim x-axis to centre, passing through (0,0)\n",
    "ax.spines['left'].set_position('zero')  #'center')\n",
    "ax.spines['bottom'].set_position('zero')  #center')\n",
    "# Eliminate upper and right axes\n",
    "ax.spines['right'].set_color('none')\n",
    "ax.spines['top'].set_color('none')\n",
    "# Show ticks in the left and lower axes only\n",
    "ax.xaxis.set_ticks_position('bottom')\n",
    "ax.yaxis.set_ticks_position('left')\n",
    "plt.ylim([min(y)-1,max(y)+1])\n",
    "lti=\"$y = P_{%i}(x)$\" %d\n",
    "ax.plot(x1, y1,label=lti)\n",
    "ax.legend(loc='upper right')\n",
    "ax.scatter(x,y, c = 'r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.2 Newton's divided differences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Notation*. Denote by $f[x_1 \\ldots x_n]$ the coefficient of the $x_{n−1}$ term in the (unique) polynomial that interpolates $(x_1,f(x_1)), \\ldots,(x_n,f(x_n))$.\n",
    "\n",
    "Using this notation, the following somewhat remarkable alternative formula for the interpolating polynomial holds, called the **Newton’s divided difference formula**:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "P(x) = f[x_1] &+ f[x_1 \\,\\, x_2](x - x_1)\\\\\n",
    "&+f[x_1 \\,\\, x_2 \\,\\, x_3](x - x_1)(x - x_2)\\\\\n",
    "&+f[x_1 \\,\\, x_2 \\,\\, x_3 \\,\\, x_4](x - x_1)(x - x_2)(x - x_3)\\\\\n",
    "&+ \\cdots\\\\\n",
    "&+f[x_1 \\cdots x_n](x - x_1) \\cdots (x - x_{n-1})\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "Moreover, the coefficients $f[x_1 \\cdots x_k]$ can be recursively calculated as follows:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "f[x_k] &= f(x_k)\\\\\n",
    "f[x_k \\,\\, x_{k+1}] &= \\frac{f[x_{k+1}] - f[x_k]}{x_{k+1} - x_k}\\\\\n",
    "f[x_k \\,\\, x_{k+1} \\,\\, x_{k+2}] &= \\frac{f[x_{k+1} \\,\\, x_{k+2}] - f[x_k \\,\\, x_{k+1}]}{x_{k+2} - x_k}\\\\\n",
    "f[x_k \\,\\, x_{k+1} \\,\\, x_{k+2} \\,\\, x_{k+3}] &= \\frac{f[x_{k+1} \\,\\, x_{k+2} \\,\\, x_{k+3}] - f[x_k \\,\\, x_{k+1} \\,\\, x_{k+2}]}{x_{k+3} - x_k}\\\\\n",
    "&\\mbox{and so on}\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getNDDCoeffs(x, y):\n",
    "    \"\"\" Creates NDD pyramid and extracts coeffs \"\"\"\n",
    "    n = np.shape(y)[0]\n",
    "    pyramid = np.zeros([n, n]) # Create a square matrix to hold pyramid\n",
    "    pyramid[::,0] = y # first column is y\n",
    "    for j in range(1,n):\n",
    "        for i in range(n-j):\n",
    "            # create pyramid by updating other columns\n",
    "            pyramid[i][j] = (pyramid[i+1][j-1] - pyramid[i][j-1]) / (x[i+j] - x[i])\n",
    "    return pyramid[0] # return first row\n",
    "\n",
    "def NDD_poly(coeff_vector,x,nt=0):\n",
    "    # create the unique polynomial of degree at most equal to size of data minus one \n",
    "    final_pol = np.polynomial.Polynomial([0.]) # our target polynomial\n",
    "    n = coeff_vector.shape[0] # get number of coeffs\n",
    "    for i in range(n):\n",
    "        p = np.polynomial.Polynomial([1.]) # create a dummy polynomial\n",
    "        for j in range(i):\n",
    "            # each vector has degree of i\n",
    "            # their terms are dependant on 'x' values\n",
    "            p_temp = np.polynomial.Polynomial([-x[j], 1.]) # (x - x_j)\n",
    "            p = np.polymul(p, p_temp) # multiply dummy with expression\n",
    "        p *= coeff_vector[i] # apply coefficient\n",
    "        final_pol = np.polyadd(final_pol, p) # add to target polynomial\n",
    "    p = np.flip(final_pol[0].coef, axis=0)\n",
    "    y=Symbol('x')\n",
    "    pp = []\n",
    "    for i in p.tolist():\n",
    "        if nt==0:\n",
    "            pp.append(Rational(i))\n",
    "        else:\n",
    "            pp.append(i)\n",
    "    p1=Poly(pp, y)\n",
    "    return p1.as_expr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#19bfc2\">EXAMPLE 3.3</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use divided differences to find the interpolating polynomial passing through the points $(0, 1), (2, 2), (3, 4)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The upper side of Newton's divided difference triangle is: [1.  0.5 0.5]\n"
     ]
    }
   ],
   "source": [
    "points=[[0,1],[2,2],[3,4]]\n",
    "\n",
    "x=np.array([p[0] for p in points])\n",
    "y=np.array([p[1] for p in points])\n",
    "\n",
    "coeff_vector = getNDDCoeffs(x, y)\n",
    "print(\"The upper side of Newton's divided difference triangle is:\",coeff_vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Newton's divided difference polynomial is:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{2}(x) =  + \\frac{x^{2}}{2} - \\frac{x}{2} + 1$"
      ],
      "text/plain": [
       "P_{2}(x) =  + x**2/2 - x/2 + 1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"The Newton's divided difference polynomial is:\")\n",
    "sp=NDD_poly(coeff_vector,x)\n",
    "\n",
    "d=len(x)-1\n",
    "\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "spl=px+sp\n",
    "spl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#19bfc2\">EXAMPLE 3.4</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add the fourth data point $(1,0)$ to the list in Example 3.3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The upper side of Newton's divided difference triangle is: [ 1.   0.5  0.5 -0.5]\n"
     ]
    }
   ],
   "source": [
    "points=[[0,1],[2,2],[3,4],[1,0]]\n",
    "\n",
    "x=np.array([p[0] for p in points])\n",
    "y=np.array([p[1] for p in points])\n",
    "\n",
    "coeff_vector = getNDDCoeffs(x, y)\n",
    "print(\"The upper side of Newton's divided difference triangle is:\",coeff_vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Newton's divided difference polynomial is:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{3}(x) =  - \\frac{x^{3}}{2} + 3 x^{2} - \\frac{7 x}{2} + 1$"
      ],
      "text/plain": [
       "P_{3}(x) =  - x**3/2 + 3*x**2 - 7*x/2 + 1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"The Newton's divided difference polynomial is:\")\n",
    "sp=NDD_poly(coeff_vector,x)\n",
    "\n",
    "d=len(x)-1\n",
    "\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "spl=px+sp\n",
    "spl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#19bfc2\">EXAMPLE 3.5</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use Newton’s divided differences to find the interpolating polynomial passing through $(0, 2), (1, 1), (2, 0), (3, −1)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The upper side of Newton's divided differences triangle is: [ 2. -1.  0.  0.]\n"
     ]
    }
   ],
   "source": [
    "points=[[0,2],[1,1],[2,0],[3,-1]]\n",
    "\n",
    "x=[p[0] for p in points]\n",
    "y=[p[1] for p in points]\n",
    "\n",
    "coeff_vector = getNDDCoeffs(x, y)\n",
    "print(\"The upper side of Newton's divided differences triangle is:\",coeff_vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Newton's divided difference polynomial is:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{1}(x) =  - x + 2$"
      ],
      "text/plain": [
       "P_{1}(x) =  - x + 2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"The Newton's divided difference polynomial is:\")\n",
    "sp=NDD_poly(coeff_vector,x)\n",
    "\n",
    "d=1 #len(x)-1\n",
    "\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "spl=px+sp\n",
    "spl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.3 How many degree $d$ polynomials pass through $n$ points?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let $P_{n-1}(x)$ be the unique polynomial of degree $\\leq n - 1$ interpolating the $n$ points $(x_1,y_1), \\ldots, (x_n,y_n)$. Then, for every $m \\geq n$, there exist infinitely many polynomials of degree $m$ given by the following one-parametric family of polynomials:\n",
    "\n",
    "$$P_m(x) = P_{n-1}(x) + c x^{m - n + 1} (x - x_1) \\cdots (x - x_n)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def NDD_poly_higher(coeff_vector,xv,d,nt=0):\n",
    "    # create an one-parametric family of polynomials of degree at least equal to size of data\n",
    "    # d = m - n\n",
    "    final_pol = np.polynomial.Polynomial([0.]) # our target polynomial\n",
    "    n = coeff_vector.shape[0] # get number of coeffs\n",
    "    for i in range(n):\n",
    "        p = np.polynomial.Polynomial([1.]) # create a dummy polynomial\n",
    "        for j in range(i):\n",
    "            # each vector has degree of i\n",
    "            # their terms are dependant on 'x' values\n",
    "            p_temp = np.polynomial.Polynomial([-x[j], 1.]) # (x - x_j)\n",
    "            p = np.polymul(p, p_temp) # multiply dummy with expression\n",
    "        p *= coeff_vector[i] # apply coefficient\n",
    "        final_pol = np.polyadd(final_pol, p) # add to target polynomial\n",
    "    p = np.flip(final_pol[0].coef, axis=0)\n",
    "    y=Symbol('x')\n",
    "    pp = []\n",
    "    for i in p.tolist():\n",
    "        if nt==0:\n",
    "            pp.append(Rational(i))\n",
    "        else:\n",
    "            pp.append(i)\n",
    "#         pp.append(Rational(i))\n",
    "    pl=Poly(pp, y)\n",
    "    c=Symbol('c')\n",
    "    lp=None\n",
    "    xx=xv.copy()\n",
    "    if d>0:\n",
    "        for i in range(d):\n",
    "            xx.append(0)\n",
    "    for i in xx:\n",
    "        if lp ==None:\n",
    "            lp = Poly(y-i)\n",
    "        else:\n",
    "            lp *= Poly(y-i)\n",
    "    llp=pl + c*lp\n",
    "    sti='P_{%i}(x)' %(n-1)\n",
    "    px=Symbol(sti)\n",
    "    plx = px + c*lp\n",
    "    return plx.as_expr(), llp.as_expr(), factor(lp), factor(lp)*c + px"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#19bfc2\">EXAMPLE 3.6</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many polynomials of each degree $0 \\leq d \\leq 5$ pass through the points $(−1, −5), (0,−1),(2,1)$, and $(3,11)$?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The upper side of Newton's divided differences triangle is: [-5.  4. -1.  1.]\n",
      "The Newton's divided difference polynomial is:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{3}(x) =  + x^{3} - 2 x^{2} + x - 1$"
      ],
      "text/plain": [
       "P_{3}(x) =  + x**3 - 2*x**2 + x - 1"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# There is a unique polynomial of degree 3 interpolating the four points. \n",
    "# Therefore there are no interpolating polynomials of degrees 0, 1, and 2.\n",
    "\n",
    "points=[[-1,-5],[0,-1],[2,1],[3,11]]\n",
    "\n",
    "x=[p[0] for p in points]\n",
    "y=[p[1] for p in points]\n",
    "\n",
    "coeff_vector = getNDDCoeffs(x, y)\n",
    "print(\"The upper side of Newton's divided differences triangle is:\",coeff_vector)\n",
    "print(\"The Newton's divided difference polynomial is:\")\n",
    "sp=NDD_poly(coeff_vector,x)\n",
    "\n",
    "d=len(x)-1\n",
    "\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "spl=px+sp\n",
    "spl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The infinitely many polynomials of degree 4 are:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{3}(x) + c x \\left(x - 3\\right) \\left(x - 2\\right) \\left(x + 1\\right)$"
      ],
      "text/plain": [
       "P_{3}(x) + c*x*(x - 3)*(x - 2)*(x + 1)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The infinitely many polynomials of degree 4 are given by:\n",
    "\n",
    "n=len(x)\n",
    "first=NDD_poly_higher(coeff_vector,x,0)[3]\n",
    "print(\"The infinitely many polynomials of degree %i are:\" %n)\n",
    "sp=first\n",
    "sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The infinitely many polynomials of degree 4 are in expanded form:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{4}(x) =  + c x^{4} + x^{3} \\left(1 - 4 c\\right) + x^{2} \\left(c - 2\\right) + x \\left(6 c + 1\\right) - 1$"
      ],
      "text/plain": [
       "P_{4}(x) =  + c*x**4 + x**3*(1 - 4*c) + x**2*(c - 2) + x*(6*c + 1) - 1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second=NDD_poly_higher(coeff_vector,x,0)[1]\n",
    "d=n\n",
    "print(\"The infinitely many polynomials of degree %i are in expanded form:\" %d)\n",
    "sp=second\n",
    "\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "spl=px+sp\n",
    "spl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The infinitely many polynomials of degree 5 are:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{3}(x) + c x^{2} \\left(x - 3\\right) \\left(x - 2\\right) \\left(x + 1\\right)$"
      ],
      "text/plain": [
       "P_{3}(x) + c*x**2*(x - 3)*(x - 2)*(x + 1)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The infinitely many polynomials of degree 5 are given by:\n",
    "\n",
    "n=len(x)\n",
    "first=NDD_poly_higher(coeff_vector,x,1)[3]\n",
    "print(\"The infinitely many polynomials of degree %i are:\" %(n+1))\n",
    "first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The infinitely many polynomials of degree 5 are in expanded form:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{5}(x) =  + c x^{5} - 4 c x^{4} + x^{3} \\left(c + 1\\right) + x^{2} \\left(6 c - 2\\right) + x - 1$"
      ],
      "text/plain": [
       "P_{5}(x) =  + c*x**5 - 4*c*x**4 + x**3*(c + 1) + x**2*(6*c - 2) + x - 1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second=NDD_poly_higher(coeff_vector,x,1)[1]\n",
    "d=n+1\n",
    "print(\"The infinitely many polynomials of degree %i are in expanded form:\" %d)\n",
    "sp=second\n",
    "\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "spl=px+sp\n",
    "spl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.5 Representing functions by approximating polynomials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A major use of polynomial interpolation is to replace evaluation of a complicated function by evaluation of a polynomial, which involves only elementary computer operations like addition, subtraction, and multiplication. Think of this as a form of compression: Something complex is replaced with something simpler and computable, with perhaps some loss in accuracy that we will have to analyze. Let us give an example from trigonometry."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#19bfc2\">EXAMPLE 3.7</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interpolate the function $f(x) = sin x$ at 4 equally spaced points on $[0,\\pi/2]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The upper side of Newton's divided differences triangle is: [ 0.          0.95492966 -0.24434036 -0.1138719 ]\n",
      "The Newton's divided difference polynomial is:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{3}(x) =  - 0.113871899071412 x^{3} - 0.0654708032116358 x^{2} + 1.02042871862363 x$"
      ],
      "text/plain": [
       "P_{3}(x) =  - 0.113871899071412*x**3 - 0.0654708032116358*x**2 + 1.02042871862363*x"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[0.,np.pi/6,np.pi/3, np.pi/2]\n",
    "y=[np.sin(a) for a in x]\n",
    "\n",
    "coeff_vector = getNDDCoeffs(x, y)\n",
    "print(\"The upper side of Newton's divided differences triangle is:\",coeff_vector)\n",
    "print(\"The Newton's divided difference polynomial is:\")\n",
    "sp=NDD_poly(coeff_vector,x,nt=1)\n",
    "\n",
    "d=len(x)-1\n",
    "\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "spl=px+sp\n",
    "spl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cop=poly(sp).coeffs()\n",
    "cop=np.array(cop)\n",
    "\n",
    "missing_powers_indices=[len(cop)]\n",
    "for k in missing_powers_indices:\n",
    "    cop=np.insert(cop,k,float(0))\n",
    "\n",
    "ip=np.poly1d(cop)\n",
    "\n",
    "fig = plt.figure(figsize=(10,8))  \n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "# Move left y-axis and bottim x-axis to centre, passing through (0,0)\n",
    "ax.spines['left'].set_position('center')\n",
    "ax.spines['bottom'].set_position('zero')  #center')\n",
    "# Eliminate upper and right axes\n",
    "ax.spines['right'].set_color('none')\n",
    "ax.spines['top'].set_color('none')\n",
    "# Show ticks in the left and lower axes only\n",
    "ax.xaxis.set_ticks_position('bottom')\n",
    "ax.yaxis.set_ticks_position('left')\n",
    "plt.ylim([min(y)-1,max(y)+0.1])\n",
    "xx = np.linspace(-max(x), max(x), 100)\n",
    "lti1=\"$y = P_{%i}(x)$\" %d\n",
    "plt.plot(xx, ip(xx),label=lti1)\n",
    "ax.scatter(x,y, c = 'r')\n",
    "lti2=\"$y = \\sin x$\" \n",
    "plt.plot(xx, np.sin(xx),label=lti2)\n",
    "ax.legend(loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 Interpolation Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.1 Interpolation error formula"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assume that we start with a function $y = f(x)$ and take data points from it to build an interpolating polynomial $P(x)$. The **interpolation error** at $x$ is $f(x) − P(x)$, the difference between the original function that provided the data points and the interpolating polynomial, evaluated at $x$. In other words, the interpolation error is the vertical distance between the curves $y = f(x)$ and $y_p = P(x)$. \n",
    "\n",
    "*Theorem*. Assume that $P(x)$ is the (degree $n - 1$ or less) interpolating polynomial fitting the $n$ points $(x_1,y_1), \\ldots, (x_n,y_n)$. If $f$ is $n$ times differentiable, then the interpolation error is:\n",
    "\n",
    "$$f(x) - P(x) = \\frac{(x - x_1)(x - x_2) \\cdots (x - x_n)}{n!} f^{(n)}(c),$$\n",
    "\n",
    "where $c$ lies between the smallest and largest of the numbers $x, x_1, \\ldots, x_n$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#19bfc2\">EXAMPLE 3.8</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find an upper bound for the difference at $x = 0.25$ and $x = 0.75$ between $f(x) = e^x$ and\n",
    "the polynomial that interpolates it at the points $−1, −0.5, 0, 0.5, 1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An upper bound of the interpolation error at 0.25 is 0.000995\n",
      "An upper bound of the interpolation error at 0.75 is 0.002323\n"
     ]
    }
   ],
   "source": [
    "x=[-1, -0.5, 0, 0.5, 1]\n",
    "y=[np.exp(a) for a in x]\n",
    "n=len(x)\n",
    "nf=np.math.factorial(n)\n",
    "\n",
    "# Since the point c is in [-1,1] and the derivative of e^x is still e^x, which is an increasing function,\n",
    "# the term f^(n)(c) is bounded by just e\n",
    "\n",
    "def g(z):\n",
    "    p=1\n",
    "    for i in np.arange(n):\n",
    "        p*=(z-x[i])\n",
    "    return abs(p*np.exp(1)/nf)\n",
    "\n",
    "pois=[0.25,0.75]\n",
    "\n",
    "for i in pois:\n",
    "    print(\"An upper bound of the interpolation error at %.2f is %.6f\" %(i,g(i)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The upper side of Newton's divided differences triangle is: [0.36787944 0.47730244 0.30963624 0.13391174 0.0434357 ]\n",
      "The Newton's divided difference polynomial is:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{4}(x) =  + 0.0434356986529606 x^{4} + 0.177347443541742 x^{3} + 0.499644936162283 x^{2} + 0.997853750102059 x + 1.0$"
      ],
      "text/plain": [
       "P_{4}(x) =  + 0.0434356986529606*x**4 + 0.177347443541742*x**3 + 0.499644936162283*x**2 + 0.997853750102059*x + 1.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[-1, -0.5, 0, 0.5, 1]\n",
    "y=[np.exp(a) for a in x]\n",
    "\n",
    "coeff_vector = getNDDCoeffs(x, y)\n",
    "print(\"The upper side of Newton's divided differences triangle is:\",coeff_vector)\n",
    "print(\"The Newton's divided difference polynomial is:\")\n",
    "sp=NDD_poly(coeff_vector,x,nt=1)\n",
    "\n",
    "d=len(x)-1\n",
    "\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "spl=px+sp\n",
    "spl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The actual interpolation error at 0.25 is 0.000393\n",
      "The actual interpolation error at 0.75 is 0.001002\n"
     ]
    }
   ],
   "source": [
    "cop=poly(sp).coeffs()\n",
    "cop=np.array(cop)\n",
    "\n",
    "missing_powers_indices=[]\n",
    "\n",
    "ip=np.poly1d(cop)\n",
    "\n",
    "pois=[0.25,0.75]\n",
    "\n",
    "for i in pois:\n",
    "    print(\"The actual interpolation error at %.2f is %.6f\" %(i,abs(np.exp(i)-ip(i))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.3 Runge phenomenon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The so-called **Runge phenomenon** is usually used to describe extreme \"polynomial wiggle\" associated with high-degree polynomial interpolation at evenly spaced points, occurring when the interpolating polynomial that goes through certain points refuses to stay between (say) 0 and 1, unlike the data points. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#19bfc2\">EXAMPLE 3.9</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interpolate $f(x) = \\frac{1}{1 + 12 x^2}$ at evenly spaced points in $[-1,1]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle P_{6}(x) =  - 0.0248873014272752 x^{6} + 0.350496161767459 x^{4} - 1.24868578341711 x^{2} + 2.77555756156289 \\cdot 10^{-16} x + 1.0$"
      ],
      "text/plain": [
       "P_{6}(x) =  - 0.0248873014272752*x**6 + 0.350496161767459*x**4 - 1.24868578341711*x**2 + 2.77555756156289e-16*x + 1.0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[-3,-2,-1,0,1,2,3]\n",
    "f = lambda z: 1/(1+12*z**2)\n",
    "y=[f(a) for a in x]\n",
    "d=len(x)-1\n",
    "\n",
    "coeff_vector = getNDDCoeffs(x, y)\n",
    "sp=NDD_poly(coeff_vector,x,nt=1)\n",
    "\n",
    "d=len(x)-1\n",
    "\n",
    "ti=\"P_{%i}(x) = \" %d\n",
    "px=Symbol(ti)  \n",
    "spl=px+sp\n",
    "spl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cop=poly(sp).coeffs()\n",
    "cop=np.array(cop)\n",
    "\n",
    "missing_powers_indices=[1,3]\n",
    "for k in missing_powers_indices:\n",
    "    cop=np.insert(cop,k,float(0))\n",
    "    \n",
    "ip=np.poly1d(cop)\n",
    "\n",
    "fig = plt.figure(figsize=(10,8))  \n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "# Move left y-axis and bottim x-axis to centre, passing through (0,0)\n",
    "ax.spines['left'].set_position('center')\n",
    "ax.spines['bottom'].set_position('zero')  #center')\n",
    "# Eliminate upper and right axes\n",
    "ax.spines['right'].set_color('none')\n",
    "ax.spines['top'].set_color('none')\n",
    "# Show ticks in the left and lower axes only\n",
    "ax.xaxis.set_ticks_position('bottom')\n",
    "ax.yaxis.set_ticks_position('left')\n",
    "plt.ylim([min(y)-0.5,max(y)+0.1])\n",
    "xx = np.linspace(-max(x), max(x), 100)\n",
    "lti1=\"$y = P_{%i}(x)$\" %d\n",
    "plt.plot(xx, ip(xx),label=lti1)\n",
    "ax.scatter(x,y, c = 'r')\n",
    "lti2=\"$y = 1/(1 + 12 x^2)$\" \n",
    "plt.plot(xx, f(xx),label=lti2)\n",
    "ax.legend(loc='lower right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}