Copy_of_EN1060_Lab03.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.6.8-final"
    },
    "colab": {
      "name": "Copy of EN1060_Lab03.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QYvqUs8IfGBv"
      },
      "source": [
        "![](https://drive.google.com/uc?id=11obWVVXPLfBElGh5hXm1QBfqLHLns1ST)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7u4GFrU2fGB2"
      },
      "source": [
        "---\n",
        "**Experiment 3: Linear Time-Inviariant Systems**\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "**Objective:** To understand the LTI properties\n",
        "\n",
        "**Outcome:**   After successfully completion of this session, the student would be able to  \n",
        "\n",
        "* Understand the impulse response of a system.\n",
        "* Understand the properties of linearity and time-invariance.\n",
        "* Apply above properties to generate system output using convolution.\n",
        "* Analyze signals in the frequency domain.\n",
        "* Apply above knowledge in a real-world application.\n",
        "\n",
        "**Equipment Required:** \n",
        "*   A personal computer.\n",
        "*   Python with NumPy, SciPy, Matplotlib.\n",
        "*   Speakers\n",
        "\n",
        "**Components Required:** None\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aJOIPI2ZfGB2"
      },
      "source": [
        "# Introduction\n",
        "\n",
        "In this laboratory we will be studying the properties of linearity and time-invariance and how we can exploit these properties to calculate the system response using only the input signal and impulse response of the system."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gRe7sMZLfGB3"
      },
      "source": [
        "# 1.0 Simulating a System Impulse Response\n",
        "\n",
        "Impulse response $h[n]$ of a system is the output of a system to an impulse input, $\\delta[n]$. First, we shall try to find the impulse response of an accumulator.\n",
        "\n",
        "## 1.1 Simple example of impulse response: The Accumulator\n",
        "\n",
        "The accumulator (system) is defined as below. \n",
        "\\begin{equation*}\n",
        "y[n] = acc\\{x[n]\\} \\to y[n] =  \\sum_{k=-\\infty}^n x[k] \n",
        "\\end{equation*}\n",
        "\n",
        "In simple terms, the current output of the accumulator is the sum (accumulation) of all the previous inputs up to the current input.\n",
        "\n",
        "First, begin your implementation by defining the impulse function, $\\delta [n]$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 316
        },
        "id": "6_aABjLvfGB3",
        "outputId": "000e740e-906b-496a-d621-0dd5e7e9bc2f"
      },
      "source": [
        "%matplotlib inline\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Define the impulse function\n",
        "def delta(t):\n",
        "    x = np.zeros(len(t))\n",
        "    for i,n in enumerate(t):\n",
        "        if n == 0:\n",
        "            x[i] = 1.0\n",
        "    return x\n",
        "\n",
        "# Visualize the impulse function\n",
        "fig, axes  = plt.subplots(1,2, sharex='all', sharey='all', figsize=(20,3))\n",
        "t = np.arange(-5,5)\n",
        "x = delta(t)\n",
        "axes[0].stem(t,x), axes[0].set_xlabel('$n$'), axes[0].set_ylabel('$\\delta[n]$')\n",
        "\n",
        "# shift the delta left by 2\n",
        "x = delta(t+2)\n",
        "print(x)\n",
        "print(t)\n",
        "axes[1].stem(t,x), axes[1].set_xlabel('$n$'), axes[1].set_ylabel('$\\delta[n+2]$')\n",
        "plt.show()"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:17: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:23: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "[0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]\n",
            "[-5 -4 -3 -2 -1  0  1  2  3  4]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x216 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kg82QNIKfGB4"
      },
      "source": [
        "Complete the function ```accumulator(x)``` below to return an array in which each index contains the accumulation of all previous values in the input array. After that, visualize the output of the accumulator to a delta input (i.e., its impulse response). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 425
        },
        "id": "rp7tHXd-fGB4",
        "outputId": "65c45f1e-29fc-476e-ee24-4f9dd64ff1f7"
      },
      "source": [
        "def accumulator(x):\n",
        "    y = np.zeros(len(x))\n",
        "    for i in range(len(x)):\n",
        "        # EDIT HERE\n",
        "        y[i] = y[i-1]+x[i]\n",
        "    return y\n",
        "\n",
        "# Visualize impulse response of Accumalator\n",
        "t = np.arange(-10., 11.)\n",
        "x = delta(t) # EDIT HERE\n",
        "y = accumulator(x)\n",
        "\n",
        "fig, axes  = plt.subplots(2,1, sharex='all', sharey='all', figsize=(20,5))\n",
        "axes[0].stem(t,x), axes[0].set_xlabel('$n$'), axes[0].set_ylabel('$x[n]$')\n",
        "axes[1].stem(t,y), axes[1].set_xlabel('$n$'), axes[1].set_ylabel('$y[n]$')\n",
        "plt.show()"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:14: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  \n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:15: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  from ipykernel import kernelapp as app\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G3ptFh1RfGB4"
      },
      "source": [
        "Implement an ‘accumulator with decay’ and plot its impulse response. The accumulator with decay is defined as below. \n",
        "\n",
        "\\begin{equation*}\n",
        "y[n] = \\sum_{n=-\\infty}^{n} x[k] e^{-0.5[n-k]}\n",
        "\\end{equation*}\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 280
        },
        "id": "q7Z_S9SSfGB5",
        "outputId": "aaf6b324-6e49-42aa-90aa-ccdb095c5d7e"
      },
      "source": [
        "# cell [2]\n",
        "\n",
        "def accumulator_decay(x):\n",
        "    y = np.zeros(len(x))\n",
        "    for i in range(len(x)):\n",
        "        # EDIT HERE\n",
        "        y[i] = y[i-1]+(x[i]*np.exp(-0.5*abs(i-len(y))))\n",
        "    return y\n",
        "\n",
        "x = delta(t)\n",
        "y = accumulator_decay(x)\n",
        "\n",
        "fig, ax  = plt.subplots(figsize=(20,3))\n",
        "ax.stem(t,y), ax.set_xlabel('$n$'), ax.set_ylabel('$y[n]$')\n",
        "ax.set_xticks([i for i in range(-10, 11, 1)])\n",
        "plt.show()"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:14: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  \n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x216 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zypowMm-fGB5"
      },
      "source": [
        "Construct the following signal $x[n]$ using the ```delta(t)``` function."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D5KgKd-1fGB5"
      },
      "source": [
        "![](https://drive.google.com/uc?export=view&id=1Lyblke6EeRjE19Ploj_F1YxzV2IS__L4)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 280
        },
        "id": "mmcTGgK4fGB5",
        "outputId": "e85d0aae-7a9a-4b90-b331-334a67e7ae38"
      },
      "source": [
        "# cell [3]\n",
        "\n",
        "n_x = np.arange(-1., 15.)\n",
        "# EDIT HERE\n",
        "x_new =delta(n_x-1)+delta(n_x-2)+delta(n_x-6)+delta(n_x-7)\n",
        "\n",
        "fig, axes  = plt.subplots(figsize=(20,3))\n",
        "axes.stem(n_x,x_new), axes.set_xlabel('$n$'), axes.set_ylabel('$x_new[n]$')\n",
        "plt.show()"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:8: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  \n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x216 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8cbcEhiCfGB6"
      },
      "source": [
        "Now plot the response of the \"accumulator with delay\" system to the above input."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 280
        },
        "id": "k0zp9w1JfGB6",
        "outputId": "8dcb954c-7c26-4c19-9a4f-76e0b6e3cf2e"
      },
      "source": [
        "# cell [4]\n",
        "\n",
        "y = accumulator_decay(x_new)\n",
        "\n",
        "fig, axes  = plt.subplots(figsize=(20,3))\n",
        "axes.stem(n_x,y), axes.set_xlabel('$n$'), axes.set_ylabel('$y[n]$')\n",
        "plt.show()"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:6: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  \n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ8AAADQCAYAAACpzMDbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAcFElEQVR4nO3df7Bed10n8Pdnk7YGlHZpg0uT1nS33brhh1ayFRZ1RhBaViRdhaEsK3W3Y9mRuvirmO6OXYfBFaY7i+vSZa2WH3aVlq2lZLQa0eo4OlKa0tKfZg0VaFJYUiBFNKWkfPaPe8K9z+Xe5CbkeZ6bm9dr5k7O+T7fc57P+cyZ5ubd86O6OwAAAAAwDv9g2gUAAAAAsHIJnwAAAAAYG+ETAAAAAGMjfAIAAABgbIRPAAAAAIyN8AkAAACAsVk97QKm4bTTTusNGzZMuwwAAACAFePOO+98tLvXzh8/LsOnDRs2ZPv27dMuAwAAAGDFqKpPLjTutjsAAAAAxkb4BAAAAMDYHJe33QEAsDS33LU7V2/bkUf27svpp6zJFRecm4vOWzftsqZCL0bpxyy9GKUfo/Rjll6MOp76IXwCAGBBt9y1O1fefG/2feXJJMnuvfty5c33JsmK/eV4MXoxSj9m6cUo/RilH7P0YtTx1g+33QEAsKCrt+342i/FB+z7ypO5etuOKVU0PXoxSj9m6cUo/RilH7P0YtTx1g/hEwAAC3pk777DGl/J9GKUfszSi1H6MUo/ZunFqOOtH8InAAAWdPopaw5rfCXTi1H6MUsvRunHKP2YpRejjrd+CJ8AAFjQFRecmzUnrBoZW3PCqlxxwblTqmh69GKUfszSi1H6MUo/ZunFqOOtHx44DgDAgg488PRNN92TJ578atat8DfxHIxejNKPWXoxSj9G6ccsvRh1vPWjunvaNUzcpk2bevv27dMuAwDgmPDqX/vLJMmNr3/BlCuZPr0YpR+z9GKUfozSj1l6MWql9aOq7uzuTfPHJ3rbXVVdWFU7qmpnVW1Z4POTqurG4fPbq2rDMH5+Vd09/Hysqv7VUvcJAAAAwPRMLHyqqlVJrknysiQbk7ymqjbOm3Zpki9099lJ3p7kbcP4fUk2dfd3Jrkwya9V1eol7hMAAACAKZnklU/nJ9nZ3Q919xNJbkiyed6czUneOyzflOTFVVXd/ffdvX8Y/6YkB+4VXMo+AQAAAJiSSYZP65I8PGd91zC24JwhbHosyalJUlXfXVX3J7k3yb8fPl/KPgEAAACYkok+8+kb0d23d/ezkvzzJFdW1TcdzvZVdVlVba+q7Xv27BlPkQAAAACMmGT4tDvJGXPW1w9jC86pqtVJTk7yubkTuvvBJF9K8uwl7vPAdtd296bu3rR27dpv4DAAAAAAWKpJhk93JDmnqs6qqhOTXJxk67w5W5NcMiy/Mslt3d3DNquTpKq+Lcm3J/nEEvcJAAAAwJSsntQXdff+qro8ybYkq5K8q7vvr6o3J9ne3VuTXJfk+qrameTzmQmTkuR7kmypqq8k+WqSn+juR5NkoX1O6pgAAAAAOLiJhU9J0t23Jrl13thVc5YfT/KqBba7Psn1S90nAAAAAMvDMfPAcQAAAACOPcInAAAAAMZG+AQAAADA2AifAAAAABgb4RMAAAAAYyN8AgAAAGBshE8AAAAAjI3wCQAAAICxET4BAAAAMDbCJwAAAADGRvgEAAAAwNgInwAAAAAYG+ETAAAAAGMjfAIAAABgbCYaPlXVhVW1o6p2VtWWBT4/qapuHD6/vao2DOMvqao7q+re4c8XzdnmT4d93j38PGNyRwQAAADAwaye1BdV1aok1yR5SZJdSe6oqq3d/cCcaZcm+UJ3n11VFyd5W5JXJ3k0yQ919yNV9ewk25Ksm7Pda7t7+0QOBAAAAIAlm+SVT+cn2dndD3X3E0luSLJ53pzNSd47LN+U5MVVVd19V3c/Mozfn2RNVZ00kaoBAAAAOGKTDJ/WJXl4zvqujF69NDKnu/cneSzJqfPm/EiSj3b3l+eMvXu45e4XqqqObtkAAAAAHKlj6oHjVfWszNyK9/o5w6/t7uck+d7h50cX2fayqtpeVdv37Nkz/mIBAAAAmGj4tDvJGXPW1w9jC86pqtVJTk7yuWF9fZIPJHldd3/8wAbdvXv482+T/HZmbu/7Ot19bXdv6u5Na9euPSoHBAAAAMDBTTJ8uiPJOVV1VlWdmOTiJFvnzdma5JJh+ZVJbuvurqpTkvxeki3d/RcHJlfV6qo6bVg+IcnLk9w35uMAAAAAYIkmFj4Nz3C6PDNvqnswyfu7+/6qenNVvWKYdl2SU6tqZ5KfSbJlGL88ydlJrhqe7XR3VT0jyUlJtlXVPUnuzsyVU78+qWMCAAAA4OBWT/LLuvvWJLfOG7tqzvLjSV61wHZvSfKWRXb7vKNZIwAAAABHzzH1wHEAAAAAji3CJwAAAADGRvgEAAAAwNgInwAAAAAYG+ETAAAAAGMjfAIAAABgbIRPAAAAAIyN8AkAAACAsRE+AQAAADA2wicAAAAAxkb4BAAAAMDYCJ8AAAAAGBvhEwAAAABjI3wCAAAAYGyETwAAAACMzUTDp6q6sKp2VNXOqtqywOcnVdWNw+e3V9WGYfwlVXVnVd07/PmiOds8bxjfWVW/WlU1uSMCAAAA4GAmFj5V1aok1yR5WZKNSV5TVRvnTbs0yRe6++wkb0/ytmH80SQ/1N3PSXJJkuvnbPPOJD+e5Jzh58KxHQQAAAAAh2WSVz6dn2Rndz/U3U8kuSHJ5nlzNid577B8U5IXV1V1913d/cgwfn+SNcNVUs9M8rTu/nB3d5LfTHLR+A8FAAAAgKWYZPi0LsnDc9Z3DWMLzunu/UkeS3LqvDk/kuSj3f3lYf6uQ+wzSVJVl1XV9qravmfPniM+CAAAAACW7ph64HhVPSszt+K9/nC37e5ru3tTd29au3bt0S8OAAAAgK8zyfBpd5Iz5qyvH8YWnFNVq5OcnORzw/r6JB9I8rru/vic+esPsU8AAAAApmSS4dMdSc6pqrOq6sQkFyfZOm/O1sw8UDxJXpnktu7uqjolye8l2dLdf3Fgcnd/OskXq+r5w1vuXpfkg+M+EAAAAACWZmLh0/AMp8uTbEvyYJL3d/f9VfXmqnrFMO26JKdW1c4kP5NkyzB+eZKzk1xVVXcPP88YPvuJJL+RZGeSjyf5/ckcEQAAAACHsnqSX9bdtya5dd7YVXOWH0/yqgW2e0uStyyyz+1Jnn10KwUAAADgaDimHjgOAAAAwLFF+AQAAADA2AifAAAAABgb4RMAAAAAY3PIB45X1dOXsJ+vdvfeo1APAAAAACvIUt5298jwUweZsyrJmUelIgAAAABWjKWETw9293kHm1BVdx2legAAAABYQZbyzKcXHKU5AAAAABxnDnnlU3c/niRV9aIkr02yN8l9Se5Jcl93f/nAHAAAAACYaym33R3wriQ/leSEJM9NclGSZyU5ewx1AQAAALACHE749MnuvmVY/j/jKAYAAACAlWUpz3w64M+q6qer6mBvvQMAAACArzmcK582JnlOkp+vqjuT3J3k7u52FRQAAAAAC1py+NTdP5IkVbUms0HUd8cteAAAAAAs4nBuu0uSdPe+7r6zu9/T3T93ONtW1YVVtaOqdlbVlgU+P6mqbhw+v72qNgzjp1bVn1TVl6rqHfO2+dNhn3cPP8843GMCAAAAYDwOGT5V1UeP0pxVSa5J8rLMXDn1mqraOG/apUm+0N1nJ3l7krcN448n+YUki4Vdr+3u7xx+PnuoWgAAAACYjKXcdvfPquqeg3xeSU5ewn7OT7Kzux9Kkqq6IcnmJA/MmbM5yS8OyzcleUdVVXf/XZI/r6qzl/A9AAAAACwTSwmfvn0Jc55cwpx1SR6es74rM8+MWnBOd++vqseSnJrk0UPs+91V9WSS30nylu7uJdQDAAAAwJgdMnzq7k8mSVV9KMnPdffHxl7V4Xltd++uqm/JTPj0o0l+c/6kqrosyWVJcuaZZ062QgAAAIDj1OE8cPznk/xKVb27qp55BN+1O8kZc9bXD2MLzqmq1Zm5ne9zB9tpd+8e/vzbJL+dmdv7Fpp3bXdv6u5Na9euPYLyAQAAADhcSw6fuvuj3f39SX43yR9U1X+uqjWH8V13JDmnqs6qqhOTXJxk67w5W5NcMiy/MsltB7uFrqpWV9Vpw/IJSV6e5L7DqAkAAACAMVrKM5++pqoqyY4k70zyliQ/XlVXdvf1h9p2eIbT5Um2JVmV5F3dfX9VvTnJ9u7emuS6JNdX1c4kn89MQHXguz+R5GlJTqyqi5K8NMknk2wbgqdVSf4oya8fzjEBAMx1y127c/W2HXlk776cfsqaXHHBubnovHXTLgsA4Ji15PCpqv4iyVlJ7k/y4SQ/luSvkryxqr63uy871D66+9Ykt84bu2rO8uNJXrXIthsW2e3zllA+AMAh3XLX7lx5873Z95WZd6ns3rsvV958b5IIoAAAjtDhXPl0WZIHFrgN7ier6sGjWBMAwFRcvW3H14KnA/Z95clcvW2H8AkA4AgtOXzq7vsP8vEPHoVaAACm6pG9+w5rHACAQzuct90tqrsfOhr7AQCYptNPWfhdKouNAwBwaEclfAIAWAmuuODcrDlh1cjYmhNW5YoLzp1SRQAAx77DetsdAMBKduC5Tm+66Z488eRXs87b7gAAvmHCJwCAOS46b13e95FPJUlufP0LplwNAMCxz213AAAAAIyN8AkAAACAsRE+AQAAADA2wicAAAAAxkb4BAAAAMDYCJ8AAAAAGBvhEwAAAABjI3wCAAAAYGwmGj5V1YVVtaOqdlbVlgU+P6mqbhw+v72qNgzjp1bVn1TVl6rqHfO2eV5V3Tts86tVVZM5GgAAAAAOZWLhU1WtSnJNkpcl2ZjkNVW1cd60S5N8obvPTvL2JG8bxh9P8gtJfm6BXb8zyY8nOWf4ufDoVw8AAADAkZjklU/nJ9nZ3Q919xNJbkiyed6czUneOyzflOTFVVXd/Xfd/eeZCaG+pqqemeRp3f3h7u4kv5nkorEeBQAAAABLNsnwaV2Sh+es7xrGFpzT3fuTPJbk1EPsc9ch9gkAAADAlBw3DxyvqsuqantVbd+zZ8+0ywEAAAA4LkwyfNqd5Iw56+uHsQXnVNXqJCcn+dwh9rn+EPtMknT3td29qbs3rV279jBLBwAAAOBITDJ8uiPJOVV1VlWdmOTiJFvnzdma5JJh+ZVJbhue5bSg7v50ki9W1fOHt9y9LskHj37pAAAAAByJ1ZP6ou7eX1WXJ9mWZFWSd3X3/VX15iTbu3trkuuSXF9VO5N8PjMBVZKkqj6R5GlJTqyqi5K8tLsfSPITSd6TZE2S3x9+AAAAAFgGJhY+JUl335rk1nljV81ZfjzJqxbZdsMi49uTPPvoVQkAAADA0XLcPHAcAAAAgMkTPgEAAAAwNsInAAAAAMZG+AQAAADA2AifAAAAABgb4RMAAAAAYyN8AgAAAGBshE8AAAAAjI3wCQAAAICxET4BAAAAMDbCJwAAAADGRvgEAAAAwNgInwAAAAAYG+ETAAAAAGMjfAIAAABgbCYaPlXVhVW1o6p2VtWWBT4/qapuHD6/vao2zPnsymF8R1VdMGf8E1V1b1XdXVXbJ3MkAAAAACzF6kl9UVWtSnJNkpck2ZXkjqra2t0PzJl2aZIvdPfZVXVxkrcleXVVbUxycZJnJTk9yR9V1T/t7ieH7b6/ux+d1LEAAAAAsDSTvPLp/CQ7u/uh7n4iyQ1JNs+bsznJe4flm5K8uKpqGL+hu7/c3X+TZOewPwAAAACWsUmGT+uSPDxnfdcwtuCc7t6f5LEkpx5i207yh1V1Z1VdttiXV9VlVbW9qrbv2bPnGzoQAAAAAJZmJTxw/Hu6+7uSvCzJG6rq+xaa1N3Xdvem7t60du3ayVYIAAAAcJyaZPi0O8kZc9bXD2MLzqmq1UlOTvK5g23b3Qf+/GySD8TteAAAAADLxiTDpzuSnFNVZ1XViZl5gPjWeXO2JrlkWH5lktu6u4fxi4e34Z2V5JwkH6mqp1bVtyRJVT01yUuT3DeBYwEAAABgCSb2trvu3l9VlyfZlmRVknd19/1V9eYk27t7a5LrklxfVTuTfD4zAVWGee9P8kCS/Une0N1PVtW3JvnAzDPJszrJb3f3H0zqmAAAAAA4uImFT0nS3bcmuXXe2FVzlh9P8qpFtv2lJL80b+yhJN9x9CsFAAAA4GhYCQ8cBwAAAGCZEj4BAAAAMDbCJwAAAADGZqLPfAKYpFvu2p2rt+3II3v35fRT1uSKC87NReetm3ZZU6Mfo/Rjll4AADBOwidgRbrlrt258uZ7s+8rTyZJdu/dlytvvjdJjst/VOvHKP2YpRcAAIyb2+6AFenqbTu+9o/pA/Z95clcvW3HlCqaLv0YpR+z9AIAgHETPgEr0iN79x3W+EqnH6P0Y5ZeAAAwbsInYEU6/ZQ1hzW+0unHKP2YpRcAAIyb8AlYka644NysOWHVyNiaE1bligvOnVJF06Ufo/Rjll4AADBuHjgOrEgHHpT8ppvuyRNPfjXrjvM3eOnHKP2YpRcAAIyb8AlWGK9Mn3XReevyvo98Kkly4+tfMOVqpk8/RunHLL0AAGCchE+wgnhlOgAAAMuNZz7BCuKV6QAAACw3widYQbwyHQAAgOVmouFTVV1YVTuqamdVbVng85Oq6sbh89urasOcz64cxndU1QVL3edKdMtdu/PCt96Ws7b8Xl741ttyy127p13SVOnHLK9MBwAAYLmZWPhUVauSXJPkZUk2JnlNVW2cN+3SJF/o7rOTvD3J24ZtNya5OMmzklyY5H9W1aol7nNFOfBMn91796Uz+0yf4zVw0Y9RXpkOAADAclPdPZkvqnpBkl/s7guG9SuTpLt/ec6cbcOcv6yq1Uk+k2Rtki1z5x6YN2x20H0uZNOmTb19+/ajd3AT9MK33pbde/fl9fd8MP/4sdmA5aTVq3LemadMsbLpuOtTe/Pl/U9+3fjx2o8kefRLX87H9/xdujsnrV6VM56+Jqd980nTLmtqHvj0F5MkG5/5tClXsjzoxyj9mKUXo/RjlH7M0otR+jFLL0bpxyj9mKUXox749BfzmbVn5N++739Mu5Sjoqru7O5N88cn+ba7dUkenrO+K8l3Lzanu/dX1WNJTh3GPzxv2wOv7jrUPpMkVXVZksuS5MwzzzyyI1gGFnt2z0IBzPFgseM+XvuRJKd980n50pf3J0k2nPrUKVczfU85cdWhJx1H9GOUfszSi1H6MUo/ZunFKP2YpRej9GOUfszSi1FPOXFVnv7UlX+xwCTDp6nq7muTXJvMXPk05XKO2OmnrMnuvfvya8/dPDK+7pQ1efWWF02pqun518OVYPMdr/044NumXcAyohej9GOUfszSi1H6MUo/ZunFKP2YpRej9GOUfszSi1HHSz8m+cDx3UnOmLO+fhhbcM5w293JST53kG2Xss8VxTN9RukHAAAALG+TDJ/uSHJOVZ1VVSdm5gHiW+fN2ZrkkmH5lUlu65mHUm1NcvHwNryzkpyT5CNL3OeKctF56/LLP/ycrDtlTSozV/j88g8/Jxedt+6Q265E+gEAAADL28Ruuxue4XR5km1JViV5V3ffX1VvTrK9u7cmuS7J9VW1M8nnMxMmZZj3/iQPJNmf5A3d/WSSLLTPSR3TtFx03jrhyhz6AQAAAMvXxN52t5wcy2+7AwAAAFiOFnvb3SRvuwMAAADgOCN8AgAAAGBsjsvb7qpqT5JPTrsOjrrTkjw67SJYlpwbHIzzg8U4N1iMc4PFODc4GOcHi1lJ58a3dffa+YPHZfjEylRV2xe6txScGxyM84PFODdYjHODxTg3OBjnB4s5Hs4Nt90BAAAAMDbCJwAAAADGRvjESnLttAtg2XJucDDODxbj3GAxzg0W49zgYJwfLGbFnxue+QQAAADA2LjyCQAAAICxET6xIlTVhVW1o6p2VtWWadfD8lBVZ1TVn1TVA1V1f1W9cdo1sbxU1aqququqfnfatbB8VNUpVXVTVf1VVT1YVS+Ydk0sH1X108PfKfdV1fuq6pumXRPTUVXvqqrPVtV9c8aeXlUfqqq/Hv78h9OskelY5Ny4evh75Z6q+kBVnTLNGpmehc6POZ/9bFV1VZ02jdrGSfjEMa+qViW5JsnLkmxM8pqq2jjdqlgm9if52e7emOT5Sd7g3GCeNyZ5cNpFsOz89yR/0N3fnuQ74hxhUFXrkvyHJJu6+9lJViW5eLpVMUXvSXLhvLEtSf64u89J8sfDOsef9+Trz40PJXl2dz83yf9NcuWki2LZeE++/vxIVZ2R5KVJPjXpgiZB+MRKcH6Snd39UHc/keSGJJunXBPLQHd/urs/Oiz/bWb+AbluulWxXFTV+iQ/mOQ3pl0Ly0dVnZzk+5JclyTd/UR3751uVSwzq5OsqarVSZ6S5JEp18OUdPefJfn8vOHNSd47LL83yUUTLYplYaFzo7v/sLv3D6sfTrJ+4oWxLCzy344keXuSNyVZkQ/mFj6xEqxL8vCc9V0RMDBPVW1Icl6S26dbCcvIr2TmL/ivTrsQlpWzkuxJ8u7hlszfqKqnTrsolofu3p3kv2bm/0p/Oslj3f2H062KZeZbu/vTw/JnknzrNIth2fp3SX5/2kWwfFTV5iS7u/tj065lXIRPwIpXVd+c5HeS/FR3f3Ha9TB9VfXyJJ/t7junXQvLzuok35Xknd19XpK/i9tmGAzP79mcmZDy9CRPrap/M92qWK565rXiK/IKBo5cVf2nzDwa4remXQvLQ1U9Jcl/THLVtGsZJ+ETK8HuJGfMWV8/jEGq6oTMBE+/1d03T7selo0XJnlFVX0iM7fqvqiq/vd0S2KZ2JVkV3cfuErypsyEUZAkP5Dkb7p7T3d/JcnNSf7FlGtiefl/VfXMJBn+/OyU62EZqaofS/LyJK8dwklIkn+Smf+p8bHhd9P1ST5aVf9oqlUdZcInVoI7kpxTVWdV1YmZefDn1inXxDJQVZWZ57Y82N3/bdr1sHx095Xdvb67N2Tmvxm3dberF0h3fybJw1V17jD04iQPTLEklpdPJXl+VT1l+DvmxfFAekZtTXLJsHxJkg9OsRaWkaq6MDO3+7+iu/9+2vWwfHT3vd39jO7eMPxuuivJdw2/k6wYwieOecOD+y5Psi0zvwC+v7vvn25VLBMvTPKjmbmq5e7h519Ouyhg2fvJJL9VVfck+c4k/2XK9bBMDFfE3ZTko0nuzczv0tdOtSimpqrel+Qvk5xbVbuq6tIkb03ykqr668xcKffWadbIdCxybrwjybck+dDwO+n/mmqRTM0i58eKV672AwAAAGBcXPkEAAAAwNgInwAAAAAYG+ETAAAAAGMjfAIAAABgbIRPAAAAAIyN8AkAAACAsRE+AQAAADA2wicAgGWoqm6uqrdU1Z9V1aeq6gemXRMAwJEQPgEALE/PSbK3u78vyRuTvHbK9QAAHBHhEwDAMlNVT0lycpK3D0MnJNk7vYoAAI6c8AkAYPnZmOTO7n5yWH9ukvumWA8AwBETPgEALD/PSXL3nPXnJrlnSrUAAHxDhE8AAMvP/PDp2XHlEwBwjKrunnYNAAAAAKxQrnwCAAAAYGyETwAAAACMjfAJAAAAgLERPgEAAAAwNsInAAAAAMZG+AQAAADA2AifAAAAABgb4RMAAAAAY/P/AbL+lQbZ8iiqAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 1440x216 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bsn4rLOUfGB6"
      },
      "source": [
        "$\\color{red}{\\text{Please show your work up to this point to an instructor and get it marked}}$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bR96qAWEfGB6"
      },
      "source": [
        "# 2.0 Understanding linearity\n",
        "\n",
        "A linear system (continous time or discrete time), is a system a that possesses the important property of superposition. The superposition property encompasses the characteristics of additivity and homogeneity (scaling). This can be mathematically expressed as follows.\n",
        "\n",
        "Let $y_1[n]$ be the response of a discrete-time system to an input $x_1[n]$, and let $y_2[n]$ be the response corresponding to the input $x_2[n]$. Then, the system is linear if, \n",
        "\n",
        "* The response to $x_1[n] + x_2[n]$ is $y_1[n] + y_2[n]$ (additivity),\n",
        "* The response to $ax_1[n]$ is $ay_1[n]$, where $a$ is any complex constant (homogeneity)\n",
        "\n",
        "Additivity and homogeneity can be expressed together as follows. Let $x_1[n]$ and $x_2[n]$ be the inputs to a system $S$. We say that the system $S$ is linear, if \n",
        "\n",
        "$$S\\{ax_1[n] + bx_2[n]\\} = aS\\{x_1[n]\\} + bS\\{x_2[n]\\}$$\n",
        "\n",
        "where, $a$ and $b$ are complex constants.\n",
        "\n",
        "Let's determine whether the accumulator obeys the property of linearity.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "92olIOZSfGB6"
      },
      "source": [
        "## 2.1 A Simple Example of a Linear System: The Accumulator\n",
        "\n",
        "First, visualize the response of the accumulator to the inputs $x_1[n] = \\delta[n]$ and $x_2[n] = \\delta[n+2]$\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 490
        },
        "id": "H4QjZFaCfGB7",
        "outputId": "8b2e8554-d4e6-4934-faed-22fa1e4e36bc"
      },
      "source": [
        "# cell [5]\n",
        "\n",
        "t = np.arange(-5., 5.)\n",
        "x1 = delta(t)\n",
        "x2 = delta(t+2)\n",
        "\n",
        "y1 = accumulator(x1)\n",
        "y2 = accumulator(x2)\n",
        "\n",
        "fig, axes  = plt.subplots(2,2, sharex='all', sharey='all', figsize=(20,5))\n",
        "axes[0,0].stem(t,x1), axes[0,0].set_xlabel('$n$'), axes[0,0].set_ylabel('$x_1[n]$')\n",
        "axes[0,1].stem(t,y1), axes[0,1].set_xlabel('$n$'), axes[0,1].set_ylabel('$y_1[n]$')\n",
        "axes[1,0].stem(t,x2), axes[1,0].set_xlabel('$n$'), axes[1,0].set_ylabel('$x_2[n]$')\n",
        "axes[1,1].stem(t,y2), axes[1,1].set_xlabel('$n$'), axes[1,1].set_ylabel('$y_2[n]$')\n",
        "plt.show()"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:11: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  # This is added back by InteractiveShellApp.init_path()\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:12: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  if sys.path[0] == '':\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:13: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  del sys.path[0]\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:14: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  \n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jx8J4bIjfGB7"
      },
      "source": [
        "Now, in the following cell, plot the following signals :\n",
        "\n",
        "$$s_1[n] = a \\times acc\\{x_1[n]\\} + b \\times acc\\{x_2[n]\\}$$\n",
        "$$s_2[n] = acc\\{a x_1[n] + b x_2[n]\\}$$ \n",
        "\n",
        "Here, \"$acc\\{ . \\}$\" denotes the ```accumulator(x)```\n",
        "function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 422
        },
        "id": "JzfmwuzwfGB7",
        "outputId": "b25b70c2-3dca-42e0-be14-c14c142cf5a0"
      },
      "source": [
        "# cell [6]\n",
        "\n",
        "a = 2\n",
        "b = -1\n",
        "\n",
        "# EDIT HERE\n",
        "s1 = a*accumulator(x1)+b*accumulator(x2)\n",
        "s2 = accumulator(a*x1+b*x2)\n",
        "\n",
        "fig, axes  = plt.subplots(1,2, sharex='all', sharey='all', figsize=(20,5))\n",
        "axes[0].stem(t,s1), axes[0].set_xlabel('$n$'), axes[0].set_ylabel('$S\\{a*x_1 [n] + b*x_2 [n]\\}$')\n",
        "axes[1].stem(t,s2), axes[1].set_xlabel('$n$'), axes[1].set_ylabel('$a*y_1 [n] + b*y_2 [n]$')\n",
        "plt.show()"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:11: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  # This is added back by InteractiveShellApp.init_path()\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:12: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  if sys.path[0] == '':\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fm9BZ-RgfGB7"
      },
      "source": [
        "### Comment your observations below. Based on your observations, discuss the linearity of the accumulator system."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "spBNCkx9fGB7"
      },
      "source": [
        "<--type-in your answer here-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qrKZpCM0fGB8"
      },
      "source": [
        "## 2.2 A Simple Example of a Non-Linear System: The Squarer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DWNSa7y7fGB8"
      },
      "source": [
        "# cell [7]\n",
        "\n",
        "def square(x):\n",
        "    return np.multiply(x,x)\n",
        "\n",
        "x1 = np.ones(5)\n",
        "x2 = 2*np.ones(5)\n",
        "a = 2\n",
        "b = -1\n",
        "\n",
        "print(a*square(x1) + b*square(x2))\n",
        "print(square(a*x1 + b*x2))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xrhacIsWfGB8"
      },
      "source": [
        "### Discuss your observations about the output of the above cell."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ffuownKbfGB8"
      },
      "source": [
        "<--type-in your answer here-->"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BSkJeIgPLLIp",
        "outputId": "a2169e40-d077-4234-ee05-ec7369b5b2d9"
      },
      "source": [
        "# cell [7]\n",
        "\n",
        "def square(x):\n",
        "    #return 3*x+1\n",
        "    return np.multiply(x,np.multiply(x,x))\n",
        "\n",
        "x1 = np.ones(5)\n",
        "x2 = 2*np.ones(5)\n",
        "a = 2\n",
        "b = -1\n",
        "\n",
        "print(a*square(x1) + b*square(x2))\n",
        "print(square(a*x1 + b*x2))\n"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[-6. -6. -6. -6. -6.]\n",
            "[0. 0. 0. 0. 0.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EvJfWRZxfGB8"
      },
      "source": [
        "### Determine whether the following functions (systems) are linear :\n",
        "\n",
        "* $y = 3x + 1$\n",
        "* $y = x^3$\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZYKJRcZbfGB8"
      },
      "source": [
        "<--type-in your answer here-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y1HlLPn-fGB9"
      },
      "source": [
        "$\\color{red}{\\text{Please show your work up to this point to an instructor and get it marked}}$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m0QRxIZrfGB9"
      },
      "source": [
        "# 3.0 Understanding Time-Invariance\n",
        "\n",
        "We call that a system (continuous time or discrete time) is time-invariant if the behavior or the characteristics of the system are fixed over time. Specifically, a system is time-invariant if a time-shift in the input signal results in an identical time-shit in the output signal. This can be expressed using the following mathematical statement.\n",
        "\n",
        "Let $x[n]$ be an input to the system $S$. We say that the system, $S$ is time-invariant if the following condition is met :\n",
        "\n",
        "$$S\\{x[n]\\} = y[n] \\implies S\\{x[n-n_0]\\} = y[n-n_0]$$ \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xD5qZHMIfGB9"
      },
      "source": [
        "## 3.1 A Simple Example of a Time-Invariant System: The Accumulator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 694
        },
        "id": "RSx6AstXfGB-",
        "outputId": "46471c5a-78c0-453a-d9cb-3d4223ffda44"
      },
      "source": [
        "# cell [8]\n",
        "\n",
        "def function1(t):\n",
        "    if (t < 0.):\n",
        "        return 0.\n",
        "    elif (t < 5.):\n",
        "        return 1.\n",
        "    elif (t < 10.):\n",
        "        return 2. - 0.2*t\n",
        "    else:\n",
        "        return 0.\n",
        "\n",
        "t = np.arange(-5, 20, 1) \n",
        "fig, axes  = plt.subplots(2,2, sharey='all', figsize=(20,10))\n",
        "\n",
        "# x(t)\n",
        "x_t = [function1(t_) for t_ in t]\n",
        "axes[0,0].stem(t, x_t) \n",
        "axes[0,0].set_xlabel('$n$'), axes[0,0].set_ylabel('$x[n]$'), axes[0,0].grid(True)\n",
        "# y(t)\n",
        "y_t = accumulator(x_t)\n",
        "axes[0,1].stem(t, y_t) \n",
        "axes[0,1].set_xlabel('$n$'), axes[0,1].set_ylabel('$y[n]$'), axes[0,1].grid(True)\n",
        "\n",
        "# x(t - 5)\n",
        "x_t_1 = [function1(t_ - 5) for t_ in t]\n",
        "axes[1,0].stem(t, x_t_1)\n",
        "axes[1,0].set_xlabel('$n$'), axes[1,0].set_ylabel('$x[n-1]$'), axes[1,0].grid(True)\n",
        "\n",
        "# y(t - 1)\n",
        "y_t_1 = accumulator(x_t_1)\n",
        "axes[1,1].stem(t, y_t_1)\n",
        "axes[1,1].set_xlabel('$n$'), axes[1,1].set_ylabel('$y[n-1])$'), axes[1,1].grid(True)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:18: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:22: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:27: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:32: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x720 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "svG4qQtAfGB-"
      },
      "source": [
        "### Discuss your observations about the output of the cell above."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oG02hOemfGB-"
      },
      "source": [
        "<--type-in your answer here-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gw8cyHrsfGB-"
      },
      "source": [
        "## 3.2 Simple Example of a Time-Variant System: The Modulator\n",
        "\n",
        "Conisder the modulator system defined below. \n",
        "\n",
        "$$y[n] = \\sin(\\frac{\\pi}{5} n) x[n]$$\n",
        "\n",
        "Implement the modulator function in the cell below and observe the cell outputs.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 694
        },
        "id": "gnvPgliNfGB_",
        "outputId": "3bcd8a6d-a246-4d9a-dcba-5d30deb54db7"
      },
      "source": [
        "# cell [9]\n",
        "\n",
        "def modulator(x_t,t):\n",
        "    # t    : Vector with time values. Refer code below. \n",
        "    # x_t  : x(t) input. Same dimensions as t. \n",
        "    y=np.zeros(len(t))\n",
        "\n",
        "    # EDIT HERE\n",
        "    for i in range(len(t)):\n",
        "      y[i]=np.sin(np.pi*t[i]/5)*x_t[i]\n",
        "    return y\n",
        "\n",
        "t = np.arange(-5, 20, 1) \n",
        " \n",
        "fig, axes  = plt.subplots(2,2, sharey='all', figsize=(20,10))\n",
        "\n",
        "# x[n]\n",
        "x_t = [function1(t_) for t_ in t]\n",
        "axes[0,0].stem(t, x_t) \n",
        "axes[0,0].set_xlabel('$n$'), axes[0,0].set_ylabel('$x[n]$'), axes[0,0].grid(True)\n",
        "\n",
        "# y[n]\n",
        "y_t = modulator(x_t,t)\n",
        "axes[0,1].stem(t, y_t) \n",
        "axes[0,1].set_xlabel('$n$'), axes[0,1].set_ylabel('$y[n]$'), axes[0,1].grid(True)\n",
        "\n",
        "# x[n - 5]\n",
        "x_t_1 = [function1(t_ - 5) for t_ in t]\n",
        "axes[1,0].stem(t, x_t_1)\n",
        "axes[1,0].set_xlabel('$n$'), axes[1,0].set_ylabel('$x[n-1]$'), axes[1,0].grid(True)\n",
        "\n",
        "# y[n - 1]\n",
        "y_t_1 = modulator(x_t_1,t)\n",
        "axes[1,1].stem(t, y_t_1)\n",
        "axes[1,1].set_xlabel('$n$'), axes[1,1].set_ylabel('$y[n-1]$'), axes[1,1].grid(True)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:19: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:24: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:29: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:34: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x720 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iaaS1bwBfGB_"
      },
      "source": [
        "### Explain your observations about the output of the cell above."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MqjmfklCfGB_"
      },
      "source": [
        "<--type-in your answer here-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fleEky6sfGCA"
      },
      "source": [
        "### Determine whether the following functions (systems) are time-invariant.\n",
        "\n",
        "* $y(t) = \\frac{x(t)}{t+1}$\n",
        "* $y(t) = x(t)e^{-3t}$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kz21IVkgfGCA"
      },
      "source": [
        "<--type-in your answer here-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dIu_VUUBfGCA"
      },
      "source": [
        "$\\color{red}{\\text{Please show your work up to this point to an instructor and get it marked}}$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FysOEQSCfGCB"
      },
      "source": [
        "# 4.0 Understanding Convolution\n",
        "\n",
        "In this section we will be exploiting the properties of linearity and time-invariance to generate the system output using only the input signal and system impulse response. This process is referred to as convolution. \n",
        "\n",
        "Decompose $x[n]$ into a sum of individual components:\n",
        "\\begin{equation*}\n",
        "x[n] =  \\sum_{k=-\\infty}^\\infty x[k] \\delta[n-k] \n",
        "\\end{equation*}\n",
        "\n",
        "If $ h[n] $ is the system reponse to an impulse $ \\delta[n] $, then the system output to input $x[n]$ can be decomposed as follows:\n",
        "\\begin{equation*}\n",
        "y[n] =  \\sum_{k=-\\infty}^\\infty x[k] h[n-k] \\\\\n",
        "y[n] = x[n] * h[n]\n",
        "\\end{equation*}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6-UpzaPPfGCB"
      },
      "source": [
        "## 4.1 Visualizing Convolution of Two Rectangular Functions\n",
        "\n",
        "Consider the convolution of two rectangular functions. \n",
        "\n",
        "$$y(t) = rect(t)*rect(t)$$\n",
        "\n",
        "First, let's define two rectangular functions using the following cell."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        },
        "id": "M34i9NpdfGCB",
        "outputId": "81b05e9c-a33b-46cf-ac09-c931c58a5ae2"
      },
      "source": [
        "# cell [10]\n",
        "\n",
        "def rect(t,w):\n",
        "    x = np.zeros(len(t))\n",
        "    for i,n in enumerate(t):\n",
        "        if n >= 0 and n < w:\n",
        "            x[i] = 1.0\n",
        "    return x\n",
        "\n",
        "# Visualize rect function\n",
        "fig, axes  = plt.subplots(1,2, sharex='all', sharey='all', figsize=(20,3))\n",
        "t = np.arange(-5,7)\n",
        "x1 = rect(t,5)\n",
        "axes[0].stem(t,x1), axes[0].set_xlabel('$n$'), axes[0].set_ylabel('$rect[n]$')\n",
        "\n",
        "# shift the rect left by 2\n",
        "x2 = rect(t+2,5)\n",
        "axes[1].stem(t,x2), axes[1].set_xlabel('$n$'), axes[1].set_ylabel('$rect[n+2]$')\n",
        "plt.show()"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:14: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  \n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:18: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x216 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bMQ5UANifGCB"
      },
      "source": [
        "Using the ```conv_sum(x1, t1, x2, t2)``` function, obtain the convolution of the above two functions and plot it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 366
        },
        "id": "8OflHRD2fGCB",
        "outputId": "111b6ccd-e7ee-43b5-9964-c6cc4a1ca3a7"
      },
      "source": [
        "# cell [11]\n",
        "\n",
        "def conv_sum(x1,t1,x2,t2):\n",
        "    ty = np.arange(0,len(x1)+len(x2)-1) + t1[0]+t2[0]\n",
        "    y = np.convolve(x1, x2)\n",
        "    return y,ty\n",
        "\n",
        "print(y)\n",
        "# EDIT HERE\n",
        "y,ty=conv_sum(x1,t,x2,t-2)\n",
        "plt.stem(ty,y)\n",
        "plt.grid()\n",
        "plt.xlabel(\"ty\")\n",
        "plt.ylabel(\"y\")\n",
        "plt.title(\"Convalution\")\n",
        "plt.show()\n"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:11: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
            "  # This is added back by InteractiveShellApp.init_path()\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kFk58rsjfGCB"
      },
      "source": [
        "## 4.2 Visualizing Convolution Step by Step\n",
        "\n",
        "Convolution requires the kernel function $h[k]$ to be reflected about the y-axis ($h[−k]$) and then shifted along the x-axis.\n",
        "\n",
        "($h[n − k]$) Observe the code in cell below and comment on the functions of ```ref(t,x)``` and ```array_shift(t1,t2,x,s)```.\n",
        "\n",
        "$$y(t) = rect(t)*rect(t)$$\n",
        "\n",
        "Edit the following cell as explained in the comments and run. Press ‘Enter’ for the next step."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 461
        },
        "id": "d4wN27I1fGCB",
        "outputId": "ab9a3468-4cf9-452c-ee43-a0cfdc67e0a5"
      },
      "source": [
        "# cell [12]\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from IPython import display\n",
        "\n",
        "def rect(t,w):\n",
        "    # Returns of square of width 'w' starting from t=0 for time array 't'. \n",
        "    \n",
        "    x = np.zeros(len(t))\n",
        "    for i,n in enumerate(t):\n",
        "        if n >= 0 and n < w:\n",
        "            x[i] = 1.0\n",
        "    return x\n",
        "\n",
        "def ref(t,x):\n",
        "    # Reflects x about the y axis. \n",
        "    \n",
        "    y = np.zeros(len(t))\n",
        "    for i,n in enumerate(t):\n",
        "        try:\n",
        "            ind = int(np.where(t==-n)[0])\n",
        "            y[i] = x[ind]\n",
        "        except:\n",
        "            pass\n",
        "    return y\n",
        "\n",
        "def plot_arr(t1,t2,x):\n",
        "    # Helper function needed for comparative plotting.\n",
        "    # x is the function with time vector t1.\n",
        "    # Returns y, which is x with time vector t2. \n",
        "    \n",
        "    y = np.zeros(len(t2))\n",
        "    for i,n in enumerate(t2):\n",
        "        try:\n",
        "            ind = int(np.where(t1==n)[0])\n",
        "            y[i] = x[ind]\n",
        "        except:\n",
        "            pass\n",
        "    return y\n",
        "\n",
        "\n",
        "def array_shift(t1,t2,x,s):\n",
        "    # Shifts the function by step 's' in the time axis.\n",
        "    # Adjusts time vector from t1 to t2. \n",
        "    \n",
        "    y = np.zeros(len(t2))\n",
        "    for i,n in enumerate(t2):\n",
        "        ind2 = n - s\n",
        "        try:\n",
        "            ind1 = int(np.where(t1==ind2)[0])\n",
        "            y[i] = x[ind1]\n",
        "        except:\n",
        "            pass\n",
        "    return y\n",
        "\n",
        "# Input functions and their time arrays. \n",
        "t1 = np.arange(-5,7)\n",
        "x1 = rect(t1,5)\n",
        "t2 = np.arange(-5,7)\n",
        "x2 = rect(t2+2,5)\n",
        "\n",
        "# Define output time array for visualization\n",
        "ty = np.arange(0,len(x1)+len(x2)-1) + t1[0]+t2[0]\n",
        "\n",
        "#  EDIT HERE\n",
        "# Obtain x1[k] by adjusting the time vector of x1 to ty. Hint: 'plot_arr' function. \n",
        "x1_k = plot_arr(t1,ty,x1)\n",
        "# Obtain x2[-k] by reflecting x2 about the y axis. Hint: 'ref' function. \n",
        "x2_ref = ref(t1,x2)\n",
        "\n",
        "y = np.zeros(len(ty))\n",
        "\n",
        "for i in range(len(ty)):\n",
        "    # Calculate x2[n-k] by shifting x2_ref along x-axis. \n",
        "    x2_ref_shift = array_shift(t2,ty,x2_ref,ty[i])\n",
        "    \n",
        "    # Calculate the dot product of x1[k] and x2[n-k]. Change the d variable here\n",
        "    d = np.dot(x2_ref_shift,x1_k)\n",
        "    y[i] = d\n",
        "    \n",
        "    fig, axes  = plt.subplots(3,1, sharex='all', sharey='all', figsize=(13,7))\n",
        "    axes[0].stem(ty,x1_k), axes[0].set_xlabel('$t$'), axes[0].set_ylabel('$x1$')\n",
        "    axes[1].stem(ty,x2_ref_shift), axes[1].set_xlabel('$t$'), axes[1].set_ylabel('$x2\\_ref\\_shift$')\n",
        "    axes[2].stem(ty,y), axes[2].set_xlabel('$t$'), axes[2].set_ylabel('$x1 * x2$')\n",
        "\n",
        "    display.display(plt.gcf())\n",
        "    display.clear_output(wait=True)\n",
        "    plt.show()\n",
        "    \n",
        "    input(\"Press Enter to continue...\")\n",
        "    "
      ],
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 936x504 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Press Enter to continue...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7vmoM5fafGCC"
      },
      "source": [
        "$\\color{red}{\\text{Please show your work up to this point to an instructor and get it marked}}$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "evgv3mkMfGCC"
      },
      "source": [
        "\n",
        "# 5.0 Signal processing in the Frequency Domain\n",
        " \n",
        "Discrete time Fourier Transform of  $x[n]$ can be obtained as follows:\n",
        "\\begin{equation*}\n",
        "X[\\Omega] = \\sum_{n=-\\infty}^\\infty x[n] e^{-j \\Omega n}\n",
        "\\end{equation*}\n",
        "\n",
        "Convolution in the time domain is equivalant to multiplication in the frequency domain:\n",
        "\\begin{equation*}\n",
        "x[n] * h[n] = \\mathcal{F}^{-1}\\{ X[\\Omega] \\times H[\\Omega] \\}\n",
        "\\end{equation*}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kZzuZhArfGCC"
      },
      "source": [
        "## 5.1 Observing two signals in the Frequency Domain\n",
        "\n",
        "Obtain the following signals and visualize them in the frequency domain by running the cell below.\n",
        "\n",
        "* $x_1[n] = \\cos(\\omega n) + \\cos(3\\omega n)$\n",
        "* $x_2[n] = 0.5 + \\cos(3\\omega n)$\n",
        "\n",
        "$$x_1[n] \\to X_1(\\Omega)$$\n",
        "$$x_2[n] \\to X_2(\\Omega)$$\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ilkaOCvIfGCC"
      },
      "source": [
        "# cell [13]\n",
        "\n",
        "%matplotlib inline\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "n = np.arange(-100., 100., 1) \n",
        "f = 1/100 # 0.01 Hz\n",
        "omega = 2*np.pi*f\n",
        "\n",
        "# EDIT HERE\n",
        "x1_n = 0\n",
        "x2_n = 0\n",
        "\n",
        "# Obtain frequency domain representations of x1[n] and x2[n]\n",
        "X1_f = np.fft.fft(x1_n)\n",
        "X2_f = np.fft.fft(x2_n)\n",
        "\n",
        "# Visualize\n",
        "freq = np.fft.fftfreq(n.shape[-1], d=1)\n",
        "valsubrange = np.concatenate((np.arange(0,9,1), np.arange(-1,-9,-1)))\n",
        "freqsubrage = np.concatenate((np.arange(0,9,1), np.arange(-1,-9,-1)))\n",
        "fig, axes  = plt.subplots(2,2, sharey='all', figsize=(20,10))\n",
        "\n",
        "# x1[n]\n",
        "axes[0,0].plot(n,x1_n) \n",
        "axes[0,0].set_xlabel('$t$'), axes[0,0].set_ylabel('$x1(t)$'), axes[0,0].grid(True)\n",
        "\n",
        "# X1(jw)\n",
        "axes[0,1].stem(freq[freqsubrage], X1_f.real[valsubrange]/len(n))\n",
        "axes[0,1].set_xlabel('$f$ (Hz)'), axes[0,1].set_ylabel('$\\mathfrak{Re}(X1(j\\omega))$'), axes[0,1].grid(True)\n",
        "\n",
        "# x2[n]\n",
        "axes[1,0].plot(n,x2_n)\n",
        "axes[1,0].set_xlabel('$t$'), axes[1,0].set_ylabel('$x2(t)$'), axes[1,0].grid(True)\n",
        "\n",
        "# X2(jw)\n",
        "axes[1,1].stem(freq[freqsubrage], X2_f.real[valsubrange]/len(n))\n",
        "axes[1,1].set_xlabel('$f$ (Hz)'), axes[1,1].set_ylabel('$\\mathfrak{Re}(X2(j\\omega))$'), axes[1,1].grid(True)\n",
        "\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_7Z0dSsEfGCC"
      },
      "source": [
        "## 5.2 Covolution of above Signals by Multiplication in the Frequency Domain\n",
        "\n",
        "Edit the following cell to multiply the two signals in frequency domain.\n",
        "\n",
        "$$x_1[n] * x_2[n] \\to X_1(\\Omega) \\times X_2(\\Omega)$$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZZfAcgqafGCC"
      },
      "source": [
        "# cell [14]\n",
        "\n",
        "# Multiply the frequency domain representations of x1[n] and x2[n]\n",
        "# EDIT HERE\n",
        "X1_X2_f = <-->\n",
        "\n",
        "# Take inverse fft to visualize in time domain\n",
        "z = np.fft.ifft(X1_X2_f).real\n",
        "fig2, axes2  = plt.subplots(1,2, sharey='all', figsize=(20,5))\n",
        "axes2[0].plot(n, z, label='$z[n]$')\n",
        "\n",
        "z_f = np.fft.fft(z)\n",
        "axes2[1].stem(freq[freqsubrage], z_f.real[valsubrange]/len(n))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3m7TG_YpfGCC"
      },
      "source": [
        "Explain the observations you made in the above cell output."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LEsmxyFIfGCD"
      },
      "source": [
        "<--type-in your answer here-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y5__jOFPfGCD"
      },
      "source": [
        "$\\color{red}{\\text{Please show your work up to this point to an instructor and get it marked}}$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GBdps0qdfGCD"
      },
      "source": [
        "\n",
        "# 6.0 A Real-world Application (Equalizer)\n",
        "\n",
        "Equalizing in audio engineering refers to manipulating the frequency components of an audio to get a desirable output. Specifically, equalizing is used to boost or suppress the energy (amplitude) of different frequency components, which may correspond to a specific sound source.\n",
        "\n",
        "Equalizers are the devices that enable this equalization process. The controllers on the device enable adjustment of gain (boost) given to each frequency band that is present in the audio.\n",
        "\n",
        "In this section we will look into a simple non-real-time implementation of an equalizer, using a filter bank. The filter bank consists of 10 filters, which separates out the audio input signal into 10 equal-width frequency bands. By adjusting the gain applied for each filter, we are able to control the boost given to the aforementioned frequency bands in the audio signal\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cb31o7YafGCD"
      },
      "source": [
        "Run cell [[15]] to load the “africa-toto.wav” file and create a ```PyAudio``` stream. ```PyAudio``` is used to play the loaded wav file. This cell also defines some variables such as ```n_channels```, ```fs``` and chunk that will be used in the following cells. Note that ```fs``` is the sample rate of the audio."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "isyi_N8NfGCD"
      },
      "source": [
        "# cell [15]\n",
        "\n",
        "import numpy as np\n",
        "import pyaudio\n",
        "import wave\n",
        "from scipy.fftpack import fft, fftshift, ifft\n",
        "from scipy import signal\n",
        "import scipy.io.wavfile as sw\n",
        "import matplotlib.pyplot as plt\n",
        "import struct\n",
        "\n",
        "# set up to read an audio file\n",
        "\n",
        "# open wav file\n",
        "wf = wave.open(\"./africa-toto.wav\", 'rb')\n",
        "# wf = wave.open(\"./africa-toto.wav\", 'rb')\n",
        "# wf = wave.open(\"./symphony-orchestra-tuning.wav\", 'rb')\n",
        "\n",
        "channels=wf.getnchannels()\n",
        "dtype = '<i2' # little-endian two-byte (int16) signed integers \n",
        "\n",
        "n_channels=wf.getnchannels() # no. of chennels in the audio\n",
        "fs = wf.getframerate() # frame rate of audio \n",
        "chunk = fs # no. of audio frames played at a time\n",
        "\n",
        "# instantiate PyAudio (for playing the sound track)\n",
        "p = pyaudio.PyAudio()\n",
        "\n",
        "# open stream (for playing the sound track)\n",
        "stream = p.open(format=p.get_format_from_width(wf.getsampwidth()),\n",
        "                channels=n_channels,\n",
        "                rate=fs,\n",
        "                output=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xSM1c0a_fGCD"
      },
      "source": [
        "Cell [[16]] plays the audio and collects the audio samples as numerical values to the numpy array ```x```. Variables ```start``` and ```dur``` describe the audio segment that we use in our experiment from the original wav file."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n2WQNAx-fGCD"
      },
      "source": [
        "# cell [16]\n",
        "\n",
        "# reading the audio file\n",
        "\n",
        "start = 200 # audio starting time frame (s)\n",
        "dur = 10 # duration selected (s)\n",
        "\n",
        "wf.rewind() # reset readframe positin to the begining of the file\n",
        "wf.setpos(wf.tell()+start*fs) # seek to the needed starting position\n",
        "\n",
        "x = np.array([]) # initialize audio signal array\n",
        "for i in range(0, dur):\n",
        "    data = wf.readframes(chunk) # read an audio frame chunk\n",
        "    if data == '': # if the audio samples ended\n",
        "        break\n",
        "    sig_chunk = np.asarray(np.frombuffer(data, dtype=dtype)) # convert the frame chunk into a numpy array\n",
        "    x = np.concatenate((x, sig_chunk)) # add the signal chunk to the signal array\n",
        "    stream.write(data) # play the audio chunk"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v7Mdj64_fGCD"
      },
      "source": [
        "Cell [[17]] generates a time domain visualization of the audio segment played. Examine the variables defined in the cell and identify their significance."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MVhOvMw7fGCE"
      },
      "source": [
        "# cell [17]\n",
        "\n",
        "# ploting original audio in time domain\n",
        "\n",
        "N = len(x) # number of audio samples (frames)\n",
        "T = 1/fs # time interval between frames\n",
        "t = np.linspace(0.0, N*T, N) # time axis for audio\n",
        "\n",
        "# plot original audio in time doamin\n",
        "fig, ax = plt.subplots(1, 1, figsize=(18,9))\n",
        "ax.grid(True)\n",
        "ax.plot(t, x, 'y')\n",
        "ax.xlabel('t (s)')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "52EYMyfqfGCE"
      },
      "source": [
        "Cell [[18]] generates a frequency domain visualization of the audio segment played. Examine the variables defined in the cell and identify their significance. Observe the frequency distribution for the audio sample played."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "08twOvhMfGCE"
      },
      "source": [
        "# cell [18]\n",
        "\n",
        "# ploting original audio in frequency domain \n",
        "\n",
        "f = np.linspace(-fs/2, fs/2+1, N) # frequency axis for audio\n",
        "xf = np.fft.fft(x) # fft command converts x into the fourier domain (X)\n",
        "\n",
        "n_filters = 10 # no. of filters (to be ued in the filter bank in the equalizer)\n",
        "fc_list = np.linspace(0, fs/2+1, n_filters+1) # cutoff frequencies for the filters in filter bank\n",
        "\n",
        "fig, ax = plt.subplots(1, 1, figsize=(18,9))\n",
        "ax.grid(True)\n",
        "ax.plot(f[N//2:], 2.0/N * np.abs(xf[0:N//2]))\n",
        "yy = np.arange(0, ax.get_ylim()[1])\n",
        "xx = np.ones(yy.shape)\n",
        "for fc in fc_list:\n",
        "    ax.plot(fc*xx, yy, 'k--')\n",
        "ax.xlabel('f (Hz)')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Agw6pwOYfGCE"
      },
      "source": [
        "In cell [[19]], complete the function ```ideal_filter(f, fc1, fc2)``` that returns the gain for given frequency input ```f```, in a filter defined by the cut-off frequencies ```fc1```, ```fc2```. Assume these cut-off frequencies are the two limits of a passband.\n",
        "\n",
        "$$\n",
        "H(f) = \n",
        "\\begin{cases}\n",
        "    1, & \\text{if } f_{c1} < |f| < f_{c2} \\\\\n",
        "    0,              & \\text{otherwise}\n",
        "\\end{cases}\n",
        "$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LFzH7KzNfGCE"
      },
      "source": [
        "In cell [[19]] , complete the function ```equalizer(H, gains, sig)``` to create the equalizer. The equalizer takes in the filter bank ```filter_bank```, the corresponding gains gains and the audio signal to be equalized ```sig``` as inputs. Attribute each gain to the corresponding filter and then filter the input signal using the modified filters. Then obtain the desired equalized signals by combining the outputs of each filter in the modified filter bank. **Do not** use loops to complete the function.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t_7jhBi8fGCE"
      },
      "source": [
        "# cell [19]\n",
        "\n",
        "# ideal filter\n",
        "\n",
        "def ideal_filter(f, fc1, fc2):    \n",
        "    gain = 0\n",
        "    #  EDIT HERE\n",
        "    return gain\n",
        "\n",
        "# equalizer\n",
        "def equalizer(filter_bank, gains, sig):\n",
        "    \n",
        "    filter_bank = np.array(filter_bank)\n",
        "    gains = np.array(gains)\n",
        "    # EDIT HERE\n",
        "            \n",
        "    return equilized_sig "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9n-SZTF2fGCE"
      },
      "source": [
        "Cell [20] creates the filter bank consisting 10 filters, which are defined by the cut off frequencies in ```fc_list``` (refer to cell [8])."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mEQoedTAfGCF"
      },
      "source": [
        "# cell [20]\n",
        "\n",
        "# filter bank\n",
        "\n",
        "filter_bank = []\n",
        "for i in range(n_filters):\n",
        "    H_i = [ideal_filter(f_, fc_list[i], fc_list[i+1]) for f_ in f] # filter with ith & (i+1)th cut off frequencies\n",
        "    filter_bank.append(H_i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0R3qmZhvfGCF"
      },
      "source": [
        "Cell [21] creates the list of gains ```gains``` that are to be attributed to each filter in the filter bank. Change the values in this list to change the gains provided to each frequency band in the audio sample."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FV0Sp9E-fGCF"
      },
      "source": [
        "# cell [21]\n",
        "\n",
        "# equalizer gains\n",
        "gains = [0.5, 0, 0, 0, 5, 0, 0, 0, 1, 1] # CHANGE HERE\n",
        "gains = np.array(gains).reshape([len(gains), 1])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I5Y_cYrHfGCF"
      },
      "source": [
        "Run cell [22] to equalize the audio sample with the assigned gains. Then run cell [23] to visualize the equalized audio sample in the frequency domain."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VzfHSTIJfGCF"
      },
      "source": [
        "# cell [22]\n",
        "\n",
        "# equalize audio\n",
        "\n",
        "equilized_sig = equalizer(filter_bank, gains, np.fft.fftshift(xf))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "DD3OuFcJfGCG"
      },
      "source": [
        "# cell [23]\n",
        "\n",
        "# visualize equalized signal in frequancy domain\n",
        "\n",
        "fig, ax = plt.subplots(1, 1, figsize=(18,9))\n",
        "ax.grid(True)\n",
        "ax.plot(f[N//2:], 2.0/N *np.abs(np.fft.fftshift(equilized_sig)[0:N//2]))\n",
        "yy = np.arange(0, ax.get_ylim()[1])\n",
        "xx = np.ones(yy.shape)\n",
        "for fc in fc_list:\n",
        "    ax.plot(fc*xx, yy, 'k--')\n",
        "ax.xlabel('f (Hz)')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fWGZwybAfGCG"
      },
      "source": [
        "Run cell [24] to play the equalized audio sample."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pd1gF91TfGCG"
      },
      "source": [
        "# cell [24]\n",
        "\n",
        "# play equalized audio\n",
        "\n",
        "equi_audio = np.fft.ifft(np.fft.fftshift(equilized_sig)) # convert to time domain\n",
        "z_int16 = equi_audio.astype(np.int16)   \n",
        "z_byte  = z_int16.tobytes()\n",
        "stream.write(z_byte)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bvylXi-ifGCG"
      },
      "source": [
        "Change the gain attributed to each band by modifying ```gains``` array in cell [21] and\n",
        "observe the changes in the audio."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LQvOQ1amfGCG"
      },
      "source": [
        "# References\n",
        "\n",
        "[[1]] Oppenheim, A. V., Willsky, A. S., & Young, I. T. (1983). Signals and systems. Englewood Cliffs, N.J: Prentice-Hall."
      ]
    }
  ]
}