Linear-Lagrange-Interpolation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "40905950e1d95fbf6072eba4021bb9d6",
     "grade": false,
     "grade_id": "cell-34048262bd9d1748",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "# <center> NRE1 2021 - Assignment 1 </center>\n",
    "___\n",
    "## <center> Regression and interpolation </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "2b696d4ec57f41f34cfc789257bb2fc9",
     "grade": false,
     "grade_id": "cell-169cdd1e61b2c4a0",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "This notebook is the a graded assignment. It counts **20% to your final mark** in the exercise with **20 points** to be achieved in total! It covers the topics of regression and interpolation presented in the lecture. Read all the tasks and the provided help carefully.\n",
    "\n",
    "\n",
    "Before you submit this assignment, make sure everything runs as you expect it to.  \n",
    "* **restart the kernel** (in the menubar, select Kernel -> Restart)\n",
    "* **run all cells** (in the menubar, select Cell -> Run All)\n",
    "\n",
    "Make sure to fill in any place that says \n",
    "```python\n",
    "# YOUR CODE HERE\n",
    "```\n",
    "or\n",
    "\n",
    "    YOUR ANSWER HERE\n",
    "\n",
    "Delete lines that read \n",
    "\n",
    "```python\n",
    "raise NotImplementedError()\n",
    "```\n",
    "when adding your solution.\n",
    "\n",
    "<font color=#ba4a00 >\n",
    "<br>\n",
    "    \n",
    "Please upload your completed notebook to Moodle **strictly following** the naming convention:\n",
    "\n",
    "* ``assignment1_XXXXXX.ipynb`` where XXXXXX corresponds to your student ID, or: \n",
    "* ``assignment1_XXXXXX_YYYYYY.ipynb`` if you submit together (both student ID's)\n",
    "\n",
    "</font>\n",
    "\n",
    "\n",
    "<br>\n",
    "<font color= #a93226>\n",
    "<br>\n",
    "<center> Remember: Copying code from someone else and pretending it is your own is serious scientific fraud!\n",
    "</center>\n",
    "\n",
    "<br><center> This assignment is due on: **Friday, 28th of May** 2021. Good luck!\n",
    "</center>\n",
    "<br>\n",
    "</font>\n",
    "\n",
    "Please fill in your name (and of your fellow student, if you submit together), and according matriculation number below (next cell). If you are more than one student, separate by a comma **,** ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAME = \"Ryan Bobby Andika\"\n",
    "MATNUM = \"416609\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here the usual imports:\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b406afe118d47c15064fadff4ec23e8b",
     "grade": false,
     "grade_id": "cell-e8710d68e866b5ef",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Task 1: Linear regression\n",
    "\n",
    "### Part A: Program control with loops\n",
    "\n",
    "Loops are an essential part to control the flow of computer programs. They are virtually essential to most programs and so common, that we will spend a little bit of extra time on them to make sure you understand the concept and the implementation in Python.\n",
    "\n",
    "In this part, we will use loops to start solving a problem that we discussed in the lecture: linear regression with least-square curve fitting methods.\n",
    "\n",
    "We consider here the simple case of obtaining the best fit line to a set of points. A line can be described in the form:\n",
    "\n",
    "$$y = a_0 + a_1 x$$\n",
    "\n",
    "The task is to find suitble values for parameters $a_0$ and $a_1$ for the line.\n",
    "\n",
    "\n",
    "We obtain the normal equations to fit a line with linear regression as shown in the lecture:\n",
    "\n",
    "$$n a_0 + a_1 \\sum_{i=1}^n x_i = \\sum_{i=1}^n y_i$$\n",
    "\n",
    "$$ a_0 \\sum_{i=1}^n x_i + a_i \\sum_{i=1}^n x_i^2 = \\sum_{i=1}^n x_i y_i$$\n",
    "\n",
    "As you can see, we have to calculate a lot of sums to solve these equations. The basic possibility to do this in a computer program is using a `for`-loop.\n",
    "\n",
    "You can think about it in the following way: $\\sum$ specifies an operation where we repeateadly add values to the previous results:\n",
    "\n",
    "$$\\sum_{i=1}^n x_i = x_1 + x_2 + \\dots + x_n$$\n",
    "\n",
    "If we want to create a program to perform this operation, we need to define a variable first to store the results and initialise it to 0, so for example:\n",
    "\n",
    "`sum_x = 0`\n",
    "\n",
    "In the next step, we iterate over all entries in the list, using a `for`-loop, and add the value of the list entry to this variable (recall that, when iterating through a list with a `for`-loop, the next element is extracted with each loop iteration).\n",
    "\n",
    "<br>\n",
    "<font color= #21618c>\n",
    "    \n",
    "### **Your task (3 pts)**: \n",
    "**Complete the function below to find the optimal values for $a_0$ and $a_1$ in a least square sense. Use loops to perform the summation operations (no `numpy` required!) from the equation above. Use the pre-defined variables to store the results. In order to solve the system of algebraic equations (SAE) to obtain $a_0$ and $a_1$ use the `np.linalg.solve()` function.**\n",
    "<font>\n",
    "<br>\n",
    "\n",
    "<font color=#ba4a00 >\n",
    "    \n",
    "*Hint*: Creating the mixed sum ($\\sum x_i y_i$) is a bit tricky. The best way is to write a `for`-loop to iterate over a range of the entries in the lists, and then extract the elements by index:\n",
    "\n",
    "\n",
    "```python\n",
    "for i in range(len(x)):\n",
    "    ...\n",
    "```\n",
    "<font>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "eaa9253e51f5e47bae59168528916adf",
     "grade": false,
     "grade_id": "cell-a57fc295893bf5e7",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def lin_regression_loops(x, y):\n",
    "    \"\"\"Perform linear regression with basic python loops    \n",
    "    \n",
    "    **Arguments**:\n",
    "        x : python list or numpy-arary with x-values\n",
    "        y : python list or numpy-array with y-values\n",
    "    \n",
    "    **Returns**:\n",
    "        (a0, a1) : tuple of two numbers\n",
    "    \"\"\"  \n",
    "    # Variables to store results of summation:\n",
    "    sum_x_i = 0\n",
    "    sum_y_i = 0\n",
    "    sum_x_i_squared = 0\n",
    "    sum_x_i_y_i = 0\n",
    "    \n",
    "    # YOUR CODE HERE\n",
    "    xy = [x[i]*y[i] for i in range(len(x))]\n",
    "    \n",
    "    for i in range(len(x)):\n",
    "        sum_x_i += x[i]\n",
    "        sum_y_i += y[i]\n",
    "        sum_x_i_squared += ((x[i])**2)\n",
    "        sum_x_i_y_i += xy[i]\n",
    "    \n",
    "    aa = np.array([[len(x), sum_x_i],[sum_x_i, sum_x_i_squared]])\n",
    "    ab = np.array([sum_y_i, sum_x_i_y_i])\n",
    "    \n",
    "    return np.linalg.solve(aa,ab) #get the a0,a1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "204e749444d2cd84390974a0b5fcbeb3",
     "grade": true,
     "grade_id": "cell-78d176ad1e0e1695",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Cell used for autograding. DO NOT EDIT!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "eea036eac9ec92c6a63ca3cca82f0d7d",
     "grade": false,
     "grade_id": "cell-ef37f61f57cde1bd",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "### Part B: Linear regression with vectorised functions\n",
    "\n",
    "You learned about the use of efficient numerical methods in chapter 4 on the `numpy` module. One of the most important aspects of the `numpy` module is the use of vectors and functions that operate directly on these vectors, the so-called \"vectorised functions\".\n",
    "\n",
    "One main point that you should always have in mind is, that it is better to use vectorised functions instead of loops, whenever this is possible. The calculations will be more efficient.\n",
    "\n",
    "<br>\n",
    "<font color= #21618c>\n",
    "    \n",
    "### **Your task** (3 pts): \n",
    "**Complete the function below to perform the summation operations with vectorised functions instead of the loops and solve the system of linear equations:**\n",
    "<font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "930185c44b4793d2aefe45c23f19a8aa",
     "grade": false,
     "grade_id": "cell-8b0666a7fe844226",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def lin_regression_vectorised(x, y):\n",
    "    \"\"\"Perform linear regression with vectorised numpy functions\n",
    "    \n",
    "    **Arguments**:\n",
    "        x : numpy-array with x-values\n",
    "        y : numpy-array with y-values\n",
    "    \n",
    "    **Returns**:\n",
    "        (a0, a1) : tuple of two numbers\n",
    "    \"\"\"    \n",
    "    # YOUR CODE HERE\n",
    "    aa = np.array([[len(x), np.sum(x)],[np.sum(x), np.sum(x**2)]])\n",
    "    ab = np.array([np.sum(y), np.sum(x*y)])\n",
    "    \n",
    "    return np.linalg.solve(aa,ab) #get the a0,a1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "945fdb3e087bdea46947a7a91f6ec964",
     "grade": true,
     "grade_id": "cell-563d16bce951f6b7",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Cell used for autograding. DO NOT EDIT!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7532daa4155156a8fe3265743d0508e6",
     "grade": false,
     "grade_id": "cell-9bfc3b7761d4d3ec",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "As a little test for Part A and B, use the data in the following two arrays to test your functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.01285714 0.85857143]\n",
      "[0.01285714 0.85857143]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1., 2., 3., 4., 5., 6., 7.])\n",
    "y = np.array([0.42, 2.32, 2.12, 4.31, 3.45, 5.92, 5.59])\n",
    "\n",
    "print(lin_regression_loops(x, y))\n",
    "print(lin_regression_vectorised(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "d371c7fdf723a96d22f1bdf8c303f0a0",
     "grade": false,
     "grade_id": "cell-59377a3c2136c806",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "If you compare the code of the vectorised function with the implementation with loops you can see another advantage of using vectorised functions: they usually provide a clearer and more easy to read implementation. Basically, it is often possible to write equations in code almost as you would write them down on paper. We will see more of this behaviour in the future."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ea5e71e04bc447797aa91bc9764d93f6",
     "grade": false,
     "grade_id": "cell-d1af5072779b4998",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "### Part C: Check results with a plot\n",
    "\n",
    "It is also a good idea to check you results with a plot using `matplotlib`. \n",
    "\n",
    "<font color= #21618c>\n",
    "    \n",
    "### Your task (1 pt):\n",
    "**Create a figure with two subplots  both containing the data used aboved (`x` and `y`) and plot the regression line calculated with the loop function in one, and the one calculated with the vectorized function in the other.**\n",
    "<font>\n",
    "<br>\n",
    "\n",
    "<font color=#ba4a00 >\n",
    "\n",
    "Hint: Obviously both subplots should look exactly the same if you implemented everything correctly. Remember title and axes labels!\n",
    "<font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a9efc37932358b85d9df1ba15fdd8699",
     "grade": true,
     "grade_id": "cell-89709f83b016ca60",
     "locked": false,
     "points": 1,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2203d140eb0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "fig, ax = plt.subplots(1,2, figsize = (10,5))\n",
    "\n",
    "ax[0].scatter(x,y,c='black',label ='Data Points')\n",
    "ax[0].plot(x,lin_regression_loops(x,y)[0] + x*lin_regression_loops(x,y)[1],\"--k\",c='blue',label ='Regression')\n",
    "ax[0].set_xlabel('x')\n",
    "ax[0].set_ylabel('y')\n",
    "ax[0].set_title('Linear Regression with for Loops')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].scatter(x,y,c='black',label ='Data Points')\n",
    "ax[1].plot(x,lin_regression_vectorised(x,y)[0] + x*lin_regression_vectorised(x,y)[1],\"--k\",c='green',label ='Regression')\n",
    "ax[1].set_xlabel('x')\n",
    "ax[1].set_ylabel('y')\n",
    "ax[1].set_title('Linear Regression with Numpy (Vectorised)')\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "bfe33e6902ac2c62cc4e06b43e5e5e65",
     "grade": false,
     "grade_id": "cell-011bb25567efae44",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "### Part D: Comparing execution time\n",
    "\n",
    "We stated above that vectorised functions are more efficent than loops and that you should use them when you can. However, we didn't provide a proof for this statement, yet. So in this task, you will use the `%%timeit` function to compare the execution time of the two functions and to test this claim.\n",
    "\n",
    "Recall: The `%%timeit` function is a so-called \"magic function\". These functions are extensions to basic Python functions which are only available in IPython and they usually perform operations for one code cell. To call the `%%timeit` function, you write it in the top of a code cell and then add the lines of code for which you want to check the execution time. These lines are then executed a couple of times to obtain a good approximation.\n",
    "\n",
    "Here is an example to test the execution time of a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37.7 µs ± 5.24 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit \n",
    "# calculate the sine for a number of values:\n",
    "x_vals = np.linspace(0,2*np.pi,1000)\n",
    "np.sin(x_vals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b2a60a6edb5f9186d578064d5f81b4f3",
     "grade": false,
     "grade_id": "cell-272f000d8cc4766a",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "As you can see from the output, the lines of code are executed a number of times to obtain a reasonable measure of execution speed, which is in the order of 10-30 micro-seconds.\n",
    "\n",
    "<font color= #21618c>\n",
    "    \n",
    "### **Your task (1 pt)**: \n",
    "**Use the `%timeit` command with your code to test the execution time of the linear regression implementation with loops and with vectorised functions (use the `x` and `y` arrays as input as above):**\n",
    "<font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8775f946cefa5ee980350a0afaaf49cc",
     "grade": true,
     "grade_id": "cell-770ff882528abbc2",
     "locked": false,
     "points": 1,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.8 µs ± 924 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "# YOUR CODE HERE\n",
    "lin_regression_vectorised(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.5 µs ± 3.43 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "# YOUR CODE HERE\n",
    "lin_regression_loops(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5ea6f05b0d647891be9b7d51076649a0",
     "grade": false,
     "grade_id": "cell-6feacec83deab55c",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "What did you observe? Which execution is faster? \n",
    "\n",
    "<font color= #21618c>\n",
    "    \n",
    "### **Your task (1 pt)**: \n",
    "**Describe your results in the following text cell:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "25d62fc6711a6610b5ed0c62ab0c2f05",
     "grade": true,
     "grade_id": "cell-c287ee8bcecfcca8",
     "locked": false,
     "points": 1,
     "schema_version": 3,
     "solution": true
    }
   },
   "source": [
    "YOUR ANSWER HERE\n",
    "\n",
    "    lin_regression_loops performed much faster than the lin_regression_vectorised."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "101ca895a441e1a8dbdf751e5a8447ea",
     "grade": false,
     "grade_id": "cell-e23169227f8f36a5",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "You may have realised that the results are a bit unexpected. The reason is that calling the vectorised functions requires a small amount of additional time. This means that the functions are mainly efficient for large arrays.\n",
    "\n",
    "To test the execution time for larger vectors, we will first generate some random example data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Random samples from normal distribution')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# test with a longer vector:\n",
    "n_samples = 1000 # define number of samples\n",
    "# generate linearly spaced samples between 0 and 10:\n",
    "x_long = np.linspace(0,10,n_samples) \n",
    "# draw random values from standard normal distribution (zero mean):\n",
    "y_long = np.random.randn(n_samples)\n",
    "# and we create a plot to visualise our samples:\n",
    "plt.plot(x_long,y_long, '.')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Random samples from normal distribution')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7d1930bbf630cb954725f053e9804af1",
     "grade": false,
     "grade_id": "cell-dd64e07a89f08504",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "<font color= #21618c>\n",
    "    \n",
    "### **Your task (1 pt)**: \n",
    "**Evaluate execution time for the two functions (now using `x_long` and `y_long`) as before and discuss the results:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27.5 µs ± 3.35 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "# YOUR CODE HERE\n",
    "x_long = np.linspace(0,10,n_samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "986 ns ± 58.8 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "# YOUR CODE HERE\n",
    "y_long = np.random.randn(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a837717e0113a91ac2648cc3410d185e",
     "grade": true,
     "grade_id": "cell-7d86d1a0e60d96d6",
     "locked": false,
     "points": 1,
     "schema_version": 3,
     "solution": true
    }
   },
   "source": [
    "YOUR ANSWER HERE\n",
    "\n",
    "    \"y_long\" performs much faster than the \"x_long.\" It might be related to the \"linspace\" that need to consider the desired range (0-10) first, then call all the numbers in correct numerical order, with the fixed gradual increment or related to the resolution of sampling (which in this case need 1000 sampling between 0 - 10). In other cases, the \"random.randn\" only call 10 samples number from a standard normal distribution which can be any value and, at least, not have to be in a correct numerical order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "71c182c7116e97aeec3d1f0b95d9853c",
     "grade": false,
     "grade_id": "cell-f1825bcfb0342031",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "## Task 2: Linear interpolation with Lagrange interpolation\n",
    "\n",
    "### Part A: Linear interpolation with two given points\n",
    "\n",
    "We discussed the formulation of Lagrange interpolating polynomials during the lecture. A big advantage of these polynomials is that the computational implementation is very straight-forward.\n",
    "\n",
    "As usual we want to obtain an estimate for an unknown value $f(x)$ at position $x$ from observations $x_i$ with a linear combination:\n",
    "\n",
    "$$f_n(x) = \\sum_{i=0}^n L_i(x), f(x_i) \\mbox{ ,}$$\n",
    "\n",
    "where $L_i$ are the weights:\n",
    "\n",
    "$$L_i(x) =  \\prod_{j = 0, j \\ne i}^n \\frac{x - x_j}{x_i - x_j}$$\n",
    "\n",
    "The first-order linear interpolation is obtained if we set $n = 1$ as:\n",
    "\n",
    "$$f_1(x) = \\frac{x - x_1}{x_0 - x_1} f(x_0) + \\frac{x - x_0}{x_1 - x_0} f(x_1)$$\n",
    "\n",
    "<font color= #21618c>\n",
    "    \n",
    "### **Your task (3 pts)**: \n",
    "**Complete the function below to approximate the value at a position x given two known values  $f(x_0)$ and $f(x_1)$:**\n",
    "<font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8f01743e090b4f76222a8e5720114cda",
     "grade": false,
     "grade_id": "cell-0982b55d433fcac8",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def linear_interp(x_0, x_1, f_x_0, f_x_1, x):\n",
    "    \"\"\"Approximate the value at position x using linear interpolation\n",
    "    \n",
    "    **Arguments**:\n",
    "        x_0 : position of first point\n",
    "        f_x_0 : value at first point\n",
    "        x_1 : position of second point\n",
    "        f_x_1 : value at second point\n",
    "        x : position of value to be approximated\n",
    "    **Returns**:\n",
    "        f_x : approximated value\n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    f_x = (((x - x_1)/(x_0 - x_1))*(f_x_0)) + (((x - x_0)/(x_1 - x_0))*(f_x_1))\n",
    "    \n",
    "    return f_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c1f1e755a47998cf9b2d1bd8356d5f59",
     "grade": true,
     "grade_id": "cell-ca70e026b732c5bd",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Cell used for autograding. DO NOT EDIT!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b9cea8e1c31d5861f781aab680077ffb",
     "grade": false,
     "grade_id": "cell-3a167f150dee438f",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "Test your implementation for a couple of values where you know the expected results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n"
     ]
    }
   ],
   "source": [
    "# To test your code, try some examples:\n",
    "print(linear_interp(0,1,0,1,0.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9f8203da2ddbe387182a086d5e4b2abc",
     "grade": false,
     "grade_id": "cell-297f110f01c0ec5a",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "### Part B: Piecewise linear interpolation with arbitrary number of given points\n",
    "\n",
    "Now that we have this function, we can use it to perform **piecewise linear interpolation** between a set of points. We now consider a set of points $x_0, x_1$ ... $x_n$. If we want to obtain the approximate value for a point $x$ in between these points, we have to perform the following steps:\n",
    "\n",
    "1. Check if the point is within our point range ($x_0 \\le x \\le x_n$), if not: do not perform interpolation (Because it would be extrapolation)\n",
    "\n",
    "2. Determine between which two points of our set point $x$ is located. \n",
    "\n",
    "3. Perform the interpolation in the appropriate interval (Use your `linear_interp()` function for this).\n",
    "\n",
    "<font color=#ba4a00 >\n",
    "    \n",
    "**Hint:** You will need a nested structure of conditional and iterative control flow elements, as well as array indexing functionality, to perform this task. \n",
    "<font>\n",
    "    \n",
    "<font color= #21618c>\n",
    "    \n",
    "### **Your task (5 pts)**:\n",
    "**Complete the function below to perform the piecewise linear interpolation for an arbitrary number of points (with values passed as Python lists or numpy arrays).**\n",
    "\n",
    "<font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1e01ec8b57fd5edd7ab33d006f66c3ee",
     "grade": false,
     "grade_id": "cell-3eb08fc9b0dc7d1f",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def linear_interp_arbitrary_points(p, f_p, x):\n",
    "    \"\"\"Approximate the value at position x using piecewiese linear interpolation\n",
    "    \n",
    "    **Arguments**:\n",
    "        p : list or numpy array with positions of points\n",
    "        f_p : list or numpy array with values of points\n",
    "        x : position of value to be approximated\n",
    "    \n",
    "    **Returns**:\n",
    "        f_x : approximated value\n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    f_x=[]\n",
    "    for i in range(1,(len(p))):\n",
    "        for j in x:\n",
    "            if j > p[i-1] and j < p[i]: #to fulfill the 1st and 2nd condition\n",
    "                f_x.append(linear_interp(p[i-1], p[i], f_p[i-1], f_p[i], j))\n",
    "            elif j == p[i-1]: #to anticipate a condition where the x_unknown giving us a 'x' number that same with the x_known\n",
    "                f_x.append(f_p[i-1])\n",
    "            else:\n",
    "                continue\n",
    "    return f_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e8a190b567bb028fddae56c05ed41e47",
     "grade": true,
     "grade_id": "cell-9d7e721969f750c3",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Cell used for autograding. DO NOT EDIT!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "26d09dfaf0575d94cab27ed95dec691c",
     "grade": false,
     "grade_id": "cell-f266eb8dc2d266e8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Part C: Plotting the results\n",
    "\n",
    "<font color= #21618c>\n",
    "    \n",
    "### **Your task (3 pts)**:\n",
    "**Given a set of known input points (`x_known` and `y_known`) and a set of positions (`x_unknown`), use a `for-loop` to estimate a value for each unknown location using our function from Part B (piecewise linear interpolation for arbitrary number of points) and plot the results (the orginal input points as well as the estimated results for the unknown locations.**\n",
    "</font>\n",
    "    \n",
    "As always when creating a plot, remember adding labels, title and a legend.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a885b8aa195052727b59b0d446172397",
     "grade": true,
     "grade_id": "cell-5a6526b53c68d7ca",
     "locked": false,
     "points": 3,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2203d2fb700>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting\n",
    "# known input points\n",
    "x_known = np.arange(0,20,4)\n",
    "y_known = np.random.randint(0,10,size=len(x_known))\n",
    "\n",
    "# unknown locations to estimate\n",
    "x_unknown = np.sort(np.random.randint(1,16,size=10))\n",
    "\n",
    "# YOUR CODE HERE\n",
    "# Call the Linear Interpolation Function\n",
    "y_new = linear_interp_arbitrary_points(x_known, y_known, x_unknown) \n",
    "\n",
    "# Create the list of Pair (x,y)\n",
    "xy_known=[]\n",
    "for m in range(len(x_known)):\n",
    "    xy_known.append(list((x_known[m],y_known[m])))\n",
    "\n",
    "xy_new=[]\n",
    "for n in range(len(x_unknown)):\n",
    "    xy_new.append(list((x_unknown[n],y_new[n])))\n",
    "\n",
    "# combine the list of Pairs between the (x,y) data of known data and new data\n",
    "xy_comb = xy_known + xy_new\n",
    "\n",
    "# Sorting a List of pairs (x,y) in term of (x) data only\n",
    "def getKey(item):\n",
    "    return item[0]\n",
    "\n",
    "sort_xy_comb = sorted(xy_comb, key=getKey)\n",
    "\n",
    "# Unpack (x,y) pairs data from the list (to create list of x and list of y in a correct order)\n",
    "x_ready,y_ready = zip(*sort_xy_comb)\n",
    "\n",
    "# Plotting\n",
    "fig, axs = plt.subplots(figsize = (10,5))\n",
    "\n",
    "#Scatter Plot\n",
    "axs.scatter(x_known, y_known,s = 60, c='red',label ='Known Data')\n",
    "axs.scatter(x_unknown, y_new,s =30 , c='black',label ='Approximated Data')\n",
    "\n",
    "#Line Plot\n",
    "axs.plot(x_ready, y_ready,\"*--k\", c='yellow',label ='Interpolation Line')\n",
    "\n",
    "#Graph Format\n",
    "axs.set_xlabel('x')\n",
    "axs.set_ylabel('y')\n",
    "axs.set_title('Linear Interpolation from Arbitary Points')\n",
    "axs.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "410b682c881586f8925c9e0d59ebcae4",
     "grade": false,
     "grade_id": "cell-f7446c6b25e73fcd",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Part D: Explanation loop\n",
    "\n",
    "<font color= #21618c>\n",
    "    \n",
    "### **Your task (1 pts)**:\n",
    "**Based on the implementation above, why do we need a `for-loop` for plotting (Part C). Briefly discuss in your own words.**\n",
    "</font>\n",
    "   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "68fac70574c1111fe8fa527bc22c17ba",
     "grade": true,
     "grade_id": "cell-ea7a61b1b183cac3",
     "locked": false,
     "points": 1,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "source": [
    "YOUR ANSWER HERE\n",
    "\n",
    "    In my case, to make a structured x-y plot among the known and the approximated data, first I used the for-loop to create the pair-list of all defined (x,y) from the: (x_known, y_known) and (x_unknown, y_new {y after the linear interpolation}). This algorithm needs to be conducted because the y_new is only created as a separated list (not linked into the x_unknown values). It will be a messed plot if we just directly plot all defined (x,y) data right after the y_new produced (because we have to link first between the data of x_known - y_known and x_unknown - y_new, then create a good order of it, to make a good plot). \n",
    "    \n",
    "    After that, I combined the pair list of (x,y) between known data and unknown data. After combining the pair-list, I have to sort the pair list with the correct order of x number (from small to big number) to create a well-structured (x,y) distribution data. \n",
    "    \n",
    "    In the data plotting using matplotlib, as long as I know, we need a separated list of x and y data to plot. Therefore, I used the unpacking data algorithm to the sorted pair-list, and produced the list of x and the list of y data with a correct order among known and unknown data respectively (which I called the x_ready and Y_ready). Then I plot the data as scatter and line plot of x and y data.    "
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}