1 - Install and Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# WELCOME TO 6.058!\n",
    "\n",
    "This semester we are going to use jupyter-notebooks. Notebooks are super awesome in that they allow us to focus on graphically displaying data and also allow us to execute code out of order if we want to do something funky.\n",
    "Consider the segment of code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp\n",
    "import scipy.signal as signal\n",
    "import matplotlib.pyplot as plt\n",
    "import IPython.display as ipd\n",
    "from ipywidgets import interact"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can execute this segment of code by clicking on it and pressing control + enter. (if this throws an error then talk to me, your software is not installed correctly).\n",
    "\n",
    "However, for most of the exercises in this course we won't be loading code one segment at a time. So, the first thing I am going to ask you to do in each notebook is to press cell up top and then Run All. This runs all code segments at the same time. Do that now!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this course we are going to be using python with numpy and scipy in order to create a lot of our software to do signal processing. We are going to access our python knowledge below. If you can't perform any of these exercises please talk to me, we can get you up to speed super fast :) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function called squarer which uses a for loop in order to square all of the elements in the list of the input signal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def squarer(inputsignal):\n",
    "    for i in inputsignal:\n",
    "        print(i**2)\n",
    "print(squarer([0,1,2,3,4,5,6,7]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now do the same thing using a list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49]\n"
     ]
    }
   ],
   "source": [
    "returned_squarer = [x**2 for x in range(8)]\n",
    "print(returned_squarer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a numpy array of one's with length 18.\n",
    "Sum all of the elements of the array. np.ones might be useful!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n"
     ]
    }
   ],
   "source": [
    "def onesandsum():\n",
    "    return np.ones(18)\n",
    "print(onesandsum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There will be a lot of times when we have to plot data. We are going to have two ways of ploting things. \n",
    "First in using matplotlib.pyplot.plot https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html\n",
    "\n",
    "You can use this function using plt.plot() followed by plt.show()\n",
    "Write a function below to do it with the supplies list of data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40f4c7c278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "datalist = [1,2,3,4,5,6,7,8,9]\n",
    "def plotdata(datalist):\n",
    "    plt.figure()\n",
    "    plt.plot(datalist)\n",
    "    plt.show()\n",
    "plotdata(datalist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also using plt.imshow() to display data from a matrix.\n",
    "Create a function below to display the given matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAAD8CAYAAABpXiE9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAADfdJREFUeJzt3X2snnV9x/H3x7bAEEaVLtKU8pR1zoc9ACcIshgyNQFmqIkswT9UjOZMJ5ku+gdqghnJMt0fmDGIpAEiLAaISrAuNQYFh2aBUbry0DbqkX9o7URBCx1Pq373x7kgt4fTntPffZ37vg++X8md87uu63df3y+/lg/Xfd0XbaoKSTpcrxp3A5KWJ8NDUhPDQ1ITw0NSE8NDUhPDQ1KTocMjyfokdyfZmWRHko/PM+e8JPuSbO9eVwxbV9J4rezhHAeAT1bVtiTHAg8kubOqds6Z9/2qelcP9SRNgKGvPKpqb1Vt68ZPA7uAdcOeV9Jk6+PK4yVJTgFOB+6b5/A5SR4Efgp8qqp2zPP+aWAaYOXvrTzzuJOP67O9V5TVK58ZdwsTb/WrfjPuFibeAw89/4uq+oOW96avx9OTHAP8B/CPVXX7nGO/D/ymqvYnuRD4l6racKjzrXnDmvqrmy7qpbdXoo3H//e4W5h47371/nG3MPFWrJ15oKqmWt7by7ctSVYBXwe+Mjc4AKrqqara3423AKuSrOmjtqTx6OPblgA3ALuq6qqDzDmhm0eSs7q6TwxbW9L49HHP41zgfcDDSbZ3+z4DnARQVdcBFwMfTXIAeBa4pPzfeaVlbejwqKofAFlgzjXANcPWkjQ5fMJUUhPDQ1ITw0NSE8NDUhPDQ1ITw0NSE8NDUhPDQ1ITw0NSE8NDUhPDQ1ITw0NSE8NDUhPDQ1ITw0NSE8NDUhPDQ1ITw0NSE8NDUhPDQ1ITw0NSE8NDUhPDQ1ITw0NSE8NDUhPDQ1ITw0NSk6HDI8n6JHcn2ZlkR5KPzzMnSa5OMpPkoSRnDFtX0ngN/RddAweAT1bVtiTHAg8kubOqdg7MuQDY0L3eAnyp+ylpmRr6yqOq9lbVtm78NLALWDdn2kbg5pp1L7A6ydpha0san17veSQ5BTgduG/OoXXAYwPbu3l5wEhaRnoLjyTHAF8HPlFVTzWeYzrJ1iRbn/vVc321JmkJ9BIeSVYxGxxfqarb55myB1g/sH1it++3VNWmqpqqqqmjVh/VR2uSlkgf37YEuAHYVVVXHWTaZuD93bcuZwP7qmrvsLUljU8f37acC7wPeDjJ9m7fZ4CTAKrqOmALcCEwAzwDfLCHupLGaOjwqKofAFlgTgEfG7aWpMnhE6aSmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmvQSHkluTPJ4kkcOcvy8JPuSbO9eV/RRV9L4rOzpPF8GrgFuPsSc71fVu3qqJ2nMernyqKp7gCf7OJek5aGvK4/FOCfJg8BPgU9V1Y65E5JMA9MAq459Ddtu+5MRtre83HPSm8bdwsT77ElPj7uFZeAfmt85qhum24CTq+rPgH8F7phvUlVtqqqpqppacfSrR9SapBYjCY+qeqqq9nfjLcCqJGtGUVvS0hhJeCQ5IUm68Vld3SdGUVvS0ujlnkeSW4DzgDVJdgOfA1YBVNV1wMXAR5McAJ4FLqmq6qO2pPHoJTyq6r0LHL+G2a9yJb1C+ISppCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJr2ER5Ibkzye5JGDHE+Sq5PMJHkoyRl91JU0Pn1deXwZOP8Qxy8ANnSvaeBLPdWVNCa9hEdV3QM8eYgpG4Gba9a9wOoka/uoLWk8RnXPYx3w2MD27m7fb0kynWRrkq2/fuZ/R9SapBYTdcO0qjZV1VRVTa04+tXjbkfSIYwqPPYA6we2T+z2SVqmRhUem4H3d9+6nA3sq6q9I6otaQms7OMkSW4BzgPWJNkNfA5YBVBV1wFbgAuBGeAZ4IN91JU0Pr2ER1W9d4HjBXysj1qSJsNE3TCVtHwYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmhgekpoYHpKaGB6SmvQSHknOT/LDJDNJLp/n+KVJfp5ke/f6cB91JY3P0H/RdZIVwLXAO4HdwP1JNlfVzjlTb6uqy4atJ2ky9HHlcRYwU1WPVtULwK3Axh7OK2mCDX3lAawDHhvY3g28ZZ5570nyNuBHwN9X1WNzJySZBqYBjuJoTvjif/bQ3ivTije9ftwtTLyn/2j1uFt4RRvVDdNvAqdU1Z8CdwI3zTepqjZV1VRVTa3iyBG1JqlFH+GxB1g/sH1it+8lVfVEVT3fbV4PnNlDXUlj1Ed43A9sSHJqkiOAS4DNgxOSrB3YvAjY1UNdSWM09D2PqjqQ5DLg28AK4Maq2pHkSmBrVW0G/i7JRcAB4Eng0mHrShqvPm6YUlVbgC1z9l0xMP408Ok+akmaDD5hKqmJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqUkv4ZHk/CQ/TDKT5PJ5jh+Z5Lbu+H1JTumjrqTxGTo8kqwArgUuAN4IvDfJG+dM+xDwy6r6Q+CLwBeGrStpvPq48jgLmKmqR6vqBeBWYOOcORuBm7rx14C3J0kPtSWNSR/hsQ54bGB7d7dv3jlVdQDYBxzfQ21JY7Jy3A0MSjINTAMcxdFj7kbSofRx5bEHWD+wfWK3b945SVYCxwFPzD1RVW2qqqmqmlrFkT20Jmmp9BEe9wMbkpya5AjgEmDznDmbgQ9044uBu6qqeqgtaUyG/thSVQeSXAZ8G1gB3FhVO5JcCWytqs3ADcC/JZkBnmQ2YCQtY73c86iqLcCWOfuuGBg/B/x1H7UkTQafMJXUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUZKjwSPLaJHcm+XH38zUHmffrJNu71+ZhakqaDMNeeVwOfLeqNgDf7bbn82xV/Xn3umjImpImwLDhsRG4qRvfBLx7yPNJWiZSVe1vTn5VVau7cYBfvrg9Z94BYDtwAPh8Vd1xkPNNA9Pd5puBR5qbWxprgF+Mu4kB9nNok9YPTF5Pr6+qY1veuHKhCUm+A5wwz6HPDm5UVSU5WBKdXFV7kpwG3JXk4ar6ydxJVbUJ2NTV3VpVUwv+E4zQpPVkP4c2af3A5PWUZGvrexcMj6p6xyEK/yzJ2qram2Qt8PhBzrGn+/loku8BpwMvCw9Jy8ew9zw2Ax/oxh8AvjF3QpLXJDmyG68BzgV2DllX0pgNGx6fB96Z5MfAO7ptkkwlub6b8wZga5IHgbuZveexmPDYNGRvS2HSerKfQ5u0fmDyemruZ6gbppJ+d/mEqaQmhoekJhMTHpPyqHuS85P8MMlMkpc9MZvkyCS3dcfvS3JK3z009HRpkp8PrMuHl7CXG5M8nmTeZ3Ay6+qu14eSnLFUvRxGT+cl2TewPlcsYS/rk9ydZGeSHUk+Ps+cka7RIns6/DWqqol4Af8MXN6NLwe+cJB5+5ewhxXMfoV8GnAE8CDwxjlz/ha4rhtfAty2xOuymJ4uBa4Z0a/T24AzgEcOcvxC4FtAgLOB+yagp/OAfx/R+qwFzujGxwI/mufXa6RrtMieDnuNJubKg8l41P0sYKaqHq2qF4Bbu74GDfb5NeDt3dO14+xpZKrqHuDJQ0zZCNxcs+4FVnfPAI2zp5Gpqr1Vta0bPw3sAtbNmTbSNVpkT4dtksLjdVW1txv/D/C6g8w7KsnWJPcm6Ttg1gGPDWzv5uWL/NKcqjoA7AOO77mPw+0J4D3dJfDXkqxfwn4Wsth+R+2cJA8m+VaSN42iYPeR9nTgvjmHxrZGh+gJDnONFnzCtE+jfNT9d8w3gVuq6vkkf8PsldFfjrmnSbKN2d83+5NcCNwBbFjKgkmOAb4OfKKqnlrKWou1QE+HvUYjvfKoqndU1ZvneX0D+NmLl26LfdQd+B6zKdqXPcDgf7VP7PbNOyfJSuA44Ikeezjsnqrqiap6vtu8HjhzCftZyGLWcKSq6qmq2t+NtwCruqedl0SSVcz+S/qVqrp9nikjX6OFempZo0n62DIJj7rfD2xIcmqSI5i9ITr3G53BPi8G7qrujtMSWbCnOZ+XL2L2M+24bAbe332jcDawb+Dj6FgkOeHF+1JJzmL29/2SBH5X5wZgV1VddZBpI12jxfTUtEajuAO9yDvCxzP7Bwr9GPgO8Npu/xRwfTd+K/Aws984PAx8aAn6uJDZu9E/AT7b7bsSuKgbHwV8FZgB/gs4bQRrs1BP/wTs6NblbuCPl7CXW4C9wP8x+1n9Q8BHgI90xwNc2/X6MDA1gvVZqKfLBtbnXuCtS9jLXwAFPMTsH0Oxvfv1G9saLbKnw14jH0+X1GSSPrZIWkYMD0lNDA9JTQwPSU0MD0lNDA9JTQwPSU3+Hzte6mrgFMiSAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40f4c8f438>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "matrix = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "def plotmatrix(matrix):\n",
    "    plt.figure()\n",
    "    plt.imshow(matrix,origin='lower')\n",
    "    plt.show()\n",
    "plotmatrix(matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we will be using IPyWidget interacts in this class to make our graphs and functions change on the fly. For example, consider this demo where we use a slider and plot that number:\n",
    "NOTE: On most all plots I add a DPI slider (dots per inch) this is just to make the graphs bigger and smaller so that they can fit your screen size better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6fffeb476537475484abd8252d2c585c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "interactive(children=(IntSlider(value=100, description='dpi', max=300, min=70), IntSlider(value=2, description='inputNum', max=10, min=1), Output()), _dom_classes=('widget-interact',))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def interactDemo(dpi=100,inputNum=2):\n",
    "    plottable = [inputNum for x in range(10)]\n",
    "    plt.figure(dpi)\n",
    "    plt.ylim(ymin=0,ymax=11)\n",
    "    plt.plot(plottable)\n",
    "    plt.show()\n",
    "interact(interactDemo,dpi=(70,300),inputNum=(1,10));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Signals and Systems Content\n",
    "\n",
    "Great, so we have covered some basics on how we are going to use the software. Let's dive into some content."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Today we are going to examine some basic syntax on what a signal and system are.\n",
    "The first signal we are concerned with is the impulse (or delta) function: This is the plot of a delta function $\\delta[n]$ (ignore the x-axis)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a35bdfb6b5a64c6c802b64fb507a1337",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "interactive(children=(IntSlider(value=100, description='dpi', max=200, min=70), Output()), _dom_classes=('widget-interact',))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "impulse = signal.unit_impulse(20,idx='mid')\n",
    "def impulseDemo(dpi=100):\n",
    "    plt.figure(dpi=dpi)\n",
    "    plt.plot(impulse,'ro')\n",
    "    plt.show()\n",
    "interact(impulseDemo,dpi=(70,200));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great, we drew a pretty impulse, but what use is this?\n",
    "First thing first, impulses are VERY useful for being able to model a general discrete signal.\n",
    "For example, consider this simple signal:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40f3d2f4a8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40f3d2f438>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "simplesignal = [0,0,0,1,2,3,0,0,0]\n",
    "plt.figure()\n",
    "fig, ax = plt.subplots()\n",
    "plt.plot(simplesignal,'ro')\n",
    "ax.set_xticklabels(range(-3,len(simplesignal)-3))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this simple signal we could use the following notation to represent it:\n",
    "$$\\delta[n-1] + 2\\delta[n-2] + 3\\delta[n-3]$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a matter of fact, all discrete signals can be represented of the form:\n",
    "$$ \\text{signal}[n] = \\sum_{i=\\infty}^{\\infty}a_{i}\\delta[n-i]$$ where $a_{i}$ is the value at that position.\n",
    "\n",
    "We will now have our first example of a homework exercise inside of the notebook.\n",
    "We have two ways of doing homework in the course, exercises inside of the notebook using software and exercises in the form of psets. Some theory is pset done on pen and paper and the applied work is best done in software. We are going to use both to make sure you understand the material.\n",
    "\n",
    "## Homework Exercise\n",
    "\n",
    "Create a plot of the function $$5\\delta[n-2] + 2\\delta[n-3] + 0.5\\delta[n-4] $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def homework1():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to being able to model discrete signals we will also use delta functions to characterize how systems perform. We will get into this later, but it is useful to keep in mind that this is INCREDIBLY useful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next signal we are going to consider is the unit step function, which looks like this:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40f3d1bfd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40f3d1be10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "impulse = [1 if x > 0 else 0  for x in range(-5,5)]\n",
    "plt.figure()\n",
    "fig, ax = plt.subplots()\n",
    "plt.plot(impulse,'bo')\n",
    "ax.set_xticklabels(range(-4,len(impulse)-4))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we now have the two most critical signals you will ever use. They are particularly useful when we seek to model systems. The impulse function we showed above can be throught of as an instant strike to the system in some way (mechanical systems getting hit by something, electrical systems exerience a voltage spike, chemical systems having a new reactant introduced etc). This is VERY useful as for a WIDE class of systems the impulse response is going to inform us of how the system will behave for ANY input that we can put into it!\n",
    "The unit step response is another useful tool. You can think of it as a gust of wind hitting an airplane, a constant voltage offset in an electrical system, constant force in mechanical systems. Often times depending on the type of system creating an ideal impulse is difficult / measuring it is hard so we use the unit step to derive the same information. You will prove on the PSET (Problem 5) that the response from a unit step and the response from a unit impulse are relatable for a certain class of systems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! We have tools to derive properties of systems. Now we just need to learn about what classes of systems we can use the properties on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By far the easiest type of system is a Linear - Time Invarient System.\n",
    "Linearity means that given the system f it obeys the following:\n",
    "$$ f(a) + f(b) = f(a+b) $$\n",
    "That is, the response of the system to two inputs seperatly is the same as the response to both at the same time.\n",
    "\n",
    "For many systems this is a reasonable approximation, if I push a block twice as hard it accelerates twice as much.\n",
    "For other systems it is not as reasonable, pushing someone on a swing twice as hard does not make them go twice as high.\n",
    "\n",
    "Time Invarience means this:\n",
    "$$ (x[n] \\text{ results in  } y[n]) \\text{  implies  } (x[n+k] \\text{  result in  } y[n+k]) $$\n",
    "\n",
    "This means that the system's response does not change over time. For almost all systems this is true (your airplane does not degrade in flight hopefully, your circuit does not change based on the seasons etc) however for some systems it is not true (chemical processes have plenty of examples of these).\n",
    "\n",
    "Finally, one property that we will bring up in this class sparingly, causality:\n",
    "A system is causal if its output at time t only depends on inputs from times t and before. As you can tell this is a really useless property in practice because everything is causal. If it were not causal then we would have figured out time travel. But for theory purposes sometimes we have to note that we are making the restriction to causal systems to make a proof work.\n",
    "\n",
    "As a side note: we will start using the abreviation LTI instead of saying Linear - Time Invarient Systems.\n",
    "\n",
    "So, now we will compute our first output from a system.\n",
    "\n",
    "So, suppose we have a system of the form:\n",
    "$$ y[n] = x[n] + 3x[n-1]$$\n",
    "Create a plot of the impulse response of the system as well as the step response.\n",
    "\n",
    "## Homework Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotImpulseResponse():\n",
    "    pass\n",
    "plotImpulseResponse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotStepResponse():\n",
    "    pass\n",
    "plotStepResponse()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, it is very convenient for us to be able to write these systems by hand and solve them, but as they get more and more complex we will start to experience handaches from the computation. Thankfully we can have code take care of it for us. The below snippet of code is finding the impulse response of the system. The one afterwards finds the step response. Verify that your homework solutions match these plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40f4bd1438>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xs = [1,3,0]\n",
    "ys = [1,0,0]\n",
    "sys = signal.TransferFunction(xs, ys,dt=1.0)\n",
    "tout,yout = signal.dimpulse(sys)\n",
    "plt.figure()\n",
    "plt.plot(tout[0:10],yout[0][0:10],'o')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40f3e11d30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xs = [1,3,0]\n",
    "ys = [1,0,0]\n",
    "sys = signal.TransferFunction(xs, ys,dt=1.0)\n",
    "tout,yout = signal.dstep(sys)\n",
    "plt.figure()\n",
    "plt.plot(tout[0:10],yout[0][0:10],'o')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the impulse response looks how we think it should look :D\n",
    "Can you use a similar piece of a code to make the step response for this system:\n",
    "$$y[n] - y[n-1] = x[n] + x[n-1]$$\n",
    "## Homework Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stepresponse2():\n",
    "    pass\n",
    "stepresponse2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework Exercise\n",
    "Why does this output settle at 4? Think about what the interaction between $y[n]$ and $y[n-1]$ is.\n",
    "\n",
    "WRITE ANSWER HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the below system. You have a slider for tweaking r in the input.\n",
    "The system looks like this:\n",
    "$ y[n] - y[n-1] = x[n] + rx[n-1]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9a39fa4bcd4a4462981ea1c8cd028a97",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='r', max=1.0, min=-1.0), Output()), _dom_classes=('widget-interact',))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def impulseresponse2(r):\n",
    "    xs = [1,r,0]\n",
    "    ys = [1,-1,0]\n",
    "    sys = signal.TransferFunction(xs, ys,dt=1.0)\n",
    "    tout,yout = signal.dimpulse(sys)\n",
    "    plt.figure()\n",
    "    plt.ylim(ymin=-0.5,ymax=2)\n",
    "    plt.plot(tout[0:10],yout[0][0:10],'o')\n",
    "    plt.show()\n",
    "    \n",
    "interact(impulseresponse2, r=(-1.0,1.0));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We must also look at a step response and consider what it looks like.\n",
    "Let's look at the step response of the following system:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2763f59d20554a6185467e80cf962dec",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='r', max=2.0, min=-2.0), Output()), _dom_classes=('widget-interact',))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def stepresponse3(r):\n",
    "    xs = [1,r,0]\n",
    "    ys = [1,-1,0]\n",
    "    sys = signal.TransferFunction(xs, ys,dt=1.0)\n",
    "    tout,yout = signal.dstep(sys)\n",
    "    plt.figure()\n",
    "    plt.ylim(ymin=-10,ymax=25)\n",
    "    plt.plot(tout[0:10],yout[0][0:10],'o')\n",
    "    plt.show()\n",
    "    \n",
    "interact(stepresponse3, r=(-2.0,2.0));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cool! We now have some analysis tools that we can use. \n",
    "Let's do some modeling in order to use them on real systems.\n",
    "First part, we are going to consider a heating system.\n",
    "Now, heating systems often have some kind of thermal mass, $M$ and some loss $R$\n",
    "We are going to model the system using the equation:\n",
    "$$T_{Heater}[n] =  T_{Room}[n] + R \\times M \\times \\frac{d T_{Room}[n]}{dt}$$\n",
    "To figure out where this equation comes from, remember from thermo that Heat in = Heat out + Heat stored.\n",
    "\n",
    "Finish the below function to find the impulse and step function of this model using $$R=1,M=5$$. What is a derivative in discrete time (if unsure look at the PSET)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40f3d1bc88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40f3d74e80>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def temperaturemodel(R=1,M=5):\n",
    "    xs = [1]\n",
    "    ys = [1]\n",
    "    sys = signal.TransferFunction(xs, ys,dt=1.0)\n",
    "    iout,iyout = signal.dimpulse(sys)\n",
    "    tout,yout = signal.dstep(sys)\n",
    "    plt.figure()\n",
    "    plt.plot(tout[0:10],yout[0][0:10],'o')\n",
    "    plt.show()\n",
    "    plt.figure()\n",
    "    plt.plot(iout[0:10],iyout[0][0:10],'o')\n",
    "    plt.show()\n",
    "    \n",
    "temperaturemodel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework Exercise\n",
    "\n",
    "Solve the differential equation for continuous time. Does this match what the differential equation tells you for continuous time step and impulse response? Write the continious time impulse and step response equations here $$\\text{impulse response equation}$$\n",
    "$$\\text{step response equation}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework Exercise\n",
    "\n",
    "Create a plot of the impulse and step responses you calculated by hand above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def temperatureImpulsePlot():\n",
    "    pass\n",
    "\n",
    "temperatureImpulsePlot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Thinking about non-LTI systems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we have been thinking about LTI systems and their responses, but what about non-LTI systems?\n",
    "In general, if something is not LTI then it can behave in many violent ways. For LTI systems in the abscene of an input there will always be a zero output. However for non-linear systems this does not hold true. In fact, for non-linear systems chaotic behavior can occur. Unfortunately right now we don't have the tools to start analyzing non-linear systems. The best we can do is to get the differentialy equations and solve them analytically / numerically. However, in lecture 7 of the course we will talk about the laplace transform, which can be used as a tool to start analyzing non-linear systems."
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}