phys512/interpolation_solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1d5fe3a8",
   "metadata": {},
   "source": [
    "# Interpolation exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3c335a6b",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of points = 11\n",
      "Maximum error for linear is 8.088451e-02\n",
      "Maximum error for cubic is 2.945822e-02\n",
      "Maximum error for spline is 1.150823e-02\n",
      "Maximum error for poly is 5.653960e-01\n"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADIQUlEQVR4nOzdd1yV5fvA8c9zFnvIniooorj3LGe5V5qjzLK0smFlU0st+6bZ9NfSlpotR47ce2/TcKDiAkRlyN5wxvP740GQQD0ocBj3+/XyBeecZ1wH4Zzr3M99X5cky7KMIAiCIAhCFaGydACCIAiCIAilIZIXQRAEQRCqFJG8CIIgCIJQpYjkRRAEQRCEKkUkL4IgCIIgVCkieREEQRAEoUoRyYsgCIIgCFWKSF4EQRAEQahSNJYOoKyZTCauX7+Og4MDkiRZOhxBEARBEMwgyzLp6en4+PigUt15bKXaJS/Xr1/H39/f0mEIgiAIgnAPoqOj8fPzu+M21S55cXBwAJQn7+joaOFoBEEQBEEwR1paGv7+/gXv43dS7ZKXm5eKHB0dRfIiCIIgCFWMOVM+xIRdQRAEQRCqFJG8CIIgCIJQpYjkRRAEQRCEKkUkL4IgCIIgVCkieREEQRAEoUoRyYsgCIIgCFWKSF4EQRAEQahSRPIiCIIgCEKVUu2K1AmCUE2ZjBB1ADLiwN4T6nQCldrSUQmCYAHlOvKyZ88eBg4ciI+PD5IksXr16rvus2vXLlq1aoWVlRX169dn0aJF5RmiIAhVwZk1MLcJ/DIAVjyjfJ3bRLlfEIQap1yTl8zMTJo3b863335r1vYRERH079+f7t27Exoayquvvsr48ePZvHlzeYYpCEJldmYNLBsLadeL3p8Wo9wvEhhBqHEkWZblCjmRJLFq1SqGDBly223efvtt1q9fz+nTpwvuGzVqFCkpKWzatMms86SlpeHk5ERqaqrobSQIVZ3JqIyw/DdxKSCBow+8ekpcQhKEKq4079+VasLuwYMH6dWrV5H7evfuzcGDB2+7T25uLmlpaUX+CYJQTUQduEPiAiBD2jVlO0EQaoxKlbzExsbi6elZ5D5PT0/S0tLIzs4ucZ/Zs2fj5ORU8M/f378iQhUEoRzlGUz8HXqNOX/tMmv737Yf4WhkEhU0kCwIgoVVquTlXkyZMoXU1NSCf9HR0ZYOSRCEe2Qwmvj9cBSd5+zglSWh/JtsbdZ+6y6beHT+QTp9vIPd5+PLOUpBECytUi2V9vLyIi4ursh9cXFxODo6YmNjU+I+VlZWWFlZVUR4giCUo9ArKYxffJSEjDwA7K3UHMtrxHXZBS+SUEnF9zHJEIsrp9QhSCaISc3hyQVHeaSlL9MGhFDLTlfBz0IQhIpQqUZeOnbsyPbt24vct3XrVjp27GihiARBKG+yLPPtzos8Mm9/QeLi7WhNRq4RvSyx2vNlJEkC/pu9SEiSxHybCWTqQQa0amWblf9e46Ev93DwUmKFPhdBECpGuSYvGRkZhIaGEhoaCihLoUNDQ7ly5QqgXPIZO3ZswfbPP/88ly9f5q233uLcuXN89913LFu2jNdee608wxQEwUKy8gy8+MdxPt0cjkkGX2cbHKw1xKTlYG+l4bNHmzNx4mtIIxaDo3fRnR19kEYsZsrktxjdrjYAeqNMcz8nAt3sSMjI5fGfDvHdzotiLowgVDPlulR6165ddO/evdj9Tz75JIsWLeKpp54iMjKSXbt2Fdnntdde48yZM/j5+TFt2jSeeuops88plkoLQtWQkJHLo/MPEJGQhVYtMaptbZb+E02ewUQ9dzt+GNuGeu72hTvcpcLu+pMxvLH8BNl6IwFudng7WXMgf+RlTPvazBzcBFVJ154EQagUSvP+XWF1XiqKSF4EofKLS8thyLf7iUnNQauWeKZLAD/suYxJhp4NPZg7qgUO1tpSHzfseirjf/mHmNQcatlqycozkmswATC0pS+fDm+GRl2prpYLgpCvytZ5EQSh+otNzWHk9weJSc0BwNvJhvm7lcTl0dZ+fP9E63tKXAAa+zjx94udaejlQHKWHmutmucfDEStklj17zXeWXkKk6lafV4ThBpJJC+CIFSY1Gw9Ty08QmRiFn61bHisnT9XkrIAeK5rIJ+UwciIh6M1f07oQDM/J1Kz9fxx5Apv926IWiXx17GrvLf6lJgDIwhVnEheBEGoEDl6I08tOMK52HTcHawY074OfxxR6jK91L0+U/o2yl9VdP9q2en4bXx72tSpRVqOge/3XKJfUy8A/jgSzdc7LpTJeQRBsAyRvAiCUO5kWeb1ZaH8G52CJMHwVr7M2XwOgPFdAnj94QZlfk5Hay0Lx7Wlqa8TiZl5HLyUiDp/wu4XWy+w6XRMmZ9TEISKIZIXQRDK3cL9kaw/FQuArVbNz/sikGV4rH1t3u1fdiMu/+VgrWXRuLYEutuRkJGHt5M1o9r6AfDa0hOcvpZaLucVBKF8ieRFEIRydehyIh9tOAvA013qolFJ5BllejXy4MPBTcotcbnJ1d6KX59pj7eTNVeTs4lOyqZLkBvZeiPP/voPqdn6cj2/IAhlTyQvgiCUm9jUHF78/RhGk0y/Jl7sOZ9Aao6Bxj6O/N+olgWXccqbr7MNPz3ZBludmv2XEvFysMLeSs31lBwmLw0VE3gFoYoRyYsgCOXCZJJ5+c/jJGbqqe1iQ3qOgYvxGXg7WbPgqbbYWVVsa7XGPk58ObIFkgR/Hb/GzXYD28/F88uByAqNRRCE+yOSF0EQysXP+yI4GpkMQHqOgb0XE7DWqvjpyTZ4OprXLbqs9W7sxVu9GwKQnWegR0N3AGZtOCfmvwhCFSKSF0EQylzY9VQ+3RwOQLCnUjAOYNbQpjT2cbJkaDzfNZD+Tb0xynA2Jp1uDdzJM5p4fdkJcg1Gi8YmCIJ5RPIiCEKZytEbeXVJKHlGE13quxGbplTSfbx9bR5p5Wfh6ECSJD4e1pRANztiUnPIMRipZaMhPC6dL7eet3R4giCYQSQvgiCUqW93XOBCfAaudjpSsvJIzdbT3N+Z6QNDLB1aAQdrLfPGtMZaq+LQ5SSM+fN1v999mX+vJFs2OEEQ7kokL4IglJlzsWl8u+sSAPZWGk5fT8PJRst3j7fCSqO+y94VK9jLgVlDmwLKnBxrjQoZeH35CXL04vKRIFRmInkRBKFMGE0yb684xc2+h1H5PYtmDW2Kr7ONBSO7vUda+TGslR8yUMtOi5u9jss3Mpm/+5KlQxME4Q5E8iIIQplYdCCSE9Ep2OvUuNrpABje2o/+zbwtHNmdvT8oBH8XG2JScwl0swPg2x0XiUjItHBkgiDcjkheBEG4b9dSsvksf3VRoIc9iZl51Hax5f1BjS0c2d05WGuZO7IFKgmORCbjV8sGvUnm7b9OiuJ1glBJieRFEIT79v6a02TrjdR1seXk1VTUKom5o1pgX8GF6O5V6zouvNQjCIDrKdkAHIlMYs2J65YMSxCE2xDJiyAI92X/xQS2nokHIDpZmefyUvf6tKpdy5JhldqkHvVp7ueESQZnWy0AH647I3ofCUIlJJIXQRDumd5o4v01YQDo1BJGGRp6OfBSj/oWjqz0NGoVnz7aHK1aIiVLj4eDFQkZeXyz44KlQxME4T9E8iIIwj1bfDCKC/EZ2FtpyDPKqFUSnw5vjlZdNV9aGng6MCn/8lFmngGAhfsjxORdQahkquYrjCAIFncjPZcvtyiTdG/2hn7uwUCa+lm2/P/9er5bPUK8HcnMNaJTSxhMMH31aUuHJQjCLUTyIgjCPfl08zky8ozY6tSk5xqo527HpJ5Blg7rvmnVKj59tBlqCfLyS+/uvZjAvgsJFo5MEISbRPIiCEKpXYzPYPmxqwBk5SnVaD8Z3hxrbeWqonuvGvs48WJ3Zd6OlUZ5mfxw3RkMRpMlwxIEIZ9IXgRBKLU5m84hy6BRKReMxnWuS+s6VWt10d282KM+gW525BpM6NQqwuPSWfpPtKXDEgQBkbwIglBKRyKS2HomDgkwmGS8HK15/eFgS4dV5qw0av43pAkAefkjLnM2niMj12DJsAR
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.interpolate\n",
    "\n",
    "# function to interpolate\n",
    "def func_sin(x):\n",
    "    f = np.sin(x) \n",
    "    return f\n",
    "\n",
    "def func_step(x):\n",
    "    # step function / discontinuous gradient\n",
    "    f = np.zeros_like(x)\n",
    "    for i, xx in enumerate(x):\n",
    "        if xx>np.pi:\n",
    "            f[i] = 1.0\n",
    "        else:\n",
    "            f[i] = (xx/np.pi)\n",
    "    return f\n",
    "\n",
    "def func_exp(x):\n",
    "    # Gaussian\n",
    "    return np.exp(-x**2/2)\n",
    "\n",
    "def func_poly(x):\n",
    "    # polynomial\n",
    "    poly = np.polynomial.Polynomial([-10, 3, 0, 0, 0, 0])\n",
    "    return poly(x)\n",
    "\n",
    "def cubic_interpolation(x, xp, fp):\n",
    "    # storage for the interpolated function and derivatives\n",
    "    f2 = np.zeros_like(x)\n",
    "    f2d = np.zeros_like(x)\n",
    "    f2dd = np.zeros_like(x)\n",
    "\n",
    "    # do a cubic polynomial fit to each interval (except the first and last)\n",
    "    for i in range(len(xp)-3):\n",
    "        poly = np.polynomial.Polynomial.fit(xp[i:i+4], fp[i:i+4], 3)    \n",
    "        ind = np.where(np.logical_and(x<xp[i+2],x>=xp[i+1]))\n",
    "        f2[ind] = poly(x[ind])\n",
    "        f2d[ind] = poly.deriv(m=1)(x[ind])\n",
    "        f2dd[ind] = poly.deriv(m=2)(x[ind])\n",
    "    \n",
    "    # exclude the first and last intervals\n",
    "    ind = np.where(np.logical_and(x>=xp[1],x<xp[-2]))\n",
    "    f2 = f2[ind]\n",
    "    f2d = f2d[ind]\n",
    "    f2dd = f2dd[ind]  \n",
    "    x2 = x[ind]\n",
    "\n",
    "    return x2, f2, f2d, f2dd\n",
    "\n",
    "# choose one of the above functions to fit\n",
    "func = func_exp\n",
    "x1 = -5\n",
    "x2 = 5\n",
    "n_points = 11    # number of sample points\n",
    "add_noise = False    # whether to add noise\n",
    "noise_amp = 0.001  # noise amplitude\n",
    "\n",
    "# Sample the function\n",
    "xp = np.linspace(x1, x2, num=n_points)\n",
    "fp = func(xp)\n",
    "# add noise\n",
    "if add_noise:\n",
    "    fp = fp + noise_amp*np.random.normal(size = len(xp))\n",
    "\n",
    "# 1. Piecewise linear interpolation\n",
    "x = np.linspace(x1, x2, num=10**3)\n",
    "f1 = np.interp(x, xp, fp)\n",
    "\n",
    "# 2. Cubic interpolation\n",
    "x2, f2, f2d, f2dd = cubic_interpolation(x, xp, fp)\n",
    "\n",
    "# 3. Spline\n",
    "f3 = scipy.interpolate.CubicSpline(xp,fp) #, bc_type = 'natural')\n",
    "\n",
    "# 4. Lagrange polynomial fit to all points\n",
    "poly = scipy.interpolate.lagrange(xp, fp)\n",
    "\n",
    "# Calculate the maximum errors\n",
    "print('Number of points = %d' %(n_points,))\n",
    "print('Maximum error for linear is %e' % (np.max(np.abs((f1-func(x))))/np.max(func(x)),)  )\n",
    "ind = np.where(np.logical_and(x>=xp[1],x<xp[-2]))\n",
    "print('Maximum error for cubic is %e' % (np.max(np.abs((f2-func(x2))))/np.max(func(x2)),)  )\n",
    "print('Maximum error for spline is %e' % (np.max(np.abs((f3(x)-func(x))))/np.max(func(x)),)  )\n",
    "print('Maximum error for poly is %e' % (np.max(np.abs((poly(x)-func(x))))/np.max(func(x)),)  )\n",
    "\n",
    "# Plot the function and different interpolations\n",
    "plt.plot(x,func(x), label=r'$f(x)$')\n",
    "plt.plot(x,poly(x),'--', label='Polynomial fit')\n",
    "plt.plot(x,f1, label='Linear')\n",
    "plt.plot(x2,f2,':', label='Cubic')\n",
    "plt.plot(x,f3(x),':', label='Spline')\n",
    "plt.plot(xp,fp, 'o')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Plot the derivatives\n",
    "plt.clf()\n",
    "plt.plot(x, func(x), label=r'$f(x)$')\n",
    "plt.plot(x2, f2, \"C0\", label = 'Cubic')\n",
    "plt.plot(x2, f2d, \"C1\", label = 'Cubic 1st derivative')\n",
    "plt.plot(x2, f2dd, \"C2\", label = 'Cubic 2nd derivative')\n",
    "plt.plot(x, f3(x), \"C0:\", label = 'Spline')\n",
    "plt.plot(x, f3(x,1), \"C1:\", label = 'Spline 1st derivative')\n",
    "plt.plot(x, f3(x,2), \"C2:\", label = 'Spline 2nd derivative')\n",
    "plt.plot(xp, fp, 'o')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae9727e6",
   "metadata": {},
   "source": [
    "Things to note:\n",
    "\n",
    "- For $N$ sample points, the error in linear interpolation decreases as $N^2$, cubic and spline decrease as $N^4$.  This is because the largest correction term (next term in the Taylor expansion) is $\\propto (\\Delta x)^2$ for linear and $\\propto (\\Delta x)^4$ for cubic. \n",
    "- The full $N-1$-order polynomial fit (Lagrange polynomial) does not behave well, often showing high frequency components, particularly near the boundaries of the domain ([Runge's phenomenon](https://en.wikipedia.org/wiki/Runge's_phenomenon)).\n",
    "- The cubic fits show discontinities in the derivatives at the sampled points; the spline (by definition) has continuous first and second derivatives.\n",
    "- The cubic and spline fits develop oscillations near discontinous changes in the function of derivatives. Adding Gaussian noise to the data points also can lead to oscillations in the interpolated function.\n",
    "- The cubic and spline interpolations are able to fit polynomials up to 3rd order exactly. The Lagrange fit will fit up to order $N-1$ exactly. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a4a3010",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}