Foundational-Math-4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Foundational Math 4 (Learn).ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMqYYp9SrmjPX0EnIq28Lmb",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/edatfreecodecamp/python-math/blob/main/Foundational_Math_4_(Learn).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EsfO5Q92tL-6"
      },
      "source": [
        "[![freeCodeCamp](https://cdn.freecodecamp.org/testable-projects-fcc/images/fcc_secondary.svg)](https://freecodecamp.org/)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qwxbk7XGKxEq"
      },
      "source": [
        "**Learn Foundational Math 4 by Building an Analog Clock**<br>\n",
        "Each of these steps will lead you toward the Certification Project. Once you complete a step, click to expand the next step."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "szp5flp1fA8-"
      },
      "source": [
        "# &darr; **Do this first** &darr;\n",
        "Copy this notebook to your own account by clicking the `File` button at the top, and then click `Save a copy in Drive`. You will need to be logged in to Google. The file will be in a folder called \"Colab Notebooks\" in your Google Drive. "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 0 - Acquire the testing library"
      ],
      "metadata": {
        "id": "VmTzihk-ZWKB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Please run this code to get the library file from FreeCodeCamp. Each step will use this library to test your code. You do not need to edit anything; just run this code cell and wait a few seconds until it tells you to go on to the next step."
      ],
      "metadata": {
        "id": "QKQK-Jr4Y3XU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# You may need to run this cell at the beginning of each new session\n",
        "\n",
        "!pip install requests\n",
        "\n",
        "# This will just take a few seconds\n",
        "\n",
        "import requests\n",
        "\n",
        "# Get the library from GitHub\n",
        "url = 'https://raw.githubusercontent.com/edatfreecodecamp/python-math/main/math-code-test-d.py'\n",
        "r = requests.get(url)\n",
        "\n",
        "# Save the library in a local working directory \n",
        "with open('math_code_test_d.py', 'w') as f:\n",
        "    f.write(r.text)\n",
        "\n",
        "# Now you can import the library\n",
        "import math_code_test_d as test\n",
        "\n",
        "# This will tell you if the code works\n",
        "test.step00()"
      ],
      "metadata": {
        "id": "zU8wre7FY8mF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Cj-FObSK2q-"
      },
      "source": [
        "#Step 1 - Drawing Shapes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CJ_o5jJpK4tN"
      },
      "source": [
        "To draw a polygon, you create an array of (x,y) verticies and an array of paths that match up with each vertex. Notice the first vertex is listed again at the end. Use `Path.MOVETO` for the first point, `Path.LINETO` to draw each line to the next point, and `Path.CLOSEPOLY` at the end. Run this code, then add the points (-1,1) and (3,1) and change the two arrays to make a hexagon."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jvCyAWK8HxCo"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.path import Path\n",
        "import matplotlib.patches as patches\n",
        "\n",
        "# Add the points (-1., 1.) and (3., 1.) to this array (in the right places)\n",
        "verts = [(0., 0.), (0., 2.), (2., 2.), (2., 0.), (0., 0.),]\n",
        "\n",
        "# Add two more Path.LINETO directions to this array\n",
        "codes = [Path.MOVETO, \n",
        "         Path.LINETO, \n",
        "         Path.LINETO,\n",
        "         Path.LINETO, \n",
        "         Path.CLOSEPOLY, ]\n",
        "\n",
        "# Keep the code below this line\n",
        "path = Path(verts, codes)\n",
        "patch = patches.PathPatch(path, facecolor='blue', lw=2)\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "ax.add_patch(patch)\n",
        "\n",
        "plt.axis([-5,5,-5,5])\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step01(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MRHJIxaULIdT"
      },
      "source": [
        "#Step 2 - Pythagorean Theorem"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HIecO24ILIdV"
      },
      "source": [
        "You have probably heard of <i>Pythagorean Theorem</i>, a<sup>2</sup> + b<sup>2</sup> = c<sup>2</sup>, as a way to find side lengths for right triangles. Side c always has to be the <i>hypotenuse</i> (the longest side, across from the right angle). Write the code to prompt for a, b, and c, and print the length of the unknown side. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q_Ln2qanLIdW"
      },
      "source": [
        "import math\n",
        "\n",
        "print(\"If you don't know a side length, just enter the letter\")\n",
        "a_string = input(\"Side a = \")\n",
        "b_string = input(\"Side b = \")\n",
        "\n",
        "# Change the next line to an input statement for c_string\n",
        "c_string = \"0\"\n",
        "\n",
        "if (a_string==\"a\"):\n",
        "    b = float(b_string)\n",
        "    c = float(c_string)\n",
        "    a = math.sqrt(c**2 - b**2)\n",
        "    print(\"a = \", a)\n",
        "\n",
        "if (b_string==\"b\"):\n",
        "    a = float(a_string)\n",
        "    c = float(c_string)\n",
        "    b = math.sqrt(c**2 - a**2)\n",
        "    print(\"b = \", b)\n",
        "\n",
        "if (c_string==\"c\"):\n",
        "    a = float(a_string)\n",
        "    b = float(b_string)\n",
        "    # Write your code here (Remember to add instead of subtract)\n",
        "\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step02(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IuJnWUEQLKE7"
      },
      "source": [
        "# Step 3 - Distance Formula"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GywerJe-LKE8"
      },
      "source": [
        "On a Cartesian graph, finding the distance between two points is really Pythagorean Theorem. Just run the following code to see this illustrated in a brief animation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WVdiSqxqLKE9"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.path import Path\n",
        "import matplotlib.patches as patches\n",
        "from IPython import display\n",
        "import math\n",
        "import time\n",
        "\n",
        "# Notice imports you used in previous steps\n",
        "# import time may be the only new addition\n",
        "\n",
        "# plot two red points then wait 1.5 seconds\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-5,15,-10,10])\n",
        "ax.text(0,2,'(1,1)')\n",
        "ax.text(7,5,'(7,4)')\n",
        "plt.plot([1],[1],'ro')\n",
        "plt.plot([7],[4],'ro')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# plot the horizontal line\n",
        "plt.plot([1,7], [1,1])\n",
        "ax.text(2,0,'change in x')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# plot the vertical line\n",
        "plt.plot([7,7], [1,4])\n",
        "ax.text(7.5,2,'change in y')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# plot the diagonal distance (hypotenuse) line \n",
        "plt.plot([1,7], [1,4])\n",
        "ax.text(2,3,'distance')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_d as test\n",
        "test.step03()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hCbQuMWFLLCE"
      },
      "source": [
        "# Step 4 - Distance Formula (Part 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uWFvfeRhLLCF"
      },
      "source": [
        "Because the \"change in x\" line is horizontal and the \"change in y\" line is vertical, they make a right angle.<br>\n",
        "Pythagorean Theorem applies here: a<sup>2</sup> + b<sup>2</sup> = c<sup>2</sup><br> \n",
        "From that animation you see that: (change in x)<sup>2</sup> + (change in y)<sup>2</sup> = (distance)<sup>2</sup><br>\n",
        "Here is another way to write this: (x<sub>2</sub> - x<sub>1</sub>)<sup>2</sup> + (y<sub>2</sub> - y<sub>1</sub>)<sup>2</sup> = d<sup>2</sup> referring to points (x<sub>1</sub> , y<sub>1</sub>) and (x<sub>2</sub> , y<sub>2</sub>)<br>\n",
        "Using example points (1,1) and (7,4) you get: (7 - 1)<sup>2</sup> + (4 - 1)<sup>2</sup> = d<sup>2</sup><br>\n",
        "Then you solve for d.<br>\n",
        "Write the code to prompt for two (x,y) points and find the distance between them.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "59giIvM4LLCF"
      },
      "source": [
        "import math\n",
        "\n",
        "point1 = input(\"Without parentheses, enter the first x,y point \")\n",
        "point2 = input(\"Without parentheses, enter the second x,y point \")\n",
        "distance = 0\n",
        "\n",
        "# This parses the first string input as two variables\n",
        "first = point1.split(\",\")\n",
        "x1 = float(first[0])\n",
        "y1 = float(first[1])\n",
        "\n",
        "# Change x2 and y2 to parse the second point\n",
        "second = point2.split(\",\")\n",
        "x2 = 0\n",
        "y2 = 0\n",
        "\n",
        "# Write your code here to calculate the distance\n",
        "distance = 0\n",
        "\n",
        "# Keep this line:\n",
        "print(\"distance = \", distance)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step04(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "drMb9BFILNLA"
      },
      "source": [
        "#Step 5 - Midpoint Formula"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lZUBLfLqLNLB"
      },
      "source": [
        "When you have a line between two points on a graph, to get the <i>midpoint</i> of that line you find the average of the x values and the average of the y values. So if the two points are ($x_1, y_1$) and ($x_2, y_2$) then the midpoint would be $(\\frac{x_1 + x_2}{2} , \\frac{y_1 + y_2}{2})$. Write code to prompt for two points and calculate the midpoint of the line between them. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GTtDx5YcLNLC"
      },
      "source": [
        "# Code from previous step - to prompt for points and parse\n",
        "point1 = input(\"Without parentheses, enter the first x,y point \")\n",
        "point2 = input(\"Without parentheses, enter the second x,y point \")\n",
        "\n",
        "# Parse the first string input as two variables\n",
        "first = point1.split(\",\")\n",
        "x1 = float(first[0])\n",
        "y1 = float(first[1])\n",
        "\n",
        "# Parse the second string input as two variables\n",
        "second = point2.split(\",\")\n",
        "x2 = float(second[0])\n",
        "y2 = float(second[1])\n",
        "\n",
        "# Change the next two lines to calculate the midpoint values\n",
        "x = 0\n",
        "y = 0\n",
        "\n",
        "# Keep the next line\n",
        "print(\"Midpoint is (\",x,\",\",y,\")\")\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step05(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dANvnqZzLPdY"
      },
      "source": [
        "#Step 6 - Trigonometry"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zmA-KlOeLPdY"
      },
      "source": [
        "The root word <i>tri</i> means \"three;\" <i>gon</i> means \"shape;\" and <i>metry</i> means \"measurement;\" so <i>trigonometry</i> means \"measurement of shapes that have three sides.\" Run the following code, and notice the descriptions of the three sides as they relate to angle A."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ASMRCU6ALPdZ"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.path import Path\n",
        "import matplotlib.patches as patches\n",
        "from IPython import display\n",
        "import math\n",
        "import time\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,12,-2,8])\n",
        "ax.text(0,1,'A')\n",
        "plt.plot([1],[1],'ro')\n",
        "plt.plot([1,7], [1,1], 'b')\n",
        "plt.plot([7,7], [1,4], 'b')\n",
        "plt.plot([1,7], [1,4], 'b')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "ax.text(2,0,'adjacent side')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "ax.text(7.5,2,'opposite side')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "ax.text(1,3,'hypotenuse')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_d as test\n",
        "test.step00()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RHslnjqULQ42"
      },
      "source": [
        "#Step 7 - Trigonometry (Part 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zNfDIWKoLQ42"
      },
      "source": [
        "Here is another perspective. Run the following code, and notice how the side descriptions are different for angle B, compared to angle A. The \"opposite\" side is across from B, and the \"adjacent\" side is next to B. The \"hypotenuse\" is always across from the right angle."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z0rSpzS6LQ42"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.path import Path\n",
        "import matplotlib.patches as patches\n",
        "from IPython import display\n",
        "import math\n",
        "import time\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,12,-2,8])\n",
        "ax.text(7,4.5,'B')\n",
        "plt.plot([7],[4],'ro')\n",
        "plt.plot([1,7], [1,1], 'b')\n",
        "plt.plot([7,7], [1,4], 'b')\n",
        "plt.plot([1,7], [1,4], 'b')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "ax.text(2,0,'opposite side')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "ax.text(7.5,2,'adjacent side')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "ax.text(1,3,'hypotenuse')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_d as test\n",
        "test.step07()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Onw98nlfLRpV"
      },
      "source": [
        "#Step 8 - Trigonometry - Sine Ratio"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EpOOEXzULRpW"
      },
      "source": [
        "The <i>sine</i> of an angle is the ratio of the opposite side over the hypotenuse. The trig functions are usually abreviated with three letters. Run the following code and notice that sin(A) = $\\frac{3}{5}$ but sin(B) = $\\frac{4}{5}$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vf9rMRkapkM3"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,12,-2,8])\n",
        "plt.plot([1],[1],'ro')\n",
        "ax.text(.5,1,'A')\n",
        "plt.plot([5],[4],'ro')\n",
        "ax.text(5,4.5,'B')\n",
        "plt.plot([1,5], [1,1], 'b')\n",
        "plt.plot([5,5], [1,4], 'b')\n",
        "plt.plot([1,5], [1,4], 'b')\n",
        "ax.text(3,0,'4')\n",
        "ax.text(5.5,2,'3')\n",
        "ax.text(2.5,3,'5')\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_d as test\n",
        "test.step08()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wVboaZONLd1x"
      },
      "source": [
        "#Step 9 - Calculating Sine Ratio"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D9IrfNCmLd1y"
      },
      "source": [
        "Finish the code below to calculate the sine ratio and print the result."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5faGO_JaLRpW"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "import math\n",
        "\n",
        "# random numbers for sides\n",
        "a = random.randint(1,9)\n",
        "b = random.randint(1,9)\n",
        "c = round(math.sqrt(a**2 + b**2),1)\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,12,-2,8])\n",
        "ax.set_title('Rounded Numbers Not Drawn to Scale')\n",
        "ax.axes.xaxis.set_visible(False)\n",
        "ax.axes.yaxis.set_visible(False)\n",
        "\n",
        "ax.text(0,1,'A')\n",
        "plt.plot([1],[1],'ro')\n",
        "plt.plot([1,5], [1,1], 'b')\n",
        "plt.plot([5,5], [1,4], 'b')\n",
        "plt.plot([1,5], [1,4], 'b')\n",
        "ax.text(3,0,b)\n",
        "ax.text(5.5,2,a)\n",
        "ax.text(2.5,3,c)\n",
        "\n",
        "plt.show()\n",
        "\n",
        "opp = float(input(\"\\n For angle A, what is measure of the opposite side? \\n\"))\n",
        "hyp = float(input(\"\\n What is measure of the hypotenuse? \\n\"))\n",
        "\n",
        "# Change the next line to calculate the sine of angle A\n",
        "sinA = 0\n",
        "\n",
        "# Keep the next line:\n",
        "print(\"The sine of A is \", sinA)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step09(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UOEMFJ6cLTLh"
      },
      "source": [
        "# Step 10 - Trigonometry - Cosine Ratio"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jG3Oox6WLTLi"
      },
      "source": [
        "The <i>cosine</i> is the ratio of the adjacent side over the hypotenuse. Notice the three letter abreviation for cosine. Run the following code and notice that cos(A) = $\\frac{4}{5}$ but cos(B) = $\\frac{3}{5}$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2X9VYLOwLTLi"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,12,-2,8])\n",
        "plt.plot([1],[1],'ro')\n",
        "ax.text(.5,1,'A')\n",
        "plt.plot([5],[4],'ro')\n",
        "ax.text(5,4.5,'B')\n",
        "plt.plot([1,5], [1,1], 'b')\n",
        "plt.plot([5,5], [1,4], 'b')\n",
        "plt.plot([1,5], [1,4], 'b')\n",
        "ax.text(3,0,'4')\n",
        "ax.text(5.5,2,'3')\n",
        "ax.text(2.5,3,'5')\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_d as test\n",
        "test.step10()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J0sC7Ib_LfW1"
      },
      "source": [
        "#Step 11 - Calculating Cosine Ratio"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F42N_UfwLfW2"
      },
      "source": [
        "Finish the code below to calculate the cosine ratio and print the result."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ecohfh9ULfW3"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "import math\n",
        "\n",
        "a = random.randint(1,9)\n",
        "b = random.randint(1,9)\n",
        "c = round(math.sqrt(a**2 + b**2),1)\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,12,-2,8])\n",
        "ax.set_title('Not Drawn to Scale')\n",
        "ax.text(0,1,'A')\n",
        "plt.plot([1],[1],'ro')\n",
        "plt.plot([1,5], [1,1], 'b')\n",
        "plt.plot([5,5], [1,4], 'b')\n",
        "plt.plot([1,5], [1,4], 'b')\n",
        "ax.text(3,0,b)\n",
        "ax.text(5.5,2,a)\n",
        "ax.text(2.5,3,c)\n",
        "plt.show()\n",
        "\n",
        "\n",
        "adj = float(input(\"For angle A, what is measure of the adjacent side? \\n\"))\n",
        "hyp = float(input(\"What is measure of the hypotenuse? \\n\"))\n",
        "\n",
        "\n",
        "# Change the next line to calculate the cosine of angle A\n",
        "cosA = 0\n",
        "\n",
        "# Keep the next line:\n",
        "print(\"The cosine of angle A is \", cosA)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step11(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hhYH2x-PLUZQ"
      },
      "source": [
        "#Step 12 - Trigonometry - Tangent Ratio"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EGk7Nx78LUZR"
      },
      "source": [
        "The <i>tangent</i> is the ratio of the opposite side over the adjacent side. As with sine and cosine, the side descriptions are relative to the angles. Run the following code and notice that the tan(A) = $\\frac{3}{4}$ but the tan(B) = $\\frac{4}{3}$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JPJsHy-MLUZR"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,12,-2,8])\n",
        "ax.text(0,1,'A')\n",
        "plt.plot([1],[1],'ro')\n",
        "plt.plot([1,5], [1,1], 'b')\n",
        "plt.plot([5,5], [1,4], 'b')\n",
        "plt.plot([1,5], [1,4], 'b')\n",
        "ax.text(3,0,'4')\n",
        "ax.text(5.5,2,'3')\n",
        "ax.text(2.5,3,'5')\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_d as test\n",
        "test.step12()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eNsZ-JsSLgFt"
      },
      "source": [
        "#Step 13 - Calculating Tangent Ratio"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BcI4uDmuLgFu"
      },
      "source": [
        "Finish the code below to calculate the tangent ratio and print the result."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rqZFa8LjLgFu"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "\n",
        "a = random.randint(1,9)\n",
        "b = random.randint(1,9)\n",
        "c = random.randint(1,9)\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,12,-2,8])\n",
        "ax.set_title('Not Drawn to Scale')\n",
        "ax.text(0,1,'A')\n",
        "plt.plot([1],[1],'ro')\n",
        "plt.plot([1,5], [1,1], 'b')\n",
        "plt.plot([5,5], [1,4], 'b')\n",
        "plt.plot([1,5], [1,4], 'b')\n",
        "ax.text(3,0,b)\n",
        "ax.text(5.5,2,a)\n",
        "ax.text(2.5,3,c)\n",
        "plt.show()\n",
        "\n",
        "opp = float(input(\"For angle A, what is measure of the opposite side? \\n\"))\n",
        "adj = float(input(\"For angle A, what is measure of the adjacent side? \\n\"))\n",
        "\n",
        "# Change the next line to calculate the tangent of angle A\n",
        "tanA = 0\n",
        "\n",
        "# Keep the next line\n",
        "print(\"The tangent of angle A is \", tanA)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step13(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V8abW4jeLWFW"
      },
      "source": [
        "#Step 14 - Remembering Trig Ratios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kN-uaoLrLWFW"
      },
      "source": [
        "Because each trig ratio is useful in a different situation, you need a good way to remember them. Many people use this acronym:<br>\n",
        "S$\\frac{o}{h}$C$\\frac{a}{h}$T$\\frac{o}{a}$ (pronounced \"so-ka-toe-ah\"). Notice how this \"word\" contains each ratio. Sine is opposite over hypotenuse. Cosine is adjacent over hypotenuse. Tangent is opposite over adjacent. Complete the following code to calculate the \"actual\" values in this trig ratio practice app, then run the app and test your understanding."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NZHfIBrDLWFW"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import math\n",
        "import random\n",
        "\n",
        "# Randomly geneerated side lengths\n",
        "a = random.randint(1,20)\n",
        "b = random.randint(1,20)\n",
        "c = round(math.sqrt(a**2 + b**2),2)\n",
        "\n",
        "# Displaying the triangle\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,12,-2,8])\n",
        "ax.set_title('Not Drawn to Scale')\n",
        "ax.text(0,1,'A')\n",
        "plt.plot([1],[1],'ro')\n",
        "ax.text(5,4.5,'B')\n",
        "plt.plot([5],[4],'ro')\n",
        "plt.plot([1,5], [1,1], 'b')\n",
        "plt.plot([5,5], [1,4], 'b')\n",
        "plt.plot([1,5], [1,4], 'b')\n",
        "ax.text(3,0,b)\n",
        "ax.text(5.5,2,a)\n",
        "ax.text(2,3,c)\n",
        "plt.show()\n",
        "\n",
        "# This calculates the sine of A to four decimal places:\n",
        "sinA_actual = round(a/c, 4)\n",
        "\n",
        "# Use sinA_actual as a model to calculate the other functions:\n",
        "cosA_actual = 0\n",
        "tanA_actual = 0\n",
        "sinB_actual = 0\n",
        "cosB_actual = 0\n",
        "tanB_actual = 0\n",
        "\n",
        "# Only change the code above this line\n",
        "\n",
        "# This will compare user input to actual values:\n",
        "print(\"Enter the ratio as a fraction, using '/' \")\n",
        "string_input = input(\"sin(A) = \")\n",
        "ratio = string_input.split(\"/\")\n",
        "n = float(ratio[0])\n",
        "d = float(ratio[1])\n",
        "ratio_input = round(n/d, 4)\n",
        "print(\"actual = \", sinA_actual, \" input = \", ratio_input)\n",
        "\n",
        "string_input = input(\"cos(A) = \")\n",
        "ratio = string_input.split(\"/\")\n",
        "n = float(ratio[0])\n",
        "d = float(ratio[1])\n",
        "ratio_input = round(n/d, 4)\n",
        "print(\"actual = \", cosA_actual, \" input = \", ratio_input)\n",
        "\n",
        "string_input = input(\"tan(A) = \")\n",
        "ratio = string_input.split(\"/\")\n",
        "n = float(ratio[0])\n",
        "d = float(ratio[1])\n",
        "ratio_input = round(n/d, 4)\n",
        "print(\"actual = \", tanA_actual, \" input = \", ratio_input)\n",
        "\n",
        "string_input = input(\"sin(B) = \")\n",
        "ratio = string_input.split(\"/\")\n",
        "n = float(ratio[0])\n",
        "d = float(ratio[1])\n",
        "ratio_input = round(n/d, 4)\n",
        "print(\"actual = \", sinB_actual, \" input = \", ratio_input)\n",
        "\n",
        "string_input = input(\"cos(B) = \")\n",
        "ratio = string_input.split(\"/\")\n",
        "n = float(ratio[0])\n",
        "d = float(ratio[1])\n",
        "ratio_input = round(n/d, 4)\n",
        "print(\"actual = \", cosB_actual, \" input = \", ratio_input)\n",
        "\n",
        "string_input = input(\"tan(B) = \")\n",
        "ratio = string_input.split(\"/\")\n",
        "n = float(ratio[0])\n",
        "d = float(ratio[1])\n",
        "ratio_input = round(n/d, 4)\n",
        "print(\"actual = \", tanB_actual, \" input = \", ratio_input)\n",
        "\n",
        "# Test your app and add a point system if you like\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step14(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xyRAzmLbLg4H"
      },
      "source": [
        "# Step 15 - Predictable Trig Ratios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "90maUrEzLg4H"
      },
      "source": [
        "Trigonometric ratios are consistent; for example, the sine of 30 degrees is always one half. These values are built into the Python math library, but the angles are measured in <i>radians</i>. If you want to use degrees, you need to cast the degree angle as a radian angle. To show the sine of a 30 degree angle you would do this: `math.sin(math.radians(30))`. In the loop, change the `ratio_c` variable to calculate the cosine of each angle, just as the `ratio_s` variable calculates the sine of each angle. In the output, notice the patterns."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xOOmmxsGLg4I"
      },
      "source": [
        "import math\n",
        "\n",
        "for a in range(37):\n",
        "    angle = a*10\n",
        "    ratio_s = round(math.sin(math.radians(angle)),4)\n",
        "    \n",
        "    # Change the following line to calculate the cosine values\n",
        "    ratio_c = 0\n",
        "\n",
        "    # Keep this line\n",
        "    print(\"sin(\", angle, \") = \", ratio_s, \"\\t\\t cos(\", angle, \") = \", ratio_c)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step15(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RAxt-Fe8xQAD"
      },
      "source": [
        "#Step 16 - Radians"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "psZ7sV0xxQAN"
      },
      "source": [
        "A <i>radian</i> is the measure of the radius along the circumference of a circle. As the formula for circumference is 2$\\pi$r, there are 2$\\pi$ radians in a complete circle. One radian corresponds to an angle of about 57 degrees, and 2$\\pi$ radians equals 360 degrees. You will usually see radians written as fractions involving pi; for example, $\\frac{3\\pi}{2}$ radians = 270 degrees. Run the following code to see the radian and degree equivalents."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gkE01nTlxQAN"
      },
      "source": [
        "import sympy\n",
        "from sympy.abc import pi\n",
        "\n",
        "for d in range(1,13):\n",
        "    print(\"\\u03C0 /\", d, \" radians = \", 180/d, \" degrees\" )\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_d as test\n",
        "test.step00()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c-KV_J_MxV24"
      },
      "source": [
        "#Step 17 - Unit Circle (Part 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "88fKneVuxV25"
      },
      "source": [
        "The <i>Unit Circle</i> is a circle with a radius of one unit and a center at (0,0). When you plot an (x,y) point, you are making a right triangle. The horizontal side is \"x,\" the vertical side is \"y,\" and the hypotenuse is the radius (which is 1 here). Run the following code and notice that when r=1, the sine of the central angle is $\\frac{y}{1}$ and the cosine of the central angle is $\\frac{x}{1}$. The (x,y) point then has coordinates of `(cos(a), sin(a))`.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1LerUPcnxV25"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.path import Path\n",
        "import matplotlib.patches as patches\n",
        "from IPython import display\n",
        "import math\n",
        "import time\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,14,-2,10])\n",
        "ax.axes.xaxis.set_visible(False)\n",
        "ax.axes.yaxis.set_visible(False)\n",
        "\n",
        "ax.text(-1.2,0,'(0,0)')\n",
        "plt.plot([0],[0],'ro')\n",
        "ax.text(8,5.5,'(x,y)')\n",
        "plt.plot([8],[5],'ro')\n",
        "ax.text(1,.2,') angle')\n",
        "\n",
        "plt.plot([0,8], [0,0], 'b')\n",
        "plt.plot([8,8], [0,5], 'b')\n",
        "plt.plot([0,8], [0,5], 'b')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "ax.text(2,-.6,'adjacent side = x')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "ax.text(8.1,2,'opposite side = y')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "ax.text(.7,3,'hypotenuse = 1')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_d as test\n",
        "test.step17()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JX-692RFxQwE"
      },
      "source": [
        "#Step 18 - Unit Circle (Part 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q79-ubU7xQwE"
      },
      "source": [
        "Remember creating polygons from arrays in step 1? To recap: Start the arrays with the first (x,y) point and the first direction (`Path.MOVETO`). Here you will see a loop that appends the other points to the first array and `Path.LINETO` directions to the other array. After the loop, append the last point (which is the same as the first point) and the `Path.CLOSEPOLY` direction. Here is the Unit Circle twist: Using the predictable sine and cosine values from an earlier step, the path will make a `Unit Circle` with each (x,y) point having the coordinates `(cos(a), sin(a))`. Run the code to see the circle, and read the code to see how it all comes together."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E4p9b015xQwF"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.path import Path\n",
        "import matplotlib.patches as patches\n",
        "import math\n",
        "\n",
        "# Start each array\n",
        "verts = [ (1., 0.),]\n",
        "codes = [Path.MOVETO,]\n",
        "\n",
        "# Loop through cosine and sine values as (x,y) points\n",
        "for a in range(37):\n",
        "    x = round(math.cos(math.radians(a*10)),4)\n",
        "    y = round(math.sin(math.radians(a*10)),4)\n",
        "    verts.append((x,y),)\n",
        "    codes.append(Path.LINETO,)\n",
        "\n",
        "# Complete the arrays\n",
        "verts.append((1.,0.),)\n",
        "codes.append(Path.CLOSEPOLY,)\n",
        "path = Path(verts, codes)\n",
        "\n",
        "# Create the graph\n",
        "fig, ax = plt.subplots()\n",
        "patch = patches.PathPatch(path, facecolor='blue', lw=2)\n",
        "ax.add_patch(patch)\n",
        "plt.axis([-2,2,-2,2])\n",
        "ax.set_aspect('equal', adjustable='box')\n",
        "plt.grid()\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_d as test\n",
        "test.step18()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VoV-HXtTxSJB"
      },
      "source": [
        "#Step 19 - Solving Triangles"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aHXIkoDYxSJC"
      },
      "source": [
        "Because the trig functions of any angle are predictable, we can use them to solve for unknown sides of a right triangle. Run the following code to see how to use `sine` to solve for `side a`. Then, following that model, add the code to use `cosine` to solve for `side b`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nHXBlwV9xSJC"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.path import Path\n",
        "import matplotlib.patches as patches\n",
        "from IPython import display\n",
        "import math\n",
        "import time\n",
        "import random\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,14,-2,10])\n",
        "ax.axes.xaxis.set_visible(False)\n",
        "ax.axes.yaxis.set_visible(False)\n",
        "\n",
        "# the random angle measure in in degrees\n",
        "rangle = random.randint(1,80)\n",
        "angle = \") angle = \" + str(rangle) + \" degrees\"\n",
        "ax.text(1,.2,angle)\n",
        "\n",
        "# the random hypotenuse measure\n",
        "sideC = random.randint(1,10)\n",
        "\n",
        "# display the triangle\n",
        "plt.plot([0,8], [0,0], 'b')\n",
        "plt.plot([8,8], [0,5], 'b')\n",
        "plt.plot([0,8], [0,5], 'b')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(0.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# label side a\n",
        "ax.text(8.1,2,\"a\") \n",
        "display.display(plt.gcf())\n",
        "time.sleep(0.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# label side b\n",
        "ax.text(4,-.6,\"b\") \n",
        "display.display(plt.gcf())\n",
        "time.sleep(0.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# label side c\n",
        "ax.text(4,3,sideC)\n",
        "display.display(plt.gcf())\n",
        "time.sleep(0.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# solve to get the measure of side a\n",
        "print(\"Set up your trig ratio for side A:\")\n",
        "print(\"sin(\", rangle, \") = a / \", sideC)\n",
        "print(\"One step of algebra:\")\n",
        "print(sideC, \" * sin(\", rangle,\") = a\")\n",
        "print(\"Solve:\")\n",
        "sin_value = round(math.sin(math.radians(rangle)), 4)\n",
        "print(sideC, \" * \", sin_value, \" = a\")\n",
        "side_a = round(sideC*sin_value,2)\n",
        "print(\"side a = \", side_a)\n",
        "print(\" \")\n",
        "\n",
        "\n",
        "# solve for side b\n",
        "print(\"Set up your trig ratio for side B:\")\n",
        "side_b = 0\n",
        "# Write your code here, keep side_b as a variable\n",
        "# hint: copy the model above, but use cos instead of sin\n",
        "\n",
        "\n",
        "print(\"side b = \", side_b)\n",
        "print(\" \")\n",
        "\n",
        "# Did you change every line except for the three static print statements?\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step19(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5kSqwjUNJMVh"
      },
      "source": [
        "#Step 20 - Calculating Length of a Ramp"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8T_LTfh9JOT1"
      },
      "source": [
        "If you know the height and the angle, you can use `sin()` to calculate the length of a ramp. Run the following code to see the situation, then add code to calculate and print the value of the hypotenuse (the length of the ramp) and run this again. You do not have to print out each step. (Hint: The calculation will involve two steps of Algebra.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m0Qti6t_x-NQ"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.path import Path\n",
        "import matplotlib.patches as patches\n",
        "from IPython import display\n",
        "import math\n",
        "import time\n",
        "import random\n",
        "\n",
        "# Basic plot set up\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,14,-2,10])\n",
        "ax.axes.xaxis.set_visible(False)\n",
        "ax.axes.yaxis.set_visible(False)\n",
        "\n",
        "# Random measure for side a\n",
        "sideA = random.randint(1,20)\n",
        "\n",
        "# Random measure for the angle\n",
        "rangle = random.randint(1,80)\n",
        "\n",
        "# Display the angle measure in in degrees\n",
        "display_angle = \") angle = \" + str(rangle) + \" degrees\"\n",
        "ax.text(1,.2,display_angle)\n",
        "\n",
        "# Displaying the graph\n",
        "plt.plot([0,8], [0,0], 'b')\n",
        "plt.plot([8,8], [0,5], 'b')\n",
        "plt.plot([0,8], [0,5], 'b')\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# Display side a measure on the graph\n",
        "ax.text(8.1,2,sideA) \n",
        "display.display(plt.gcf())\n",
        "time.sleep(1)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# Display the label \"c\" for the hypotenuse\n",
        "ax.text(4,3, \"c\")\n",
        "display.display(plt.gcf())\n",
        "time.sleep(1)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# The angle measure in radians\n",
        "radian_angle = math.radians(rangle)\n",
        "\n",
        "# Write your code here, keep sideC as the variable, use sideA\n",
        "sideC = 0\n",
        "\n",
        "\n",
        "# Keept the following line:\n",
        "print(\"Length of the ramp = \", sideC)\n",
        "print(\" \")\n",
        "\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step20(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PK99WivdJZho"
      },
      "source": [
        "# Step 21 - Calculating Rope Tension"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ugPONe3DJZhp"
      },
      "source": [
        "Tension is the force pulling on a rope. Two ropes hanging straight down have less tension than two ropes hanging at an angle (holding up the same object, the same distance from the ceiling). As that angle increases, you can use `cos()` to calculate the tension. The hypotenuse is the force on the rope at that angle. The adjacent side is the tension if the rope was hanging straight down. Run the following code to see the situation, then add code to calculate and print the force on the angled rope. (Hint: This will involve two steps of Algebra.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iIcTngr0JZhp"
      },
      "source": [
        "# change this code\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.path import Path\n",
        "import matplotlib.patches as patches\n",
        "from IPython import display\n",
        "import math\n",
        "import time\n",
        "import random\n",
        "\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-3,3,0,6])\n",
        "ax.axes.xaxis.set_visible(False)\n",
        "ax.axes.yaxis.set_visible(False)\n",
        "plt.plot([-1,-1],[1,5], 'b-') # vertical force 1\n",
        "plt.plot([1,1],[1,5], 'b-') # vertical force 2\n",
        "plt.plot([-1,-2],[1,5], 'g-') # diagonal force 1\n",
        "plt.plot([1,2],[1,5], 'g-') # diagonal force 2\n",
        "\n",
        "\n",
        "# The angle measure in in degrees\n",
        "rangle = random.randint(1,80)\n",
        "display_angle = \"angle = \" + str(rangle) + \" degrees\"\n",
        "\n",
        "# The angle measure in radians\n",
        "radian_angle = math.radians(rangle)\n",
        "\n",
        "# ransom measure for vertical force\n",
        "sideA = random.randint(1,20)\n",
        "\n",
        "# displaying the lines\n",
        "ax.text(0.1, 4, \"upward\")\n",
        "ax.text(0.2, 3.5, \"force =\")\n",
        "ax.text(0.3, 3, sideA)\n",
        "ax.text(1.6, 2.5, \"diagonal\")\n",
        "ax.text(1.5,2, \"force = ?\")\n",
        "ax.text(0,.5, display_angle)\n",
        "ax.text(-2.5, 2.5, \"symetrical\")\n",
        "ax.text(-2,2, \"forces\")\n",
        "\n",
        "# Write your code here, keep sideC as the variable, use sideA\n",
        "sideC = 0\n",
        "\n",
        "\n",
        "\n",
        "# Keept the following line:\n",
        "print(\"Force on diagonal rope = \", sideC)\n",
        "print(\" \")\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step21(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2IYXggXbaDhk"
      },
      "source": [
        "#Step 22 - Tangents and Surveying"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0BCPz4zNaDht"
      },
      "source": [
        "Using survey equipment to measure great distances involves tangent ratios. Actual surveying involves angles that are much smaller than the angles here. Run this code to see the triangle, then write code to calculate the distance."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BOKldDIraDhu"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.path import Path\n",
        "import matplotlib.patches as patches\n",
        "from IPython import display\n",
        "import math\n",
        "import time\n",
        "import random\n",
        "\n",
        "# Set up the graph\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,14,-2,10])\n",
        "ax.axes.xaxis.set_visible(False)\n",
        "ax.axes.yaxis.set_visible(False)\n",
        "\n",
        "# Display the graph\n",
        "plt.plot([0,8], [0,0], 'b')\n",
        "plt.plot([8,8], [0,5], 'b')\n",
        "plt.plot([0,8], [0,5], 'b')\n",
        "display.display(plt.gcf())\n",
        "plt.title(\"Not Drawn to Scale\",fontsize=16)\n",
        "time.sleep(.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# The \"opposite side\" will always be 0.5\n",
        "sideA = 0.5\n",
        "ax.text(8.1,2, sideA) \n",
        "display.display(plt.gcf())\n",
        "time.sleep(1)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "ax.text(2,-1, \"<---- distance ---->\")\n",
        "display.display(plt.gcf())\n",
        "time.sleep(.5)\n",
        "display.clear_output(wait=True)\n",
        "\n",
        "# Random angle measure in in degrees\n",
        "rangle = random.randint(1,4)\n",
        "display_angle = \") angle = \" + str(rangle) + \" degrees\"\n",
        "ax.text(1,.2,display_angle)\n",
        "\n",
        "# The angle measure in radians\n",
        "radian_angle = math.radians(rangle)\n",
        "\n",
        "\n",
        "# Write your code here, keep sideB as the variable, use sideA as the height\n",
        "sideB = 0\n",
        "\n",
        "\n",
        "\n",
        "# Keept the following line:\n",
        "print(\"distance = \", sideB)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step22(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iwafuTyFaFj-"
      },
      "source": [
        "#Step 23 - Law of Sines"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rUVSqoAwaFj_"
      },
      "source": [
        "You do not need a right angle to solve a triangle. Each side is proportional to the sine of the angle across from it. Here is the formula:<br>\n",
        "$\\frac{a}{sin(A)} = \\frac{b}{sin(B)} = \\frac{c}{sin(C)}$ \n",
        "You only need two of these three ratios to use the <i>Law of Sines</i>. This means that if you know an angle, the side across from it, and one other thing, you can cross-multiply to solve for the other angle or side. Complete the code to take an angle, the side across, and an angle or side as input. Then use the Law of Sines to calculate the missing value. Notice the \"model\" uses the inverse function, `arcsin()`, to find the angle when you know the ratio. Your code will not need that because you will know both angles."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZqWawk1MaFj_"
      },
      "source": [
        "import math\n",
        "import numpy as np\n",
        "\n",
        "# Prompt for known values\n",
        "print(\"First, the known ratio\")\n",
        "angleA = float(input(\"Known angle: \"))\n",
        "sideA = float(input(\"Side across: \"))\n",
        "print(\"If you don't know the value, put 'x' (no quotes or spaces)\")\n",
        "angleB = input(\"Other angle: \")\n",
        "sideB = input(\"Other side: \")\n",
        "\n",
        "# Use this part as a model\n",
        "if(angleB==\"x\"):\n",
        "    side_B = float(sideB)\n",
        "    ratioB = side_B*math.sin(math.radians(angleA))/sideA\n",
        "    radians_B = np.arcsin(ratioB)\n",
        "    angle_B = radians_B*180/math.pi\n",
        "    print(\"angle = \", angle_B)\n",
        "\n",
        "if(sideB==\"x\"):\n",
        "    angle_B = float(angleB)\n",
        "    # complete the code here to solve for side_B\n",
        "    side_B = 0\n",
        "\n",
        "    # keep this line:\n",
        "    print(\"side = \", side_B)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step23(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dOlksjAQaI2x"
      },
      "source": [
        "#Step 24 - Law of Cosines"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W8lBskWJaI2y"
      },
      "source": [
        "The <i>Law of Cosines</i> works if you know two sides and the angle between them or if you know all three sides. This formula also does not require a right angle. If the known sides are \"a\" and \"b\" and the known angle between them is \"C,\" then the formula is<br>\n",
        "c<sup>2</sup> = a<sup>2</sup> + b<sup>2</sup> - 2*a*b*cos(C)<br>\n",
        "You would use this to solve for side c. You can use the same formula when you know all three sides, and you would solve for angle C. Complete the code to prompt for values and calculate the missing angle or side."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wbYpi3pTaI2y"
      },
      "source": [
        "import math\n",
        "import numpy as np\n",
        "\n",
        "# Get input\n",
        "sideA = float(input(\"Side a: \"))\n",
        "sideB = float(input(\"Side b: \"))\n",
        "print(\"If you don't know the value, put 'x' (no quotes or spaces)\")\n",
        "sideC = input(\"Side c: \")\n",
        "angleC = input(\"Angle C: \")\n",
        "\n",
        "# Solve for angle C\n",
        "if(angleC==\"x\"):\n",
        "    side_C = float(sideC)\n",
        "    step1 = side_C**2 - sideB**2 - sideA**2\n",
        "    step2 = -2*sideA*sideB\n",
        "    ratio_C = step1/step2\n",
        "    radians_C = np.arccos(ratio_C)\n",
        "    angle_C = radians_C*180/math.pi\n",
        "    print(\"Angle C = \", angle_C)\n",
        "\n",
        "# Solve for side c\n",
        "if(sideC==\"x\"):\n",
        "    angle_C = float(angleC)\n",
        "    # complete the code here and change the next line\n",
        "    side_C = 0\n",
        "\n",
        "\n",
        "    # keep this line:\n",
        "    print(\"side  = \", side_C)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step24(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "22Kmv2k4aJ7T"
      },
      "source": [
        "#Step 25 - A New Area Formula"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PrBRKcCJaJ7T"
      },
      "source": [
        "You can also find the area of a triangle without knowing the base or the height. Here is the formula:<br> \n",
        "Area = $\\frac{1}{2}*a*b*sin(C)$ Where `a` and `b` are two sides and `C` is the angle between them. Complete the code to prompt for the sides and the angle, then calculate the area."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cPL56Ju3aJ7U"
      },
      "source": [
        "import math\n",
        "\n",
        "sideA = float(input(\"Side a = \"))\n",
        "sideB = float(input(\"Side b = \"))\n",
        "angleC = float(input(\"Angle C = \"))\n",
        "\n",
        "# Write your code here, use the area variable\n",
        "area = 0\n",
        "\n",
        "\n",
        "# Keep this line:\n",
        "print(\"Area = \", area)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step25(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FnaYnCN1_8qW"
      },
      "source": [
        "#Step 26 - Solving any Triangle"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mLEbMg3Y_8qk"
      },
      "source": [
        "Now put it all together, building on the code you wrote earlier. Prompt for the different things you would know about a triangle, and use your formulas to calculate and output every side, every angle, and the area. This code already displays a triange for reference. You will see comments in the several places where you will add your code."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fS002_K1_8ql"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import math\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([-2,12,-2,8])\n",
        "ax.set_title('Not Drawn to Scale')\n",
        "\n",
        "# Draw the sides of the triangle\n",
        "plt.plot([1],[1],'ro')\n",
        "plt.plot([1,5], [1,1], 'b')\n",
        "plt.plot([5],[1],'ro')\n",
        "plt.plot([5,4], [1,4], 'b')\n",
        "plt.plot([4],[4],'ro')\n",
        "plt.plot([1,4], [1,4], 'b')\n",
        "\n",
        "# Label the sides and angles\n",
        "ax.text(0.3,0.8,\"A\")\n",
        "ax.text(4,4.5,\"B\")\n",
        "ax.text(5.4,0.4,\"C\")\n",
        "ax.text(4.9,2.5,\"a\")\n",
        "ax.text(3,0.4,\"b\")\n",
        "ax.text(2,3,\"c\")\n",
        "ax.axes.xaxis.set_visible(False)\n",
        "ax.axes.yaxis.set_visible(False)\n",
        "plt.show()\n",
        "\n",
        "# Show options\n",
        "print(\"What do you know?\")\n",
        "print(\"1 = two sides and the angle between\")\n",
        "print(\"2 = three sides\")\n",
        "print(\"3 = side, angle across, and another angle\")\n",
        "print(\"4 = side, angle across, and another side\")\n",
        "print(\"5 = a right angle and two sides\")\n",
        "print(\"6 = a right angle, a side, and another angle\")\n",
        "opt_number = input(\"Enter one option number: \\n\")\n",
        "\n",
        "# Keep all of the code above this line\n",
        "\n",
        "# Use these variables:\n",
        "angleA = 0\n",
        "sideA = 0\n",
        "angleB = 0\n",
        "sideB = 0\n",
        "angleC = 0\n",
        "sideC = 0\n",
        "\n",
        "\n",
        "# Law of Cosines to find unknown side\n",
        "if(opt_number==\"1\"):\n",
        "    sideA = float(input(\"Side A = \\n\"))\n",
        "    # complete this code\n",
        "\n",
        "\n",
        "# Law of Cosines to find unknown angle\n",
        "if(opt_number==\"2\"):\n",
        "    sideA = float(input(\"Side A = \\n\"))\n",
        "    # complete this code\n",
        "\n",
        "\n",
        "# Law of Sines to find unknown side\n",
        "if(opt_number==\"3\"):\n",
        "    sideA = float(input(\"Side A = \\n\"))\n",
        "    # complete this code\n",
        "\n",
        "\n",
        "# Law of Sines to find unknown angle\n",
        "if(opt_number==\"4\"):\n",
        "    sideA = float(input(\"Side A = \\n\"))\n",
        "    # complete this code\n",
        "\n",
        "\n",
        "# Pythagorean theorem\n",
        "if(opt_number==\"5\"):\n",
        "    print(\"Make Angle C the right angle\")\n",
        "    angleC = 90\n",
        "    sideA = float(input(\"Side A = \\n\"))\n",
        "    # complete this code\n",
        "\n",
        "\n",
        "# Trig ratios\n",
        "if(opt_number==\"6\"):\n",
        "    print(\"Make Angle C the right angle\")\n",
        "    angleC = 90\n",
        "    sideA = float(input(\"Side A = \\n\"))\n",
        "    # complete this code\n",
        "\n",
        "\n",
        "# Use these print statements and variables:\n",
        "print(\"Angle A = \", angleA)\n",
        "print(\"Side A = \", sideA)\n",
        "print(\"Angle B = \", angleB)\n",
        "print(\"Side B = \", sideB)\n",
        "print(\"Angle C = \", angleC)\n",
        "print(\"Side C = \", sideC)\n",
        "print(\"Area = \", area)\n",
        "\n",
        "\n",
        "# This step does not have a test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D60zGdMbJawF"
      },
      "source": [
        "#Step 27 - Sine Graphs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2LyQ6LSzJawG"
      },
      "source": [
        "The word \"sine\" comes from the word \"sinuous,\" which means \"curvy.\" You can see this pattern in the graph, where the x value is an angle measure (in radians) and `y = sin(x)`. Run the following code to see one part of a sine graph."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "siYvJ2R4JawG"
      },
      "source": [
        "import numpy as np\n",
        "import time\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "x = np.linspace(0, 7, 280)\n",
        "y = np.sin(x)\n",
        "\n",
        "figure, ax = plt.subplots(figsize=(8,6))\n",
        "plt.plot(x, y)\n",
        "plt.title(\"y = sin(x)\",fontsize=25)\n",
        "plt.xlabel(\"angle measure in radians\",fontsize=18)\n",
        "plt.ylabel(\"sin(x)\",fontsize=18)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step27()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j4cMUBfph6UQ"
      },
      "source": [
        "#Step 28 - Sine Graphs and Sound"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SjyfVYOCh6Ud"
      },
      "source": [
        "You can model music or any sound with a sine graph, using the equation `y = a*sin(b*x)`. The extra multiplier \"a\" is the amplitude (height) of the sine wave, representing volume of a sound. The \"b\" is the frequency in Hertz (waves per second), representing the pitch of the sound. Run the following code and adjust the sliders to see how \"a\" and \"b\" affect the graph. Actual sound frequencies are much higher than this graph shows."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bPZxINKIh6Ue"
      },
      "source": [
        "%matplotlib inline\n",
        "from ipywidgets import interactive\n",
        "import numpy as np\n",
        "import time\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# defining the function for the graph\n",
        "def f(a,b):\n",
        "    plt.axis([0,16,-8,8]) \n",
        "    x = np.linspace(0, 16, 640)\n",
        "    plt.plot(x, a*np.sin(b*x))\n",
        "    plt.title(\"y = a*sin(b*x)\",fontsize=16)\n",
        "    plt.show()\n",
        "\n",
        "# setting up the sliders\n",
        "interactive_plot = interactive(f, a=(1, 8), b=(1, 16))\n",
        "interactive_plot\n",
        "\n",
        "# This step does not have a test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RODnL3Lph77F"
      },
      "source": [
        "#Step 29 - Frequencies and Harmony"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G2o31djnh77F"
      },
      "source": [
        "When two frequencies occur at the same time, you add them. This produces interesting effects. You can see the harmony (regular patterns) when one frequency is twice the other frequency and no regular patterns with other factors. Run the code then change the frequencies and run it again."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H41PaFzCh77G"
      },
      "source": [
        "import numpy as np\n",
        "import time\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# change frequencies to see harmony\n",
        "frequency1 = 1\n",
        "frequency2 = 2\n",
        "\n",
        "x = np.linspace(0, 32, 512)\n",
        "y1 = np.sin(frequency1*x)\n",
        "y2 = np.sin(frequency2*x)\n",
        "title = \"Frequencies \" + str(frequency1) + \" and \" + str(frequency2)\n",
        "\n",
        "figure, ax = plt.subplots(figsize=(8,6))\n",
        "plt.plot(x, y1+y2)\n",
        "\n",
        "plt.title(title,fontsize=16)\n",
        "\n",
        "plt.xlabel(\"X\",fontsize=18)\n",
        "plt.ylabel(\"sinX\",fontsize=18)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_d as test\n",
        "test.step29()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 30 - Certification Project 4"
      ],
      "metadata": {
        "id": "RblYaSUUZKiP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Build an analog stopwatch that tics once each second. Use your knowledge of drawing shapes to create the circular face. The \"second hand\" will be a line from the center to the edge, making one complete rotation in exactly one minute. Each aspect of this project involves code already written in this section, so make use of your previous work. Hints:<br>\n",
        "<ul>\n",
        "<li>Make the coordinate (0,0) the center of the clock</li>\n",
        "<li>Use radians for the angles. Each second is $\\pi$/30 radians</li>\n",
        "<li>Draw a line from (0,0) to (x,y) and animate that line</li>\n",
        "<li>The x coordinate is r * cos(angle)</li>\n",
        "<li>The y coordinate is r * sin(angle)</li>\n",
        "<li>Use a formula for the angle so the clock doesn't run \"backwards\"</li>\n",
        "</ul>\n"
      ],
      "metadata": {
        "id": "3KfyXgJMZGMY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Write your code here\n"
      ],
      "metadata": {
        "id": "DDyisUrYZFbn"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}