Foundational-Math-2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Foundational Math 2 (Learn).ipynb",
      "provenance": [],
      "collapsed_sections": [
        "szp5flp1fA8-",
        "iNcDJ45bGtYk",
        "ZWDxpIPUFfda",
        "i1mBd8gGFvBV",
        "MYQL57cD2ejS",
        "jIHKROStFMcR",
        "wLDO_IRrFw7z",
        "ExVB2joZF0rk",
        "3MqIpFTOF1m9",
        "NKq_qwCsF3Dj",
        "wvdngkOTF4Hi",
        "Q19Wm90DF5zf",
        "YSY2k7S3F6d7",
        "ykj42UNeF7K5",
        "QSKeBTgXHRAv",
        "0epVLhL0F88U",
        "8FCFQaq1Hizh",
        "BhKPZQJZF9w0",
        "I0mklEluF-jI",
        "eFehWNexGASC",
        "WbqugasGGCKJ",
        "hN_fvENUGBAm",
        "vteEy9QFGD5I",
        "VXxx7RCVSs4j",
        "jpo7oASHGEu7",
        "pE5o0-VMaIy3",
        "D7ASvHg3b2Ph"
      ],
      "authorship_tag": "ABX9TyMgIJXFt8DsKZCyvmAbfh4p",
      "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_2_(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": "7ECUmRBSGOb4"
      },
      "source": [
        "**Learn Foundational Math 2 by Building Cartesian Graphs**<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": "iNcDJ45bGtYk"
      }
    },
    {
      "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": "2_U7sdv4zaww"
      }
    },
    {
      "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-b.py'\n",
        "r = requests.get(url)\n",
        "\n",
        "# Save the library in a local working directory \n",
        "with open('math_code_test_b.py', 'w') as f:\n",
        "    f.write(r.text)\n",
        "\n",
        "# Now you can import the library\n",
        "import math_code_test_b as test\n",
        "\n",
        "# This will tell you if the code works\n",
        "test.step01()"
      ],
      "metadata": {
        "id": "aDuDRHETG3Oy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZWDxpIPUFfda"
      },
      "source": [
        "# Step 1 - Cartesian Coordinates"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eTWzFpChFltm"
      },
      "source": [
        "Learn Cartesian coordinates by building a scatterplot game. The Cartesian plane is the classic x-y coordinate grid (invented by Ren$\\acute{e}$ DesCartes) where \"<i>x</i>\" is the horizontal axis and \"<i>y</i>\" is the vertical axis. Each (x,y) coordinate pair is a point on the graph. The point (0,0) is the \"origin.\" The x value tells how much to move right (positive) or left (negative) from the origin. The y value tells you how much you move up (positive) or down (negative) from the origin. Notice that you are importing `matplotlib` to create the graph. The following code just displays one quadrant of the Cartesian graph. Just run this code to see how Python displays a graph.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OGdjnZw0Fmf7"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.show()\n",
        "\n",
        "# Just run this code to see a blank graph\n",
        "import math_code_test_b as test\n",
        "test.step01()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i1mBd8gGFvBV"
      },
      "source": [
        "# Step 2 - Cartesian Coordinates (Part 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aylg20IGFvBW"
      },
      "source": [
        "Here you will create a standard window but still not highlight each axis. Run this code once, then change the window size to 20 in each direction and run it again."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EKfFo4_EFvBX"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "\n",
        "# Only change the numbers in the next line:\n",
        "plt.axis([-10,10,-10,10]) \n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step02(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 3 - Graph Dimensions"
      ],
      "metadata": {
        "id": "MYQL57cD2ejS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "When you look at this code, you can see how Python sets up window dimensions. You will also notice that it is easier and more organized to define the dimensions as variables. Run the code, then change just the `xmax` value to 20 and run it again to see the difference."
      ],
      "metadata": {
        "id": "b2k229tOz9YQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -10\n",
        "ymax = 10\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.show()\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step03(In[-1].split('# Only change code above this line')[0])"
      ],
      "metadata": {
        "id": "uXvHo-5a2Zi_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 4 - Displaying Axis Lines"
      ],
      "metadata": {
        "id": "jIHKROStFMcR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice the code to `plot` a line for the x axis and a line for the y axis. The `'b'` makes the line blue. Run the code, then change each 'b' to 'g' to make the lines green. "
      ],
      "metadata": {
        "id": "NhrHvY1YEndp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -10\n",
        "ymax = 10\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "plt.show()\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step04(In[-1].split('# Only change code above this line')[0])"
      ],
      "metadata": {
        "id": "mgWhRLtwFGOd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wLDO_IRrFw7z"
      },
      "source": [
        "# Step 5 - Plotting a Point"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iOZ8TJISFw71"
      },
      "source": [
        "Now you will plot a point on the graph. Notice the `'ro'` makes the point a red dot. Run the code, then change the location of the point to (-5,1) and run it again. Keep the window size the same. Notice the difference between plotting a point and plotting a line."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N09NlV3DFw71"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -10\n",
        "ymax = 10\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "# Change only the numbers in the following line:\n",
        "plt.plot([5],[4], 'ro')\n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step05(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ExVB2joZF0rk"
      },
      "source": [
        "# Step 6 - Plotting Several Points"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G48kO0jcF0rl"
      },
      "source": [
        "You have actually been using arrays to plot each singular point so far. In this step, you will see an array of x values and an array of y values defined before the plot statement. Notice that these two short arrays create one point: (4,2). Add two numbers to each array so that it also plots points (1,1) and (2,5)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YkRIMNimF0rm"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# only change the next two lines:\n",
        "x = [4]\n",
        "y = [2]\n",
        "\n",
        "# Only change code above this line\n",
        "\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -10\n",
        "ymax = 10\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax],'b') # blue y axis\n",
        "\n",
        "plt.plot(x, y, 'ro') # red points\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step06(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3MqIpFTOF1m9"
      },
      "source": [
        "# Step 7 - Plotting Points and Lines"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1O1_p4BqF1m-"
      },
      "source": [
        "Notice the subtle difference between plotting points and lines. Each `plot()` statement takes an array of x values, an array of y values, and a third argument to tell what you are plotting. The default plot is a line. The letters `'r'` and `'b'` (and `'g'` and a few others) indicate common colors. The \"o\" in `'ro'` indicates a dot, where `'rs'` would indicate a red square and `'r^'` would indicate a red triangle. Plot a red line and two green squares. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oMRcOD7hF1m-"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Use these numbers:\n",
        "linex = [2,4]\n",
        "liney = [1,5]\n",
        "pointx = [1,6]\n",
        "pointy = [6,3]\n",
        "\n",
        "# Keep these lines:\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -10\n",
        "ymax = 10\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "# Change the next two lines:\n",
        "plt.plot()\n",
        "plt.plot()\n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step07(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NKq_qwCsF3Dj"
      },
      "source": [
        "# Step 8 - Making a Scatterplot Game"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sBh-rNyOF3Dk"
      },
      "source": [
        "To make the game, you can make a loop that plots a random point and asks the user to input the (x,y) coordinates. Notice the `for` loop that runs three rounds of the game. Run the code, play the game, then you can go on to the next step."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uR5TFWbLF3Dk"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "\n",
        "score = 0\n",
        "\n",
        "xmin = -8\n",
        "xmax = 8\n",
        "ymin = -8\n",
        "ymax = 8\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "\n",
        "for i in range(0,3):\n",
        "    xpoint = random.randint(xmin, xmax)\n",
        "    ypoint = random.randint(ymin, ymax)\n",
        "    x = [xpoint]  \n",
        "    y = [ypoint]\n",
        "    plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "    plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "    plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "    plt.plot(x, y, 'ro')\n",
        "    print(\" \")\n",
        "    plt.grid() # displays grid lines on graph\n",
        "    plt.show()\n",
        "    guess = input(\"Enter the coordinates of the red point point: \\n\")\n",
        "    guess_array = guess.split(\",\")\n",
        "    xguess = int(guess_array[0])\n",
        "    yguess = int(guess_array[1])\n",
        "    if xguess == xpoint and yguess == ypoint:\n",
        "        score = score + 1\n",
        "    \n",
        "print(\"Your score: \", score) # notice this is not in the loop\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step08(score)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wvdngkOTF4Hi"
      },
      "source": [
        "# Step 9 - Graphing Linear Equations"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fTzBZAmtF4Hj"
      },
      "source": [
        "Besides graphing points, you can graph <i>linear equations</i> (or <i>functions</i>). The graph will be a straight line, and the equation will not have any exponents. For these graphs, you will import `numpy` and use the `linspace()` function to define the x values. That function takes three arguments: starting number, ending number, and number of steps. Notice the `plot()` function only has two arguments: the x values and a function (y = 2x - 3) for the y values. Run this code, then use the same x values to graph `y = -x + 3`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xJ0pkcFsF4Hj"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -10\n",
        "ymax = 10\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "x = np.linspace(-9,9,36) \n",
        "\n",
        "# Only change the next line to graph y = -x + 3\n",
        "plt.plot(x, 2*x - 3)\n",
        "\n",
        "\n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step09(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q19Wm90DF5zf"
      },
      "source": [
        "# Step 10 - Creating Interactive Graphs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JNEjD9DxF5zh"
      },
      "source": [
        "Like the previous graphs, you will graph a line. This time, you will create two sliders to change the <i>slope</i> and the <i>y intecept</i>. Notice the additional imports and other changes: You define a function with two arguments. All of the graphing happens within that `f(m,b)` function. The `interactive()` function calls your defined function and sets the boundaries for the sliders. Run this code then adjust the sliders and notice how they affect the graph."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9lh41CENF5zh"
      },
      "source": [
        "%matplotlib inline\n",
        "from ipywidgets import interactive\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Define the graphing function\n",
        "def f(m, b):\n",
        "    xmin = -10\n",
        "    xmax = 10\n",
        "    ymin = -10\n",
        "    ymax = 10\n",
        "    plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "    plt.plot([xmin,xmax],[0,0],'black') # black x axis\n",
        "    plt.plot([0,0],[ymin,ymax], 'black') # black y axis\n",
        "    plt.title('y = mx + b')\n",
        "    x = np.linspace(-10, 10, 1000)\n",
        "    plt.plot(x, m*x+b)\n",
        "    plt.show()\n",
        "\n",
        "# Set up the sliders\n",
        "interactive_plot = interactive(f, m=(-9, 9), b=(-9, 9))\n",
        "interactive_plot\n",
        "\n",
        "\n",
        "# Just run this code and use the sliders\n",
        "import math_code_test_b as test\n",
        "test.step01()\n",
        "interactive_plot"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YSY2k7S3F6d7"
      },
      "source": [
        "# Step 11 - Graphing Systems"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8MG28-VPF6d8"
      },
      "source": [
        "When you graph two equations on the same coordinate plane, they are a <i>system of equations</i>. Notice how the `points` variable defines the number of points and the `linspace()` function uses that variable. Run this code to see the graph, then change `y2` so that it graphs y = -x - 3."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wYHGm-PAF6d9"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -10\n",
        "ymax = 10\n",
        "points = 2*(xmax-xmin)\n",
        "\n",
        "# Define the x values once\n",
        "x = np.linspace(xmin,xmax,points)\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "# line 1\n",
        "y1 = 2*x\n",
        "plt.plot(x, y1)\n",
        "\n",
        "# line 2\n",
        "y2 = x**2 - 3\n",
        "plt.plot(x, y2)\n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step11(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ykj42UNeF7K5"
      },
      "source": [
        "# Step 12 - Systems of Equations - Algebra"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n_-rpo6nF7K7"
      },
      "source": [
        "In a system of equations, the solution is the point where the two equations intersect, the (x,y) values that work in each equation. To work with algabraic expressions, you will import `sympy` and define x and y as symbols. If you have two equations and two variables, set each equation equal to zero. The `linsolve()` function takes the non-zero side of each equation and the variables used. Notice the syntax. Run the code, then change the two equations to solve 2x + y - 15 = 0 and 3x - y = 0."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6dFzZfqRF7K7"
      },
      "source": [
        "from sympy import *\n",
        "x,y = symbols('x y')\n",
        "\n",
        "\n",
        "# Change the equations in the following line: \n",
        "print(linsolve([2*x + y - 1, x - 2*y + 7], (x, y)))\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step12(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 13 - Solutions as Coordinates"
      ],
      "metadata": {
        "id": "QSKeBTgXHRAv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `linsolve()` function returns a <i>finite set</i>, and you can convert that \"finite set\" into (x,y) coordinates. Notice how the code parses the `solution` variable into two separate variables. Just run the code to see how this works."
      ],
      "metadata": {
        "id": "D2Ca3L-fHCzi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sympy import *\n",
        "x,y = symbols('x y')\n",
        "\n",
        "# Use variables for each equation\n",
        "first = x + y\n",
        "second = x - y\n",
        "\n",
        "# parse finite set answer as coordinate pair\n",
        "solution = linsolve([first, second], (x, y))\n",
        "x_solution = solution.args[0][0]\n",
        "y_solution = solution.args[0][1]\n",
        "\n",
        "print(\"x = \", x_solution)\n",
        "print(\"y = \", y_solution)\n",
        "print(\" \")\n",
        "print(\"Solution: (\",x_solution,\",\",y_solution,\")\")\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_b as test\n",
        "test.step01()"
      ],
      "metadata": {
        "id": "7uhBD85SHK3S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0epVLhL0F88U"
      },
      "source": [
        "# Step 14 - Systems from User Input"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VhoI5uNrF88V"
      },
      "source": [
        "For more flexibility, you can get each equation as user input (instead of defining them in the code). Run this code and try it out - to solve any system of two equations."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8irtXhucF88W"
      },
      "source": [
        "from sympy import *\n",
        "\n",
        "x,y = symbols('x y')\n",
        "print(\"Remember to use Python syntax with x and y as variables\")\n",
        "print(\"Notice how each equation is already set equal to zero\")\n",
        "first = input(\"Enter the first equation: 0 = \")\n",
        "second = input(\"Enter the second equation: 0 = \")\n",
        "solution = linsolve([first, second], (x, y))\n",
        "x_solution = solution.args[0][0]\n",
        "y_solution = solution.args[0][1]\n",
        "\n",
        "print(\"x = \", x_solution)\n",
        "print(\"y = \", y_solution)\n",
        "\n",
        "\n",
        "# Just run this code and test it with different equations\n",
        "import math_code_test_b as test\n",
        "test.step14()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 15 - Solve and graph a system"
      ],
      "metadata": {
        "id": "8FCFQaq1Hizh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now you can put it all together: solve a system of equations, graph the system, and plot a point where the two lines intersect. Notice how this code is not like the previous solving equations code or the graphing code or the user input code. Python uses `sympy` to get the (x,y) solution and `numpy` to get the values to graph, so the user inputs nummerical values and the code uses them in two different ways. Think about how you would do this if the user input values for ax + by = c."
      ],
      "metadata": {
        "id": "wMwKLQvyHaWp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sympy import *\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "print(\"First equation: y = mx + b\")\n",
        "mb_1 = input(\"Enter m and b, separated by a comma: \")\n",
        "mb_in1 = mb_1.split(\",\")\n",
        "m1 = float(mb_in1[0])\n",
        "b1 = float(mb_in1[1])\n",
        "\n",
        "print(\"Second equation: y = mx + b\")\n",
        "mb_2 = input(\"Enter m and b, separated by a comma: \")\n",
        "mb_in2 = mb_2.split(\",\")\n",
        "m2 = float(mb_in2[0])\n",
        "b2 = float(mb_in2[1])\n",
        "\n",
        "# Solve the system of equations\n",
        "x,y = symbols('x y')\n",
        "first = m1*x + b1 - y\n",
        "second = m2*x + b2 - y \n",
        "solution = linsolve([first, second], (x, y))\n",
        "x_solution = round(float(solution.args[0][0]),3)\n",
        "y_solution = round(float(solution.args[0][1]),3)\n",
        "\n",
        "# Make sure the window includes the solution\n",
        "xmin = int(x_solution) - 20\n",
        "xmax = int(x_solution) + 20\n",
        "ymin = int(y_solution) - 20\n",
        "ymax = int(y_solution) + 20\n",
        "points = 2*(xmax-xmin)\n",
        "\n",
        "# Define the x values once for the graph\n",
        "graph_x = np.linspace(xmin,xmax,points)\n",
        "\n",
        "# Define the y values for the graph\n",
        "y1 = m1*graph_x + b1\n",
        "y2 = m2*graph_x + b2\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "# line 1\n",
        "plt.plot(graph_x, y1)\n",
        "\n",
        "# line 2\n",
        "plt.plot(graph_x, y2)\n",
        "\n",
        "# point\n",
        "plt.plot([x_solution],[y_solution],'ro')\n",
        "\n",
        "plt.show()\n",
        "print(\" \")\n",
        "print(\"Solution: (\", x_solution, \",\", y_solution, \")\")\n",
        "\n",
        "\n",
        "# Run this code and test it with different equations\n"
      ],
      "metadata": {
        "id": "wLBNm5j6HffY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BhKPZQJZF9w0"
      },
      "source": [
        "# Step 16 - Quadratic Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BYmD2FYHF9w1"
      },
      "source": [
        "Any function that involves x<sup>2</sup> is a \"quadratic\" function because \"x squared\" could be the area of a square. The graph is a parabola. The formula is y = ax<sup>2</sup> + bx + c, where `b` and `c` can be zero but `a` has to be a number. Here is a graph of the simplest parabola. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sfQl_A1CF9w1"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -10\n",
        "ymax = 10\n",
        "points = 2*(xmax-xmin)\n",
        "x = np.linspace(xmin,xmax,points)\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "y = x**2\n",
        "\n",
        "plt.plot(x,y)\n",
        "plt.show()\n",
        "\n",
        "# Just run this code. The next step will transform the graph\n",
        "import math_code_test_b as test\n",
        "test.step01()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I0mklEluF-jI"
      },
      "source": [
        "# Step 17 - Quadratic Function ABC's"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AJuHf8ySF-jJ"
      },
      "source": [
        "Using the parabola formula y = ax<sup>2</sup> + bx + c, you will change the values of `a`, `b`, and `c` to see how they affect the graph. Run the code and use the sliders to change the values of `a` and `b`. Then change the code in the three places indicated to add a slider for `c`. You may remember this type of interactive graph from an earlier step. Move each slider to see how it affects the graph."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9IVFnXxVF-jJ"
      },
      "source": [
        "%matplotlib inline\n",
        "from ipywidgets import interactive\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Change the next line to include c:\n",
        "def f(a,b):\n",
        "    plt.axis([-10,10,-10,10]) # window size\n",
        "    plt.plot([-10,10],[0,0],'k') # blue x axis\n",
        "    plt.plot([0,0],[-10,10], 'k') # blue y axis\n",
        "    x = np.linspace(-10, 10, 1000)\n",
        "\n",
        "    # Change the next line to add c to the end of the function:\n",
        "    plt.plot(x, a*x**2 + b*x)\n",
        "    plt.show()\n",
        "\n",
        "# Change the next line to add a slider to change the c value\n",
        "interactive_plot = interactive(f, a=(-9, 9), b=(-9,9))\n",
        "interactive_plot\n",
        "\n",
        "\n",
        "# Run the code once, then change the code and run it again\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step17(In[-1].split('# Only change code above this line')[0])\n",
        "interactive_plot"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eFehWNexGASC"
      },
      "source": [
        "# Step 18 - Quadratic Functions - Vertex"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p8hAZw_CGASD"
      },
      "source": [
        "The <i>vertex</i> is the point where the parabola turns around. The x value of the vertex is $\\frac{-b}{2a}$ (and then you would calculate the y value to get the point). Write the code to find the vertex, given `a`, `b`, and `c` as inputs. Remember the parabola forumula is y = ax<sup>2</sup> + bx + c"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cjMI5uZZGASD"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# \\u00b2 prints 2 as an exponent\n",
        "print(\"y = ax\\u00b2 + bx + c\")\n",
        "\n",
        "a = float(input(\"a = \"))\n",
        "b = float(input(\"b = \"))\n",
        "c = float(input(\"c = \"))\n",
        "\n",
        "# Write your code here, changing vx and vy\n",
        "vx = 0\n",
        "vy = 0\n",
        "\n",
        "\n",
        "# Only change the code above this line\n",
        "\n",
        "print(\" (\", vx, \" , \", vy, \")\")\n",
        "print(\" \")\n",
        "\n",
        "xmin = int(vx)-10\n",
        "xmax = int(vx)+10\n",
        "ymin = int(vy)-10\n",
        "ymax = int(vy)+10\n",
        "points = 2*(xmax-xmin)\n",
        "x = np.linspace(xmin,xmax,points)\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "plt.plot([vx],[vy],'ro') # vertex\n",
        "\n",
        "x = np.linspace(vx-10,vx+10,100) \n",
        "y = a*x**2 + b*x + c\n",
        "plt.plot(x,y)\n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step18(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WbqugasGGCKJ"
      },
      "source": [
        "# Step 19 - Projectile Motion"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TtM_pFHaGCKK"
      },
      "source": [
        "The path of every projectile is a parabola. For something thrown or launched upward, the `a` value is -4.9 (meters per second squared); the `b` value is the initial velocity (in meters per second); the `c` value is the initial height (in meters); the `x` value is time (in seconds); and the `y` value is the height at that time. In this code, change `vx` and `vy` to represent the vertex. Plotting that (x,y) vertex point is already in the code."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FTNV_bjuGCKL"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "a = -4.9\n",
        "b = float(input(\"Initial velocity = \"))\n",
        "c = float(input(\"Initial height = \"))\n",
        "\n",
        "# Change vx and vy to represent the vertex\n",
        "vx = 0\n",
        "vy = 0\n",
        "\n",
        "\n",
        "# Also change the following dimensions to display the vertex\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -10\n",
        "ymax = 10\n",
        "\n",
        "# You do not need to change anything below this line\n",
        "points = 2*(xmax-xmin)\n",
        "x = np.linspace(xmin,xmax,points)\n",
        "y = a*x**2 + b*x + c\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "plt.plot(x,y) # plot the line for the equation\n",
        "plt.plot([vx],[vy],'ro') # plot the vertex point\n",
        "\n",
        "print(\" (\", vx, \",\", vy, \")\")\n",
        "print(\" \")\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step19(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hN_fvENUGBAm"
      },
      "source": [
        "# Step 20 - Quadratic Functions - C"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GrJNli5pGBAn"
      },
      "source": [
        "Like many other functions, the `c` value (also called the \"constant\" because it is not a variable) affects the vertical shift of the graph. Run the following code to see how changing the `c` value changes the graph."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hiSN0VexGBAn"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import time\n",
        "from IPython import display\n",
        "\n",
        "x = np.linspace(-4,4,16) \n",
        "fig, ax = plt.subplots()\n",
        "cvalue = \"c = \"\n",
        "\n",
        "for c in range(10):\n",
        "    y = -x**2+c\n",
        "    plt.plot(x,y)\n",
        "    cvalue = \"c = \", c\n",
        "    ax.set_title(cvalue)\n",
        "    display.display(plt.gcf())\n",
        "    time.sleep(0.5)\n",
        "    display.clear_output(wait=True)\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_b as test\n",
        "test.step01()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vteEy9QFGD5I"
      },
      "source": [
        "# Step 21 - The Quadratic Formula"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xALyhEsNGD5J"
      },
      "source": [
        "For a projectile, you also need to find the point when it hits the ground. On a graph, you would call these points the \"roots\" or \"x intercepts\" or \"zeros\" (because y = 0 at these points). The <i>quadratic formula</i> gives you the x value when y = 0. Given `a`,`b` and `c`, here is the quadratic formula:<br> x = $\\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}$ Notice it's the vertex plus or minus something: $\\frac{-b}{2a} + \\frac{\\sqrt{b^2 - 4ac}}{2a}$ and $\\frac{-b}{2a} - \\frac{\\sqrt{b^2 - 4ac}}{2a}$ <br>\n",
        "Write the code to output two x values, given a, b, and c as input. Use `math.sqrt()` for the square root."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R3OIh1pOGD5K"
      },
      "source": [
        "import math\n",
        "\n",
        "# \\u00b2 prints 2 as an exponent\n",
        "print(\"0 = ax\\u00b2 + bx + c\")\n",
        "a = float(input(\"a = \"))\n",
        "b = float(input(\"b = \"))\n",
        "c = float(input(\"c = \"))\n",
        "x1 = 0\n",
        "x2 = 0\n",
        "\n",
        "# Check for non-real answers:\n",
        "if b**2-4*a*c < 0:\n",
        "    print(\"No real roots\")\n",
        "else:\n",
        "    # Write your code here, changing x1 and x2\n",
        "    x1 = 0\n",
        "    x2 = 0\n",
        "    print(\"The roots are \", x1, \" and \", x2)\n",
        "\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step21(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VXxx7RCVSs4j"
      },
      "source": [
        "# Step 22 - Table of Values"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Bd8bgPISiRH"
      },
      "source": [
        "In addition to graphing a function, you may need a table of values. This code shows how to make a simple table of (x,y) values. Run the code, then change the title to \"y = 3x + 2\" and change the function in the table. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e4dBSioJGGd3"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "ax = plt.subplot()\n",
        "ax.set_axis_off()\n",
        "title = \"y = 2x\" # Change this title\n",
        "cols = ('x', 'y')\n",
        "rows = []\n",
        "for a in range(1,10):\n",
        "    rows.append([a, 2*a]) # Change only the function in this line\n",
        "    \n",
        "ax.set_title(title) \n",
        "plt.table(cellText=rows, colLabels=cols, cellLoc='center', loc='upper left')\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_b as test\n",
        "test.step22(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jpo7oASHGEu7"
      },
      "source": [
        "# Step 23 - Projectile Game"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WHx9faGkGEu7"
      },
      "source": [
        "Learn quadratic functions by building a projectile game. Starting at (0,0) you launch a toy rocket that must clear a wall. You can randomize the height and location of the wall. The goal is to determine what initial velocity would get the rocket over the wall. Bonus: make an animation of the path of the rocket.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-yFfSgoeWHN3"
      },
      "source": [
        "# Write your code here\n",
        "\n",
        "\n",
        "# This step does not have a test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 24 - Define Graphing Functions"
      ],
      "metadata": {
        "id": "pE5o0-VMaIy3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Building on what you have already done, create a menu with the following options:<br>\n",
        "<ul>\n",
        "<li>Display the graph and a table of values for any \"y=\" equation input</li>\n",
        "<li>Solve a system of two equations without graphing</li>\n",
        "<li>Graph two equations and plot the point of intersection</li>\n",
        "<li>Given a, b and c in a quadratic equation, plot the roots and vertex</li>\n",
        "</ul>\n",
        "Then think about how you will define a function for each item."
      ],
      "metadata": {
        "id": "c5tXoITnag_P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Write your code here\n",
        "\n",
        "\n",
        "# This step does not have a test"
      ],
      "metadata": {
        "id": "lvuStaKYalPo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 25 - Certification Project 2"
      ],
      "metadata": {
        "id": "D7ASvHg3b2Ph"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Build a graphing calculator that performs the functions mentioned in the previous step:\n",
        "<ul>\n",
        "<li>Display the graph and a table of values for any \"y=\" equation input</li>\n",
        "<li>Solve a system of two equations without graphing</li>\n",
        "<li>Graph two equations and plot the point of intersection</li>\n",
        "<li>Given a, b and c in a quadratic equation, plot the roots and vertex</li>\n",
        "</ul>\n",
        "Define each of the functions, and make each option call a function."
      ],
      "metadata": {
        "id": "KBcTUf08cRy1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Write your code here\n",
        "\n",
        "\n",
        "# This step does not have a test"
      ],
      "metadata": {
        "id": "bmuz1zCecVCX"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}