From 9895f2ee0348420c58dde8ab290096044ccb6aba Mon Sep 17 00:00:00 2001 From: Manish Date: Fri, 28 Jul 2023 22:30:16 +1000 Subject: [PATCH] Solution --- Financial Calculator.ipynb | 1926 ++++++++++++++++++++++++++++++++++++ Financial Calculator.md | 1045 +++++++++++++++++++ output_11_0.png | Bin 0 -> 17382 bytes output_14_0.png | Bin 0 -> 38123 bytes output_65_0.png | Bin 0 -> 25121 bytes output_8_0.png | Bin 0 -> 16293 bytes 6 files changed, 2971 insertions(+) create mode 100644 Financial Calculator.ipynb create mode 100644 Financial Calculator.md create mode 100644 output_11_0.png create mode 100644 output_14_0.png create mode 100644 output_65_0.png create mode 100644 output_8_0.png 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 0000000000000000000000000000000000000000..e3c5b30eb3741d48b06fdf74214f36f2017ee595 GIT binary patch literal 17382 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 H!L$DduIu5@ literal 0 HcmV?d00001 diff --git a/output_65_0.png b/output_65_0.png new file mode 100644 index 0000000000000000000000000000000000000000..99810bb9fa8f1811f9cef988487351a8de6db8d8 GIT binary patch literal 25121 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 f+uGb>=VQNl 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 a-Wpyv6jf literal 0 HcmV?d00001