Foundational-Math-3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Foundational Math 3 (Learn).ipynb",
      "provenance": [],
      "collapsed_sections": [
        "szp5flp1fA8-",
        "KDloBuvnHQTS",
        "r1AM-AcqkbyF",
        "8wXbGsoYkm60",
        "tBxuJtHck2Oo",
        "s3z_zaNWlet8",
        "yoavB8H_ljVn",
        "MlRfYVIylkQf",
        "NGH1FcttllvS",
        "Sx0kwIdalmmY",
        "S-DVSzwDvKvE",
        "H6LTAPYplxvi",
        "iaEBltZXln-Q",
        "l5GwlqRdlpEu",
        "8vdTo36Pl0yv",
        "U_7bv7aG4UJe",
        "B7DOz9nh4XAb",
        "cqvLtj7t4VMN",
        "GsLj1NhZl1ya",
        "d7Lc9KfMYU8Y",
        "VkD30ljxlyw9",
        "bJzxcKIfz8Qt",
        "8iWUAktvPLYp",
        "rzaQj8dEOfzb",
        "UptjjiCOTSS2",
        "CRa5i8s3UCuL"
      ],
      "authorship_tag": "ABX9TyOtNETEbd5KmOY6z+1ReD6+",
      "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_3_(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": "57mlyO58UfN0"
      },
      "source": [
        "**Learn Foundational Math 3 by Building a Financial App**<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": "KDloBuvnHQTS"
      }
    },
    {
      "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": "JiW6TlNezZKS"
      }
    },
    {
      "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-c.py'\n",
        "r = requests.get(url)\n",
        "\n",
        "# Save the library in a local working directory \n",
        "with open('math_code_test_c.py', 'w') as f:\n",
        "    f.write(r.text)\n",
        "\n",
        "# Now you can import the library\n",
        "import math_code_test_c as test\n",
        "\n",
        "# This will tell you if the code works\n",
        "test.step00()"
      ],
      "metadata": {
        "id": "eTlHceacGa1C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r1AM-AcqkbyF"
      },
      "source": [
        "# Step 1 - Graphing Inequalities"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K8rdL_OEkd-t"
      },
      "source": [
        "Learn Inequalities by Building Shaded Graphs. Notice how you set up the plot, like you learned in the last certification. Run the following code and you will see that the graph of y <u>></u> 2x is not quite right. Because y is greater, the shading should be above the line. The second two arguments in the `fill_between()` function give a range of y values to shade. Change just that part of the code to make the graph correct. (Hint: Think about the top of the graph.)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QAVgVP3xUd4J"
      },
      "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",
        "plt.title(\"y > 2x\")\n",
        " \n",
        "y1 = 2*x\n",
        "plt.plot(x, y1)\n",
        "\n",
        "# Only change code below this line\n",
        "plt.fill_between(x, y1, 0)\n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step01(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8wXbGsoYkm60"
      },
      "source": [
        "# Step 2 - Graphing inequalities - Part 2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ehY1G02Dkv7r"
      },
      "source": [
        "The default graph will give you a solid line, but you can change the type of line and the color. As `'b'` is for a solid blue line, `'b--'` will be a dashed blue line and `'r--'` will display a dashed red line. Change the code to graph a dashed red line. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Pp_SmUikwgy"
      },
      "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",
        "y1 = 2*x\n",
        "\n",
        "# Only change the next line:\n",
        "plt.plot(x, y1)\n",
        "\n",
        "plt.fill_between(x, y1, ymin)\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step02(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tBxuJtHck2Oo"
      },
      "source": [
        "# Step 3 - Making Art with Graphs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PTr63nCrlTiM"
      },
      "source": [
        "Now plot four inequalities on the graph, in a pattern. Notice how you only need to define the x values once. In the `fill_between()` function notice a fourth argument, `facecolor=`, to indicate a different color for the shaded area. The color name in single quotes, like 'green' or 'yellow' or any common color name. Run the code to see the pattern, then reverse the order of the colors and run it again."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Iyoq1h3vlV-a"
      },
      "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",
        "# Only change the lines indicated below\n",
        "\n",
        "# line 1\n",
        "y1 = x+6\n",
        "plt.plot(x, y1)\n",
        "plt.fill_between(x, y1, 10, facecolor='red') # change this line\n",
        "\n",
        "# line 2\n",
        "y2 = x+3\n",
        "plt.plot(x, y2)\n",
        "plt.fill_between(x, y2, y1, facecolor='yellow') # change this line\n",
        "\n",
        "# line 3\n",
        "y3 = x-1\n",
        "plt.plot(x, y3)\n",
        "plt.fill_between(x, y3, y2, facecolor='green') # change this line\n",
        "\n",
        "# line 4\n",
        "y4 = x-4\n",
        "plt.plot(x, y4)\n",
        "plt.fill_between(x, y4, y3, facecolor='blue') # change this line\n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step03(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s3z_zaNWlet8"
      },
      "source": [
        "# Step 4 - Monomials"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BTOGQIpElet-"
      },
      "source": [
        "A <i>monomial</i> means \"one thing\" or one term. In a math equation, each term has a sign, a coefficient, and a variable to an exponent. Here are some examples: In the term -3x<sup>2</sup> you can see that the sign is negative, the coefficient is 3, the variable is x, the exponent is 2. The term x also has all of these parts: the sign is positive, the coefficient is 1, the variable is x, and the exponent is 1. In the term 5, the sign is positive, the coefficient is 5, the variable is still x, and the exponent is zero (notice that you don't need to write some of these parts, like x<sup>0</sup>). You can use `sympy` to display monomials nicely. Just run the code to see how this looks.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oAPKmzeblet_"
      },
      "source": [
        "from sympy import symbols, Eq\n",
        "\n",
        "x = symbols('x')\n",
        "eq1 = Eq(-2*x**3 , -16)\n",
        "display(eq1)\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_c as test\n",
        "test.step00()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lnP9BOpPlhdK"
      },
      "source": [
        "# Step 5 - Polynomials"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ABF6PI7TlhdL"
      },
      "source": [
        "A \"monomial\" is one thing. A \"binomial\" is two things. A \"trinomial\" is three things. A \"polynomial\" is many things. In standard form, `x` is the variable; you put your terms in order from highest exponent to lowest; refer to the coefficients with letters in alphabetical order; and set all of this equal to `y` (because it is a function that you can graph). Example: y = ax<sup>4</sup> + bx<sup>3</sup> + cx<sup>2</sup> + dx + e <br>\n",
        "Write code to prompt for integer input and display a polynomial. Remember to use the `**` for exponents. Parts of this are already done for you."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "USVAJRualhdL"
      },
      "source": [
        "from IPython.display import display, Math\n",
        "from sympy import *\n",
        "\n",
        "x,y = symbols('x y')\n",
        "\n",
        "a = int(input(\"Enter coefficient A: \"))\n",
        "b = int(input(\"Enter coefficient B: \"))\n",
        "# continue this to prompt for variables c and d\n",
        "\n",
        "# change the next line to display the full polynomial\n",
        "y = a*x**3 + b*x**2 \n",
        "\n",
        "print(\"Here is your equation:\")\n",
        "display(Math(\"y = \" + latex(y)))\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step05(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yoavB8H_ljVn"
      },
      "source": [
        "# Step 6 - Interactive Polynomial Graph"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3yk-TKO6ljVo"
      },
      "source": [
        "For this polynomial, y = ax<sup>2</sup> + bx + c, you can move the sliders to adjust the coefficients and see how that affects the graph. Notice how the `f()` function takes two arguments and the `interactive()` function defines two sliders. Run this code and interact with it. Then add the third coefficient (\"c\") by changing three things: the `def` line so that the function takes three arguments, the `plt.plot` line so that it includes \"+ c\", and the `interactive` line to include a third slider."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sOecWXLOljVo"
      },
      "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:\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, 200)\n",
        "    plt.plot(x, a*x**2+b*x) # Change this line\n",
        "    plt.show()\n",
        "\n",
        "# Change the next line:\n",
        "interactive_plot = interactive(f, a=(-9, 9), b=(-9, 9))\n",
        "display(interactive_plot)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step06(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MlRfYVIylkQf"
      },
      "source": [
        "# Step 7 - Exponential Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H16dtXc0lkQg"
      },
      "source": [
        "The general formula for an `exponential function` is $y = a*b^{x}$ (where `a` and `b` are constants and `x` is the variable in the exponent). The shape of exponential graphs, especially when not drawn to scale, are very consistent, so the numerical values are more important to calculate. Things that grow exponentially include populations, investments, and other \"percent increase\" situations. Run this code and use the sliders to see the slight changes. Notice the scale. Then change the slider so that `a` has negative values from -9 to -1 and see how that changes the graph."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8KIMFu7LlkQg"
      },
      "source": [
        "%matplotlib inline\n",
        "from ipywidgets import interactive\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -100\n",
        "ymax = 100\n",
        "\n",
        "def f(a, b):\n",
        "    plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "    plt.plot([xmin,xmax],[0,0],'k') # x axis\n",
        "    plt.plot([0,0],[ymin,ymax], 'k') # y axis\n",
        "    x = np.linspace(xmin, xmax, 1000)\n",
        "    plt.plot(x, a*b**x)\n",
        "    plt.show()\n",
        "\n",
        "# Only change the next line:\n",
        "interactive_plot = interactive(f, a=(1, 9), b=(1, 9))\n",
        "display(interactive_plot)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step07(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NGH1FcttllvS"
      },
      "source": [
        "# Step 8 - Percent Increase"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KLKYiioGllvT"
      },
      "source": [
        "One formula for calculating a percent increase is <b>A = P(1 + r)<sup>t</sup></b> where `A` would be the `y` value on a graph and `t` would be the `x` value. `A` is the <i>annuity</i>, which is the amount you have at the end. `P` is the <i>principle</i>, which is the amount you have at the beginning. `R` (usually not capitalized) is the <i>rate</i>, a percent converted to a decimal. The exponent `t` represents <i>time</i>, usually in years. The code already prompts for `P`, `r` and `t`, so use those variables to calculate the annuity value. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vkp6zmxIllvT"
      },
      "source": [
        "p = float(input(\"Starting amount = \"))\n",
        "r = float(input(\"Enter the percentage rate, converted to a decimal: \"))\n",
        "t = float(input(\"How many years will this investment grow? \"))\n",
        "\n",
        "# Change the next line to calculate the annuity\n",
        "a = 0\n",
        "\n",
        "print(\"The annuity is \", a)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step08(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sx0kwIdalmmY"
      },
      "source": [
        "# Step 9 - Percent Decrease"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wx7fXQDKlmmZ"
      },
      "source": [
        "The percent decrease formula is very similar, except you subtract the rate, so the formula is <b>A = P(1 - r)<sup>t</sup></b>. Some things that decrease by a percent include car values, decay of some elements, and sales discounts. Use the existing variables to calculate the final value (`a`). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zJmQoa6YlmmZ"
      },
      "source": [
        "p = float(input(\"Starting amount = \"))\n",
        "r = float(input(\"Enter the percentage rate, converted to a decimal: \"))\n",
        "t = float(input(\"How many years will this decrease continue? \"))\n",
        "\n",
        "# Change the next line to calculate the final amount\n",
        "a = 0\n",
        "\n",
        "print(\"The final amount is \", a)\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step09(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Step 10 - Compound Interest"
      ],
      "metadata": {
        "id": "S-DVSzwDvKvE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "When you use percent increase formulas for money in the bank, it's called <i>compound interest</i>. The amount of money you earn beyond the original principle is the interest. When the bank calculates the interest and adds it to the principle, that process is called <i>compounding</i> and it can happen any number of times per year. The formula is <b> A = P(1 + $\\frac{r}{n}$)<sup>nt</sup></b> where <i>n</i> is the number of times the bank compounds the money per year. Notice that if n = 1 then this formula is the same as the formula from an earlier step. Write the code to calculate the annuity (hint: use extra parentheses). "
      ],
      "metadata": {
        "id": "qf181QFOvCgd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "p = float(input(\"Starting amount: \"))\n",
        "r = float(input(\"Percentage rate, converted to a decimal: \"))\n",
        "t = float(input(\"Number of years this investment will grow: \"))\n",
        "n = int(input(\"Number of times compounded per year: \"))\n",
        "\n",
        "# Change the next line to calculate the annuity\n",
        "annuity = 0\n",
        "\n",
        "print(\"The annuity is \", annuity)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step10(In[-1].split('# Only change code above this line')[0])"
      ],
      "metadata": {
        "id": "O0FAXixVvGXh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H6LTAPYplxvi"
      },
      "source": [
        "# Step 11 - Continuous Growth"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5oRPxD6olxvi"
      },
      "source": [
        "In the first formula, A = P(1 + r)<sup>t</sup>, money is compounded annually.<br>\n",
        "In the second formula, A = P(1 + $\\frac{r}{n})^{nt}$, money is compounded `n` times per year.<br>\n",
        "As `n` gets to be a really big number, you get a different formula, A = Pe$^{rt}$, for continuous growth.<br>\n",
        "In this formula, `e` is a constant, about equal to 2.718281828. The following code already prompts for the four variables once. Use those variables to compare the annuity from the three formulas. Notice you need to `import math` to use `math.e` (the best approximation of e)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kf3Q0Yg7lxvk"
      },
      "source": [
        "import math\n",
        "\n",
        "p = float(input(\"Principle: \"))\n",
        "r = float(input(\"Rate: \"))\n",
        "t = int(input(\"Time: \"))\n",
        "n = int(input(\"N: \"))\n",
        "\n",
        "# Only change the following three formulas:\n",
        "a_annual = 0\n",
        "a_n_times = 0\n",
        "a_continuous = 0 # use math.e in this formula\n",
        "\n",
        "# Only change the code above this line\n",
        "\n",
        "print(\"Compounded annually, anuity = \", a_annual)\n",
        "print(\"Compounded \", n, \"times per year, anuity = \", a_n_times)\n",
        "print(\"Compounded continuously, anuity = \", a_continuous)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step11(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iaEBltZXln-Q"
      },
      "source": [
        "# Step 12 - Investments"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you have an investment where you contrubute money every month and the value also increases by a consistent percentage, you can create a loop to calculate the accumulated value. In each iteration, use the <i>simple interest</i> formula: interest = principle * rate * time. (Hint: for one month, t = $\\frac{1}{12}$ or you can just divide by 12.)"
      ],
      "metadata": {
        "id": "JTQ9uZw3UeGT"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t7sRzH5Oln-R"
      },
      "source": [
        "p = float(input(\"Starting amount: \"))\n",
        "r = float(input(\"Annual percentage rate: \"))\n",
        "t = int(input(\"Number of years: \"))\n",
        "monthly = float(input(\"Monthly contribution: \"))\n",
        "\n",
        "# Hint: keep updating this annuity variable in the loop\n",
        "annuity = p \n",
        "\n",
        "# Each iteration of the loop represents one month\n",
        "for a in range(12*t):\n",
        "    annuity = annuity + monthly\n",
        "    # Change the next line to calculate the interest\n",
        "    interest = 0\n",
        "    annuity = annuity + interest\n",
        "\n",
        "# Keep this line:\n",
        "print(\"Annuity = \", annuity)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step12(p,r,t,monthly,annuity)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l5GwlqRdlpEu"
      },
      "source": [
        "# Step 13 - Mortgage Payments"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "50OH4hj8lpEv"
      },
      "source": [
        "When borrowing a large amount of money over a long period of time, the formula to calculate monthly payments gets complicated. Here it is:<br>\n",
        " monthly payment = P$\\frac{\\frac{r}{12}(1 + \\frac{r}{12})^{12t}}{(1 + \\frac{r}{12})^{12t} - 1}$ where, as usual, `P` is the principle, `r` is the annual interest rate (as a decimal), and  `t` is the time in years. Write the code to prompt for these variables and calculate the monthly payment. Hint: Use other variables and do this in steps."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E5X8_WbnlpEv"
      },
      "source": [
        "p = float(input(\"Amount borrowed: \"))\n",
        "r = float(input(\"Annual percentage rate: \"))\n",
        "t = float(input(\"Number of years: \"))\n",
        "\n",
        "# Write your code here and change the pmt variable\n",
        "\n",
        "pmt = 0\n",
        "\n",
        "\n",
        "print(\"Monthly payment = $\", pmt)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step13(p,r,t,pmt)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8vdTo36Pl0yv"
      },
      "source": [
        "# Step 14 - Exponents and Logarithms"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gyMju8CVl0yw"
      },
      "source": [
        "Exponential functions and logarithmic functions are inverses of each other. Here is an example: <b>2<sup>4</sup> = 16</b> and <b>log<sub>2</sub>16 = 4</b>. Both have the same information rearranged in different ways. If you had 2<sup>4</sup> = x you would be able to do that easily, but if you had 2<sup>x</sup> = 16 it would be more difficult. You could write that last equation as a logarithm: log<sub>2</sub>16 = x. In Python, you would write this as `math.log(16,2)`. In both cases, you would read it as \"the log, base 2, of 16\" and the answer would be an exponent. The logarithm is especially useful when the exponent is not a nice integer. Write code to prompt for the base and the result, then use loagarithms to calculate the exponent."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ehtA_ATbl0yw"
      },
      "source": [
        "import math\n",
        "\n",
        "base = float(input(\"base: \"))\n",
        "result = float(input(\"result: \"))\n",
        "\n",
        "# Just change the next line:\n",
        "exp = 0\n",
        "\n",
        "print(\"exponent = \", exp)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step14(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U_7bv7aG4UJe"
      },
      "source": [
        "# Step 15 - Natural Logs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uKjifZw04UJe"
      },
      "source": [
        "If you know the rate, how long will it take for something to double? \n",
        "Start with the continuous growth formula:<br>\n",
        "A = Pe<sup>rt</sup><br>\n",
        "If annuity is two times the principle, divide both sides by P\n",
        "and get this:<br>\n",
        "2 = e<sup>rt</sup><br>\n",
        "Because of the base <i>e</i>, take the natural log of both sides and get this:<br>\n",
        "ln(2) = rt<br>\n",
        "Then divide by r to solve for t or divide by t to solve for r. In Python, use `math.log()` with one argument and no base to calculate natural log (which is a logarithm with base e). So the natural log of 2 is `math.log(2)`. Just run the code to see this example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dM3RxByK4UJe"
      },
      "source": [
        "import math\n",
        "\n",
        "r = float(input(\"Enter the annual rate as a decimal: \\n\"))\n",
        "t = math.log(2)/r\n",
        "print(\"Your money will double in \", t, \" years\")\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_c as test\n",
        "test.step00()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B7DOz9nh4XAb"
      },
      "source": [
        "# Step 16 - Common Logs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MD3dH5yF4XAb"
      },
      "source": [
        "The <i>common log</i> is base 10, because that is our number system. Run this code a few times to see how the exponents relate to moving the decimal point to get the resulting number. Notice the floor function. Then take out the floor function to see the exact logarithm."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n390hG0GcEXI"
      },
      "source": [
        "import math\n",
        "\n",
        "n = input('Enter a number with several digits or several decimal places: ')\n",
        "n = float(n)\n",
        "\n",
        "\n",
        "# Rund the code then change the next line:\n",
        "exp = math.floor(math.log(n, 10))\n",
        "\n",
        "# This avoids a weird Python quirk:\n",
        "if n==1000:\n",
        "    exp = 3;\n",
        "\n",
        "print(\"exponent = \", exp)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step16(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cqvLtj7t4VMN"
      },
      "source": [
        "# Step 17 - Scientific Notation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-Uh4YmRt4VMN"
      },
      "source": [
        "<i>Scientific Notation</i> is a way of writing very large or very small numbers without all of the zeros or decimal places. For example, 45,000,000 could be written as 4.5 x 10<sup>7</sup> in scientific notation and 0.00000045 could be written as 4.5 x 10<sup>-7</sup>. The notation requires base 10, so it will always use the structure <b>n $*$ 10<sup>x</sup></b> where n is one digit then the decimal point. Change the code below to print each number in scientific notation. Determine the value of each variable by counting (not writing code). You will automate this process in the next step."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UyPF6dKz4VMO"
      },
      "source": [
        "a = 156000000000\n",
        "b = 0.000000000413\n",
        "\n",
        "# Change the code below this line\n",
        "\n",
        "a1 = 1.56\n",
        "a2 = 11\n",
        "b1 = 0\n",
        "b2 = 0\n",
        "\n",
        "print(a, \" = \", a1, \"* 10^\", a2) \n",
        "\n",
        "print(b, \" = \", b1, \"* 10^\", b2) \n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step17(b1,b2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GsLj1NhZl1ya"
      },
      "source": [
        "#Step 18 - Logs and Scientific Notation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uhWbIGVml1yb"
      },
      "source": [
        "Writing code for scientific notation, you will make use of logarithms with base 10. Remember that scientific notation is in the form n $*$ 10<sup>x</sup> where `n` is one digit and then a decimal. To convert a number to scientific notation, take the log of the number and use the `floor()` function to get the expoenent (just as you did in a previous step). Divide the original number by 10 to that exponent and you get `n` (hint: dividing by 10<sup>x</sup> is the same as multiplying by 10<sup>-x</sup>). Rounding is usually necessary. Write the code to convert numbers to scientific notation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y8PXrFCYl1yb"
      },
      "source": [
        "import math\n",
        "\n",
        "a = .00000000000234\n",
        "b = 12300000000000\n",
        "\n",
        "# Use these three lines as a model\n",
        "x1 = math.floor(math.log(a,10))\n",
        "n1 = round(a*10**(-x1),2)\n",
        "print(\"a = \", n1, \"* 10^\", x1)\n",
        "\n",
        "# Change the next two lines to match the model\n",
        "x2 = 0\n",
        "n2 = 0\n",
        "print(\"b = \", n2, \"* 10^\", x2)\n",
        "\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step18(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d7Lc9KfMYU8Y"
      },
      "source": [
        "# Step 19 - Scientific Notation Conversion"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "21gdVKfeYc5R"
      },
      "source": [
        "Now ask for a number as input, and write the code to convert that number into scientific notation. You can re-use code you used in the previous step, using `n` and `x` as variables to print n * 10^x."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VkOkpmrP4XAb"
      },
      "source": [
        "import math\n",
        "\n",
        "a = float(input('Enter a number to convert to scientific notation: '))\n",
        "\n",
        "# write your code here\n",
        "n = 0\n",
        "x = 0\n",
        "print(a, \" = \")\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step19(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VkD30ljxlyw9"
      },
      "source": [
        "# Step 20 - Graphing Exponents and Logs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A7YL0fIdlyw-"
      },
      "source": [
        "When not writing code, the <i>natural log</i> is written as \"ln\" and it means a logarithm with base e. Like any pair of inverse functions, the line y = e<sup>x</sup> and the line y = ln(x) are mirrored over the line y = x.  Because of the `np.linspace()` function in this code, `np.log()` works, but `math.log()` does not work here. Both log() functions in Python use e as the base by default. When using the `numpy` library, use `np.log10()` for base 10, `np.log2()` for base 2, etc. Because log functions can only have positive x values, the np.linspace() function will define a positive range for the log() function. Run this code, then change the blue line function to graph y = 2<sup>x</sup> and change the green line function to graph y = log<sub>2</sub>x and notice the similarities between the graphs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fJiDmoW1lyw_"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import math\n",
        "\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],'k') # x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'k') # y axis\n",
        "\n",
        "# Same x values for two lines\n",
        "x1 = np.linspace(xmin, xmax, 1000)\n",
        "\n",
        "# Blue line for y = e^x \n",
        "plt.plot(x1, math.e**x1, 'b')  # Change this line\n",
        "\n",
        "# Red line for y = x\n",
        "plt.plot(x1, x1, 'r')\n",
        "\n",
        "# Different x values for y = log(x) because x > 0\n",
        "x2 = np.linspace(.001, xmax, 500)\n",
        "\n",
        "# Green line for y = log(x)\n",
        "plt.plot(x2, np.log(x2), 'g')  # Change this line\n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step20(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bJzxcKIfz8Qt"
      },
      "source": [
        "# Step 21 - Log Application - pH Scale"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pfF3voqSz8Q9"
      },
      "source": [
        "The pH scale, for measuring acids and bases, is a logarithmic scale. The negative log of the hydrogen concentration is the pH. Example: if the hydrogen concentration is .007 then that would be 7 * 10<sup>-3</sup> and therefore a pH of 3. Write the code to prompt for hydrogen concentration and then print the pH. Hint: the <i>ceiling</i> function (`math.ceil()`) works better than rounding here."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tepkvSubz8Q9"
      },
      "source": [
        "import math\n",
        "\n",
        "decimal = float(input(\"Enter the hydrogen concentration as a decimal number: \"))\n",
        "\n",
        "# Write your code here\n",
        "h = 0\n",
        "\n",
        "print(\"pH = \", h)\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_c as test\n",
        "test.step21(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 22 - Functions for the Project"
      ],
      "metadata": {
        "id": "8iWUAktvPLYp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define a function for calculating mortgage payments and a function for calculating investment balance. Use code you wrote in earlier steps. Each function should prompt for input and print the output."
      ],
      "metadata": {
        "id": "a9gRwbr-PGPC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Write your code here\n",
        "\n",
        "\n",
        "# This step does not have a test"
      ],
      "metadata": {
        "id": "neFvvCOzO_WB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 23 - More Functions"
      ],
      "metadata": {
        "id": "rzaQj8dEOfzb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a function that produces an interactive polynomial graph (with sliders). Use code from an earlier step."
      ],
      "metadata": {
        "id": "C6OV8KzQOTS_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Write your code here\n",
        "\n",
        "\n",
        "# This step does not have a test"
      ],
      "metadata": {
        "id": "6cGh0vE1OYyC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 24 - New Function"
      ],
      "metadata": {
        "id": "UptjjiCOTSS2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a function to print the time required for money to double, given the rate. Use the continuous growth formula from an earlier step."
      ],
      "metadata": {
        "id": "XKXNbHzGTKAp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Write your code here\n",
        "\n",
        "\n",
        "# This step does not have a test"
      ],
      "metadata": {
        "id": "kWs_IpxrTYyl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 25 - Certification Project 3"
      ],
      "metadata": {
        "id": "CRa5i8s3UCuL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Build a financial app that calculates all of the following:<br>\n",
        "<ul>\n",
        "<li>Mortgage payment - given principle, rate, time</li>\n",
        "<li>Retirement account balance at time of retirement</li>\n",
        "<li>Time required for money to double - given the rate</li>\n",
        "<li>Rate of growth - given starting value, time, and ending value</li>\n",
        "</ul>"
      ],
      "metadata": {
        "id": "nngVpvqeT4U7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Write your code here\n",
        "\n"
      ],
      "metadata": {
        "id": "fa2o--pDT-Sd"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}