M104A HW5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 1\n",
    "#### a)\n",
    "Let $p(x)$ be a polynomial of degree at most $n$, and $l_n(x)$ be an interpolating polynomial of $(p(x)$ of Lagrange Form, and $t_n(x)$ an interpolating polynomial of Newton's form, both of degree at most $n$. Then if both $l_n(x)$ and $t_n(x)$ both interpolate $p(x)$ equally at the same nodes, then the polynomial of the difference $l_n(x) - t_n(x)$ must contain $n+1$ zeros, which implies that $l_n(x) - t_(x)$ is identically the zero polynomial. Thus, $l_n(x) = t_n(x)$, and therefore the leading coefficients of either polynomial are equivalent.\n",
    "\n",
    "#### b)\n",
    "Consider a divided difference $f[x_0,...,x_k,...,x_l,...,x_n]$, where $x_i$ are arbitrary nodes, and k<l. Then if we switch $x_k$ and $x_l$ in the ordering, then our summation of lagrange constants within (1) is unchanged since the index of $x_k$ and $x_l$ can be manipulated to represent the new ordering. Therefore, taking any permutation of $x_0, x_1, ..., x_n$ leaves our divided difference unchanged."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "By: Daniel Arredondo\n",
    "Last Edited: 05/24/2020\n",
    "\n",
    "NewtCof:\n",
    "in: list of nodes and list of evaluated nodes\n",
    "out: a single array, meant to be coefficients of Newtons Form (Newton's Divided Differences)\n",
    "\n",
    "Horner_Func\n",
    "in: list of nodes, list of evaluated nodes, points of x to approximate to\n",
    "out: list of approximations at each x\n",
    "'''\n",
    "\n",
    "import numpy as np\n",
    "import math as m\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as mat \n",
    "\n",
    "def NewtCof(lst_f, lst_x): #lst_x are nodes, lst_f are values of f(nodes)\n",
    "    c_j = np.array([]) #empty array\n",
    "    n = len(lst_x) #length of list of nodes\n",
    "    for x in range(n):\n",
    "        c_j = np.append(c_j, lst_f[x]) #we create a dummy list to modify\n",
    "    for k in range(1, n+1):\n",
    "        for j in range(n-1, k-1, -1):\n",
    "            c_j[j] = (c_j[j]-c_j[j-1])/(lst_x[j]-lst_x[j-k])\n",
    "    return c_j\n",
    "\n",
    "def Horner_Func(x, lst_f, lst_x):\n",
    "    n = len(lst_x) #take length of array\n",
    "    NC = NewtCof(lst_f,lst_x) #create our coefficients within the function\n",
    "    p = NC[n-1] # We then set our value p to the last value in NC\n",
    "    for j in range(n-2,-1,-1):\n",
    "        p = NC[j] + (x - lst_x[j])*p \n",
    "    return p\n",
    "        \n",
    "def func(x): # Function for (2.b)\n",
    "    temp = x**2\n",
    "    temp *= -1\n",
    "    return (m.exp(temp))\n",
    "\n",
    "def tempfunc(x): #Test function using an interesting graph\n",
    "    temp_1 = 5*(x)\n",
    "    return (abs(m.sin(temp_1))) #Next time use a lambda function\n",
    "\n",
    "# The following code is used to test the mapping function of\n",
    "# the previous code, as to prepare for question (2.b)\n",
    "\n",
    "temp_nodes = np.arange(-1,1.01, 0.2) # Our nodes we will approximate with\n",
    "temp_fnodes = np.array([]) # Will hold the values of p(x) for x in nodes\n",
    "\n",
    "temp_x = np.arange(-1,1.01,0.02) # resolution x, size 100\n",
    "temp_truef = np.array([]) #resolution f(x) and will hold the true values at f(x)\n",
    "\n",
    "test_poly_approx = np.array([]) # our approximations from Horner_Func\n",
    "\n",
    "for t in temp_nodes:\n",
    "    temp_fnodes = np.append(temp_fnodes, tempfunc(t))\n",
    "    \n",
    "for tt in temp_x:\n",
    "    temp_truef = np.append(temp_truef, tempfunc(tt))\n",
    "    test_poly_approx = np.append(test_poly_approx, Horner_Func(tt,temp_fnodes, temp_nodes))\n",
    "    \n",
    "mat.plot(temp_x, temp_truef, color='blue', label='f(x)')\n",
    "mat.plot(temp_x, test_poly_approx, color='red', label='p(x)')\n",
    "mat.grid(True, which='both')\n",
    "mat.legend(loc='lower left')\n",
    "mat.xlabel('$x$')\n",
    "mat.title('Test: Difference between $|sin(5x)|$ and $p(x)$')\n",
    "mat.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#\n",
    "#     Problem 2.b\n",
    "#\n",
    "\n",
    "list_of_nodes = np.arange(-1,1.01, 0.2)\n",
    "list_of_fnodes = np.array([])\n",
    "\n",
    "list_of_x = np.arange(-1,1.01,0.02)\n",
    "list_of_truef = np.array([])\n",
    "\n",
    "poly_approx = np.array([])\n",
    "\n",
    "for xx in list_of_nodes:\n",
    "    list_of_fnodes = np.append(list_of_fnodes, func(xx))\n",
    "    \n",
    "for i in list_of_x:\n",
    "    list_of_truef = np.append(list_of_truef, func(i))\n",
    "    poly_approx = np.append(poly_approx, Horner_Func(i,list_of_fnodes, list_of_nodes))\n",
    "    \n",
    "#print(list_of_truef[0:25]-poly_approx[:25])\n",
    "\n",
    "mat.plot(list_of_x, list_of_truef - poly_approx, color='green')\n",
    "mat.grid(True, which='both')\n",
    "mat.ylabel('$f(x) - p_n(x)$')\n",
    "mat.xlabel('$x$')\n",
    "mat.title('Error between $e^{-x^2}$ and $p_{10}(x)$')\n",
    "mat.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5675445848373015\n"
     ]
    }
   ],
   "source": [
    "x_0 = 0.5\n",
    "x_1 = 0.6\n",
    "\n",
    "y_0 = -0.106530659712633 \n",
    "y_1 = 0.051188363905973\n",
    "\n",
    "finv_0_1 = (x_1-x_0)/(y_1-y_0)\n",
    "# print(finv_0_1)\n",
    "# print(-y_0*finv_0_1)\n",
    "print(x_0 - y_0*finv_0_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, $p_1(0) =$ 0.5675445848373015"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 4\n",
    "We construct the table of Newton's Divided Differences as follows:\n",
    "\n",
    "$\n",
    "\\begin{matrix}\n",
    "0&|&0&&&\\\\\n",
    "0&|&0&0&&\\\\\n",
    "1&|&2&2&2&\\\\\n",
    "1&|&2&3&1&-1 \\\\\n",
    "\\end{matrix}\n",
    "$\n",
    "\n",
    "\n",
    "and therefore\n",
    "$$\n",
    "p(x) = 0 + 0(x-0) + 2(x-0)^2 - (x-0)^2(x-1) = 3x^2 - x^3\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 15.   30.   37.5 187.5]\n",
      "[  15.           30.          162.5        -541.66666667]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "UoA - Math 270 stuff\n",
    "24 May 2020\n",
    "'''\n",
    "f_list_2 = [15,21,40,46]\n",
    "f_list_1 = [15,21,30,51]\n",
    "\n",
    "x_list = [0.0, 0.2, 0.4, 0.6]\n",
    "print(NewtCof(f_list_1, x_list))\n",
    "print(NewtCof(f_list_2, x_list))"
   ]
  },
  {
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}