1_1_Introduction_to_Labs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 1.1: Introduction to Labs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%matplotlib widget\n",
    "import rad.css as css\n",
    "import rad.example as ex\n",
    "import rad.quiz as qz\n",
    "from rad.const import c, k\n",
    "from rad.radar import to_db, from_db, deg2rad, rad2deg\n",
    "from math import sqrt, sin, asin, cos, acos, tan, atan2, pi, log, log10\n",
    "css.add_custom_css()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome class! To begin, there will be a short overview of the interactive tools that we will use throughout the course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The backbones of our tutorials are called **Jupyter notebooks**<sup>[[1]](#ref_jupyter)</sup>. A Jupyter notebook is a convenient way to weave together text, images, math formulae, and working, editable code. Behind the scenes of the notebook is a programming language of choice: MATLAB, Python, Julia, Java, C++, etc. For this course, we will use Python<sup>[[2]](#ref_python)</sup> as it is openly available. Do *<font color=\"BlueViolet\">not</font>* worry if you have little or no experience with Python: the course will require very little coding, and we will cover what is needed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appearance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before doing anything, we should start by making the notebooks easy to read. \n",
    "\n",
    "### Font Size\n",
    "First, we can change the font size: to increase the font size, go to *<font color=\"DarkBlue\">Settings > JupyterLab Theme > Increase Content Font Size</font>*. This can be done repeatedly until the text is comfortable to read.\n",
    "\n",
    "<div style=\"text-align: center\"> <img src=\"img/incr_font.png\" width=\"475px\" justify=\"center\"></img></div>\n",
    "\n",
    "### Hidden Code\n",
    "To make the notebooks easier to read, most background code needed for examples and quizzes has been hidden by default; anytime you see a large ellipsis <img src=\"img/hide_code_icon.png\"></img>, there is code being suppressed (e.g., one of them is right below the title at the top of this notebook). To see what is going on in the background, we can click on the ellipsis to reveal it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first thing we will want to do upon opening a new notebook is click the *<font color=\"DarkBlue\">Run All</font>* button <img width=\"18px\" src=\"img/run_all_icon.png\"> at the top; it will ask if it is okay to restart, we can select *<font color=\"DarkBlue\">Restart</font>*. This ensures that all examples and interactive code will be loaded and ready. Go ahead and do it for this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebooks and Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each notebook is made up of a list of **cells**; each cell can be either text or code. The cell you are reading right now is an example of a **text cell** (also called a *Markdown* cell; Markdown<sup>[[3]](#ref_markdown)</sup> is a quick way to format text). Below this, we will see our first example of a **code cell**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "print(\"The value of x is \" + str(x) + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code cell above sets the value of a variable ``x`` to one and then prints its value. To run the code, first single-click on the cell to highlight it. Then, to **evaluate** the cell, you can either: \n",
    "\n",
    "  * Click the *<font color=\"DarkBlue\">Run Cell</font>* <img width=\"12px\" src=\"img/run_cell_icon.png\"></img> button on the top bar of the notebook\n",
    "  \n",
    "  * Press *Shift+Enter* "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After evaluating the cell, you can see the output printed below it. Also, in brackets to the left of the cell, you can see the evaluation number; if you evaluate the cell again, you can see the number go up. The evaluation numbers help you keep track of what you have run and in what order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: center\"> <img src=\"img/eval_no.png\" width=\"275px\" justify=\"center\"></img></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To **edit** any cell, you can double-click on it; this means you can edit any code you want and rerun it to see what changed. As an example, you can double-click the code cell above and change the value of ``x`` to any number you want and then re-evaluate.\n",
    "\n",
    "<div style=\"text-align: center\"> <img src=\"img/edit_cell.gif\" width=\"600px\" justify=\"center\"></img></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To **add** a cell, single-click on an existing cell and then click the *<font color=\"DarkBlue\">Add Cell Below</font>* <img width=\"11px\" src=\"img/add_cell.png\"></img> button. A new cell will be created below the one you selected. To change the type of cell (i.e., code, text), select the cell by single-clicking and then use the dropdown menu at the top."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: center\"> <img src=\"img/add_cell.gif\" width=\"600px\" justify=\"center\"></img></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** You can also edit and evaluate text cells. Evaluating a text cell turns it from raw text into a properly formatted web snippet. This can be a helpful way to add notes to your personal version of a notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interactive Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The primary tools for interaction in Jupyter notebooks are interactive plots with controls called *widgets*. To see how widgets work, we can first look at plotting a simple sine wave. There will be three variables to change: *<font color=\"DarkBlue\">Amplitude</font>*, *<font color=\"DarkBlue\">Frequency</font>*, and *<font color=\"DarkBlue\">Initial Phase</font>* (we will discuss these more later). Try moving the sliders for each variable to see the plot adjust."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "ex.ex_1_1_1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two useful features in the interactive plots: *zooming* and *live cursor data*. To zoom in on a particular part of the plot, you can use the *<font color=\"DarkBlue\">Zoom Box</font>* <img src=\"img/zoom_box.png\"></img> button. Try clicking it and drawing a box around a part of the plot. To drag the plot around, you can use the *<font color=\"DarkBlue\">Pan</font>* <img src=\"img/pan.png\"></img> button. To return to the original plot view at any time, you can click the *<font color=\"DarkBlue\">Reset View</font>* <img src=\"img/reset_view.png\"></img> button. The current location of the cursor inside the plot is continuously displayed below the plot; this is very helpful for finding values and locations of points on a curve or image."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quizzes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There will also be a number of quizzes to challenge you as the course progresses. These will most often be in the form of a blank text box and a submit button. For example, below see an example quiz that asks you to enter an answer of one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enter a value of one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Unless otherwise stated, the tolerance for quiz answers will be within ±1% of the true answer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For some of the quizzes, it will be helpful to have a calculator handy. If one is not available, no problem! We can use the Jupyter notebook for calculations. In most spots where calculations are necessary, a *Scratch Space* code cell is provided that can be used. As discussed above, we can also simply add a code cell anywhere using the *<font color=\"DarkBlue\">Add Cell Below</font>* <img width=\"11px\" src=\"img/add_cell.png\"></img> button. \n",
    "\n",
    "Most mathematical operations are as you would expect. For instance, to calculate the value of $2\\sin(5 \\pi /2) + 1$, we would use the following code cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2*sin(5*pi/2) + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a short list of the mathematical operators:\n",
    "\n",
    "| Operation           | Symbol |\n",
    "|---------------------|--------|\n",
    "| Addition            | `+`    |\n",
    "| Subtraction         | `-`    |\n",
    "| Multiplication      | `*`    |\n",
    "| Division            | `/`    |\n",
    "| Exponent            | `**`   |\n",
    "| Square root         | `sqrt` |\n",
    "| Logarithm           | `log`  |\n",
    "| Logarithm (Base 10) | `log10`|\n",
    "\n",
    "Here is a list of trigonometric functions:\n",
    "\n",
    "| Function       | Symbol    |\n",
    "|----------------|-----------|\n",
    "| Sine           | `sin`     |\n",
    "| Arcsine        | `asin`    |\n",
    "| Cosine         | `cos`     |\n",
    "| Arccosine      | `acos`    |\n",
    "| Tangent        | `tan`     |\n",
    "| Arctangent     | `atan2`   |\n",
    "\n",
    "Here are some handy constants:\n",
    "\n",
    "| Constant       | Symbol |\n",
    "|----------------|--------|\n",
    "| $\\pi$          | `pi`   |\n",
    "| Speed of light | `c`   |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** All of these functions (along with useful definitions and formulae) are kept in the [Reference](Reference.ipynb) notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(a)** Using the operators and functions above, evaluate the following expression: $$3\\times7.1 - 5.2$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_2a()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(b)** Calculate the value of $\\log_{10}\\left(2.72^3\\right) + \\cos(4\\pi/7)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_2b()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Engineering Notation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For very large or small numbers, it can be convenient to write them in the form $a \\times 10^b$, such as $0.000005 = 5 \\times 10^{-6}$. These can be represented in notebook calculations using *engineering notation*. All this means is instead of writing $a \\times 10^b$, you type `aEb`. For instance, if you wanted to use $5 \\times 10^{-6}$, you type `5E-6`.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate the value of: \n",
    "$$\\frac{7.76 \\times 10^{4}}{5.1 \\times 10^{-3}}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_3()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** One of the easiest ways to satisfy the ±1% tolerance for quiz answers is to write answers in engineering notation with at least two decimal places defined."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables and Formulae"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we progress through the course, we will encounter several useful formulae that will be need to be evaluated. For instance, we may have the formula $y = 3x - 10$ and evaluate it when $x = 1.1$. To do this, we can first create the `x` variable and set it to `1.1` with the following code: `x = 1.1`. We can then evaluate the formula by calling `y = 3*x - 10`. The following code cell does this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1.1\n",
    "y = 3*x - 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we run this code cell, we notice that it does not output an answer (this is because the value gets stored away in `y`). To get the answer, we can use the `print()` function and call `print(y)`. The following code cell does this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1.1\n",
    "y = 3*x - 10\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(a)** Evaluate the formula $y = 15.2/x + 1.2$ where $x = -10$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_4a()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(b)** Evaluate the formula $y = \\cos(5x + a)$ where $x = \\pi/2$ and $a = -0.1$. **Hint:** All variables must be defined before evaluating the formula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_4b()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few preliminary topics to cover before we get to the radar course itself. In the following, we will review the basics of: \n",
    "\n",
    "- *Decibels*, a useful unit for simplifying radar analysis\n",
    "- *Sine waves*, the main structure of radar transmissions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Review: Decibels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many quantities dealing with radar systems can be extremely large or small. For instance, it is common to use megawatts of power for transmission ($10^6~\\mathrm{W}$), and receive signals on the order of picowatts ($10^{-12}~\\mathrm{W}$). Instead of dealing with that immense scale of numbers, the quantities are often converted to **decibels** (dB); this makes the values much easier to remember and/or manipulate without pen and paper. Here is a short list of example numbers and their corresponding decibel value:\n",
    "\n",
    "<div style=\"text-align: center\"> <img src=\"img/db.png\" width=\"300px\" justify=\"center\"></img></div>\n",
    "\n",
    "To convert a number, $x$, to the value in decibels, $x_d$, we use the following formula:\n",
    "$$ x_d = 10\\log_{10}(x) $$\n",
    "In code for calculations, the conversion to decibels looks like `x_d = 10*log10(x)`. Going back to the example values for radar, instead of using $10^6~\\mathrm{W}$, we can write $60~\\mathrm{dBW}$; likewise, we can talk about receiving signals with a power of $-120~\\mathrm{dBW}$ instead of dealing with $10^{-12}~\\mathrm{W}$.\n",
    "\n",
    "**Note:** For this course, the original unit will be written at the end of $\\mathrm{dB}$ to keep track of it; for instance, $\\mathrm{dBW}$ means it is in decibels and the original unit was watts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(a)** What is $1.5 \\times 10^5$ in decibels?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_5a()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(b)** What is $7.2 \\times 10^{-7}$ in decibels?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_5b()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To convert from the value in decibels, $x_d$, back to the original value, $x$, we use:\n",
    "\n",
    "$$\n",
    "\\displaystyle x = 10^{x_d/10}\n",
    "$$\n",
    "\n",
    "In other words: you first divide the number in decibels by ten, then take ten to that power. In code, this would be written as `x = 10**(x_d/10)`. You can verify this from the examples above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(a)** What is $51.2~\\mathrm{dBW}$ in watts (W)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_6a()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(b)** What is $-20.1~\\mathrm{dBW}$ in watts (W)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_6b()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To save time in calculations, we have added two functions that you can use in your notebook calculations: \n",
    "\n",
    "- `to_db()`, convert from original units to decibels\n",
    "- `from_db()`, convert from decibels to original units\n",
    "\n",
    "For instance, to convert $567.2~\\mathrm{W}$ to $\\mathrm{dBW}$, we can write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "to_db(567.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which gives us $27.5374~\\mathrm{dBW}$. Now to convert back, we write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from_db(27.5374)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A helpful property of decibels is *<font color=\"BlueViolet\">turning multiplication into addition</font>*. This is convenient as it can be cumbersome to multiply very large or small numbers together quickly where adding their equivalent values in decibels. In general, \n",
    "$$\n",
    "\\begin{align}\n",
    "z &= xy\\\\\n",
    "z_{d} &= x_{d} + y_{d}\\\\\n",
    "\\end{align}\n",
    "$$\n",
    "and\n",
    "$$\n",
    "\\begin{align}\n",
    "z &= x/y\\\\\n",
    "z_{d} &= x_{d} - y_{d}\\\\\n",
    "\\end{align}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means we can turn the following multiplication: $z = (4.4 \\times 10^{3})(2.8 \\times 10^{-4})$ into its decibel equivalent: $z_d = 36.4345 + (-35.5284)$, which is much easier to estimate quickly, i.e., it is going to be roughly $1~\\mathrm{dB}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last property of decibels we will cover is *<font color=\"BlueViolet\">converting exponents into scalars</font>*. Because the decibel is calculated using a logarithm, the following is true:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "x &= a^b\\\\\n",
    "x_{d} &= b \\cdot a_d\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "So, if we want the a quantity $a^b$ in decibels, we simply find $a$ in decibels (i.e., $a_d$) and then multiply it by $b$. For example, the value $43^5$ in decibels can be calculated as $5 \\cdot 10\\log_{10}(43)$, or using code `5*to_db(43)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is $3.7^5$ in decibels? (Hint: $3.7$ in decibels is $5.682~\\mathrm{dB}$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_7()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Review: Sine Waves"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sine waves form the main backbone for ranging sensor transmissions because they are easy to generate with hardware and are well understood. A sine wave as a function of time, $y(t)$, is described mathematically as\n",
    "\n",
    "$$\n",
    "y(t) = a\\sin(2\\pi f t + \\phi)\n",
    "$$\n",
    "\n",
    "where\n",
    "- $a$ is the **amplitude**, which decides the size of the wave\n",
    "- $f$ is the **frequency** of the wave (in Hz), which dictates how quickly the sine wave varies as a function of time, i.e., how many sine wave cycles per second\n",
    "- $\\phi$ is the initial **phase** (in radians), which defines where the sine wave starts at time $t = 0$\n",
    "\n",
    "Another important property is the **period**, $T$, which is the inverse of the frequency (i.e., $T = 1/f$) and the duration of a sine wave cycle. This can be measured by calculating the time from peak-to-peak or valley-to-valley.\n",
    "\n",
    "By eye, you can see the period and the amplitude of an example sine wave below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div style=\"text-align: center\"> <img src=\"img/sine_ex.png\" width=\"450px\" justify=\"center\"></img> </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see one peak at $t = 1~\\mathrm{s}$ and the next one at $t = 6~\\mathrm{s}$, so the period of this sine wave is $T = 6 - 1= 5~\\mathrm{s}$, since the frequency is the inverse of the period, this gives a frequency of $f = 1/5~\\mathrm{Hz}$. The amplitude is the distance from the zero to the peak (or valley) of a wave; in this case, the amplitude is $a = 5$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now revisit the interactive plot from above, showing how amplitude, phase, and frequency affect a sine wave. Try putting in the values we just calculated, i.e., $a = 5, f = 0.2~\\mathrm{Hz}, \\phi = 0~\\mathrm{deg}$, and verifying that the sine wave matches the picture above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "ex.ex_1_1_1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the following plot of a sine wave, estimate its amplitude, period, and frequency. *Hint: Remember you can zoom in, pan, and use your cursor to find values of the curve.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "ex.ex_1_1_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(a)** What is the amplitude?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_8a()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(b)** What is the period?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_8b()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(c)** What is the frequency?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "qz.quiz_1_1_8c()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Scratch space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, we covered the basics of Jupyter notebooks, along with reviews of decibels and sine wave properties. The main operations for interacting with Jupyter notebooks are:\n",
    "- Click *<font color=\"DarkBlue\">Run All</font>* button <img width=\"18px\" src=\"img/run_all_icon.png\"> to prepare a newly-opened notebook\n",
    "- Create a new cell using the *<font color=\"DarkBlue\">Add Cell Below</font>* <img width=\"11px\" src=\"img/add_cell.png\"></img> button\n",
    "- Evaluate a cell using the *<font color=\"DarkBlue\">Run Cell</font>* <img width=\"12px\" src=\"img/run_cell_icon.png\"></img> button\n",
    "- Interact with plots using the *<font color=\"DarkBlue\">Zoom Box</font>* <img src=\"img/zoom_box.png\"></img>, *<font color=\"DarkBlue\">Pan</font>*, and *<font color=\"DarkBlue\">Reset View</font>* <img src=\"img/reset_view.png\"></img> buttons\n",
    "\n",
    "Decibels are a great way to take extremely large and small numbers and convert them to a scale that is much easier to remember and manipulate. Conversion to decibels is $x_d = 10\\log_{10}(x)$ and conversion back is $x = 10^{x_d/10}$. You can convert multiplications $z = xy$ into additions $z_d = x_d + y_d$ and exponentiation $x = a^b$ to scaling $x_d = b \\cdot a_d$.\n",
    "\n",
    "Sine waves are very important to radar as they provide the basis for transmissions. A sine wave is defined by its amplitude, frequency, and initial phase. The frequency of a sine wave is the number of cycles that occurs within a seconds and its period is the time between cycles; the period is the inverse of the frequency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Footnotes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "n/a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "source": [
    "## References\n",
    "\n",
    "<a id=\"ref_jupyter\">[1]</a> *Project Jupyter* [https://jupyter.org](https://jupyter.org)\n",
    "\n",
    "<a id=\"ref_python\">[2]</a> *Python* [https://python.org](https://python.org)\n",
    "\n",
    "<a id=\"ref_markdown\">[3]</a> *Markdown Guide* [https://www.markdownguide.org/](https://www.markdownguide.org/)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}