diff --git a/Financial Calculator.ipynb b/Financial Calculator.ipynb new file mode 100644 index 0000000..5d8f5eb --- /dev/null +++ b/Financial Calculator.ipynb @@ -0,0 +1,1926 @@ +{ + "cells": [ + { + "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**
\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": [ + "# ↓ **Do this first** ↓\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", + "metadata": { + "id": "KDloBuvnHQTS" + }, + "source": [ + "# Step 0 - Acquire the Testing Library" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JiW6TlNezZKS" + }, + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "eTlHceacGa1C" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: requests in /usr/local/lib/python3.8/dist-packages (2.31.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.8/dist-packages (from requests) (3.2.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/lib/python3/dist-packages (from requests) (2.8)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/lib/python3/dist-packages (from requests) (1.25.8)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/lib/python3/dist-packages (from requests) (2019.11.28)\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.1.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython3 -m pip install --upgrade pip\u001b[0m\n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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()" + ] + }, + { + "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 > 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", + "execution_count": 4, + "metadata": { + "id": "QAVgVP3xUd4J" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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, ymax)\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])" + ] + }, + { + "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", + "execution_count": 7, + "metadata": { + "id": "3Pp_SmUikwgy" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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, 'r--')\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])" + ] + }, + { + "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", + "execution_count": 9, + "metadata": { + "id": "Iyoq1h3vlV-a" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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='blue') # change this line\n", + "\n", + "# line 2\n", + "y2 = x+3\n", + "plt.plot(x, y2)\n", + "plt.fill_between(x, y2, y1, facecolor='green') # change this line\n", + "\n", + "# line 3\n", + "y3 = x-1\n", + "plt.plot(x, y3)\n", + "plt.fill_between(x, y3, y2, facecolor='yellow') # change this line\n", + "\n", + "# line 4\n", + "y4 = x-4\n", + "plt.plot(x, y4)\n", + "plt.fill_between(x, y4, y3, facecolor='red') # 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])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "s3z_zaNWlet8" + }, + "source": [ + "# Step 4 - Monomials" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BTOGQIpElet-" + }, + "source": [ + "A monomial 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 -3x2 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 x0). You can use `sympy` to display monomials nicely. Just run the code to see how this looks. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "oAPKmzeblet_" + }, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle - 2 x^{3} = -16$" + ], + "text/plain": [ + "Eq(-2*x**3, -16)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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()" + ] + }, + { + "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 = ax4 + bx3 + cx2 + dx + e
\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", + "execution_count": 12, + "metadata": { + "id": "USVAJRualhdL" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Enter coefficient A: 3\n", + "Enter coefficient B: 56\n", + "Enter coefficient C: 2\n", + "Enter coefficient D: 6\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Here is your equation:\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle y = 3 x^{3} + 56 x^{2} + 2 x + 6$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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", + "c = int(input(\"Enter coefficient C: \"))\n", + "d = int(input(\"Enter coefficient D: \"))\n", + "\n", + "# change the next line to display the full polynomial\n", + "y = a*x**3 + b*x**2 + c*x + d\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])" + ] + }, + { + "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 = ax2 + 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", + "execution_count": 14, + "metadata": { + "id": "sOecWXLOljVo" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bf7d65a7ba8c49c890ef0eb7511a8dc6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=0, description='a', max=9, min=-9), IntSlider(value=0, description='b', …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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, c):\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+c) # Change this line\n", + " plt.show()\n", + "\n", + "# Change the next line:\n", + "interactive_plot = interactive(f, a=(-9, 9), b=(-9, 9), c=(-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])" + ] + }, + { + "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", + "execution_count": 16, + "metadata": { + "id": "8KIMFu7LlkQg" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cbc82089f65346b1aec267812b8770a8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=-5, description='a', max=-1, min=-9), IntSlider(value=5, description='b'…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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=(-9, -1), 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])" + ] + }, + { + "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 A = P(1 + r)t where `A` would be the `y` value on a graph and `t` would be the `x` value. `A` is the annuity, which is the amount you have at the end. `P` is the principle, which is the amount you have at the beginning. `R` (usually not capitalized) is the rate, a percent converted to a decimal. The exponent `t` represents time, usually in years. The code already prompts for `P`, `r` and `t`, so use those variables to calculate the annuity value." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "Vkp6zmxIllvT" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Starting amount = 100\n", + "Enter the percentage rate, converted to a decimal: 0.06\n", + "How many years will this investment grow? 5\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The annuity is 133.82255776000002\n", + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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 = p*(1+r)**t\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])" + ] + }, + { + "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 A = P(1 - r)t. 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", + "execution_count": 18, + "metadata": { + "id": "zJmQoa6YlmmZ" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Starting amount = 2323\n", + "Enter the percentage rate, converted to a decimal: 0.12\n", + "How many years will this decrease continue? 27\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final amount is 73.63450265803228\n", + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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 = p*(1-r)**t\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])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "S-DVSzwDvKvE" + }, + "source": [ + "# Step 10 - Compound Interest" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qf181QFOvCgd" + }, + "source": [ + "When you use percent increase formulas for money in the bank, it's called compound interest. 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 compounding and it can happen any number of times per year. The formula is A = P(1 + $\\frac{r}{n}$)nt where n 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)." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "id": "O0FAXixVvGXh" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Starting amount: 100\n", + "Percentage rate, converted to a decimal: 0.12\n", + "Number of years this investment will grow: 4\n", + "Number of times compounded per year: 4\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The annuity is 160.47064390987882\n", + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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 = p*(1+(r/n))**(n*t)\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])" + ] + }, + { + "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)t, money is compounded annually.
\n", + "In the second formula, A = P(1 + $\\frac{r}{n})^{nt}$, money is compounded `n` times per year.
\n", + "As `n` gets to be a really big number, you get a different formula, A = Pe$^{rt}$, for continuous growth.
\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", + "execution_count": 22, + "metadata": { + "id": "kf3Q0Yg7lxvk" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Principle: 100\n", + "Rate: 0.08\n", + "Time: 5\n", + "N: 12\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compounded annually, anuity = 146.93280768000005\n", + "Compounded 12 times per year, anuity = 148.9845708301605\n", + "Compounded continuously, anuity = 149.18246976412703\n", + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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 = p*(1+r)**t\n", + "a_n_times = p*(1+r/n)**(n*t)\n", + "a_continuous = p*math.e**(r*t) # 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])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iaEBltZXln-Q" + }, + "source": [ + "# Step 12 - Investments" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JTQ9uZw3UeGT" + }, + "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 simple interest formula: interest = principle * rate * time. (Hint: for one month, t = $\\frac{1}{12}$ or you can just divide by 12.)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "id": "t7sRzH5Oln-R" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Starting amount: 100\n", + "Annual percentage rate: 0.08\n", + "Number of years: 5\n", + "Monthly contribution: 10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Annuity = 888.6515903655937\n", + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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 = annuity * (r/12)\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)" + ] + }, + { + "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:
\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", + "execution_count": 33, + "metadata": { + "id": "E5X8_WbnlpEv" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Amount borrowed: 1000\n", + "Annual percentage rate: 0.12\n", + "Number of years: 5\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Monthly payment = $ 22.24444768490176\n", + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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", + "common = (1 + (r/12))**(12*t)\n", + "pmt = p*((r/12)*common)/(common-1)\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)" + ] + }, + { + "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: 24 = 16 and log216 = 4. Both have the same information rearranged in different ways. If you had 24 = x you would be able to do that easily, but if you had 2x = 16 it would be more difficult. You could write that last equation as a logarithm: log216 = 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 logarithms to calculate the exponent." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "id": "ehtA_ATbl0yw" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "base: 2\n", + "result: 24\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "exponent = 4.584962500721157\n", + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "source": [ + "import math\n", + "\n", + "base = float(input(\"base: \"))\n", + "result = float(input(\"result: \"))\n", + "\n", + "# Just change the next line:\n", + "exp = math.log(result, base)\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])" + ] + }, + { + "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:
\n", + "A = Pert
\n", + "If annuity is two times the principle, divide both sides by P\n", + "and get this:
\n", + "2 = ert
\n", + "Because of the base e, take the natural log of both sides and get this:
\n", + "ln(2) = rt
\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", + "execution_count": 35, + "metadata": { + "id": "dM3RxByK4UJe" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Enter the annual rate as a decimal: \n", + " 0.05\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your money will double in 13.862943611198904 years\n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B7DOz9nh4XAb" + }, + "source": [ + "# Step 16 - Common Logs" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MD3dH5yF4XAb" + }, + "source": [ + "The common log 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", + "execution_count": 37, + "metadata": { + "id": "n390hG0GcEXI" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Enter a number with several digits or several decimal places: 1232.43524\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "exponent = 3.090764107949619\n", + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "source": [ + "import math\n", + "\n", + "n = input('Enter a number with several digits or several decimal places: ')\n", + "n = float(n)\n", + "\n", + "\n", + "# Run the code then change the next line:\n", + "exp = 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])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cqvLtj7t4VMN" + }, + "source": [ + "# Step 17 - Scientific Notation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-Uh4YmRt4VMN" + }, + "source": [ + "Scientific Notation 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 107 in scientific notation and 0.00000045 could be written as 4.5 x 10-7. The notation requires base 10, so it will always use the structure n $*$ 10x 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", + "execution_count": 39, + "metadata": { + "id": "UyPF6dKz4VMO" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "156000000000 = 1.56 * 10^ 11\n", + "4.13e-10 = 4.13 * 10^ -10\n", + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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 = 4.13\n", + "b2 = -10\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)" + ] + }, + { + "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 $*$ 10x 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 10x is the same as multiplying by 10-x). Rounding is usually necessary. Write the code to convert numbers to scientific notation." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "id": "y8PXrFCYl1yb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a = 2.34 * 10^ -12\n", + "b = 1.23 * 10^ 13\n", + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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 = math.floor(math.log(b, 10))\n", + "n2 = round(b*10**(-x2), 2)\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])" + ] + }, + { + "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", + "execution_count": 48, + "metadata": { + "id": "VkOkpmrP4XAb" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Enter a number to convert to scientific notation: 0.005\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a = 5.0*10^-3\n", + " \n", + "You should use x = math.floor(math.log(a,10)) in your code\n", + "You should use n = round(a*10**(-x),2) in your code\n" + ] + } + ], + "source": [ + "import math\n", + "\n", + "a = float(input('Enter a number to convert to scientific notation: '))\n", + "\n", + "# write your code here\n", + "n = math.floor(math.log(a, 10))\n", + "x = round(a/10**n, 2)\n", + "print(f\"a = {x}*10^{n}\")\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])" + ] + }, + { + "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 natural log is written as \"ln\" and it means a logarithm with base e. Like any pair of inverse functions, the line y = ex 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 = 2x and change the green line function to graph y = log2x and notice the similarities between the graphs." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "id": "fJiDmoW1lyw_" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n", + "Code test passed\n", + "Go on to the next step\n" + ] + } + ], + "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, 2**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.log2(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])" + ] + }, + { + "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-3 and therefore a pH of 3. Write the code to prompt for hydrogen concentration and then print the pH. Hint: the ceiling function (`math.ceil()`) works better than rounding here." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "id": "tepkvSubz8Q9" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Enter the hydrogen concentration as a decimal number: 0.007\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pH = 3\n", + " \n", + "Code test passed\n" + ] + } + ], + "source": [ + "import math\n", + "\n", + "decimal = float(input(\"Enter the hydrogen concentration as a decimal number: \"))\n", + "\n", + "# Write your code here\n", + "h = math.ceil(-math.log(decimal, 10))\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])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8iWUAktvPLYp" + }, + "source": [ + "# Step 22 - Functions for the Project" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a9gRwbr-PGPC" + }, + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "id": "neFvvCOzO_WB" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Provide following information to estimate your retirement savings:\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Current savings: 0\n", + "Estimated rate of return on investments (in decimal): 0.05\n", + "Monthly savings: 1300\n", + "Number of years till retirement: 40\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated retirement savings: 1992092.1458609407\n" + ] + } + ], + "source": [ + "# Write your code here\n", + "def monthly_mortage_payment():\n", + " print(\"Provide following information to calculate monthly mortgage payment:\")\n", + " p = float(input(\"Loan amount: \"))\n", + " r = float(input(\"Rate of inerest (in decimal): \"))\n", + " t = float(input(\"Loan duration (in years): \"))\n", + " common = (1+ (r/12))**(t*12)\n", + " monthly_payment = p * (((r/12)*common)/(common-1))\n", + " print(\"Monthly payment will be:\", monthly_payment)\n", + "\n", + "def retirement_corpus():\n", + " print(\"Provide following information to estimate your retirement savings:\")\n", + " s = float(input(\"Current savings: \"))\n", + " r = float(input(\"Estimated rate of return on investments (in decimal): \"))/12\n", + " m = float(input(\"Monthly savings: \"))\n", + " t = float(input(\"Number of years till retirement: \"))\n", + "\n", + " for i in range(int(t*12)):\n", + " s += m\n", + " s = s + (s*r)\n", + "\n", + " print(\"Estimated retirement savings: \", s)\n", + "# This step does not have a test" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rzaQj8dEOfzb" + }, + "source": [ + "# Step 23 - More Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C6OV8KzQOTS_" + }, + "source": [ + "Create a function that produces an interactive polynomial graph (with sliders). Use code from an earlier step." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "id": "6cGh0vE1OYyC" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b8d46f4a3db44e4b8636c1e797e351c7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.0, description='a', max=10.0, min=-10.0), FloatSlider(value=0.0, des…" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Write your code here\n", + "\n", + "def f(a, b, c):\n", + " xlo = -100\n", + " xhi = 100\n", + " ylo = -100\n", + " yhi = 100\n", + "\n", + " plt.clf()\n", + " fig = plt.subplot()\n", + " plt.axis([xlo, xhi, ylo, yhi])\n", + " plt.plot([xlo, xhi], [0, 0], \"black\")\n", + " plt.plot([0, 0], [ylo, yhi], \"black\")\n", + "\n", + " x = np.linspace(xlo, xhi, (xhi-xlo)*5)\n", + " y = a*x**2 + b*x + c\n", + " plt.plot(x, y)\n", + "\n", + " plt.grid()\n", + " plt.show()\n", + "\n", + "interactive_graph = interactive(f, a=(-10, 10, 0.1), b=(-10, 10, 0.1), c=(-10, 10, 0.1))\n", + "interactive_graph\n", + "# This step does not have a test" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UptjjiCOTSS2" + }, + "source": [ + "# Step 24 - New Function" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XKXNbHzGTKAp" + }, + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "id": "kWs_IpxrTYyl" + }, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Give rate of interest/return (in decimal) to find time to double: 0.05\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "It will take 13.86 years for amount to double.\n" + ] + } + ], + "source": [ + "# Write your code here\n", + "def time_to_double():\n", + " r = float(input(\"Give rate of interest/return (in decimal) to find time to double: \"))\n", + " t = round(math.log(2)/r, 2)\n", + " print(f\"It will take {t} years for amount to double.\")\n", + "# This step does not have a test" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CRa5i8s3UCuL" + }, + "source": [ + "# Step 25 - Certification Project 3" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nngVpvqeT4U7" + }, + "source": [ + "Build a financial app that calculates all of the following:
\n", + "
    \n", + "
  • Mortgage payment - given principle, rate, time
    • \n", + "
  • Retirement account balance at time of retirement
    • \n", + "
  • Time required for money to double - given the rate
    • \n", + "
  • Rate of growth - given starting value, time, and ending value
    • \n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "id": "fa2o--pDT-Sd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Provide following information to determine needed rate of grwoth for given amount to reach desired amount in given time (years): \n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Current amount: 100\n", + "Desired future amount: 200\n", + "Number of years: 13.8\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.0% rate of growth is needed for 100.0 to reach 200.0 in 13.8 years.\n" + ] + } + ], + "source": [ + "# Write your code here\n", + "def time_to_double():\n", + " print(\"Provide following information to determine needed rate of grwoth for given amount to reach desired amount in given time (years): \")\n", + " p = float(input(\"Current amount: \"))\n", + " a = float(input(\"Desired future amount: \"))\n", + " t = float(input(\"Number of years: \"))\n", + " r = round(math.log(a/p)/t, 2)\n", + " print(f\"{r*100}% rate of growth is needed for {p} to reach {a} in {t} years.\")\n", + "\n", + "rate_of_grwoth()" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "What would you like to do?\n", + "Mortgage payment - given principle, rate, time\n", + "Retirement account balance at time of retirement\n", + "Rate of growth - given starting value, time, and ending value\n", + "Time required for money to double - given the raten\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + " 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Provide following information to calculate monthly mortgage payment:\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Loan amount: 1000000\n", + "Rate of inerest (in decimal): 0.06\n", + "Loan duration (in years): 30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Monthly payment will be: 5995.505251527569\n" + ] + } + ], + "source": [ + "options = [\n", + " (monthly_mortage_payment, \"Mortgage payment - given principle, rate, time\"),\n", + " (retirement_corpus, \"Retirement account balance at time of retirement\"),\n", + " (rate_of_grwoth, \"Rate of growth - given starting value, time, and ending value\"),\n", + " (time_to_double, \"Time required for money to double - given the raten\")\n", + "]\n", + "\n", + "print(\"What would you like to do?\")\n", + "[print(o[1]) for o in options]\n", + "selected = int(input())\n", + "\n", + "if selected >= 1 and selected <= len(options):\n", + " options[selected-1][0]()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [ + "szp5flp1fA8-", + "KDloBuvnHQTS", + "r1AM-AcqkbyF", + "8wXbGsoYkm60", + "tBxuJtHck2Oo", + "s3z_zaNWlet8", + "yoavB8H_ljVn", + "MlRfYVIylkQf", + "NGH1FcttllvS", + "Sx0kwIdalmmY", + "S-DVSzwDvKvE", + "H6LTAPYplxvi", + "iaEBltZXln-Q", + "l5GwlqRdlpEu", + "U_7bv7aG4UJe", + "B7DOz9nh4XAb", + "cqvLtj7t4VMN", + "GsLj1NhZl1ya", + "d7Lc9KfMYU8Y", + "VkD30ljxlyw9", + "bJzxcKIfz8Qt", + "8iWUAktvPLYp", + "rzaQj8dEOfzb", + "UptjjiCOTSS2", + "CRa5i8s3UCuL" + ], + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Financial Calculator.md b/Financial Calculator.md new file mode 100644 index 0000000..6715327 --- /dev/null +++ b/Financial Calculator.md @@ -0,0 +1,1045 @@ +[![freeCodeCamp](https://cdn.freecodecamp.org/testable-projects-fcc/images/fcc_secondary.svg)](https://freecodecamp.org/) + +**Learn Foundational Math 3 by Building a Financial App**
+Each of these steps will lead you toward the Certification Project. Once you complete a step, click to expand the next step. + +# ↓ **Do this first** ↓ +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. + +# Step 0 - Acquire the Testing Library + +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. + + +```python +# You may need to run this cell at the beginning of each new session + +!pip install requests + +# This will just take a few seconds + +import requests + +# Get the library from GitHub +url = 'https://raw.githubusercontent.com/edatfreecodecamp/python-math/main/math-code-test-c.py' +r = requests.get(url) + +# Save the library in a local working directory +with open('math_code_test_c.py', 'w') as f: + f.write(r.text) + +# Now you can import the library +import math_code_test_c as test + +# This will tell you if the code works +test.step00() +``` + + Requirement already satisfied: requests in /usr/local/lib/python3.8/dist-packages (2.31.0) + Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.8/dist-packages (from requests) (3.2.0) + Requirement already satisfied: idna<4,>=2.5 in /usr/lib/python3/dist-packages (from requests) (2.8) + Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/lib/python3/dist-packages (from requests) (1.25.8) + Requirement already satisfied: certifi>=2017.4.17 in /usr/lib/python3/dist-packages (from requests) (2019.11.28) + WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv +  + [notice] A new release of pip is available: 23.1.2 -> 23.2.1 + [notice] To update, run: python3 -m pip install --upgrade pip + Code test passed + Go on to the next step + + +# Step 1 - Graphing Inequalities + +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 > 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.) + + + +```python +import matplotlib.pyplot as plt +import numpy as np + +xmin = -10 +xmax = 10 +ymin = - 10 +ymax = 10 +points = 2*(xmax-xmin) +x = np.linspace(xmin,xmax,points) + +fig, ax = plt.subplots() +plt.axis([xmin,xmax,ymin,ymax]) # window size +plt.plot([xmin,xmax],[0,0],'b') # blue x axis +plt.plot([0,0],[ymin,ymax], 'b') # blue y axis + +plt.title("y > 2x") + +y1 = 2*x +plt.plot(x, y1) + +# Only change code below this line +plt.fill_between(x, y1, ymax) + +plt.show() + + +# Only change code above this line +import math_code_test_c as test +test.step01(In[-1].split('# Only change code above this line')[0]) +``` + + + +![png](output_8_0.png) + + + + + Code test passed + Go on to the next step + + +# Step 2 - Graphing inequalities - Part 2 + +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. + + +```python +import matplotlib.pyplot as plt +import numpy as np + +xmin = -10 +xmax = 10 +ymin = - 10 +ymax = 10 +points = 2*(xmax-xmin) +x = np.linspace(xmin,xmax,points) + +fig, ax = plt.subplots() +plt.axis([xmin,xmax,ymin,ymax]) # window size +plt.plot([xmin,xmax],[0,0],'b') # blue x axis +plt.plot([0,0],[ymin,ymax], 'b') # blue y axis + +y1 = 2*x + +# Only change the next line: +plt.plot(x, y1, 'r--') + +plt.fill_between(x, y1, ymin) +plt.show() + + + +# Only change code above this line +import math_code_test_c as test +test.step02(In[-1].split('# Only change code above this line')[0]) +``` + + + +![png](output_11_0.png) + + + + + Code test passed + Go on to the next step + + +# Step 3 - Making Art with Graphs + +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. + + +```python +import matplotlib.pyplot as plt +import numpy as np + +xmin = -10 +xmax = 10 +ymin = - 10 +ymax = 10 +points = 2*(xmax-xmin) +x = np.linspace(xmin,xmax,points) + +fig, ax = plt.subplots() +plt.axis([xmin,xmax,ymin,ymax]) # window size +plt.plot([xmin,xmax],[0,0],'b') # blue x axis +plt.plot([0,0],[ymin,ymax], 'b') # blue y axis + +# Only change the lines indicated below + +# line 1 +y1 = x+6 +plt.plot(x, y1) +plt.fill_between(x, y1, 10, facecolor='blue') # change this line + +# line 2 +y2 = x+3 +plt.plot(x, y2) +plt.fill_between(x, y2, y1, facecolor='green') # change this line + +# line 3 +y3 = x-1 +plt.plot(x, y3) +plt.fill_between(x, y3, y2, facecolor='yellow') # change this line + +# line 4 +y4 = x-4 +plt.plot(x, y4) +plt.fill_between(x, y4, y3, facecolor='red') # change this line + +plt.show() + + + +# Only change code above this line +import math_code_test_c as test +test.step03(In[-1].split('# Only change code above this line')[0]) +``` + + + +![png](output_14_0.png) + + + + + Code test passed + Go on to the next step + + +# Step 4 - Monomials + +A monomial 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 -3x2 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 x0). You can use `sympy` to display monomials nicely. Just run the code to see how this looks. + + +```python +from sympy import symbols, Eq + +x = symbols('x') +eq1 = Eq(-2*x**3 , -16) +display(eq1) + + +# Just run this code +import math_code_test_c as test +test.step00() +``` + + +$\displaystyle - 2 x^{3} = -16$ + + + Code test passed + Go on to the next step + + +# Step 5 - Polynomials + +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 = ax4 + bx3 + cx2 + dx + e
+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. + + +```python +from IPython.display import display, Math +from sympy import * + +x,y = symbols('x y') + +a = int(input("Enter coefficient A: ")) +b = int(input("Enter coefficient B: ")) +# continue this to prompt for variables c and d +c = int(input("Enter coefficient C: ")) +d = int(input("Enter coefficient D: ")) + +# change the next line to display the full polynomial +y = a*x**3 + b*x**2 + c*x + d + +print("Here is your equation:") +display(Math("y = " + latex(y))) + + +# Only change code above this line +import math_code_test_c as test +test.step05(In[-1].split('# Only change code above this line')[0]) +``` + + Enter coefficient A: 3 + Enter coefficient B: 56 + Enter coefficient C: 2 + Enter coefficient D: 6 + + + Here is your equation: + + + +$\displaystyle y = 3 x^{3} + 56 x^{2} + 2 x + 6$ + + + + Code test passed + Go on to the next step + + +# Step 6 - Interactive Polynomial Graph + +For this polynomial, y = ax2 + 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. + + +```python +%matplotlib inline +from ipywidgets import interactive +import matplotlib.pyplot as plt +import numpy as np + +# Change the next line: +def f(a, b, c): + plt.axis([-10,10,-10,10]) # window size + plt.plot([-10,10],[0,0],'k') # blue x axis + plt.plot([0,0],[-10,10], 'k') # blue y axis + x = np.linspace(-10, 10, 200) + plt.plot(x, a*x**2+b*x+c) # Change this line + plt.show() + +# Change the next line: +interactive_plot = interactive(f, a=(-9, 9), b=(-9, 9), c=(-9, 9)) +display(interactive_plot) + + +# Only change code above this line +import math_code_test_c as test +test.step06(In[-1].split('# Only change code above this line')[0]) +``` + + + interactive(children=(IntSlider(value=0, description='a', max=9, min=-9), IntSlider(value=0, description='b', … + + + + Code test passed + Go on to the next step + + +# Step 7 - Exponential Functions + +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. + + +```python +%matplotlib inline +from ipywidgets import interactive +import matplotlib.pyplot as plt +import numpy as np + +xmin = -10 +xmax = 10 +ymin = -100 +ymax = 100 + +def f(a, b): + plt.axis([xmin,xmax,ymin,ymax]) # window size + plt.plot([xmin,xmax],[0,0],'k') # x axis + plt.plot([0,0],[ymin,ymax], 'k') # y axis + x = np.linspace(xmin, xmax, 1000) + plt.plot(x, a*b**x) + plt.show() + +# Only change the next line: +interactive_plot = interactive(f, a=(-9, -1), b=(1, 9)) +display(interactive_plot) + + +# Only change code above this line +import math_code_test_c as test +test.step07(In[-1].split('# Only change code above this line')[0]) +``` + + + interactive(children=(IntSlider(value=-5, description='a', max=-1, min=-9), IntSlider(value=5, description='b'… + + + + Code test passed + Go on to the next step + + +# Step 8 - Percent Increase + +One formula for calculating a percent increase is A = P(1 + r)t where `A` would be the `y` value on a graph and `t` would be the `x` value. `A` is the annuity, which is the amount you have at the end. `P` is the principle, which is the amount you have at the beginning. `R` (usually not capitalized) is the rate, a percent converted to a decimal. The exponent `t` represents time, usually in years. The code already prompts for `P`, `r` and `t`, so use those variables to calculate the annuity value. + + +```python +p = float(input("Starting amount = ")) +r = float(input("Enter the percentage rate, converted to a decimal: ")) +t = float(input("How many years will this investment grow? ")) + +# Change the next line to calculate the annuity +a = p*(1+r)**t + +print("The annuity is ", a) + + +# Only change code above this line +import math_code_test_c as test +test.step08(In[-1].split('# Only change code above this line')[0]) +``` + + Starting amount = 100 + Enter the percentage rate, converted to a decimal: 0.06 + How many years will this investment grow? 5 + + + The annuity is 133.82255776000002 + + Code test passed + Go on to the next step + + +# Step 9 - Percent Decrease + +The percent decrease formula is very similar, except you subtract the rate, so the formula is A = P(1 - r)t. 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`). + + +```python +p = float(input("Starting amount = ")) +r = float(input("Enter the percentage rate, converted to a decimal: ")) +t = float(input("How many years will this decrease continue? ")) + +# Change the next line to calculate the final amount +a = p*(1-r)**t + +print("The final amount is ", a) + +# Only change code above this line +import math_code_test_c as test +test.step09(In[-1].split('# Only change code above this line')[0]) +``` + + Starting amount = 2323 + Enter the percentage rate, converted to a decimal: 0.12 + How many years will this decrease continue? 27 + + + The final amount is 73.63450265803228 + + Code test passed + Go on to the next step + + +# Step 10 - Compound Interest + +When you use percent increase formulas for money in the bank, it's called compound interest. 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 compounding and it can happen any number of times per year. The formula is A = P(1 + $\frac{r}{n}$)nt where n 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). + + +```python +p = float(input("Starting amount: ")) +r = float(input("Percentage rate, converted to a decimal: ")) +t = float(input("Number of years this investment will grow: ")) +n = int(input("Number of times compounded per year: ")) + +# Change the next line to calculate the annuity +annuity = p*(1+(r/n))**(n*t) + +print("The annuity is ", annuity) + + +# Only change code above this line +import math_code_test_c as test +test.step10(In[-1].split('# Only change code above this line')[0]) +``` + + Starting amount: 100 + Percentage rate, converted to a decimal: 0.12 + Number of years this investment will grow: 4 + Number of times compounded per year: 4 + + + The annuity is 160.47064390987882 + + Code test passed + Go on to the next step + + +# Step 11 - Continuous Growth + +In the first formula, A = P(1 + r)t, money is compounded annually.
+In the second formula, A = P(1 + $\frac{r}{n})^{nt}$, money is compounded `n` times per year.
+As `n` gets to be a really big number, you get a different formula, A = Pe$^{rt}$, for continuous growth.
+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). + + +```python +import math + +p = float(input("Principle: ")) +r = float(input("Rate: ")) +t = int(input("Time: ")) +n = int(input("N: ")) + +# Only change the following three formulas: +a_annual = p*(1+r)**t +a_n_times = p*(1+r/n)**(n*t) +a_continuous = p*math.e**(r*t) # use math.e in this formula + +# Only change the code above this line + +print("Compounded annually, anuity = ", a_annual) +print("Compounded ", n, "times per year, anuity = ", a_n_times) +print("Compounded continuously, anuity = ", a_continuous) + + +# Only change code above this line +import math_code_test_c as test +test.step11(In[-1].split('# Only change code above this line')[0]) +``` + + Principle: 100 + Rate: 0.08 + Time: 5 + N: 12 + + + Compounded annually, anuity = 146.93280768000005 + Compounded 12 times per year, anuity = 148.9845708301605 + Compounded continuously, anuity = 149.18246976412703 + + Code test passed + Go on to the next step + + +# Step 12 - Investments + +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 simple interest formula: interest = principle * rate * time. (Hint: for one month, t = $\frac{1}{12}$ or you can just divide by 12.) + + +```python +p = float(input("Starting amount: ")) +r = float(input("Annual percentage rate: ")) +t = int(input("Number of years: ")) +monthly = float(input("Monthly contribution: ")) + +# Hint: keep updating this annuity variable in the loop +annuity = p + +# Each iteration of the loop represents one month +for a in range(12*t): + annuity = annuity + monthly + # Change the next line to calculate the interest + interest = annuity * (r/12) + annuity = annuity + interest + +# Keep this line: +print("Annuity = ", annuity) + + +# Only change code above this line +import math_code_test_c as test +test.step12(p,r,t,monthly,annuity) +``` + + Starting amount: 100 + Annual percentage rate: 0.08 + Number of years: 5 + Monthly contribution: 10 + + + Annuity = 888.6515903655937 + + Code test passed + Go on to the next step + + +# Step 13 - Mortgage Payments + +When borrowing a large amount of money over a long period of time, the formula to calculate monthly payments gets complicated. Here it is:
+ 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. + + +```python +p = float(input("Amount borrowed: ")) +r = float(input("Annual percentage rate: ")) +t = float(input("Number of years: ")) + +# Write your code here and change the pmt variable +common = (1 + (r/12))**(12*t) +pmt = p*((r/12)*common)/(common-1) + + +print("Monthly payment = $", pmt) + + +# Only change code above this line +import math_code_test_c as test +test.step13(p,r,t,pmt) +``` + + Amount borrowed: 1000 + Annual percentage rate: 0.12 + Number of years: 5 + + + Monthly payment = $ 22.24444768490176 + + Code test passed + Go on to the next step + + +# Step 14 - Exponents and Logarithms + +Exponential functions and logarithmic functions are inverses of each other. Here is an example: 24 = 16 and log216 = 4. Both have the same information rearranged in different ways. If you had 24 = x you would be able to do that easily, but if you had 2x = 16 it would be more difficult. You could write that last equation as a logarithm: log216 = 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 logarithms to calculate the exponent. + + +```python +import math + +base = float(input("base: ")) +result = float(input("result: ")) + +# Just change the next line: +exp = math.log(result, base) + +print("exponent = ", exp) + + +# Only change code above this line +import math_code_test_c as test +test.step14(In[-1].split('# Only change code above this line')[0]) +``` + + base: 2 + result: 24 + + + exponent = 4.584962500721157 + + Code test passed + Go on to the next step + + +# Step 15 - Natural Logs + +If you know the rate, how long will it take for something to double? +Start with the continuous growth formula:
+A = Pert
+If annuity is two times the principle, divide both sides by P +and get this:
+2 = ert
+Because of the base e, take the natural log of both sides and get this:
+ln(2) = rt
+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. + + +```python +import math + +r = float(input("Enter the annual rate as a decimal: \n")) +t = math.log(2)/r +print("Your money will double in ", t, " years") + + +# Just run this code +import math_code_test_c as test +test.step00() +``` + + Enter the annual rate as a decimal: + 0.05 + + + Your money will double in 13.862943611198904 years + Code test passed + Go on to the next step + + +# Step 16 - Common Logs + +The common log 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. + + +```python +import math + +n = input('Enter a number with several digits or several decimal places: ') +n = float(n) + + +# Run the code then change the next line: +exp = math.log(n, 10) + +# This avoids a weird Python quirk: +if n==1000: + exp = 3; + +print("exponent = ", exp) + + +# Only change code above this line +import math_code_test_c as test +test.step16(In[-1].split('# Only change code above this line')[0]) +``` + + Enter a number with several digits or several decimal places: 1232.43524 + + + exponent = 3.090764107949619 + + Code test passed + Go on to the next step + + +# Step 17 - Scientific Notation + +Scientific Notation 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 107 in scientific notation and 0.00000045 could be written as 4.5 x 10-7. The notation requires base 10, so it will always use the structure n $*$ 10x 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. + + +```python +a = 156000000000 +b = 0.000000000413 + +# Change the code below this line + +a1 = 1.56 +a2 = 11 +b1 = 4.13 +b2 = -10 + +print(a, " = ", a1, "* 10^", a2) + +print(b, " = ", b1, "* 10^", b2) + + +# Only change code above this line +import math_code_test_c as test +test.step17(b1,b2) +``` + + 156000000000 = 1.56 * 10^ 11 + 4.13e-10 = 4.13 * 10^ -10 + + Code test passed + Go on to the next step + + +# Step 18 - Logs and Scientific Notation + +Writing code for scientific notation, you will make use of logarithms with base 10. Remember that scientific notation is in the form n $*$ 10x 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 10x is the same as multiplying by 10-x). Rounding is usually necessary. Write the code to convert numbers to scientific notation. + + +```python +import math + +a = .00000000000234 +b = 12300000000000 + +# Use these three lines as a model +x1 = math.floor(math.log(a,10)) +n1 = round(a*10**(-x1),2) +print("a = ", n1, "* 10^", x1) + +# Change the next two lines to match the model +x2 = math.floor(math.log(b, 10)) +n2 = round(b*10**(-x2), 2) +print("b = ", n2, "* 10^", x2) + + + +# Only change code above this line +import math_code_test_c as test +test.step18(In[-1].split('# Only change code above this line')[0]) +``` + + a = 2.34 * 10^ -12 + b = 1.23 * 10^ 13 + + Code test passed + Go on to the next step + + +# Step 19 - Scientific Notation Conversion + +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. + + +```python +import math + +a = float(input('Enter a number to convert to scientific notation: ')) + +# write your code here +n = math.floor(math.log(a, 10)) +x = round(a/10**n, 2) +print(f"a = {x}*10^{n}") + +# Only change code above this line +import math_code_test_c as test +test.step19(In[-1].split('# Only change code above this line')[0]) +``` + + Enter a number to convert to scientific notation: 0.005 + + + a = 5.0*10^-3 + + You should use x = math.floor(math.log(a,10)) in your code + You should use n = round(a*10**(-x),2) in your code + + +# Step 20 - Graphing Exponents and Logs + +When not writing code, the natural log is written as "ln" and it means a logarithm with base e. Like any pair of inverse functions, the line y = ex 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 = 2x and change the green line function to graph y = log2x and notice the similarities between the graphs. + + +```python +import matplotlib.pyplot as plt +import numpy as np +import math + +xmin = -10 +xmax = 10 +ymin = -10 +ymax = 10 +plt.axis([xmin,xmax,ymin,ymax]) # window size +plt.plot([xmin,xmax],[0,0],'k') # x axis +plt.plot([0,0],[ymin,ymax], 'k') # y axis + +# Same x values for two lines +x1 = np.linspace(xmin, xmax, 1000) + +# Blue line for y = e^x +plt.plot(x1, 2**x1, 'b') # Change this line + +# Red line for y = x +plt.plot(x1, x1, 'r') + +# Different x values for y = log(x) because x > 0 +x2 = np.linspace(.001, xmax, 500) + +# Green line for y = log(x) +plt.plot(x2, np.log2(x2), 'g') # Change this line + +plt.show() + + +# Only change code above this line +import math_code_test_c as test +test.step20(In[-1].split('# Only change code above this line')[0]) +``` + + + +![png](output_65_0.png) + + + + + Code test passed + Go on to the next step + + +# Step 21 - Log Application - pH Scale + +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-3 and therefore a pH of 3. Write the code to prompt for hydrogen concentration and then print the pH. Hint: the ceiling function (`math.ceil()`) works better than rounding here. + + +```python +import math + +decimal = float(input("Enter the hydrogen concentration as a decimal number: ")) + +# Write your code here +h = math.ceil(-math.log(decimal, 10)) + +print("pH = ", h) + +# Only change code above this line +import math_code_test_c as test +test.step21(In[-1].split('# Only change code above this line')[0]) +``` + + Enter the hydrogen concentration as a decimal number: 0.007 + + + pH = 3 + + Code test passed + + +# Step 22 - Functions for the Project + +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. + + +```python +# Write your code here +def monthly_mortage_payment(): + print("Provide following information to calculate monthly mortgage payment:") + p = float(input("Loan amount: ")) + r = float(input("Rate of inerest (in decimal): ")) + t = float(input("Loan duration (in years): ")) + common = (1+ (r/12))**(t*12) + monthly_payment = p * (((r/12)*common)/(common-1)) + print("Monthly payment will be:", monthly_payment) + +def retirement_corpus(): + print("Provide following information to estimate your retirement savings:") + s = float(input("Current savings: ")) + r = float(input("Estimated rate of return on investments (in decimal): "))/12 + m = float(input("Monthly savings: ")) + t = float(input("Number of years till retirement: ")) + + for i in range(int(t*12)): + s += m + s = s + (s*r) + + print("Estimated retirement savings: ", s) +# This step does not have a test +``` + + Provide following information to estimate your retirement savings: + + + Current savings: 0 + Estimated rate of return on investments (in decimal): 0.05 + Monthly savings: 1300 + Number of years till retirement: 40 + + + Estimated retirement savings: 1992092.1458609407 + + +# Step 23 - More Functions + +Create a function that produces an interactive polynomial graph (with sliders). Use code from an earlier step. + + +```python +# Write your code here + +def f(a, b, c): + xlo = -100 + xhi = 100 + ylo = -100 + yhi = 100 + + plt.clf() + fig = plt.subplot() + plt.axis([xlo, xhi, ylo, yhi]) + plt.plot([xlo, xhi], [0, 0], "black") + plt.plot([0, 0], [ylo, yhi], "black") + + x = np.linspace(xlo, xhi, (xhi-xlo)*5) + y = a*x**2 + b*x + c + plt.plot(x, y) + + plt.grid() + plt.show() + +interactive_graph = interactive(f, a=(-10, 10, 0.1), b=(-10, 10, 0.1), c=(-10, 10, 0.1)) +interactive_graph +# This step does not have a test +``` + + + + + interactive(children=(FloatSlider(value=0.0, description='a', max=10.0, min=-10.0), FloatSlider(value=0.0, des… + + + +# Step 24 - New Function + +Create a function to print the time required for money to double, given the rate. Use the continuous growth formula from an earlier step. + + +```python +# Write your code here +def time_to_double(): + r = float(input("Give rate of interest/return (in decimal) to find time to double: ")) + t = round(math.log(2)/r, 2) + print(f"It will take {t} years for amount to double.") +# This step does not have a test +``` + + Give rate of interest/return (in decimal) to find time to double: 0.05 + + + It will take 13.86 years for amount to double. + + +# Step 25 - Certification Project 3 + +Build a financial app that calculates all of the following:
+
    +
  • Mortgage payment - given principle, rate, time
    • +
  • Retirement account balance at time of retirement
    • +
  • Time required for money to double - given the rate
    • +
  • Rate of growth - given starting value, time, and ending value
    • +
+ + +```python +# Write your code here +def time_to_double(): + print("Provide following information to determine needed rate of grwoth for given amount to reach desired amount in given time (years): ") + p = float(input("Current amount: ")) + a = float(input("Desired future amount: ")) + t = float(input("Number of years: ")) + r = round(math.log(a/p)/t, 2) + print(f"{r*100}% rate of growth is needed for {p} to reach {a} in {t} years.") + +rate_of_grwoth() +``` + + Provide following information to determine needed rate of grwoth for given amount to reach desired amount in given time (years): + + + Current amount: 100 + Desired future amount: 200 + Number of years: 13.8 + + + 5.0% rate of growth is needed for 100.0 to reach 200.0 in 13.8 years. + + + +```python +options = [ + (monthly_mortage_payment, "Mortgage payment - given principle, rate, time"), + (retirement_corpus, "Retirement account balance at time of retirement"), + (rate_of_grwoth, "Rate of growth - given starting value, time, and ending value"), + (time_to_double, "Time required for money to double - given the raten") +] + +print("What would you like to do?") +[print(o[1]) for o in options] +selected = int(input()) + +if selected >= 1 and selected <= len(options): + options[selected-1][0]() +``` + + What would you like to do? + Mortgage payment - given principle, rate, time + Retirement account balance at time of retirement + Rate of growth - given starting value, time, and ending value + Time required for money to double - given the raten + + + 1 + + + Provide following information to calculate monthly mortgage payment: + + + Loan amount: 1000000 + Rate of inerest (in decimal): 0.06 + Loan duration (in years): 30 + + + Monthly payment will be: 5995.505251527569 + + + +```python + +``` diff --git a/output_11_0.png b/output_11_0.png new file mode 100644 index 0000000..e3c5b30 Binary files /dev/null and b/output_11_0.png differ diff --git a/output_14_0.png b/output_14_0.png new file mode 100644 index 0000000..d0514e6 Binary files /dev/null and b/output_14_0.png differ diff --git a/output_65_0.png b/output_65_0.png new file mode 100644 index 0000000..99810bb Binary files /dev/null and b/output_65_0.png differ diff --git a/output_8_0.png b/output_8_0.png new file mode 100644 index 0000000..bac4d76 Binary files /dev/null and b/output_8_0.png differ