├── Algebra-with-Python ├── blank ├── Week-05-problems.pdf ├── Week-09-problems.pdf ├── Week-12-problems.pdf ├── Week-13-spreadsheet.xlsx ├── Week-02-code.ipynb ├── Week-01-code.ipynb ├── Week-03-xtra.ipynb ├── Week-07-code.ipynb ├── Week-03-practice.ipynb ├── Week-01-practice.ipynb ├── Week-02-practice.ipynb ├── Week-03-code.ipynb ├── Week-15-code-graphing-data.ipynb ├── Week-06-code.ipynb ├── Week-02-xtra.ipynb ├── Week-13-code.ipynb ├── Week-05-xtra.ipynb ├── Week-05-code.ipynb ├── Week-01-02-03-xtra-practice-problems.ipynb ├── Week-12-code.ipynb └── Week-15-code-economics.ipynb ├── __init__.py ├── setup.py ├── math-code-test-e.py ├── math-code-test-b.py ├── math-code-test-c.py ├── math-code-test-a.py └── math-code-test-d.py /Algebra-with-Python/blank: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /__init__.py: -------------------------------------------------------------------------------- 1 | # My dreams are not as empty as this file 2 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-05-problems.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edatfreecodecamp/python-math/HEAD/Algebra-with-Python/Week-05-problems.pdf -------------------------------------------------------------------------------- /Algebra-with-Python/Week-09-problems.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edatfreecodecamp/python-math/HEAD/Algebra-with-Python/Week-09-problems.pdf -------------------------------------------------------------------------------- /Algebra-with-Python/Week-12-problems.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edatfreecodecamp/python-math/HEAD/Algebra-with-Python/Week-12-problems.pdf -------------------------------------------------------------------------------- /Algebra-with-Python/Week-13-spreadsheet.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edatfreecodecamp/python-math/HEAD/Algebra-with-Python/Week-13-spreadsheet.xlsx -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | from setuptools import setup, find_packages 2 | 3 | setup( 4 | name='python-math', 5 | version='1.0', 6 | packages=find_packages(include=['python-math', 'python-math.math-code-test-a']) 7 | ) 8 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-02-code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_02 - code to solve for x.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyMkb9lq6CM95aGaiVyafZkM", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "source": [ 34 | "Solving for x. The variable `eq` is the equation set equal to zero. This will print an array of solutions." 35 | ], 36 | "metadata": { 37 | "id": "9IAp4XVs3eNW" 38 | } 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": { 44 | "id": "x2tNfcmT3T8F" 45 | }, 46 | "outputs": [], 47 | "source": [ 48 | "import sympy \n", 49 | "from sympy import symbols \n", 50 | "from sympy.solvers import solve \n", 51 | "\n", 52 | "x = symbols('x') \n", 53 | "\n", 54 | "# Put the equation here\n", 55 | "eq = 2*x - 4\n", 56 | "\n", 57 | "print(\"x = \", solve(eq,x))\n", 58 | "\n" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "source": [ 64 | "" 65 | ], 66 | "metadata": { 67 | "id": "NWSbM1W34Hdl" 68 | }, 69 | "execution_count": null, 70 | "outputs": [] 71 | } 72 | ] 73 | } 74 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-01-code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_01 - code for proportions.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyMgp+q7JQAWEmr+nT99f9uW", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "source": [ 34 | "Set up a proportion:
\n", 35 | "$\\frac{n1}{d1}=\\frac{n2}{d2}$" 36 | ], 37 | "metadata": { 38 | "id": "v-0em0IOJeBX" 39 | } 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": null, 44 | "metadata": { 45 | "id": "NipG5UbBJWVd" 46 | }, 47 | "outputs": [], 48 | "source": [ 49 | "# Put a zero in for the unknown value\n", 50 | "n1 = 1\n", 51 | "d1 = 2\n", 52 | "n2 = 4\n", 53 | "d2 = 0\n", 54 | "\n", 55 | "if n2==0:\n", 56 | " answer = d2 * n1 / d1\n", 57 | " print(\"n2 = \", answer)\n", 58 | "\n", 59 | "if d2==0:\n", 60 | " answer = n2 * d1 / n1\n", 61 | " print(\"d2 = \", answer)\n" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "source": [ 67 | "" 68 | ], 69 | "metadata": { 70 | "id": "xUz4_xyHbqte" 71 | }, 72 | "execution_count": null, 73 | "outputs": [] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "source": [ 78 | "" 79 | ], 80 | "metadata": { 81 | "id": "bi38Sk39cVU9" 82 | }, 83 | "execution_count": null, 84 | "outputs": [] 85 | } 86 | ] 87 | } 88 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-03-xtra.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_03 - xtra.ipynb", 7 | "provenance": [], 8 | "authorship_tag": "ABX9TyOy/6ZIJWEZJqMCM/pn0zsM", 9 | "include_colab_link": true 10 | }, 11 | "kernelspec": { 12 | "name": "python3", 13 | "display_name": "Python 3" 14 | }, 15 | "language_info": { 16 | "name": "python" 17 | } 18 | }, 19 | "cells": [ 20 | { 21 | "cell_type": "markdown", 22 | "metadata": { 23 | "id": "view-in-github", 24 | "colab_type": "text" 25 | }, 26 | "source": [ 27 | "\"Open" 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "source": [ 33 | "Factoring and solving for a variable" 34 | ], 35 | "metadata": { 36 | "id": "qT5nPS3LaPAj" 37 | } 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "metadata": { 43 | "colab": { 44 | "base_uri": "https://localhost:8080/" 45 | }, 46 | "id": "egdhbgMnYPYA", 47 | "outputId": "97ee4c6e-8d01-4d86-93f1-9ba95e485338" 48 | }, 49 | "outputs": [ 50 | { 51 | "output_type": "stream", 52 | "name": "stdout", 53 | "text": [ 54 | "x = (-b + sqrt(-4*a*c + b**2))/(2*a)\n", 55 | "x = -(b + sqrt(-4*a*c + b**2))/(2*a)\n" 56 | ] 57 | } 58 | ], 59 | "source": [ 60 | "from sympy import *\n", 61 | "import math\n", 62 | "\n", 63 | "# Identify all variables\n", 64 | "var('a b c d x') \n", 65 | "\n", 66 | "# Left and right sides of the equal sign\n", 67 | "left = 0\n", 68 | "right = a*x**2 + b*x + c\n", 69 | "\n", 70 | "# Variable to solve for\n", 71 | "variable = x\n", 72 | "\n", 73 | "# Sympy equation left = right\n", 74 | "eq1 = Eq(left,right) \n", 75 | "\n", 76 | "# Sympy solve for that variable\n", 77 | "sol = solve(eq1,variable) \n", 78 | "\n", 79 | "# Show factored results\n", 80 | "for s in sol:\n", 81 | " print(variable, \" = \", s)\n" 82 | ] 83 | } 84 | ] 85 | } -------------------------------------------------------------------------------- /Algebra-with-Python/Week-07-code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_07 - Graphing systems of equations.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyP7cOBrCT9Vc2tnYjzV+ois", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "source": [ 34 | "Use numpy library instead of a loop" 35 | ], 36 | "metadata": { 37 | "id": "SNgivprofX7W" 38 | } 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": { 44 | "id": "fCBMXJEmeum4" 45 | }, 46 | "outputs": [], 47 | "source": [ 48 | "import matplotlib.pyplot as plt\n", 49 | "import numpy as np\n", 50 | "\n", 51 | "xmin = -10\n", 52 | "xmax = 10\n", 53 | "ymin = -10\n", 54 | "ymax = 10\n", 55 | "\n", 56 | "# Define how many points to plot \n", 57 | "points = 10*(xmax-xmin)\n", 58 | "\n", 59 | "# Define the array of x values once\n", 60 | "x = np.linspace(xmin,xmax,points)\n", 61 | "\n", 62 | "fig, ax = plt.subplots()\n", 63 | "plt.axis([xmin,xmax,ymin,ymax]) # window size\n", 64 | "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n", 65 | "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n", 66 | "\n", 67 | "# line 1\n", 68 | "y1 = 3*x\n", 69 | "plt.plot(x, y1) \n", 70 | "\n", 71 | "# line 2\n", 72 | "y2 = x**3\n", 73 | "plt.plot(x, y2) \n", 74 | "\n", 75 | "ax.grid(True)\n", 76 | "plt.show()\n", 77 | "\n" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "source": [ 83 | "" 84 | ], 85 | "metadata": { 86 | "id": "bE2BsE3yf4AI" 87 | }, 88 | "execution_count": null, 89 | "outputs": [] 90 | } 91 | ] 92 | } -------------------------------------------------------------------------------- /Algebra-with-Python/Week-03-practice.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_03 - practice.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyPgSVErHh4/W5FM6OuBVV0B", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "source": [ 34 | "Run this code to generate some practice problems" 35 | ], 36 | "metadata": { 37 | "id": "tbUQXIqJwzgm" 38 | } 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": { 44 | "id": "tbyFnUTI6PD2" 45 | }, 46 | "outputs": [], 47 | "source": [ 48 | "# converts string input (even fractions) to float\n", 49 | "def string_frac(in_string):\n", 50 | " if \"/\" in in_string:\n", 51 | " nd = in_string.split(\"/\")\n", 52 | " n = float(nd[0])\n", 53 | " d = float(nd[1])\n", 54 | " ans = n/d\n", 55 | " return ans\n", 56 | " else:\n", 57 | " ans = float(in_string)\n", 58 | " return ans\n", 59 | "\n", 60 | "\n", 61 | "# Decimal to fraction\n", 62 | "def dec_to_frac_test():\n", 63 | " import random\n", 64 | " import math\n", 65 | " # Uses string_frac()\n", 66 | " print(\"Convert the following decimal to a fraction\")\n", 67 | " print(\"Just use the / to write your fraction\")\n", 68 | " places = random.randint(1,4)\n", 69 | " decimal = round(random.random(), places)\n", 70 | " print(decimal)\n", 71 | " d = 10**places\n", 72 | " n = decimal*d\n", 73 | " ans_in = input(\"Fraction: \")\n", 74 | " if string_frac(ans_in)==decimal:\n", 75 | " print(\"Correct! \\n\")\n", 76 | " else:\n", 77 | " print(\"Try again\")\n", 78 | " print(\"The answer is \", n, \"/\", d)\n", 79 | "\n", 80 | "\n", 81 | "# Fraction to percent\n", 82 | "def frac_to_perc_test():\n", 83 | " import random\n", 84 | " print(\"Convert the following fraction to a percent\")\n", 85 | " n = round(random.randint(1,99))\n", 86 | " d = round(random.randint(2,200))\n", 87 | " print(n, \"/\", d)\n", 88 | " percent = round(n/d*100,2)\n", 89 | " print(\"Round your answer to two decimal places\")\n", 90 | " ans = float(input(\"Percent: \"))\n", 91 | " if ans==percent:\n", 92 | " print(\"Correct!\")\n", 93 | " else:\n", 94 | " print(\"Try again\")\n", 95 | " print(\"The answer is \", percent)\n", 96 | "\n", 97 | "\n", 98 | "# test loop\n", 99 | "for a in range(3):\n", 100 | " dec_to_frac_test()\n", 101 | " frac_to_perc_test()\n", 102 | " print(\" \")\n" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "source": [ 108 | "" 109 | ], 110 | "metadata": { 111 | "id": "cKDMJm1pAaiA" 112 | }, 113 | "execution_count": null, 114 | "outputs": [] 115 | } 116 | ] 117 | } -------------------------------------------------------------------------------- /Algebra-with-Python/Week-01-practice.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_01 - practice.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyMdjXwsvy+ey4yxWz8L7VMa", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "source": [ 34 | "Run this code to practice solving proportions. It will give you four practice problems. If you don't get them all correct, you can run this again to get more practice. Your answer can be a fraction, decimal, or whole number." 35 | ], 36 | "metadata": { 37 | "id": "8Js2i4mQi-S7" 38 | } 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": { 44 | "id": "wj5n3OeHi4JF" 45 | }, 46 | "outputs": [], 47 | "source": [ 48 | "# converts string input (including fractions) to float\n", 49 | "def string_frac(in_string):\n", 50 | " if \"/\" in in_string:\n", 51 | " nd = in_string.split(\"/\")\n", 52 | " n = float(nd[0])\n", 53 | " d = float(nd[1])\n", 54 | " ans = n/d\n", 55 | " return ans\n", 56 | " else:\n", 57 | " ans = float(in_string)\n", 58 | " return ans\n", 59 | "\n", 60 | "\n", 61 | "# Proportions - unknown numerator\n", 62 | "def proportions_n():\n", 63 | " import random\n", 64 | " # Uses string_frac() function\n", 65 | " n1 = random.randint(1,21)\n", 66 | " d1 = random.randint(1,21)\n", 67 | " n2 = \"x\"\n", 68 | " d2 = random.randint(1,21)\n", 69 | " print(n1, \"\\t\\t\", n2)\n", 70 | " print(\"--- \\t = \\t ---\")\n", 71 | " print(d1, \"\\t\\t\", d2)\n", 72 | " print(\" \")\n", 73 | " ans_in = input(\"x = \")\n", 74 | " answer = d2*n1/d1\n", 75 | " if string_frac(ans_in)==answer:\n", 76 | " print(\"Correct! \\n\")\n", 77 | " else:\n", 78 | " print(\"Try again\")\n", 79 | " print(\"The correct answer is \", answer, \"\\n\")\n", 80 | "\n", 81 | "\n", 82 | "# Proportions - unknown denominator\n", 83 | "def proportions_d():\n", 84 | " import random\n", 85 | " # Uses string_frac() function\n", 86 | " n1 = random.randint(1,21)\n", 87 | " d1 = random.randint(1,21)\n", 88 | " n2 = random.randint(1,21)\n", 89 | " d2 = \"x\"\n", 90 | " print(n1, \"\\t\\t\", n2)\n", 91 | " print(\"--- \\t = \\t ---\")\n", 92 | " print(d1, \"\\t\\t\", d2)\n", 93 | " print(\" \")\n", 94 | " ans_in = input(\"x = \")\n", 95 | " answer = d1*n2/n1\n", 96 | " if string_frac(ans_in)==answer:\n", 97 | " print(\"Correct! \\n\")\n", 98 | " else:\n", 99 | " print(\"Try again\")\n", 100 | " print(\"The correct answer is \", answer, \"\\n\")\n", 101 | "\n", 102 | "\n", 103 | "# test loop\n", 104 | "for a in range(2):\n", 105 | " proportions_n()\n", 106 | " proportions_d()\n", 107 | " print(\" \")\n", 108 | "\n" 109 | ] 110 | } 111 | ] 112 | } 113 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-02-practice.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_02 - practice.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyMV/yzTL1QGat9LUOT7JkSK", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "source": [ 34 | "Run this code to practice solving one-step and two-step problems. It will give you 12 practice problems. If you don't get them all correct, you can run this again to get more practice. Your answer can be a fraction, decimal, or whole number." 35 | ], 36 | "metadata": { 37 | "id": "afTMw7ajsmo4" 38 | } 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": { 44 | "id": "cWodkgQDlKuV" 45 | }, 46 | "outputs": [], 47 | "source": [ 48 | "# converts string input (even fractions) to float\n", 49 | "def string_frac(in_string):\n", 50 | " if \"/\" in in_string:\n", 51 | " nd = in_string.split(\"/\")\n", 52 | " n = float(nd[0])\n", 53 | " d = float(nd[1])\n", 54 | " ans = n/d\n", 55 | " return ans\n", 56 | " else:\n", 57 | " ans = float(in_string)\n", 58 | " return ans\n", 59 | "\n", 60 | "\n", 61 | "# Simplest one-step addition\n", 62 | "def one_step_add():\n", 63 | " import random\n", 64 | " # Display problem\n", 65 | " a = random.randint(-4,10)\n", 66 | " b = random.randint(2,24)\n", 67 | " print(\"x + \", a, \" = \", b)\n", 68 | " ans = float(input(\"x = \"))\n", 69 | " answer = b-a\n", 70 | " # Test input\n", 71 | " if ans==answer:\n", 72 | " print(\"Correct! \\n\")\n", 73 | " else:\n", 74 | " print(\"Try again\")\n", 75 | " print(\"The correct answer is \", answer, \"\\n\")\n", 76 | "\n", 77 | "\n", 78 | "# One-step additon with negaive numbers\n", 79 | "def one_step_subtract():\n", 80 | " import random\n", 81 | " a = random.randint(-19,-1)\n", 82 | " b = random.randint(2,24)\n", 83 | " print(a, \" + x = \", b)\n", 84 | " ans = float(input(\"x = \"))\n", 85 | " # test\n", 86 | " answer = b-a\n", 87 | " if ans==answer:\n", 88 | " print(\"Correct! \\n\")\n", 89 | " else:\n", 90 | " print(\"Try again\")\n", 91 | " print(\"The correct answer is \", answer, \"\\n\")\n", 92 | "\n", 93 | "# One-step multiply\n", 94 | "def one_step_mult():\n", 95 | " # Uses string_frac()\n", 96 | " import random\n", 97 | " a = random.randint(1,11)\n", 98 | " b = random.randint(2,24)\n", 99 | " print(a, \"x = \", b)\n", 100 | " ans_in = (input(\"x = \"))\n", 101 | " answer = b/a\n", 102 | " # test\n", 103 | " if string_frac(ans_in)==answer:\n", 104 | " print(\"Correct! \\n\")\n", 105 | " else:\n", 106 | " print(\"Try again\")\n", 107 | " print(\"The correct answer is \", answer, \"\\n\")\n", 108 | "\n", 109 | "\n", 110 | "# One-step divide\n", 111 | "def one_step_div():\n", 112 | " import random\n", 113 | " a = random.randint(1,11)\n", 114 | " b = random.randint(2,24)\n", 115 | " print(\"x/\", a, \" = \", b)\n", 116 | " ans = float(input(\"x = \"))\n", 117 | " answer = b*a\n", 118 | " # test\n", 119 | " if ans==answer:\n", 120 | " print(\"Correct! \\n\")\n", 121 | " else:\n", 122 | " print(\"Try again\")\n", 123 | " print(\"The correct answer is \", answer, \"\\n\")\n", 124 | "\n", 125 | "\n", 126 | "# Two-step problems\n", 127 | "def two_step():\n", 128 | " import random\n", 129 | " # Uses string_frac()\n", 130 | " a = random.randint(1,11)\n", 131 | " b = random.randint(-7,12)\n", 132 | " c = random.randint(2,36)\n", 133 | " print(a, \"x + \", b, \" = \", c)\n", 134 | " print(\"Round answer to two decimal places\")\n", 135 | " ans_in = input(\"x = \")\n", 136 | " answer = (c-b)/a\n", 137 | " # test\n", 138 | " if round(string_frac(ans_in),2)==round(answer,2):\n", 139 | " print(\"Correct! \\n\")\n", 140 | " else:\n", 141 | " print(\"Try again\")\n", 142 | " print(\"The correct answer is \", answer, \"\\n\")\n", 143 | "\n", 144 | "\n", 145 | "# test loop\n", 146 | "for a in range(2):\n", 147 | " one_step_add()\n", 148 | " one_step_subtract()\n", 149 | " one_step_mult()\n", 150 | " one_step_div()\n", 151 | " two_step()\n", 152 | " print(\" \")\n", 153 | "\n", 154 | "two_step()\n", 155 | "two_step()\n" 156 | ] 157 | } 158 | ] 159 | } 160 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-03-code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_03 - fractions and decimals.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyMIdlDkaGai/6IQIVg0lmv/", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "source": [ 34 | "Positive and negative exponents" 35 | ], 36 | "metadata": { 37 | "id": "-jJISeLWBmPO" 38 | } 39 | }, 40 | { 41 | "cell_type": "code", 42 | "source": [ 43 | "print(10**1)\n", 44 | "print(10**2)\n", 45 | "print(10**3)\n", 46 | "\n", 47 | "print(10**0)\n", 48 | "\n", 49 | "print(10**-1)\n", 50 | "print(10**-2)\n", 51 | "print(10**-3)\n" 52 | ], 53 | "metadata": { 54 | "id": "NkMTAVF0BlqE", 55 | "colab": { 56 | "base_uri": "https://localhost:8080/" 57 | }, 58 | "outputId": "9ad0555b-b96f-419f-d6a5-dd9063aac857" 59 | }, 60 | "execution_count": null, 61 | "outputs": [ 62 | { 63 | "output_type": "stream", 64 | "name": "stdout", 65 | "text": [ 66 | "10\n", 67 | "100\n", 68 | "1000\n", 69 | "1\n", 70 | "0.1\n", 71 | "0.01\n", 72 | "0.001\n" 73 | ] 74 | } 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "source": [ 80 | "User input comes in as a string. You can find the length of the string" 81 | ], 82 | "metadata": { 83 | "id": "M6tAOp4pDAtB" 84 | } 85 | }, 86 | { 87 | "cell_type": "code", 88 | "source": [ 89 | "text = input(\"Enter a number\")\n", 90 | "print(text)\n", 91 | "\n", 92 | "print(len(text))\n", 93 | "\n", 94 | "# error - can't do math here\n", 95 | "# print(text+3)\n" 96 | ], 97 | "metadata": { 98 | "id": "pzYatQcjCWhp", 99 | "colab": { 100 | "base_uri": "https://localhost:8080/" 101 | }, 102 | "outputId": "8695010a-dd21-4160-f4b8-a8ff2314f3a2" 103 | }, 104 | "execution_count": null, 105 | "outputs": [ 106 | { 107 | "output_type": "stream", 108 | "name": "stdout", 109 | "text": [ 110 | "Enter a number.123\n", 111 | ".123\n", 112 | "4\n" 113 | ] 114 | } 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "source": [ 120 | "Cast input as a `float` or `int` variable" 121 | ], 122 | "metadata": { 123 | "id": "3x1_knXsDG29" 124 | } 125 | }, 126 | { 127 | "cell_type": "code", 128 | "source": [ 129 | "text = input(\"Enter a number\")\n", 130 | "num = float(text)\n", 131 | "print(num + 4)\n" 132 | ], 133 | "metadata": { 134 | "id": "8mtkOWLXDPZK", 135 | "colab": { 136 | "base_uri": "https://localhost:8080/" 137 | }, 138 | "outputId": "4a632d26-51bd-44ff-f1b0-4d9de8c03b09" 139 | }, 140 | "execution_count": null, 141 | "outputs": [ 142 | { 143 | "output_type": "stream", 144 | "name": "stdout", 145 | "text": [ 146 | "Enter a number.123\n", 147 | "4.123\n" 148 | ] 149 | } 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "source": [ 155 | "Now put it all together" 156 | ], 157 | "metadata": { 158 | "id": "MB7AkCnVEz7N" 159 | } 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": null, 164 | "metadata": { 165 | "id": "pDaZckUyBKRl", 166 | "colab": { 167 | "base_uri": "https://localhost:8080/" 168 | }, 169 | "outputId": "4f179500-e52a-49cc-ce57-3c345ce8f581" 170 | }, 171 | "outputs": [ 172 | { 173 | "output_type": "stream", 174 | "name": "stdout", 175 | "text": [ 176 | "Enter a decimal number to convert: .2\n", 177 | "The decimal is 0.2\n", 178 | "The fraction is 2 / 10\n", 179 | "The percent is 20.0 %\n" 180 | ] 181 | } 182 | ], 183 | "source": [ 184 | "\n", 185 | "# Get string input, which will include a decimal point\n", 186 | "digits = input(\"Enter a decimal number to convert: \")\n", 187 | "\n", 188 | "# Get number of decimal places as an integer\n", 189 | "exponent = int(len(digits))-1\n", 190 | "\n", 191 | "# Convert the input to a float number\n", 192 | "n = float(digits)\n", 193 | "\n", 194 | "# Use the exponent to get the numerator\n", 195 | "numerator = int(n * 10**exponent)\n", 196 | "\n", 197 | "# Use the expoent to get the denominator\n", 198 | "denominator = 10**exponent\n", 199 | "\n", 200 | "# percent is the first two decimal places\n", 201 | "percent = n * 100\n", 202 | "\n", 203 | "# Output\n", 204 | "print(\"The decimal is \", n)\n", 205 | "print(\"The fraction is \", numerator, \"/\", denominator)\n", 206 | "print(\"The percent is \", percent, \" %\")\n", 207 | "\n" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "source": [ 213 | "" 214 | ], 215 | "metadata": { 216 | "id": "ScSV9M4iGj9E" 217 | }, 218 | "execution_count": null, 219 | "outputs": [] 220 | } 221 | ] 222 | } -------------------------------------------------------------------------------- /Algebra-with-Python/Week-15-code-graphing-data.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [], 7 | "authorship_tag": "ABX9TyPlcYtx5gQ09koFSwvjBiey", 8 | "include_colab_link": true 9 | }, 10 | "kernelspec": { 11 | "name": "python3", 12 | "display_name": "Python 3" 13 | }, 14 | "language_info": { 15 | "name": "python" 16 | } 17 | }, 18 | "cells": [ 19 | { 20 | "cell_type": "markdown", 21 | "metadata": { 22 | "id": "view-in-github", 23 | "colab_type": "text" 24 | }, 25 | "source": [ 26 | "\"Open" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "source": [ 32 | "Imports - Run this once" 33 | ], 34 | "metadata": { 35 | "id": "6MqbJhO67vEZ" 36 | } 37 | }, 38 | { 39 | "cell_type": "code", 40 | "source": [ 41 | "import pandas as pd\n", 42 | "import matplotlib.pyplot as plt\n", 43 | "from google.colab import files\n", 44 | "import io\n" 45 | ], 46 | "metadata": { 47 | "id": "xYlbmYF27tHs" 48 | }, 49 | "execution_count": null, 50 | "outputs": [] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "source": [ 55 | "Upload .csv file from your computer (one option)" 56 | ], 57 | "metadata": { 58 | "id": "I4W1sIjgN8cb" 59 | } 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": { 65 | "id": "ceZeWhkONC7e" 66 | }, 67 | "outputs": [], 68 | "source": [ 69 | "# dialog to upload from computer:\n", 70 | "uploaded = files.upload()\n", 71 | "file_name = next(iter(uploaded))\n", 72 | "table_1 = pd.read_csv(io.BytesIO(uploaded[file_name]))\n" 73 | ] 74 | }, 75 | { 76 | "cell_type": "markdown", 77 | "source": [ 78 | "Get .csv from a URL (another option)" 79 | ], 80 | "metadata": { 81 | "id": "Lxr7ANq5OAlf" 82 | } 83 | }, 84 | { 85 | "cell_type": "code", 86 | "source": [ 87 | "# Data relating to Old Faithful geyser eruptions\n", 88 | "url = \"https://people.sc.fsu.edu/~jburkardt/data/csv/faithful.csv\"\n", 89 | "\n", 90 | "table_1 = pd.read_csv(url)\n" 91 | ], 92 | "metadata": { 93 | "id": "r3hb1T9TOFib" 94 | }, 95 | "execution_count": null, 96 | "outputs": [] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "source": [ 101 | "Those imports and that url variable will be good for maybe 20 minutes, so you don't have to repeat those steps each time. Now determine what columns you want and convert them to numpy arrays." 102 | ], 103 | "metadata": { 104 | "id": "EeVG44BfOSvE" 105 | } 106 | }, 107 | { 108 | "cell_type": "code", 109 | "source": [ 110 | "# You could just display the whole table, but that might be too much\n", 111 | "# table_1\n", 112 | "\n", 113 | "# Get the headers so you can see the column names and two rows\n", 114 | "print(table_1.head(2))\n", 115 | "\n", 116 | "# Column names as a variable\n", 117 | "col_names = table_1.columns\n", 118 | "\n", 119 | "# Another way to get column names\n", 120 | "print(\"\\n column names:\")\n", 121 | "for a in range(len(col_names)):\n", 122 | " print(a, \" \", col_names[a])\n", 123 | "\n", 124 | "# One more way\n", 125 | "print(\"\\n column names:\")\n", 126 | "for col in col_names:\n", 127 | " print(col)\n" 128 | ], 129 | "metadata": { 130 | "id": "H112yU5SOqsX" 131 | }, 132 | "execution_count": null, 133 | "outputs": [] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "source": [ 138 | "Graph index and one other column as (x,y) points." 139 | ], 140 | "metadata": { 141 | "id": "QMzZL-FYOrX2" 142 | } 143 | }, 144 | { 145 | "cell_type": "code", 146 | "source": [ 147 | "# convert values to numpy arrays\n", 148 | "x = table_1['Index'].to_numpy()\n", 149 | "y = table_1[' \"Eruption length (mins)\"'].to_numpy()\n", 150 | "\n", 151 | "#graph\n", 152 | "xmin = x.min() - 5\n", 153 | "xmax = x.max() + 5\n", 154 | "ymin = 0 #y.min() - 5\n", 155 | "ymax = 6 #y.max() + 5\n", 156 | "\n", 157 | "fig, ax = plt.subplots()\n", 158 | "plt.axis([xmin,xmax,ymin,ymax]) # window size\n", 159 | "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n", 160 | "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n", 161 | "plt.plot(x,y,'ro') # scatterplot \n", 162 | "#plt.plot(x,y,'b') # line graph\n", 163 | "plt.show()\n" 164 | ], 165 | "metadata": { 166 | "id": "dGixsI7ROz0i" 167 | }, 168 | "execution_count": null, 169 | "outputs": [] 170 | }, 171 | { 172 | "cell_type": "markdown", 173 | "source": [ 174 | "Using variables for column names" 175 | ], 176 | "metadata": { 177 | "id": "y7bdq9ycBMuj" 178 | } 179 | }, 180 | { 181 | "cell_type": "code", 182 | "source": [ 183 | "x_name = col_names[0]\n", 184 | "y_name = col_names[2]\n", 185 | "\n", 186 | "# convert values to numpy arrays\n", 187 | "x = table_1[x_name].to_numpy()\n", 188 | "y = table_1[y_name].to_numpy()\n", 189 | "\n", 190 | "#graph\n", 191 | "xmin = 1#x.min() - 5\n", 192 | "xmax = 55 #x.max() + 5\n", 193 | "ymin = y.min() - 5\n", 194 | "ymax = y.max() + 5\n", 195 | "\n", 196 | "fig, ax = plt.subplots()\n", 197 | "plt.axis([xmin,xmax,ymin,ymax]) # window size\n", 198 | "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n", 199 | "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n", 200 | "plt.plot(x,y,'ro') # scatterplot \n", 201 | "plt.plot(x,y,'b') # line graph\n", 202 | "ax.set_xlabel(x_name)\n", 203 | "ax.set_ylabel(y_name)\n", 204 | "plt.show()\n" 205 | ], 206 | "metadata": { 207 | "id": "3deQqJ3xBZ5u" 208 | }, 209 | "execution_count": null, 210 | "outputs": [] 211 | } 212 | ] 213 | } 214 | -------------------------------------------------------------------------------- /math-code-test-e.py: -------------------------------------------------------------------------------- 1 | # Tests for Foundational Math Cert 5 2 | 3 | def step00(): 4 | print("Code test passed") 5 | print("Go on to the next step") 6 | 7 | 8 | def step01(): 9 | print("Was your prediction correct? What is the next number in the sequence?") 10 | print("Code test passed") 11 | print("Go on to the next step") 12 | 13 | 14 | def step02(code): 15 | import re 16 | print(" ") 17 | # print(3+2*a, ", ", end=" ") 18 | if re.search("print\(3\s*\+\s*2\*a\,\s*\"\,\s*\"\,\s*end\=\"\s*\"\)", code): 19 | print("Code test passed") 20 | print("Go on to the next step") 21 | else: 22 | print("You should use print(3+2*a, \", \", end=\" \") in your code") 23 | 24 | 25 | def step03(code): 26 | import re 27 | print(" ") 28 | # print(3*2**a, ", ", end=" ") 29 | if re.search("print\(3\*2\*\*a\,\s*\"\,\s*\"\,\s*end\=\"\s*\"\)", code): 30 | print("Code test passed") 31 | print("Go on to the next step") 32 | else: 33 | print("You should use print(3*2**a, \", \", end=\" \") in your code") 34 | 35 | 36 | def step04(code): 37 | import re 38 | print(" ") 39 | code_count = 0 40 | # next_number = a_list[n-1]*2+3 41 | if re.search("next\_number\s*=\s*0", code): 42 | print("Now just change the \'next_number = 0\' line") 43 | elif re.search("next\_number\s*=\s*a\_list\[n\-1\]\s*\*2\s*\+\s*3", code): 44 | print("Code test passed") 45 | else: 46 | print("You should use next_number = a_list[n-1]*2+3 in your code") 47 | 48 | 49 | def step05(code): 50 | import re 51 | print(" ") 52 | # fib[n-1] + fib[n-2] 53 | if re.search("fib\[n\-1\]\s*\+\s*fib\[n\-2\]", code): 54 | print("Code test passed") 55 | print("Go on to the next step") 56 | else: 57 | print("You should use fib[n-1] + fib[n-2] in your code") 58 | 59 | 60 | def step06(code): 61 | import re 62 | print(" ") 63 | code_count = 0 64 | # for x in range(len(b_list)): 65 | if re.search("range\(len\(b\_list\)\)\:", code): 66 | code_count = code_count + 1 67 | else: 68 | print("You should use range(len(b_list)): in your code") 69 | 70 | # plt.plot([x], [b_list[x]], 'bo') 71 | if re.search("plt\.plot\(\[[a-z]\]\,\s*\[b\_list\[[a-z]\]\]\,", code): 72 | code_count = code_count + 1 73 | else: 74 | print("You should use plt.plot([n], [b_list[n]], \'ro\') in your code") 75 | 76 | if code_count==2: 77 | print("Code test passed") 78 | print("Go on to the next step") 79 | 80 | 81 | def step07(code): 82 | import re 83 | print(" ") 84 | # sum = sum + element 85 | if sum==0: 86 | print("Now update the sum variable in the loop") 87 | elif re.search("sum\s*\=\s*sum\s*\+\s*element", code): 88 | print("Code test passed") 89 | print("Go on to the next step") 90 | else: 91 | print("You should use sum = sum + element in your code") 92 | 93 | 94 | def step08(code): 95 | import re 96 | print(" ") 97 | if re.search("range\(11\)\:", code): 98 | print("Now change the range to 42 and run this again") 99 | elif re.search("range\(42\)\:", code): 100 | print("Now change the range to 100 and run this again") 101 | if re.search("range\(100\)\:", code): 102 | print("Code test passed") 103 | print("Go on to the next step") 104 | 105 | 106 | def step09(code): 107 | import re 108 | print(" ") 109 | # print(math.factorial(number), 110 | if re.search("print\(number\,\s*\"\!\s*\=\s*\"\)", code): 111 | print("Now change the first print statement to include math.factorial()") 112 | elif re.search("print\(number\,\s*\"\!\s*\=\s*\"\,\s*math\.factorial\(number\)\)", code): 113 | print("Code test passed") 114 | print("Go on to the next step") 115 | else: 116 | print("You should use print(number, \"! = \", math.factorial(number)) in your code") 117 | 118 | 119 | def step10(code): 120 | import re 121 | print(" ") 122 | # for a in range(11): 123 | if re.search("for a in range\(11\)\:", code): 124 | print("Now change the range to be 100") 125 | elif re.search("for a in range\(100\)\:", code): 126 | print("Code test passed") 127 | print("Go on to the next step") 128 | else: 129 | print("You should use for a in range(100): in your code") 130 | 131 | 132 | def step11(code): 133 | import re 134 | print(" ") 135 | # probability = correct/possible 136 | if re.search("probability\s*\=\s*correct\/possible", code): 137 | print("Code test passed") 138 | print("Go on to the next step") 139 | else: 140 | print("You should use probability = correct/possible in your code") 141 | 142 | 143 | def step12(code): 144 | import re 145 | print(" ") 146 | if re.search("combined\_prob\s*\=\s*0", code): 147 | print("Now change the combined_prob line") 148 | elif re.search("combined\_prob\s*\=\s*prob\*prob\*prob\*prob", code): 149 | print("Code test passed") 150 | print("Go on to the next step") 151 | elif re.search("combined\_prob\s*\=\s*prob\*\*4", code): 152 | print("Code test passed") 153 | print("Go on to the next step") 154 | else: 155 | print("You should use combined_prob = prob**4 in your code") 156 | 157 | 158 | def step13(code): 159 | import re 160 | print(" ") 161 | if re.search("combined\_prob\s*\=\s*0", code): 162 | print("Now change the combined_prob line") 163 | elif re.search("combined\_prob\s*\=\s*prob\s*\+\s*prob\s*\+\s*prob", code): 164 | print("Code test passed") 165 | print("Go on to the next step") 166 | elif re.search("combined\_prob\s*\=\s*prob\s*\*3", code): 167 | print("Code test passed") 168 | print("Go on to the next step") 169 | else: 170 | print("You should use combined_prob = prob + prob + prob in your code") 171 | 172 | 173 | def step14(code): 174 | import re 175 | print(" ") 176 | # starters = math.factorial(n)/(math.factorial(r)*math.factorial(n-r)) 177 | if re.search("starters\s*\=\s*0", code): 178 | print("Now change the starters = 0 line") 179 | elif re.search("starters\s*\=\s*math\.factorial\(n\)\/\(math\.factorial\(r\)\*math\.factorial\(n\s*\-\s*r\)\)", code): 180 | print("Code test passed") 181 | print("Go on to the next step") 182 | else: 183 | print("You should use starters = math.factorial(n)/(math.factorial(r)*math.factorial(n-r)) in your code") 184 | 185 | def step15(code): 186 | import re 187 | print(" ") 188 | # arr = math.factorial(n)/math.factorial(n-r) 189 | if re.search("arr\s*\=\s*0", code): 190 | print("Now change the arr = 0 line") 191 | elif re.search("arr\s*\=\s*math\.factorial\(n\)\/math\.factorial\(n\s*\-\s*r\)", code): 192 | print("Code test passed") 193 | else: 194 | print("You should use arr = math.factorial(n)/math.factorial(n-r) in your code") 195 | 196 | -------------------------------------------------------------------------------- /math-code-test-b.py: -------------------------------------------------------------------------------- 1 | # Tests for Foundational Math Cert 2 2 | 3 | def step01(): 4 | print("Code test Passed") 5 | print("Go on to the next step") 6 | 7 | 8 | def step02(code): 9 | import re 10 | print(" ") 11 | if re.search("plt\.axis\(\[\-20\,\s*20\,\s*\-20\,\s*20\]\)", code): 12 | print("Code test passed") 13 | print("Go on to the next step") 14 | elif re.search("plt\.axis\(\[\-10\,\s*10\,\s*\-10\,\s*10\]\)", code): 15 | print("Now change the values in plt.axis() and re-run the code.") 16 | else: 17 | print("You should use plt.axis([-20,20,-20,20]) in your code") 18 | 19 | 20 | def step03(code): 21 | import re 22 | print(" ") 23 | if re.search("xmax\s*=\s*20", code): 24 | print("Code test passed") 25 | print("Go on to the next step") 26 | elif re.search("xmax\s*=\s*10", code): 27 | print("Now change the values xmax to 20 and re-run the code.") 28 | else: 29 | print("You should use xmax = 20 in your code") 30 | 31 | 32 | def step04(code): 33 | import re 34 | print(" ") 35 | code_count = 0 36 | #plt.plot([xmin,xmax],[0,0],'b') # blue x axis 37 | if re.search("plt\.plot\(\[xmin\,xmax\]\,\[0\,0\]\,\s*\'g\'\)", code): 38 | code_count = code_count+1 39 | elif re.search("plt\.plot\(\[xmin\,xmax\]\,\[0\,0\]\,\s*\'b\'\)", code): 40 | print("Now change the 'b' to 'g' for each axis and re-run the code.") 41 | else: 42 | print("You should use plt.plot([xmin,xmax],[0,0],'g') in your code") 43 | 44 | #plt.plot([0,0],[ymin,ymax], 'b') # blue y axis 45 | if re.search("plt\.plot\(\[0\,0\]\,\[ymin\,ymax\]\,\s*\'g\'\)", code): 46 | code_count = code_count+1 47 | elif re.search("plt\.plot\(\[0\,0\]\,\[ymin\,ymax\]\,\s*\'b\'\)", code): 48 | print("Now change the 'b' to 'g' for each axis and re-run the code.") 49 | else: 50 | print("You should use plt.plot([0,0],[ymin,ymax], 'g') in your code") 51 | 52 | if code_count==2: 53 | print("Code test passed") 54 | print("Go on to the next step") 55 | 56 | 57 | def step05(code): 58 | import re 59 | print(" ") 60 | if re.search("plt\.plot\(\[\-5\]\,\s*\[1\]\,\s*\'ro\'\)", code): 61 | print("Code test passed") 62 | print("Go on to the next step") 63 | else: 64 | print("You should use plt.plot([-5],[1], \'ro\') in your code") 65 | 66 | 67 | def step06(code): 68 | import re 69 | code_count = 0 70 | print(" ") 71 | if re.search("x\s*\=\s*\[4\,\s*1\,\s*2\]", code): 72 | code_count = code_count + 1 73 | else: 74 | print("You should use x = [4,1,2] in your code") 75 | 76 | if re.search("y\s*\=\s*\[2\,\s*1\,\s*5\]", code): 77 | code_count = code_count + 1 78 | else: 79 | print("You should use y = [2,1,5] in your code") 80 | 81 | if code_count == 2: 82 | print("Code test passed") 83 | print("Go on to the next step") 84 | 85 | 86 | def step07(code): 87 | import re 88 | code_count = 0 89 | print(" ") 90 | if re.search("plt.plot\(linex\,\s*liney\,\s*\'r\'\)", code): 91 | code_count = code_count + 1 92 | else: 93 | print("You should use plt.plot(linex, liney, \'r\') in your code") 94 | 95 | if re.search("plt.plot\(pointx\,\s*pointy\,\s*\'gs\'\)", code): 96 | code_count = code_count + 1 97 | else: 98 | print("You should use plt.plot(pointx, pointy, \'gs\') in your code") 99 | 100 | if code_count == 2: 101 | print("Code test passed") 102 | print("Go on to the next step") 103 | 104 | 105 | def step08(count): 106 | if count==3: 107 | print("You scored 3 out of 3. Good job!") 108 | 109 | print("You can go on to the next step") 110 | 111 | 112 | def step09(code): 113 | import re 114 | print(" ") 115 | if re.search("plt\.plot\(x\,\s*\-x\s*\+\s*3\)", code): 116 | print("Code test passed") 117 | print("Go on to the next step") 118 | elif re.search("plt\.plot\(x\,\s*2\*x\s*\-\s*3\)", code): 119 | print("Now change the equation and re-run the code.") 120 | else: 121 | print("You should use plt.plot(x, -x + 3) in your code.") 122 | 123 | 124 | # step 10 re-uses step01() 125 | 126 | 127 | def step11(code): 128 | import re 129 | print(" ") 130 | if re.search("y2\s*\=\s*\-x\s*\-\s*3", code): 131 | print("Code test passed") 132 | print("Go on to the next step") 133 | elif re.search("y2\s*\=\s*x\*\*2\s*\-\s*3", code): 134 | print("Now change y2 and re-run the code.") 135 | else: 136 | print("You should use y2 = -x - 3 in your code.") 137 | 138 | 139 | def step12(code): 140 | import re 141 | print(" ") 142 | if re.search("linsolve\(\[2\*x\s*\+\s*y\s*\-\s*15\,\s*3\*x\s*\-\s*y\],\s*\(x\,\s*y\)\)", code): 143 | print("Code test passed") 144 | print("Go on to the next step") 145 | elif re.search("linsolve\(\[2\*x\s*\+\s*y\s*\-\s*1\,\s*x\s*\-\s*2\*y\s*\+\s*7\]\,\s*\(x\, y\)\)", code): 146 | print("Now change the equations and re-run the code.") 147 | else: 148 | print("You should use linsolve([2*x + y - 15, 3*x - y], (x,y)) in your code.") 149 | 150 | 151 | # step 13 uses step01() 152 | 153 | def step14(): 154 | print(" ") 155 | print("If you didn't get a syntax error, code test passed") 156 | 157 | 158 | # steps 15 and 16 re-use step01() 159 | 160 | 161 | def step17(code): 162 | import re 163 | code_count = 0 164 | first_run = 0 165 | 166 | if re.search("f\(a\,b\)\:", code): 167 | print("Now change the code and run it again") 168 | first_run = 1 169 | 170 | if re.search("f\(a\,\s*b\,\s*c\)\:", code): 171 | code_count = code_count + 1 172 | elif first_run==1: 173 | code_count = 0 174 | else: 175 | print("You should use f(a,b,c): in your code") 176 | 177 | # plt.plot(x, a*x**2 + b*x + c) 178 | if re.search("\(x\,\s*a\*x\*\*2\s*\+\s*b\*x\s*\+\s*c\)", code): 179 | code_count = code_count + 1 180 | elif first_run==1: 181 | code_count = 0 182 | else: 183 | print("You should use plt.plot(x, a*x**2 + b*x + c) in your code") 184 | 185 | # interactive(f, a=(-9, 9), b=(-9,9), c=(-9,9)) 186 | if re.search("\(f\,\s*a\=\(\-9\,\s*9\)\,\s*b\=\(\-9\,\s*9\)\,\s*c\=\(\-9\,\s*9\)\)", code): 187 | code_count = code_count + 1 188 | elif first_run==1: 189 | code_count = 0 190 | else: 191 | print("You should include 'interactive(f, a=(-9, 9), b=(-9,9), c=(-9,9))' in your code") 192 | 193 | if code_count == 3: 194 | print("Code test passed") 195 | print("Go on to the next step") 196 | 197 | print(" ") 198 | 199 | 200 | 201 | def step18(code): 202 | import re 203 | print(" ") 204 | code_count = 0 205 | if re.search("vx\s*\=\s*\-b\/\(2\*a\)", code): 206 | code_count = code_count + 1 207 | else: 208 | print("You should include vx = -b/(2*a)") 209 | 210 | if re.search("vy\s*\=\s*a\*vx\*\*2\s*\+\s*b\*vx\s*\+\s*c", code): 211 | code_count = code_count + 1 212 | else: 213 | print("You should include vy = a*vx**2 + b*vx + c") 214 | 215 | if code_count==2: 216 | print("Code test passed") 217 | print("Go on to the next step") 218 | 219 | 220 | def step19(code): 221 | import re 222 | print(" ") 223 | # vx = -b/(2*a) 224 | # vy = a*vx**2 + b*vx + c 225 | code_count = 0 226 | if re.search("vx\s*\=\s*\-b\/\(2\*a\)", code): 227 | code_count = code_count + 1 228 | else: 229 | print("You should include vx = -b/(2*a)") 230 | 231 | if re.search("vy\s*\=\s*a\*vx\*\*2\s*\+\s*b\*vx\s*\+\s*c", code): 232 | code_count = code_count + 1 233 | else: 234 | print("You should include vy = a*vx**2 + b*vx + c") 235 | 236 | if code_count==2: 237 | print("Code test passed") 238 | print("Go on to the next step") 239 | 240 | 241 | # step 20 - no test 242 | 243 | 244 | def step21(code): 245 | import re 246 | print(" ") 247 | code_count = 0 248 | if re.search("x1\s*\=\s*\(\-b\s*\+\s*math\.sqrt\(b\*\*2\s*\-\s*4\*a\*c\)\)\/\(2\*a\)", code): 249 | code_count = code_count + 1 250 | else: 251 | print("You should include x1 = (-b + math.sqrt(b**2 - 4*a*c))/(2*a)") 252 | 253 | if re.search("x2\s*\=\s*\(\-b\s*\-\s*math\.sqrt\(b\*\*2\s*\-\s*4\*a\*c\)\)\/\(2\*a\)", code): 254 | code_count = code_count + 1 255 | else: 256 | print("You should include x2 = (-b - math.sqrt(b**2 - 4*a*c))/(2*a)") 257 | 258 | if code_count==2: 259 | print("Code test passed") 260 | print("Go on to the next step") 261 | 262 | 263 | def step22(code): 264 | import re 265 | print(" ") 266 | if re.search("rows\.append\(\[a\,\s*2\*a\]\)", code): 267 | print("Now change the equation to y = 3x + 2") 268 | elif re.search("rows\.append\(\[a\,\s*3\*a\+2\]\)", code): 269 | print("Code test passed") 270 | print("Go on to the next step") 271 | else: 272 | print("Your code should include rows.append([a, 3*a+2])") 273 | 274 | -------------------------------------------------------------------------------- /math-code-test-c.py: -------------------------------------------------------------------------------- 1 | # Tests for Foundational Math Cert 3 2 | 3 | 4 | def step00(): 5 | print("Code test passed") 6 | print("Go on to the next step") 7 | 8 | 9 | def step01(code): 10 | import re 11 | print(" ") 12 | if re.search("plt\.fill_between\(x\,\s*y1\,\s*0\)", code): 13 | print("Now change the code to shade above the line and run it again.") 14 | elif re.search("plt\.fill_between\(x\,\s*y1\,\s*ymax\)", code): 15 | print("Code test passed") 16 | print("Go on to the next step") 17 | else: 18 | print("You should use plt.fill_between(x, y1, ymax) in your code") 19 | 20 | 21 | def step02(code): 22 | import re 23 | print(" ") 24 | if re.search("plt\.plot\(x\,\s*y1\)", code): 25 | print("Now change the code to make a dashed red line and run it again.") 26 | elif re.search("plt\.plot\(x\,\s*y1\,\s*\'r\-\-\'\)", code): 27 | print("Code test passed") 28 | print("Go on to the next step") 29 | else: 30 | print("You should use plt.plot(x, y1, 'r--') in your code") 31 | 32 | 33 | def step03(code): 34 | import re 35 | print(" ") 36 | if re.search("\(x\,\s*y1\,\s*10\,\s*facecolor\s*\=\s*\'red\'\)", code): 37 | print("Now change the code to reverse the color order.") 38 | elif re.search("plt\.fill\_between\(x\,\s*y1\,\s*10\,\s*facecolor\=\'blue\'\)", code): 39 | print("Code test passed") 40 | print("Go on to the next step") 41 | else: 42 | print("you should use `plt.fill_between(x, y1, 10, facecolor='blue')` in your code") 43 | 44 | 45 | def step05(code): 46 | import re 47 | print(" ") 48 | code_count = 0 49 | if re.search("c\s*\=\s*int\(input\(\"Enter coefficient C\:\s*\"\)\)", code): 50 | code_count = code_count + 1 51 | else: 52 | print("You should use c = int(input(\"Enter coefficient C: \")) in your code") 53 | 54 | if re.search("d\s*\=\s*int\(input\(\"Enter coefficient D\:\s*\"\)\)", code): 55 | code_count = code_count + 1 56 | else: 57 | print("You should use d = int(input(\"Enter coefficient D: \")) in your code") 58 | 59 | if re.search("y\s*\=\s*a\*x\*\*3\s*\+\s*b\*x\*\*2\s*\+\s*c\*x\s*\+\s*d", code): 60 | code_count = code_count + 1 61 | else: 62 | print("You should use y = a*x**3 + b*x**2 + c*x + d in your code") 63 | 64 | if code_count==3: 65 | print("Code test passed") 66 | print("Go on to the next step") 67 | 68 | 69 | def step06(code): 70 | import re 71 | print(" ") 72 | code_count = 0 73 | if re.search("plt\.plot\(x\,\s*a\*x\*\*2\s*\+\s*b\*x\)", code): 74 | print("Now change the three lines of code and run this again.") 75 | elif re.search("plt\.plot\(x\,\s*a\*x\*\*2\s*\+\s*b\*x\s*\+\s*c\)", code): 76 | code_count = code_count + 1 77 | 78 | if re.search("f\(a\,\s*b\,\s*c\)", code): 79 | code_count = code_count + 1 80 | 81 | if re.search("c\s*=\s*\(\-9\,\s*9\)\)", code): 82 | code_count = code_count + 1 83 | 84 | if code_count==3: 85 | print("Code test passed") 86 | print("Go on to the next step") 87 | 88 | 89 | def step07(code): 90 | import re 91 | print(" ") 92 | code_count = 0 93 | if re.search("a\s*=\s*\(1\,\s*9\)\,\s*b\=\(1\,\s*9\)\)", code): 94 | print("Now change the interactive_plot and run this again.") 95 | elif re.search("a\s*=\s*\(\-9\,\s*\-1\)\,\s*b\=\(1\,\s*9\)\)", code): 96 | print("Code test passed") 97 | print("Go on to the next step") 98 | else: 99 | print("You should use interactive(f, a=(-9, -1), b=(1, 9)) in your code.") 100 | 101 | 102 | def step08(code): 103 | import re 104 | print(" ") 105 | if re.search("a\s*\=\s*p\*\(1\s*\+\s*r\)\*\*t", code): 106 | print("Code test passed") 107 | print("Go on to the next step") 108 | else: 109 | print("You should use a = p*(1+r)**t in your code.") 110 | 111 | 112 | def step09(code): 113 | import re 114 | print(" ") 115 | if re.search("a\s*\=\s*p\*\(1\s*\-\s*r\)\*\*t", code): 116 | print("Code test passed") 117 | print("Go on to the next step") 118 | else: 119 | print("You should use a = p*(1-r)**t in your code.") 120 | 121 | 122 | def step10(code): 123 | import re 124 | print(" ") 125 | if re.search("annuity\s*\=\s*p\*\(1\s*\+\s*\(r\/n\)\)\*\*\(n\*t\)", code): 126 | print("Code test passed") 127 | print("Go on to the next step") 128 | else: 129 | print("You should use annuity = p*(1+(r/n))**(n*t) in your code.") 130 | 131 | 132 | def step11(code): 133 | import re 134 | print(" ") 135 | code_count = 0 136 | # a_annual = p*(1+r)**t 137 | if re.search("a\_annual\s*\=\s*p\*\(1\+r\)\*\*t", code): 138 | code_count = code_count + 1 139 | else: 140 | print("You should use a_annual = p*(1+r)**t in your code") 141 | 142 | # a_n_times = p*(1+r/n)**(n*t) 143 | if re.search("a\_n\_times\s*\=\s*p\*\(1\+r\/n\)\*\*\(n\*t\)", code): 144 | code_count = code_count + 1 145 | else: 146 | print("You should use a_n_times = p*(1+r/n)**(n*t) in your code") 147 | 148 | # a_continuous = p*math.e**(r*t) 149 | if re.search("a\_continuous\s*\=\s*p\*math\.e\*\*\(r\*t\)", code): 150 | code_count = code_count + 1 151 | else: 152 | print("You should use a_continuous = p*math.e**(r*t) in your code") 153 | 154 | if code_count==3: 155 | print("Code test passed") 156 | print("Go on to the next step") 157 | 158 | 159 | def step12(p,r,t,monthly,annuity): 160 | print(" ") 161 | a2 = p 162 | for b in range(12*t): 163 | a2 = a2 + monthly 164 | interest = a2*r/12 165 | a2 = a2 + interest 166 | 167 | if annuity==a2: 168 | print("Code test passed") 169 | print("Go on to the next step") 170 | else: 171 | print("You should use interest = annuity * r / 12 in your code.") 172 | 173 | 174 | def step13(p,r,t,pmt): 175 | # one solution: 176 | mult = 1+(r/12) 177 | exp = 12*t 178 | top = r/12*mult**exp 179 | bot = (mult**exp)-1 180 | pmt2 = p*top/bot 181 | print(" ") 182 | if pmt==pmt2: 183 | print("Code test passed") 184 | print("Go on to the next step") 185 | else: 186 | print("Here is one way to write the code, using extra variables:") 187 | print("mult = 1+r/12") 188 | print("exp = 12*t") 189 | print("top = r/12*mult**exp") 190 | print("bot = (mult**exp)-1") 191 | print("pmt = top/bot") 192 | 193 | 194 | def step14(code): 195 | import re 196 | print(" ") 197 | if re.search("exp\s*\=\s*math\.log\(result\,\s*base\)", code): 198 | print("Code test passed") 199 | print("Go on to the next step") 200 | else: 201 | print("You should use exp = math.log(result, base) in your code") 202 | 203 | 204 | # Step 15 re-uses step00() 205 | 206 | 207 | def step16(code): 208 | import re 209 | print(" ") 210 | if re.search("exp\s*\=\s*math\.floor\(math\.log\(n\,\s*10\)\)", code): 211 | print("Now remove the math.floor function and run it again.") 212 | elif re.search("exp\s*\=\s*math\.log\(n\,\s*10\)", code): 213 | print("Code test passed") 214 | print("Go on to the next step") 215 | else: 216 | print("You should use exp = math.log(n, 10) in your code") 217 | 218 | 219 | def step17(b1,b2): 220 | import re 221 | print(" ") 222 | code_count = 0 223 | if b1==4.13: 224 | code_count = code_count + 1 225 | else: 226 | print("b1 should be 4.13") 227 | 228 | if b2==-10: 229 | code_count = code_count + 1 230 | else: 231 | print("b2 should be -10") 232 | 233 | if code_count==2: 234 | print("Code test passed") 235 | print("Go on to the next step") 236 | 237 | 238 | def step18(code): 239 | import re 240 | print(" ") 241 | code_count = 0 242 | if re.search("x2\s*\=\s*math\.floor\(math\.log\(b\,\s*10\)\)", code): 243 | code_count = code_count + 1 244 | else: 245 | print("You should use x2 = math.floor(math.log(b,10)) in your code") 246 | 247 | if re.search("n2\s*\=\s*round\(b\*10\*\*\(\-x2\)\,\s*2\)", code): 248 | code_count = code_count + 1 249 | else: 250 | print("You should use n2 = round(b*10**(-x2),2) in your code") 251 | 252 | if code_count==2: 253 | print("Code test passed") 254 | print("Go on to the next step") 255 | 256 | 257 | def step19(code): 258 | import re 259 | print(" ") 260 | code_count = 0 261 | if re.search("x\s*=\s*math\.floor\(math\.log\(a\,\s*10\)\)", code): 262 | code_count = code_count + 1 263 | else: 264 | print("You should use x = math.floor(math.log(a,10)) in your code") 265 | 266 | if re.search("n\s*=\s*round\(a\*10\*\*\(\-x\)\,\s*2\)", code): 267 | code_count = code_count + 1 268 | else: 269 | print("You should use n = round(a*10**(-x),2) in your code") 270 | 271 | if code_count==2: 272 | print("Code test passed") 273 | print("Go on to the next step") 274 | 275 | 276 | def step20(code): 277 | import re 278 | print(" ") 279 | code_count = 0 280 | 281 | # plt.plot(x2, np.log2(x2), 'g') 282 | if re.search("plt\.plot\(x1\,\s*math\.e\*\*x1\,\s*\'b\'\)", code): 283 | print("Now change the blue line and run this again") 284 | elif re.search("plt\.plot\(x2\,\s*np\.log2\(x2\)\,\s*\'g\'\)", code): 285 | code_count = code_count + 1 286 | else: 287 | print("You should use plt.plot(x2, np.log2(x2), 'g') in your code") 288 | 289 | # plt.plot(x1, 2**x1, 'b') 290 | if re.search("plt\.plot\(x1\,\s*math\.e\*\*x1\,\s*\'b\'\)", code): 291 | print("Now change the green line and run this again") 292 | elif re.search("plt\.plot\(x1\,\s*2\*\*x1\,\s*\'b\'\)", code): 293 | code_count = code_count + 1 294 | else: 295 | print("You should use plt.plot(x1, 2**x1, 'b') in your code") 296 | 297 | if code_count==2: 298 | print("Code test passed") 299 | print("Go on to the next step") 300 | 301 | 302 | def step21(code): 303 | # math.ceil(-math.log(decimal, 10)) 304 | import re 305 | print(" ") 306 | if re.search("math\.ceil\(\-math\.log\(decimal\,\s*10\)\)", code): 307 | print("Code test passed") 308 | else: 309 | print("You should use h = math.ceil(-math.log(decimal, 10)) in your code") 310 | 311 | 312 | 313 | 314 | 315 | 316 | 317 | 318 | 319 | 320 | 321 | 322 | 323 | -------------------------------------------------------------------------------- /math-code-test-a.py: -------------------------------------------------------------------------------- 1 | # Tests for Foundational Math Cert 1 2 | 3 | def step01(code): 4 | import re 5 | print(" ") 6 | if re.search("print\s*\(\s*a\s*\+\s*b\s*\)", code): 7 | print("Code test passed") 8 | print("Go on to the next step") 9 | else: 10 | print("You should use print(a + b) in your code") 11 | 12 | 13 | def step02(code): 14 | import re 15 | print(" ") 16 | if re.search("print\s*\(\s*c\s*\-\s*d\s*\)", code): 17 | print("Code test passed") 18 | print("Go on to the next step") 19 | else: 20 | print("You should use print(c - d) in your code") 21 | 22 | 23 | def step03(code): 24 | import re 25 | print(" ") 26 | if re.search("print\s*\(\s*[e]\s*\*\s*[f]\s*\)", code): 27 | print("Code test passed") 28 | print("Go on to the next step") 29 | else: 30 | print("You should use print(e * f) in your code") 31 | 32 | 33 | def step04(code): 34 | import re 35 | print(" ") 36 | if re.search("print\s*\(\s*[g]\s*\/\s*[h]\s*\)", code): 37 | print("Code test passed") 38 | print("Go on to the next step") 39 | else: 40 | print("You should use print(g/h) in your code") 41 | 42 | 43 | def step05(code): 44 | import re 45 | print(" ") 46 | if re.search("intB\s*\=\s*int\(strB\)", code): 47 | print("Code test passed") 48 | print("Go on to the next step") 49 | else: 50 | print("You should use intB = int(strB) in your code") 51 | 52 | 53 | def step06(code): 54 | import re 55 | print(" ") 56 | #intA = int(input('Enter an integer: ')) 57 | if re.search("intB\s*\=\s*int\(input\(\'Enter an integer\:\s*\'\)\)", code): 58 | print("Code test passed") 59 | print("Go on to the next step") 60 | else: 61 | print("You should use intB = int(input('Enter an integer: ')) in your code") 62 | 63 | 64 | def step07(code): 65 | import re 66 | print(" ") 67 | #b = float(input('Enter a number: ')) 68 | if re.search("b\s*\=\s*float\(input\(\'Enter a number\:\s*\'\)\)", code): 69 | print("Code test passed") 70 | print("Go on to the next step") 71 | else: 72 | print("You should use b = float(input('Enter a number: ')) in your code") 73 | 74 | 75 | def step08(answer): 76 | print(" ") 77 | if answer==8: 78 | print("Code test passed") 79 | print("Go on to the next step") 80 | else: 81 | print("You can try again if you like") 82 | 83 | 84 | def step09(code): 85 | import re 86 | print(" ") 87 | # print(a%b) 88 | if re.search("print\(a\s*\%\s*b\)", code): 89 | print("Code test passed") 90 | print("Go on to the next step") 91 | else: 92 | print("You should use print(a % b) in your code") 93 | 94 | 95 | def step10(code): 96 | import re 97 | print(" ") 98 | if re.search("if number\s*\%\s*test\_factor\s*\=\=\s*0\:", code): 99 | print("Code test passed") 100 | print("Go on to the next step") 101 | else: 102 | print("You should use if number % test_factor == 0: in your code") 103 | 104 | 105 | def step11(code): 106 | import re 107 | print(" ") 108 | if re.search("if number\s*\%\s*test\_factor\s*\=\=\s*0:", code): 109 | print("Code test passed") 110 | print("Go on to the next step") 111 | else: 112 | print("Your code should include if number % test_factor == 0:") 113 | 114 | 115 | def step12(code): 116 | import re 117 | print(" ") 118 | if re.search("if test\_number\:", code): 119 | print("Now change the if statement") 120 | elif re.search("if number\s*\%\s*test\_number\=\=0\:", code): 121 | print("Code test passed") 122 | print("Go on to the next step") 123 | else: 124 | print("Your code should include if number % test_number == 0:") 125 | 126 | 127 | def step13(code): 128 | import re 129 | print(" ") 130 | if re.search("print\(1\/n\)", code): 131 | print("Code test passed") 132 | print("Go on to the next step") 133 | else: 134 | print("Your code should include print(1/n)") 135 | 136 | 137 | def step14(code): 138 | import re 139 | print(" ") 140 | if re.search("b\s*=\s*float\(sp\[1\]\)", code): 141 | print("Code test passed") 142 | print("Go on to the next step") 143 | else: 144 | print("Your code should include b = float(sp[1])") 145 | 146 | 147 | def step15(code): 148 | import re 149 | print(" ") 150 | if re.search("print\(n\*\*2\)", code): 151 | print("Code test passed") 152 | print("Go on to the next step") 153 | else: 154 | print("Your code should include print(n**2)") 155 | 156 | 157 | def step16(code): 158 | import re 159 | print(" ") 160 | if re.search("print\(math\.sqrt\(n\)\)", code): 161 | print("Code test passed") 162 | print("Go on to the next step") 163 | else: 164 | print("Your code should include print(math.sqrt(n))") 165 | 166 | 167 | def step17(code): 168 | import re 169 | print(" ") 170 | if re.search("print\(math\.floor\(n\)\)", code): 171 | print("Code test passed") 172 | print("Go on to the next step") 173 | else: 174 | print("Your code should include print(math.floor(n))") 175 | 176 | 177 | def step18(code): 178 | import re 179 | print(" ") 180 | code_count=0 181 | 182 | # if n % (maybe_factor**2) == 0: 183 | if re.search("if n\s*\%\s*\(maybe\_factor\*\*2\)\s*\=\=\s*0\:", code): 184 | code_count = code_count + 1 185 | else: 186 | print("Your code should include if n % (maybe_factor**2) == 0:") 187 | 188 | # max_factor = maybe_factor 189 | if re.search("max\_factor\s*\=\s*maybe\_factor\*\*2", code): 190 | code_count = code_count + 1 191 | else: 192 | print("Your code should include max_factor = maybe_factor**2") 193 | 194 | if code_count==2: 195 | print("Code test passed") 196 | print("Go on to the next step") 197 | 198 | 199 | def step19(): 200 | print("\n Test passed. You can go on to the next step.") 201 | 202 | 203 | def step20(): 204 | print("\n Test passed. This is this your factored square root:\n") 205 | 206 | 207 | def step21(code): 208 | import re 209 | print(" ") 210 | code_count = 0 211 | code = In[-1].split('# Only change code above this line')[0]; 212 | if re.search("print\(round\(a\,\s*\-6\)", code): 213 | code_count = code_count + 1 214 | else: 215 | print("Your code should inlcude 'print(round(a,-6)'") 216 | 217 | if re.search("print\(round\(b\,\s*3\)", code): 218 | code_count = code_count + 1 219 | else: 220 | print("Your code should inlcude 'print(round(b,3)'") 221 | 222 | if code_count == 2: 223 | print("Code test passed") 224 | print("Go on to the next step") 225 | 226 | 227 | def step22(): 228 | print(" ") 229 | # one solution 230 | numerator2 = int(n*10**exponent) 231 | denominator2 = 10**exponent 232 | percent2 = n*100 233 | code_count = 0 234 | if numerator2==numerator: 235 | code_count = code_count + 1 236 | else: 237 | print("You should use numerator = int(n*10**exponent) in your code") 238 | 239 | if denominator2==denominator: 240 | code_count = code_count + 1 241 | else: 242 | print("You should use denominator = 10**exponent in your code") 243 | 244 | if percent2==percent: 245 | code_count = code_count + 1 246 | else: 247 | print("You should use percent = n*100 in your code") 248 | 249 | if code_count==3: 250 | print("Code test passed") 251 | print("Go on to the next step") 252 | 253 | 254 | def step23(code): 255 | import re 256 | print(" ") 257 | code_count = 0 258 | if re.search("def say\_something\(\)\:", code): 259 | print("Now change the name of the function") 260 | elif re.search("def fun\(\)\:", code): 261 | code_count = code_count+1 262 | else: 263 | print("You should include def fun(): in your code") 264 | 265 | if re.search("\nsay\_something\(\)", code): 266 | print("Also remember to call the function") 267 | elif re.search("\nfun\(\)\s*", code): 268 | code_count = code_count+1 269 | else: 270 | print("Remember to call the function fun() in your code") 271 | 272 | if code_count==2: 273 | print("Code test passed") 274 | print("Go on to the next step") 275 | 276 | 277 | def step24(code): 278 | import re 279 | print(" ") 280 | code_count = 0 281 | if re.search("nom\s*\=\s*input", code): 282 | print("Now change the variable name from 'nom' to 'nombre'") 283 | elif re.search("nombre\s*\=\s*input", code): 284 | code_count = code_count + 1 285 | else: 286 | print("Your code should include nombre = input(...") 287 | 288 | if re.search("greeting\(nom\)", code): 289 | print("Now change the argument when you call the function") 290 | elif re.search("greeting\(nombre\)", code): 291 | code_count = code_count + 1 292 | else: 293 | print("Your code should include greeting(nombre)") 294 | 295 | if code_count==2: 296 | print("Code test passed") 297 | print("You can go on to the next step") 298 | 299 | 300 | def step25(code): 301 | import re 302 | print(" ") 303 | code_count = 0 304 | if re.search("add\(first\,\s*second\)", code): 305 | print("Now include the third variable when you call the function") 306 | elif re.search("add\(first\,\s*second\,\s*third\)", code): 307 | code_count = code_count + 1 308 | else: 309 | print("Your code should include add(first,second,third)") 310 | 311 | if re.search("def add\(a\,\s*b\)\:", code): 312 | print("Now change the argument when you define the function") 313 | elif re.search("def add\(a\,\s*b\,\s*c\)\:", code): 314 | code_count = code_count + 1 315 | else: 316 | print("Your code should include def add(a,b,c):") 317 | 318 | if re.search("sum\s*\=\s*a\s*\+\s*b\s*\+\s*c", code): 319 | code_count = code_count + 1 320 | elif re.search("sum\s*\=\s*a\s*\+\s*b", code): 321 | print("Now change the sum line in the function") 322 | else: 323 | print("Your code should include sum = a + b + c") 324 | 325 | if code_count==3: 326 | print("Code test passed") 327 | print("You can go on to the next step") 328 | 329 | 330 | def step26(code): 331 | import re 332 | print(" ") 333 | code_count = 0 334 | if re.search("return number\*2", code): 335 | print("Now change the return statement in the function") 336 | elif re.search("return number\*3", code): 337 | print("Code test passed") 338 | print("You can go on to the next step") 339 | else: 340 | print("Your code should include return number*3") 341 | 342 | 343 | def step27(code): 344 | print("If you didn't get a syntax error, you are ready for the project") 345 | 346 | # probably add 3 more steps 347 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-06-code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_06 - factoring.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyNv7W9XXU829Mm7h60R21cP", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "source": [ 34 | "The modulus (`%`) finds the remainder " 35 | ], 36 | "metadata": { 37 | "id": "x8RGjdh8PwIe" 38 | } 39 | }, 40 | { 41 | "cell_type": "code", 42 | "source": [ 43 | "#print(5%3) \n", 44 | "\n", 45 | "print(31%10) \n" 46 | ], 47 | "metadata": { 48 | "id": "2uoBCLFnPvtC", 49 | "colab": { 50 | "base_uri": "https://localhost:8080/" 51 | }, 52 | "outputId": "b65443c1-0d64-41e7-8a84-f6d175b9ed6c" 53 | }, 54 | "execution_count": null, 55 | "outputs": [ 56 | { 57 | "output_type": "stream", 58 | "name": "stdout", 59 | "text": [ 60 | "1\n" 61 | ] 62 | } 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "source": [ 68 | "Use the modulus in a loop to find factors" 69 | ], 70 | "metadata": { 71 | "id": "JLX_cWbhQU3v" 72 | } 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": { 78 | "id": "w--Zka73nnBA", 79 | "colab": { 80 | "base_uri": "https://localhost:8080/" 81 | }, 82 | "outputId": "7bc34e5c-2be0-4df9-b67b-57159b7fe39d" 83 | }, 84 | "outputs": [ 85 | { 86 | "output_type": "stream", 87 | "name": "stdout", 88 | "text": [ 89 | "1\n", 90 | "2\n", 91 | "3\n", 92 | "4\n", 93 | "6\n", 94 | "12\n" 95 | ] 96 | } 97 | ], 98 | "source": [ 99 | "\n", 100 | "number = 12 \n", 101 | "\n", 102 | "# Find all factors \n", 103 | "for test_factor in range(1,number+1): \n", 104 | " if number%test_factor==0: \n", 105 | " print(test_factor) \n" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "source": [ 111 | "Reduce fractions to lowest terms" 112 | ], 113 | "metadata": { 114 | "id": "_D4O3GOnROuQ" 115 | } 116 | }, 117 | { 118 | "cell_type": "code", 119 | "source": [ 120 | "numerator = 12\n", 121 | "denominator = 24\n", 122 | "factor = 1\n", 123 | "\n", 124 | "# Find greatest common factor \n", 125 | "for test_factor in range(1,denominator+1): \n", 126 | " if numerator%test_factor==0 and denominator%test_factor==0:\n", 127 | " factor = test_factor \n", 128 | "\n", 129 | "# Divide out greatest common factor \n", 130 | "n = int(numerator/factor) \n", 131 | "d = int(denominator/factor) \n", 132 | "\n", 133 | "print(\"original: \", numerator, \"/\", denominator) \n", 134 | "print(\"reduced: \", n, \"/\", d) \n" 135 | ], 136 | "metadata": { 137 | "id": "6Q01c0zyQd2-", 138 | "colab": { 139 | "base_uri": "https://localhost:8080/" 140 | }, 141 | "outputId": "e0d12799-989c-48f5-9ebb-c4456833067a" 142 | }, 143 | "execution_count": null, 144 | "outputs": [ 145 | { 146 | "output_type": "stream", 147 | "name": "stdout", 148 | "text": [ 149 | "original: 12 / 24\n", 150 | "reduced: 1 / 2\n" 151 | ] 152 | } 153 | ] 154 | }, 155 | { 156 | "cell_type": "markdown", 157 | "source": [ 158 | "You can add this code to the decimal-to-fraction code" 159 | ], 160 | "metadata": { 161 | "id": "PNMJQnJITZsU" 162 | } 163 | }, 164 | { 165 | "cell_type": "code", 166 | "source": [ 167 | "# Get the decimal number to convert\n", 168 | "digits = input(\"Enter a decimal number to convert: \") \n", 169 | "\n", 170 | "# Convert to fraction \n", 171 | "exponent = int(len(digits))-1 \n", 172 | "n = float(digits) \n", 173 | "numerator = int(n * 10**exponent) \n", 174 | "denominator = 10**exponent \n", 175 | "\n", 176 | "# Reduce that fraction\n", 177 | "factor = 1 \n", 178 | "for test_factor in range(1,denominator+1): \n", 179 | " if numerator%test_factor==0 and denominator%test_factor==0: \n", 180 | " factor = test_factor \n", 181 | "\n", 182 | "# Divide out greatest common factor \n", 183 | "num = int(numerator/factor) \n", 184 | "den = int(denominator/factor) \n", 185 | "\n", 186 | "# Output \n", 187 | "print(\"The decimal is \", n) \n", 188 | "print(\"The fraction is \", num, \"/\", den) \n" 189 | ], 190 | "metadata": { 191 | "id": "sCvtP7UCSU8X", 192 | "colab": { 193 | "base_uri": "https://localhost:8080/" 194 | }, 195 | "outputId": "6cfa54ae-2963-41db-9b38-ff6a72b63891" 196 | }, 197 | "execution_count": null, 198 | "outputs": [ 199 | { 200 | "output_type": "stream", 201 | "name": "stdout", 202 | "text": [ 203 | "Enter a decimal number to convert: .02\n", 204 | "The decimal is 0.02\n", 205 | "The fraction is 1 / 50\n" 206 | ] 207 | } 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "source": [ 213 | "Next level... factoring square roots" 214 | ], 215 | "metadata": { 216 | "id": "KMJIAXH8Vgg5" 217 | } 218 | }, 219 | { 220 | "cell_type": "code", 221 | "source": [ 222 | "import math\n", 223 | "\n", 224 | "print(math.sqrt(24)) \n" 225 | ], 226 | "metadata": { 227 | "id": "-giePhMGUxd3", 228 | "colab": { 229 | "base_uri": "https://localhost:8080/" 230 | }, 231 | "outputId": "71d9e39e-8ac9-4306-e032-d7652d40aaa6" 232 | }, 233 | "execution_count": null, 234 | "outputs": [ 235 | { 236 | "output_type": "stream", 237 | "name": "stdout", 238 | "text": [ 239 | "4.898979485566356\n" 240 | ] 241 | } 242 | ] 243 | }, 244 | { 245 | "cell_type": "markdown", 246 | "source": [ 247 | "Divide out any perfect square factors. For example:
\n", 248 | " $\\sqrt{12}$ = $\\sqrt{4 * 3}$ = 2$\\sqrt{3}$
\n", 249 | "Because 4 is a square number, the square root of 4 is now outside the radical." 250 | ], 251 | "metadata": { 252 | "id": "raHMQ-AIWgUs" 253 | } 254 | }, 255 | { 256 | "cell_type": "code", 257 | "source": [ 258 | "import math\n", 259 | "\n", 260 | "# number to factor\n", 261 | "n = 12 \n", 262 | "\n", 263 | "# This variable will change\n", 264 | "max_factor = 1 \n", 265 | "\n", 266 | "# The key ingredient\n", 267 | "upper_limit = math.floor(math.sqrt(n)) + 1 \n", 268 | "\n", 269 | "# Find square factors\n", 270 | "for maybe_factor in range(1,upper_limit): \n", 271 | " if n % (maybe_factor**2) == 0: \n", 272 | " max_factor = maybe_factor \n", 273 | "\n", 274 | "# Results so far\n", 275 | "print(\"n = \", n) \n", 276 | "print(\"Square rooted factor = \", max_factor) \n", 277 | "print(\"Square factor = \", max_factor**2) \n", 278 | "print(\"integer: \", n/(max_factor**2)) \n" 279 | ], 280 | "metadata": { 281 | "id": "aR-ny0yGWy_5", 282 | "colab": { 283 | "base_uri": "https://localhost:8080/" 284 | }, 285 | "outputId": "44bc5ecf-dd18-4f41-addd-148a97af7c3f" 286 | }, 287 | "execution_count": null, 288 | "outputs": [ 289 | { 290 | "output_type": "stream", 291 | "name": "stdout", 292 | "text": [ 293 | "n = 12\n", 294 | "Square rooted factor = 2\n", 295 | "Square factor = 4\n", 296 | "integer: 3.0\n" 297 | ] 298 | } 299 | ] 300 | }, 301 | { 302 | "cell_type": "markdown", 303 | "source": [ 304 | "Using Sympy to make this look nice" 305 | ], 306 | "metadata": { 307 | "id": "66QuFOmPavkK" 308 | } 309 | }, 310 | { 311 | "cell_type": "code", 312 | "source": [ 313 | "import math\n", 314 | "import sympy\n", 315 | "from sympy import symbols\n", 316 | "\n", 317 | "n = 24 \n", 318 | "\n", 319 | "# Use these variables\n", 320 | "upper_limit = math.floor(math.sqrt(n)) + 1 \n", 321 | "max_factor = 1 \n", 322 | "other_factor = 1 \n", 323 | "square_root = 1 \n", 324 | "\n", 325 | "# Slightly different variable strategy\n", 326 | "for maybe_factor in range(1, upper_limit): \n", 327 | " if n % (maybe_factor**2) == 0: \n", 328 | " max_factor = maybe_factor**2 \n", 329 | "\n", 330 | "# Divide out the greatest square factor\n", 331 | "other_factor = n/max_factor \n", 332 | "\n", 333 | "# Output variables\n", 334 | "square_root = int(math.sqrt(max_factor)) \n", 335 | "other_factor = int(other_factor) \n", 336 | "output = square_root*sympy.sqrt(other_factor) \n", 337 | "\n", 338 | "# Sympy output without print statement - must be last line\n", 339 | "output " 340 | ], 341 | "metadata": { 342 | "id": "GOGAgeL5aOUn", 343 | "colab": { 344 | "base_uri": "https://localhost:8080/", 345 | "height": 38 346 | }, 347 | "outputId": "5a6ae80e-833e-40e0-e4a1-44799f506db0" 348 | }, 349 | "execution_count": null, 350 | "outputs": [ 351 | { 352 | "output_type": "execute_result", 353 | "data": { 354 | "text/plain": [ 355 | "2*sqrt(6)" 356 | ], 357 | "text/latex": "$\\displaystyle 2 \\sqrt{6}$" 358 | }, 359 | "metadata": {}, 360 | "execution_count": 13 361 | } 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "source": [ 367 | "" 368 | ], 369 | "metadata": { 370 | "id": "m2w_NB_IbgSG" 371 | }, 372 | "execution_count": null, 373 | "outputs": [] 374 | } 375 | ] 376 | } -------------------------------------------------------------------------------- /Algebra-with-Python/Week-02-xtra.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_02 - xtra problems.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyMkDMOxl20Pu1aULjQXT9WP", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "source": [ 34 | "Simplest solve-for-x code" 35 | ], 36 | "metadata": { 37 | "id": "LmokZPV-0DiX" 38 | } 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": { 44 | "id": "ckVvVnV0_unB", 45 | "colab": { 46 | "base_uri": "https://localhost:8080/" 47 | }, 48 | "outputId": "a9f5edc7-9040-44f4-d581-fca75b1f9c00" 49 | }, 50 | "outputs": [ 51 | { 52 | "output_type": "execute_result", 53 | "data": { 54 | "text/plain": [ 55 | "[-sqrt(2), sqrt(2)]" 56 | ] 57 | }, 58 | "metadata": {}, 59 | "execution_count": 14 60 | } 61 | ], 62 | "source": [ 63 | "import sympy \n", 64 | "from sympy import symbols \n", 65 | "from sympy.solvers import solve \n", 66 | "\n", 67 | "x = symbols('x') \n", 68 | "\n", 69 | "# Put the equation here\n", 70 | "eq = 2*x**2 - 4\n", 71 | "\n", 72 | "solve(eq,x)\n" 73 | ] 74 | }, 75 | { 76 | "cell_type": "markdown", 77 | "source": [ 78 | "Prompt for someone to enter the equation, then solve" 79 | ], 80 | "metadata": { 81 | "id": "NjNAC8YtFA7P" 82 | } 83 | }, 84 | { 85 | "cell_type": "code", 86 | "source": [ 87 | "import sympy\n", 88 | "from sympy import symbols\n", 89 | "from sympy.solvers import solve\n", 90 | "\n", 91 | "x = symbols('x')\n", 92 | "eq = input('Enter equation: 0 = ')\n", 93 | "\n", 94 | "print(\"x = \", solve(eq,x))\n" 95 | ], 96 | "metadata": { 97 | "id": "Hbri3pi4E_0t", 98 | "colab": { 99 | "base_uri": "https://localhost:8080/" 100 | }, 101 | "outputId": "6490cacd-8a59-4c5e-c83d-4d2e09aca107" 102 | }, 103 | "execution_count": null, 104 | "outputs": [ 105 | { 106 | "output_type": "stream", 107 | "name": "stdout", 108 | "text": [ 109 | "Enter equation: 0 = 3*x-6\n", 110 | "x = [2]\n" 111 | ] 112 | } 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "source": [ 118 | "Doing more with the solution" 119 | ], 120 | "metadata": { 121 | "id": "4umZtVuOBRth" 122 | } 123 | }, 124 | { 125 | "cell_type": "code", 126 | "source": [ 127 | "import sympy \n", 128 | "from sympy import symbols \n", 129 | "from sympy.solvers import solve \n", 130 | "\n", 131 | "x = symbols('x') \n", 132 | "\n", 133 | "# Put the equation here\n", 134 | "eq = 2*x - 4\n", 135 | "\n", 136 | "solution = solve(eq,x)\n", 137 | "print(\"x = \", solution[0])" 138 | ], 139 | "metadata": { 140 | "id": "7AKDuplzBLs8", 141 | "colab": { 142 | "base_uri": "https://localhost:8080/" 143 | }, 144 | "outputId": "18314f9e-2388-49d0-b87b-e88fcff8188f" 145 | }, 146 | "execution_count": null, 147 | "outputs": [ 148 | { 149 | "output_type": "stream", 150 | "name": "stdout", 151 | "text": [ 152 | "x = 2\n" 153 | ] 154 | } 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "source": [ 160 | "Multiple answers" 161 | ], 162 | "metadata": { 163 | "id": "fjHiCB3cFcKl" 164 | } 165 | }, 166 | { 167 | "cell_type": "code", 168 | "source": [ 169 | "import sympy \n", 170 | "from sympy import symbols \n", 171 | "from sympy.solvers import solve \n", 172 | "\n", 173 | "x = symbols('x') \n", 174 | "\n", 175 | "eq = input('Enter equation: 0 = ')\n", 176 | "\n", 177 | "solution = solve(eq,x)\n", 178 | "for s in solution:\n", 179 | " print(\"x = \", s)\n", 180 | "\n", 181 | "\n" 182 | ], 183 | "metadata": { 184 | "id": "JAvk-AYdFj0k", 185 | "colab": { 186 | "base_uri": "https://localhost:8080/" 187 | }, 188 | "outputId": "7fc4edc2-36b8-40c8-cc82-6f2d668f1c3b" 189 | }, 190 | "execution_count": null, 191 | "outputs": [ 192 | { 193 | "output_type": "stream", 194 | "name": "stdout", 195 | "text": [ 196 | "Enter equation: 0 = (x-1)*(x+2)*(x-3)\n", 197 | "x = -2\n", 198 | "x = 1\n", 199 | "x = 3\n" 200 | ] 201 | } 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "source": [ 207 | "Solving in other ways" 208 | ], 209 | "metadata": { 210 | "id": "UO90DRn1ElWm" 211 | } 212 | }, 213 | { 214 | "cell_type": "code", 215 | "source": [ 216 | "from sympy import *\n", 217 | "\n", 218 | "\n", 219 | "var('x y') \n", 220 | "\n", 221 | "# First equation set equal to zero, ready to solve\n", 222 | "first = 2*x - y\n", 223 | "\n", 224 | "\n", 225 | "# Sympy syntax for equation equal to zero, ready to factor\n", 226 | "eq1 = Eq(first,0) \n", 227 | "\n", 228 | "# Sympy solve for x\n", 229 | "sol = solve(eq1,x) \n", 230 | "\n", 231 | "# Show factored results\n", 232 | "print(\"x = \", sol[0])\n", 233 | "\n" 234 | ], 235 | "metadata": { 236 | "id": "aYJgodznDAh9", 237 | "colab": { 238 | "base_uri": "https://localhost:8080/" 239 | }, 240 | "outputId": "2d3a9980-fad3-4689-ac3c-b2d43e34e63e" 241 | }, 242 | "execution_count": null, 243 | "outputs": [ 244 | { 245 | "output_type": "stream", 246 | "name": "stdout", 247 | "text": [ 248 | "x = y/2\n" 249 | ] 250 | } 251 | ] 252 | }, 253 | { 254 | "cell_type": "markdown", 255 | "source": [ 256 | "Factoring" 257 | ], 258 | "metadata": { 259 | "id": "qYjbHYiAPoNj" 260 | } 261 | }, 262 | { 263 | "cell_type": "code", 264 | "source": [ 265 | "import sympy \n", 266 | "from sympy import * \n", 267 | "\n", 268 | "var('x y') \n", 269 | "\n", 270 | "# Equation set equal to zero, ready to solve\n", 271 | "#eq = x**2-4\n", 272 | "eq = x**3 - 2*x**2 - 5*x + 6 \n", 273 | "\n", 274 | "sympy.factor(eq)\n" 275 | ], 276 | "metadata": { 277 | "id": "2JjZ1cPNPqe8", 278 | "colab": { 279 | "base_uri": "https://localhost:8080/", 280 | "height": 38 281 | }, 282 | "outputId": "908a0ea9-f6fd-45e1-9855-4fb184156cf0" 283 | }, 284 | "execution_count": null, 285 | "outputs": [ 286 | { 287 | "output_type": "execute_result", 288 | "data": { 289 | "text/plain": [ 290 | "(x - 3)*(x - 1)*(x + 2)" 291 | ], 292 | "text/latex": "$\\displaystyle \\left(x - 3\\right) \\left(x - 1\\right) \\left(x + 2\\right)$" 293 | }, 294 | "metadata": {}, 295 | "execution_count": 2 296 | } 297 | ] 298 | }, 299 | { 300 | "cell_type": "markdown", 301 | "source": [ 302 | "Explaining how each function works" 303 | ], 304 | "metadata": { 305 | "id": "Kdhalbn6Axlb" 306 | } 307 | }, 308 | { 309 | "cell_type": "code", 310 | "source": [ 311 | "# converts string input (including fractions) to float\n", 312 | "def string_frac(in_string):\n", 313 | " if \"/\" in in_string:\n", 314 | " nd = in_string.split(\"/\")\n", 315 | " n = float(nd[0])\n", 316 | " d = float(nd[1])\n", 317 | " ans = n/d\n", 318 | " return ans\n", 319 | " else:\n", 320 | " ans = float(in_string)\n", 321 | " return ans\n", 322 | "\n", 323 | "\n", 324 | "# Simplest one-step addition\n", 325 | "def one_step_add():\n", 326 | " import random\n", 327 | " # Display problem\n", 328 | " a = random.randint(-4,10)\n", 329 | " b = random.randint(2,24)\n", 330 | " print(\"x + \", a, \" = \", b) \n", 331 | " ans = float(input(\"x = \"))\n", 332 | " answer = b-a\n", 333 | " # Test input\n", 334 | " if ans==answer:\n", 335 | " print(\"Correct! \\n\")\n", 336 | " else:\n", 337 | " print(\"Try again\")\n", 338 | " print(\"The correct answer is \", answer, \"\\n\")\n", 339 | "\n", 340 | "\n", 341 | "# One-step additon with negaive numbers\n", 342 | "def one_step_subtract():\n", 343 | " import random\n", 344 | " a = random.randint(-19,-1)\n", 345 | " b = random.randint(2,24)\n", 346 | " print(a, \" + x = \", b)\n", 347 | " ans = float(input(\"x = \"))\n", 348 | " # test\n", 349 | " answer = b-a\n", 350 | " if ans==answer:\n", 351 | " print(\"Correct! \\n\")\n", 352 | " else:\n", 353 | " print(\"Try again\")\n", 354 | " print(\"The correct answer is \", answer, \"\\n\")\n", 355 | "\n", 356 | "# One-step multiply\n", 357 | "def one_step_mult():\n", 358 | " # Uses string_frac()\n", 359 | " import random\n", 360 | " a = random.randint(1,11) \n", 361 | " b = random.randint(2,24)\n", 362 | " print(a, \"x = \", b) \n", 363 | " ans_in = (input(\"x = \"))\n", 364 | " answer = b/a\n", 365 | " # test\n", 366 | " if string_frac(ans_in)==answer:\n", 367 | " print(\"Correct! \\n\")\n", 368 | " else:\n", 369 | " print(\"Try again\")\n", 370 | " print(\"The correct answer is \", answer, \"\\n\")\n", 371 | "\n" 372 | ], 373 | "metadata": { 374 | "id": "EDb4C13-Avt9" 375 | }, 376 | "execution_count": null, 377 | "outputs": [] 378 | }, 379 | { 380 | "cell_type": "markdown", 381 | "source": [ 382 | "Can't do string to fraction" 383 | ], 384 | "metadata": { 385 | "id": "7cS0UihuLnot" 386 | } 387 | }, 388 | { 389 | "cell_type": "code", 390 | "source": [ 391 | "print(3/4)\n" 392 | ], 393 | "metadata": { 394 | "id": "b2kw4OFGLzaE", 395 | "colab": { 396 | "base_uri": "https://localhost:8080/" 397 | }, 398 | "outputId": "8d145c33-784d-4623-e953-25155d9341f6" 399 | }, 400 | "execution_count": null, 401 | "outputs": [ 402 | { 403 | "output_type": "stream", 404 | "name": "stdout", 405 | "text": [ 406 | "0.75\n" 407 | ] 408 | } 409 | ] 410 | }, 411 | { 412 | "cell_type": "code", 413 | "source": [ 414 | "frac = float(input(\"fraction = \"))\n", 415 | "print(frac)\n" 416 | ], 417 | "metadata": { 418 | "id": "gMUhKFIWL4Iz" 419 | }, 420 | "execution_count": null, 421 | "outputs": [] 422 | } 423 | ] 424 | } -------------------------------------------------------------------------------- /math-code-test-d.py: -------------------------------------------------------------------------------- 1 | # Tests for Foundational Math Cert 4 2 | 3 | def step00(): 4 | print("Code test passed") 5 | print("Go on to the next step") 6 | 7 | 8 | def step01(code): 9 | import re 10 | print(" ") 11 | # verts = [(0., 0.), (0., 2.), (2., 2.), (2., 0.), (0., 0.),] 12 | # verts = [(0., 0.), (-1., 1.), (0., 2.), (2., 2.), (3., 1.), (2., 0.), (0., 0.),] 13 | if re.search("verts\s*\=\s*\[\(0\.\,\s*0\.\)\,\s*\(0\.\,\s*2\.\)\,\s*\(2\.\,\s*2\.\)\,\s*\(2\.\,\s*0\.\)\,\s*\(0\.\,\s*0\.\)\,\s*\]", code): 14 | print("Now change the code and run it again.") 15 | elif re.search("verts\s*\=\s*\[\(0\.\,\s*0\.\)\,\s*\(\-1\.\,\s*1\.\)\,\s*\(0\.\,\s*2\.\)\,\s*\(2\.\,\s*2\.\)\,\s*\(3\.\,\s*1\.\)\,\s*\(2\.\,\s*0\.\)\,\s*\(0\.\,\s*0\.\)\,\s*\]", code): 16 | print("Code test passed") 17 | print("Go on to the next step") 18 | else: 19 | print("You should use verts = [(0., 0.), (-1., 1.), (0., 2.), (2., 2.), (3., 1.), (2., 0.), (0., 0.),] in your code") 20 | 21 | 22 | def step02(code): 23 | import re 24 | print(" ") 25 | code_count = 0 26 | # input 27 | if re.search("c\_string\s*=\s*input\(\"Side\s*c\s*=\s*\"\)", code): 28 | code_count = code_count + 1 29 | else: 30 | print("You should use c_string = input(\"Side c = \") in your code") 31 | 32 | # if 33 | if re.search("if\s*\(c\_string\s*\=\=\s*\"c\"\)\:", code): 34 | code_count = code_count + 1 35 | else: 36 | print("You should use if (c_string==\"c\"): in your code") 37 | 38 | # formula 39 | if re.search("c\s*=\s*math\.sqrt\(a\*\*2\s*\+\s*b\*\*2\)", code): 40 | code_count = code_count + 1 41 | else: 42 | print("You should use c = math.sqrt(a**2 + b**2) in your code") 43 | 44 | # print 45 | if re.search("print\(\"c\s*=\s*\"\,\s*c\)", code): 46 | code_count = code_count + 1 47 | else: 48 | print("You should use print(\"c = \", c) in your code") 49 | 50 | # code count 51 | if code_count==4: 52 | print("Code test passed") 53 | print("Go on to the next step") 54 | 55 | 56 | def step03(): 57 | print("Notice how the distance is the hypotenuse") 58 | print("Go on to the next step") 59 | 60 | 61 | def step04(code): 62 | import re 63 | print(" ") 64 | code_count = 0 65 | 66 | # x2 = float(second[0]) 67 | if re.search("x2\s*\=\s*float\(second\[0\]\)", code): 68 | code_count = code_count + 1 69 | else: 70 | print("You should use x2 = float(second[0]) in your code") 71 | 72 | # y2 = float(second[1]) 73 | if re.search("y2\s*\=\s*float\(second\[1\]\)", code): 74 | code_count = code_count + 1 75 | else: 76 | print("You should use y2 = float(second[1]) in your code") 77 | 78 | # distance = math.sqrt((x2-x1)**2 + (y2-y1)**2) 79 | if re.search("distance\s*\=\s*math\.sqrt\(\(x2\-x1\)\*\*2\s*\+\s*\(y2\-y1\)\*\*2\)", code): 80 | code_count = code_count + 1 81 | else: 82 | print("You should use distance = math.sqrt((x2-x1)**2 + (y2-y1)**2) in your code") 83 | 84 | # code count 85 | if code_count==3: 86 | print("Code test passed") 87 | print("Go on to the next step") 88 | 89 | 90 | def step05(code): 91 | import re 92 | print(" ") 93 | code_count = 0 94 | # x = (x1+x2)/2 95 | if re.search("x\s*\=\s*\(x1\s*\+\s*x2\)\/2", code): 96 | code_count = code_count + 1 97 | else: 98 | print("You should use x = (x1+x2)/2 in your code") 99 | 100 | # y = (y1+y2)/2 101 | if re.search("y\s*\=\s*\(y1\s*\+\s*y2\)\/2", code): 102 | code_count = code_count + 1 103 | else: 104 | print("You should use y = (y1+y2)/2 in your code") 105 | 106 | # code count 107 | if code_count==2: 108 | print("Code test passed") 109 | print("Go on to the next step") 110 | 111 | 112 | def step06(): 113 | print("Notice the description of each side") 114 | print("Go on to the next step") 115 | 116 | 117 | def step07(): 118 | print("Notice how the description of each side changed") 119 | print("Go on to the next step") 120 | 121 | 122 | def step08(): 123 | print("Notice the different ratios for A and B") 124 | print("Go on to the next step") 125 | 126 | 127 | def step09(code): 128 | import re 129 | print(" ") 130 | code_count = 0 131 | if re.search("sinA\s*\=\s*opp\/hyp", code): 132 | print("Code test passed") 133 | print("Go on to the next step") 134 | else: 135 | print("You should use sinA = opp/hyp in your code") 136 | 137 | 138 | def step10(): 139 | print(" ") 140 | print("Notice the different ratios for A and B") 141 | print("Go on to the next step") 142 | 143 | 144 | def step11(code): 145 | import re 146 | print(" ") 147 | code_count = 0 148 | if re.search("cosA\s*\=\s*adj\/hyp", code): 149 | print("Code test passed") 150 | print("Go on to the next step") 151 | else: 152 | print("You should use cosA = adj/hyp in your code") 153 | 154 | 155 | def step12(): 156 | print(" ") 157 | print("Notice the different ratios for A and B") 158 | print("Go on to the next step") 159 | 160 | 161 | def step13(code): 162 | import re 163 | print(" ") 164 | if re.search("tanA\s*\=\s*opp\/adj", code): 165 | print("Code test passed") 166 | print("Go to the next step") 167 | else: 168 | print("You should use tanA = opp/adj in your code") 169 | 170 | 171 | def step14(code): 172 | import re 173 | print(" ") 174 | code_count = 0 175 | # cosA_actual = round(b/c,4) 176 | if re.search("cosA\_actual\s*\=\s*round\(b\/c\,\s*4\)", code): 177 | code_count = code_count + 1 178 | else: 179 | print("You should use cosA_actual = round(b/c,4) in your code") 180 | 181 | # tanA_actual = round(a/b,4) 182 | if re.search("tanA\_actual\s*\=\s*round\(a\/b\,\s*4\)", code): 183 | code_count = code_count + 1 184 | else: 185 | print("You should use tanA_actual = round(a/b,4) in your code") 186 | 187 | # sinB_actual = round(b/c,4) 188 | if re.search("sinB\_actual\s*\=\s*round\(b\/c\,\s*4\)", code): 189 | code_count = code_count + 1 190 | else: 191 | print("You should use sinB_actual = round(b/c,4) in your code") 192 | 193 | # cosB_actual = round(a/c,4) 194 | if re.search("cosB\_actual\s*\=\s*round\(a\/c\,\s*4\)", code): 195 | code_count = code_count + 1 196 | else: 197 | print("You should use cosB_actual = round(a/c,4) in your code") 198 | 199 | # tanB_actual = round(b/a,4) 200 | if re.search("tanB\_actual\s*\=\s*round\(b\/a\,\s*4\)", code): 201 | code_count = code_count + 1 202 | else: 203 | print("You should use tanB_actual = round(b/a,4) in your code") 204 | 205 | if code_count==5: 206 | print("Code test passed") 207 | print("Go to the next step") 208 | 209 | 210 | def step15(code): 211 | import re 212 | print(" ") 213 | code_count = 0 214 | if re.search("round\(math\.cos\(math\.radians\(angle\)", code): 215 | print("Code test passed") 216 | print("Go to the next step") 217 | else: 218 | print("Your code should include ratio_c = round(math.cos(math.radians(angle)),4)") 219 | 220 | 221 | # step 16 re-uses step 00 222 | 223 | 224 | def step17(): 225 | print(" ") 226 | print("Look at the triangle and notice the pattern") 227 | print("Go to the next step") 228 | print(" ") 229 | 230 | 231 | def step18(): 232 | print("See how the sin() and cos() relate to points on the circle") 233 | print("Go on to the next step") 234 | 235 | 236 | def step19(code): 237 | import re 238 | print(" ") 239 | code_count = 0 240 | # cos_value 241 | if re.search("cos\_value\s*\=\s*0", code): 242 | print("Scroll up to see the example, then write the code to solve for b") 243 | elif re.search("\=\s*round\(math\.cos\(math\.radians\(rangle\)\)\,\s*4\)", code): 244 | code_count = code_count + 1 245 | else: 246 | print("Your code should include cos_value = round(math.cos(math.radians(rangle)), 4)") 247 | 248 | # side_b 249 | if re.search("side\_b\s*\=\s*0", code): 250 | print(" ") 251 | elif re.search("side\_b\s*\=\s*round\(sideC\*cos\_value\,2\)", code): 252 | code_count = code_count + 1 253 | else: 254 | print("Your code should include side_b = round(sideC*cos_value,2)") 255 | 256 | if code_count==2: 257 | print("Code test passed") 258 | print("Go on to the next step") 259 | 260 | 261 | def step20(code): 262 | import re 263 | print(" ") 264 | code_count = 0 265 | # sideA/math.sin(radian_angle) 266 | if re.search("sideC\s*=\s*0", code): 267 | print("Now write the code to solve for sideC") 268 | elif re.search("sideA\/math\.sin\(radian\_angle\)", code): 269 | print("Code test passed") 270 | print("Go on to the next step") 271 | else: 272 | print("Your code should include sideC = sideA/math.sin(radian_angle)") 273 | 274 | 275 | def step21(code): 276 | import re 277 | print(" ") 278 | code_count = 0 279 | # sideA/math.cos(radian_angle) 280 | if re.search("sideC\s*=\s*0", code): 281 | print("Now write the code to solve for the diagonal force") 282 | elif re.search("sideA\/math\.cos\(radian\_angle\)", code): 283 | print("Code test passed") 284 | print("Go on to the next step") 285 | else: 286 | print("Your code should include sideC = sideA/math.cos(radian_angle)") 287 | 288 | 289 | def step22(code): 290 | import re 291 | print(" ") 292 | code_count = 0 293 | # sideA/math.tan(radian_angle) 294 | if re.search("sideB\s*=\s*0", code): 295 | print("Now write the code to solve for the distance") 296 | print(" ") 297 | elif re.search("sideA\/math\.tan\(radian\_angle\)", code): 298 | print("Code test passed") 299 | print("Go on to the next step") 300 | else: 301 | print("Your code should include sideC = sideA/math.cos(radian_angle)") 302 | 303 | 304 | def step23(code): 305 | import re 306 | print(" ") 307 | code_count = 0 308 | # side_B = math.sin(math.radians(angle_B))*sideA/math.sin(math.radians(angleA)) 309 | if re.search("sideB\s*=\s*0", code): 310 | print("Now write the code to solve for side b") 311 | print(" ") 312 | elif re.search("side\_B\s*\=\s*math\.sin\(math\.radians\(angle\_B\)\)\*sideA\/math\.sin\(math\.radians\(angleA\)\)", code): 313 | print("Code test passed") 314 | print("Go on to the next step") 315 | else: 316 | print("Your code should include side_B = math.sin(math.radians(angle_B))*sideA/math.sin(math.radians(angleA))") 317 | 318 | 319 | def step24(code): 320 | import re 321 | print(" ") 322 | code_count = 0 323 | # almost = sideA**2 + sideB**2 - 2*sideA*sideB*math.cos(math.radians(angle_C)) 324 | # side_C = math.sqrt(almost) 325 | if re.search("sideC\s*=\s*0", code): 326 | print("Now write the code to solve for side c") 327 | print(" ") 328 | elif re.search("sideA\*\*2\s*\+\s*sideB\*\*2\s*\-\s*2\*sideA\*sideB\*math\.cos\(math\.radians\(angle\_C\)\)", code): 329 | print("Code test passed") 330 | print("Go on to the next step") 331 | else: 332 | print("Your code should include side_C = math.sqrt(sideA**2 + sideB**2 - 2*sideA*sideB*math.cos(math.radians(angle_C)))") 333 | 334 | 335 | def step25(code): 336 | import re 337 | print(" ") 338 | code_count = 0 339 | # area = 0.5*sideA*sideB*math.sin(math.radians(angleC)) 340 | if re.search("area\s*=\s*0", code): 341 | print("Now write the code to find the area") 342 | print(" ") 343 | elif re.search("area\s*\=\s*0\.5\*sideA\*sideB\*math\.sin\(math\.radians\(angleC\)\)", code): 344 | print("Code test passed") 345 | print("Go on to the next step") 346 | else: 347 | print("Your code should include area = 0.5*sideA*sideB*math.sin(math.radians(angleC))") 348 | 349 | 350 | # no test for step 26 351 | 352 | 353 | def step27(): 354 | print("Notice the pattern, then go on to the next step") 355 | print(" ") 356 | 357 | 358 | # no test for step 28 359 | 360 | 361 | def step29(): 362 | print("Notice which frequency combinations produce more regular patterns \n") 363 | 364 | 365 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-13-code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "id": "view-in-github", 7 | "colab_type": "text" 8 | }, 9 | "source": [ 10 | "\"Open" 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": { 16 | "id": "l48ljbtEwCIq" 17 | }, 18 | "source": [ 19 | "Simple interest
\n", 20 | "principle * rate * time = interest" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": { 27 | "id": "7SGCtdoGvswP", 28 | "colab": { 29 | "base_uri": "https://localhost:8080/" 30 | }, 31 | "outputId": "1af4ca54-c78b-47fd-89c9-ec8faf2a5874" 32 | }, 33 | "outputs": [ 34 | { 35 | "output_type": "stream", 36 | "name": "stdout", 37 | "text": [ 38 | "interest = 50.0\n" 39 | ] 40 | } 41 | ], 42 | "source": [ 43 | "p = 1000\n", 44 | "r = .05\n", 45 | "t = 1\n", 46 | "interest = p*r*t\n", 47 | "print(\"interest = \", interest)\n" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": { 53 | "id": "JX_4BnO2wnVU" 54 | }, 55 | "source": [ 56 | "New amount = principle + interest" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": { 63 | "id": "eWfb95dxww0U", 64 | "colab": { 65 | "base_uri": "https://localhost:8080/" 66 | }, 67 | "outputId": "d00e25e9-4830-478c-d8a0-cf9059d4a459" 68 | }, 69 | "outputs": [ 70 | { 71 | "output_type": "stream", 72 | "name": "stdout", 73 | "text": [ 74 | "New amount = 1150.0\n" 75 | ] 76 | } 77 | ], 78 | "source": [ 79 | "p = 1000\n", 80 | "r = .05\n", 81 | "t = 3\n", 82 | "interest = p*r*t\n", 83 | "a = p + interest\n", 84 | "print(\"New amount = \", a)\n" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": { 90 | "id": "c4r9qvhsxMHA" 91 | }, 92 | "source": [ 93 | "The algebra for any percent increase:
\n", 94 | "New amount = p + p*r
\n", 95 | "new amount = p * (1 + r)
\n", 96 | "\n", 97 | "\n" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": { 104 | "id": "2K1yAOMwxvxE", 105 | "colab": { 106 | "base_uri": "https://localhost:8080/" 107 | }, 108 | "outputId": "aea4dfba-0643-4b3f-eaf0-b2001d7b7d43" 109 | }, 110 | "outputs": [ 111 | { 112 | "output_type": "stream", 113 | "name": "stdout", 114 | "text": [ 115 | "New amount = 1050.0\n" 116 | ] 117 | } 118 | ], 119 | "source": [ 120 | "p = 1000\n", 121 | "r = .05\n", 122 | "a = p*(1+r)\n", 123 | "print(\"New amount = \", a)\n" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": { 129 | "id": "uObwM4RAx7mx" 130 | }, 131 | "source": [ 132 | "Compounding is adding the interest to the principle and then calculating percent increase from this new amount
\n", 133 | "Original amount = P
\n", 134 | "New amount = P*(1+r)
\n", 135 | "Compounded again = P*(1+r)*(1+r)
\n", 136 | "And again = P*(1+r)*(1+r)*(1+r) = P(1+r)3" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": { 143 | "id": "FaIHh86Wztag", 144 | "colab": { 145 | "base_uri": "https://localhost:8080/" 146 | }, 147 | "outputId": "64ae26c2-1b02-44ac-f9be-ce6c17d1c308" 148 | }, 149 | "outputs": [ 150 | { 151 | "output_type": "stream", 152 | "name": "stdout", 153 | "text": [ 154 | "Annuity = 1157.6250000000002\n" 155 | ] 156 | } 157 | ], 158 | "source": [ 159 | "P = 1000\n", 160 | "r = .05\n", 161 | "t = 3\n", 162 | "annuity = p*(1+r)**t\n", 163 | "\n", 164 | "print(\"Annuity = \", annuity)\n" 165 | ] 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "metadata": { 170 | "id": "MByKs5750erH" 171 | }, 172 | "source": [ 173 | "When the compunding happens `n` times per year, here is the formula:
\n", 174 | "A = P(1 + $\\frac{r}{n})^{nt}$" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": null, 180 | "metadata": { 181 | "id": "lOiY47piBYg-", 182 | "colab": { 183 | "base_uri": "https://localhost:8080/" 184 | }, 185 | "outputId": "59987cd6-538a-45c5-cd96-83d3393d4727" 186 | }, 187 | "outputs": [ 188 | { 189 | "output_type": "stream", 190 | "name": "stdout", 191 | "text": [ 192 | "Annuity = 1161.4722313334678\n" 193 | ] 194 | } 195 | ], 196 | "source": [ 197 | "P = 1000\n", 198 | "r = .05\n", 199 | "t = 3\n", 200 | "n = 12\n", 201 | "\n", 202 | "# use extra parentheses\n", 203 | "annuity = p*(1+(r/n))**(n*t)\n", 204 | "\n", 205 | "print(\"Annuity = \", annuity)\n" 206 | ] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": { 211 | "id": "rXT0ZjbTCcFm" 212 | }, 213 | "source": [ 214 | "the irrational number e" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": { 221 | "colab": { 222 | "base_uri": "https://localhost:8080/" 223 | }, 224 | "id": "FAQSLlRkCpPc", 225 | "outputId": "7fcc6ceb-18fe-40be-b33e-2deb526ee071" 226 | }, 227 | "outputs": [ 228 | { 229 | "output_type": "stream", 230 | "name": "stdout", 231 | "text": [ 232 | "2.718281828459045\n" 233 | ] 234 | } 235 | ], 236 | "source": [ 237 | "import math\n", 238 | "\n", 239 | "print(math.e)\n" 240 | ] 241 | }, 242 | { 243 | "cell_type": "markdown", 244 | "metadata": { 245 | "id": "jwkJMQaZDWFh" 246 | }, 247 | "source": [ 248 | "Continuous growth: Annuity = Pert" 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": null, 254 | "metadata": { 255 | "id": "I3XM_jH1C5AB", 256 | "colab": { 257 | "base_uri": "https://localhost:8080/" 258 | }, 259 | "outputId": "94db8735-a1f0-4d65-d8da-0f22c293c655" 260 | }, 261 | "outputs": [ 262 | { 263 | "output_type": "stream", 264 | "name": "stdout", 265 | "text": [ 266 | "1161.8298860036332 or 1161.834242728283\n" 267 | ] 268 | } 269 | ], 270 | "source": [ 271 | "import math\n", 272 | "\n", 273 | "p = 1000\n", 274 | "r = .05\n", 275 | "t = 3\n", 276 | "n = 1000\n", 277 | "\n", 278 | "n_times = p*(1+(r/n))**(n*t)\n", 279 | "\n", 280 | "continuous = p*math.e**(r*t)\n", 281 | "\n", 282 | "print(n_times, \" or \", continuous)\n", 283 | "\n" 284 | ] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "metadata": { 289 | "id": "UZfzA-XlIp-F" 290 | }, 291 | "source": [ 292 | "Mortgage formula
\n", 293 | "monthly payment = P$\\frac{\\frac{r}{12}(1 + \\frac{r}{12})^{12t}}{(1 + \\frac{r}{12})^{12t} - 1}$ \n" 294 | ] 295 | }, 296 | { 297 | "cell_type": "code", 298 | "execution_count": null, 299 | "metadata": { 300 | "colab": { 301 | "base_uri": "https://localhost:8080/" 302 | }, 303 | "id": "5do22sV_Fa7I", 304 | "outputId": "22bf51ff-2958-402b-bb2c-9f949e6a8526" 305 | }, 306 | "outputs": [ 307 | { 308 | "output_type": "stream", 309 | "name": "stdout", 310 | "text": [ 311 | "monthly payment = 1362.69\n" 312 | ] 313 | } 314 | ], 315 | "source": [ 316 | "p = 240000\n", 317 | "r = .055\n", 318 | "t = 30\n", 319 | "\n", 320 | "# Break down that formula into parts\n", 321 | "numerator = (r/12)*(1+(r/12))**(12*t) \n", 322 | "denominator = (1+(r/12))**(12*t) - 1 \n", 323 | "payment = round(p*numerator/denominator, 2)\n", 324 | "\n", 325 | "print(\"monthly payment = \", payment)\n" 326 | ] 327 | }, 328 | { 329 | "cell_type": "markdown", 330 | "metadata": { 331 | "id": "V4YPkA6CLM1b" 332 | }, 333 | "source": [ 334 | "Amortization (mortgage payment schedule)" 335 | ] 336 | }, 337 | { 338 | "cell_type": "code", 339 | "execution_count": null, 340 | "metadata": { 341 | "id": "tpRMuLdDJ6s8", 342 | "colab": { 343 | "base_uri": "https://localhost:8080/" 344 | }, 345 | "outputId": "5987d0d3-1bb4-46f2-8254-7368802776e9" 346 | }, 347 | "outputs": [ 348 | { 349 | "output_type": "stream", 350 | "name": "stdout", 351 | "text": [ 352 | "payment = 1362.69\n", 353 | "month \t balance \t interest\n", 354 | "0 \t 240000.0 \t 1100.0\n", 355 | "24 \t 233351.69 \t 1069.53\n", 356 | "48 \t 225932.19 \t 1035.52\n", 357 | "72 \t 217652.04 \t 997.57\n", 358 | "96 \t 208411.46 \t 955.22\n", 359 | "120 \t 198098.97 \t 907.95\n", 360 | "144 \t 186590.25 \t 855.21\n", 361 | "168 \t 173746.54 \t 796.34\n", 362 | "192 \t 159412.99 \t 730.64\n", 363 | "216 \t 143416.81 \t 657.33\n", 364 | "240 \t 125565.08 \t 575.51\n", 365 | "264 \t 105642.58 \t 484.2\n", 366 | "288 \t 83409.15 \t 382.29\n", 367 | "312 \t 58596.68 \t 268.57\n", 368 | "336 \t 30906.0 \t 141.65\n", 369 | "359 \t 1359.74 \t 6.23\n" 370 | ] 371 | } 372 | ], 373 | "source": [ 374 | "p = 240000.00\n", 375 | "r = .055\n", 376 | "t = 30\n", 377 | "\n", 378 | "\n", 379 | "# Break down that formula into parts\n", 380 | "numerator = (r/12)*(1+(r/12))**(12*t)\n", 381 | "denominator = (1+(r/12))**(12*t) - 1\n", 382 | "payment = round(p* numerator/denominator, 2)\n", 383 | "\n", 384 | "print(\"payment = \", payment)\n", 385 | "\n", 386 | "# loop to show interest amounts\n", 387 | "balance = p\n", 388 | "print(\"month \\t balance \\t interest\") \n", 389 | "for a in range(12*t):\n", 390 | " interest = round(balance*r/12, 2)\n", 391 | " if a%24==0 or a==359:\n", 392 | " print(a, \"\\t\", balance, \"\\t\", interest) \n", 393 | " balance = round(balance+interest-payment,2) \n", 394 | "\n" 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": { 400 | "id": "zu20IkH4SULn" 401 | }, 402 | "source": [ 403 | "Retirement account estimation" 404 | ] 405 | }, 406 | { 407 | "cell_type": "code", 408 | "execution_count": null, 409 | "metadata": { 410 | "id": "xhyuJ4eyOCan", 411 | "colab": { 412 | "base_uri": "https://localhost:8080/" 413 | }, 414 | "outputId": "9e809783-0d51-4384-c8e8-aaf1f8d3addc" 415 | }, 416 | "outputs": [ 417 | { 418 | "output_type": "stream", 419 | "name": "stdout", 420 | "text": [ 421 | "annuity = 1061597.32\n", 422 | "Annual income from interest = 84927.79\n" 423 | ] 424 | } 425 | ], 426 | "source": [ 427 | "# Change these variables\n", 428 | "p = 1000\n", 429 | "r = .08\n", 430 | "t = 38\n", 431 | "monthly = 350\n", 432 | "\n", 433 | "# The loop will update this variable\n", 434 | "annuity = p\n", 435 | "\n", 436 | "# loop for contribution and percent growth\n", 437 | "for a in range(12*t):\n", 438 | " annuity = (annuity+monthly)*(1+(r/12))\n", 439 | "\n", 440 | "print(\"annuity = \", round(annuity, 2))\n", 441 | "print(\"Annual income from interest = \", round(annuity*r, 2))\n" 442 | ] 443 | }, 444 | { 445 | "cell_type": "code", 446 | "execution_count": null, 447 | "metadata": { 448 | "id": "3tAAhpmlT06e" 449 | }, 450 | "outputs": [], 451 | "source": [] 452 | } 453 | ], 454 | "metadata": { 455 | "colab": { 456 | "provenance": [], 457 | "authorship_tag": "ABX9TyOdYRBlOoMILITAGdItP1e1", 458 | "include_colab_link": true 459 | }, 460 | "kernelspec": { 461 | "display_name": "Python 3", 462 | "name": "python3" 463 | }, 464 | "language_info": { 465 | "name": "python" 466 | } 467 | }, 468 | "nbformat": 4, 469 | "nbformat_minor": 0 470 | } 471 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-05-xtra.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_05 - xtra.ipynb", 7 | "provenance": [], 8 | "authorship_tag": "ABX9TyPJZvfip8BB28alleDX0UgY", 9 | "include_colab_link": true 10 | }, 11 | "kernelspec": { 12 | "name": "python3", 13 | "display_name": "Python 3" 14 | }, 15 | "language_info": { 16 | "name": "python" 17 | } 18 | }, 19 | "cells": [ 20 | { 21 | "cell_type": "markdown", 22 | "metadata": { 23 | "id": "view-in-github", 24 | "colab_type": "text" 25 | }, 26 | "source": [ 27 | "\"Open" 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "source": [ 33 | "Notes and work" 34 | ], 35 | "metadata": { 36 | "id": "5aS6gYl3ulv5" 37 | } 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "metadata": { 43 | "id": "ORJreCNZsqhu" 44 | }, 45 | "outputs": [], 46 | "source": [ 47 | "1500 = 10x + 500\n", 48 | "0 = 10x - 1000" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "source": [ 54 | "Solve an equation" 55 | ], 56 | "metadata": { 57 | "id": "h9wdH3LhuG2C" 58 | } 59 | }, 60 | { 61 | "cell_type": "code", 62 | "source": [ 63 | "import sympy \n", 64 | "from sympy import symbols \n", 65 | "from sympy.solvers import solve \n", 66 | "\n", 67 | "x = symbols('x') \n", 68 | "\n", 69 | "# Put the equation here\n", 70 | "eq = 10*x - 1000\n", 71 | "\n", 72 | "solution = solve(eq,x)\n", 73 | "print(\"x = \", solution[0])\n" 74 | ], 75 | "metadata": { 76 | "colab": { 77 | "base_uri": "https://localhost:8080/" 78 | }, 79 | "id": "Gy6sVbqVuKRB", 80 | "outputId": "72b30f48-046e-47b6-ba96-3affbf68d1d0" 81 | }, 82 | "execution_count": null, 83 | "outputs": [ 84 | { 85 | "output_type": "stream", 86 | "name": "stdout", 87 | "text": [ 88 | "x = 100\n" 89 | ] 90 | } 91 | ] 92 | }, 93 | { 94 | "cell_type": "markdown", 95 | "source": [ 96 | "Graph the solution" 97 | ], 98 | "metadata": { 99 | "id": "xZzkJ2-FuYxx" 100 | } 101 | }, 102 | { 103 | "cell_type": "code", 104 | "source": [ 105 | "import matplotlib.pyplot as plt\n", 106 | "import numpy as np\n", 107 | "\n", 108 | "x1 = 0\n", 109 | "y1 = 0\n", 110 | "x2 = 40\n", 111 | "y2 = 13\n", 112 | "\n", 113 | "# Develop the equation y = mx + b\n", 114 | "m = (y2 - y1) / (x2 - x1)\n", 115 | "b = y1 - m*x1\n", 116 | "print(\"y = \", m, \"x + \", b)\n", 117 | "\n", 118 | "# For the graph\n", 119 | "xmin = 0\n", 120 | "xmax = 100\n", 121 | "ymin = 0\n", 122 | "ymax = 50\n", 123 | "\n", 124 | "# For the line on the graph\n", 125 | "y3 = m*xmin + b \n", 126 | "y4 = m*xmax + b \n", 127 | "\n", 128 | "# Basic setup for the graph\n", 129 | "fig, ax = plt.subplots()\n", 130 | "plt.axis([xmin,xmax,ymin,ymax]) # window size\n", 131 | "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n", 132 | "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n", 133 | "\n", 134 | "# Add details to the graph\n", 135 | "ax.set_xlabel(\"thousands\")\n", 136 | "ax.set_ylabel(\"tons\")\n", 137 | "ax.grid(True)\n", 138 | "#ax.set_xticks(np.arange(xmin, xmax, 2))\n", 139 | "#ax.set_yticks(np.arange(ymin, ymax, 1))\n", 140 | "\n", 141 | "\n", 142 | "# Plot the linear function as a red line\n", 143 | "plt.plot([xmin,xmax],[y3,y4],'r')\n", 144 | "\n", 145 | "plt.show()\n" 146 | ], 147 | "metadata": { 148 | "colab": { 149 | "base_uri": "https://localhost:8080/", 150 | "height": 301 151 | }, 152 | "id": "ngy3aRPTubfh", 153 | "outputId": "9ed22531-b870-491b-8996-0c8ed5d58fa2" 154 | }, 155 | "execution_count": null, 156 | "outputs": [ 157 | { 158 | "output_type": "stream", 159 | "name": "stdout", 160 | "text": [ 161 | "y = 0.325 x + 0.0\n" 162 | ] 163 | }, 164 | { 165 | "output_type": "display_data", 166 | "data": { 167 | "text/plain": [ 168 | "
" 169 | ], 170 | "image/png": "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\n" 171 | }, 172 | "metadata": { 173 | "needs_background": "light" 174 | } 175 | } 176 | ] 177 | } 178 | ] 179 | } -------------------------------------------------------------------------------- /Algebra-with-Python/Week-05-code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Week_05 - code for slope intercept.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyOVRfR3KiJySdIydXFQbyUE", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "source": [ 34 | "x1 = 1\n", 35 | "y1 = 7\n", 36 | "x2 = 2\n", 37 | "y2 = 10\n", 38 | "\n", 39 | "slope = (y2 - y1) / (x2 - x1)\n", 40 | "\n", 41 | "print(\"slope = \", slope)" 42 | ], 43 | "metadata": { 44 | "id": "2-ceeTFP6aQ7" 45 | }, 46 | "execution_count": null, 47 | "outputs": [] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "source": [ 52 | "
\n", 53 | "
\n", 54 | "
\n", 55 | "Next, developing equations...\n", 56 | "
\n", 57 | "
\n", 58 | "
" 59 | ], 60 | "metadata": { 61 | "id": "QVaWF-Yk6kYJ" 62 | } 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": { 68 | "id": "CKVgsCTmKjyw", 69 | "colab": { 70 | "base_uri": "https://localhost:8080/" 71 | }, 72 | "outputId": "6a74166a-ac9d-4d24-cc50-15fbdbfd0378" 73 | }, 74 | "outputs": [ 75 | { 76 | "output_type": "stream", 77 | "name": "stdout", 78 | "text": [ 79 | "y = -0.06506849315068493 x + 125.12328767123287\n" 80 | ] 81 | } 82 | ], 83 | "source": [ 84 | "x1 = 632 #1\n", 85 | "y1 = 84 #7\n", 86 | "x2 = 1800 #2\n", 87 | "y2 = 8 #10\n", 88 | "\n", 89 | "# The slope is \"m\"\n", 90 | "m = (y2 - y1) / (x2 - x1)\n", 91 | "\n", 92 | "# The y intercept is \"b\"\n", 93 | "b = y1 - m*x1\n", 94 | "\n", 95 | "# The full equation\n", 96 | "print(\"y = \", m, \"x + \", b)\n" 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "source": [ 102 | "Also display the graph" 103 | ], 104 | "metadata": { 105 | "id": "XxRKIPpM9RsJ" 106 | } 107 | }, 108 | { 109 | "cell_type": "code", 110 | "source": [ 111 | "import matplotlib.pyplot as plt\n", 112 | "\n", 113 | "x1 = 2\n", 114 | "y1 = 3\n", 115 | "x2 = 6\n", 116 | "y2 = 8\n", 117 | "\n", 118 | "# Develop the equation y = mx + b\n", 119 | "m = (y2 - y1) / (x2 - x1)\n", 120 | "b = y1 - m*x1\n", 121 | "print(\"y = \", m, \"x + \", b)\n", 122 | "\n", 123 | "# For the graph\n", 124 | "xmin = -10\n", 125 | "xmax = 10\n", 126 | "ymin = -10\n", 127 | "ymax = 10\n", 128 | "\n", 129 | "# For the line on the graph\n", 130 | "y3 = m*xmin + b \n", 131 | "y4 = m*xmax + b \n", 132 | "\n", 133 | "# Basic setup for the graph\n", 134 | "fig, ax = plt.subplots()\n", 135 | "plt.axis([xmin,xmax,ymin,ymax]) # window size\n", 136 | "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n", 137 | "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n", 138 | "\n", 139 | "# Plot the linear function as a red line\n", 140 | "plt.plot([xmin,xmax],[y3,y4],'r')\n", 141 | "\n", 142 | "plt.show()\n" 143 | ], 144 | "metadata": { 145 | "id": "4gn7sGDENUZr", 146 | "colab": { 147 | "base_uri": "https://localhost:8080/", 148 | "height": 287 149 | }, 150 | "outputId": "b51a57a7-53b3-43b8-da1a-9aff93029048" 151 | }, 152 | "execution_count": null, 153 | "outputs": [ 154 | { 155 | "output_type": "stream", 156 | "name": "stdout", 157 | "text": [ 158 | "y = 1.25 x + 0.5\n" 159 | ] 160 | }, 161 | { 162 | "output_type": "display_data", 163 | "data": { 164 | "text/plain": [ 165 | "
" 166 | ], 167 | "image/png": "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\n" 168 | }, 169 | "metadata": { 170 | "needs_background": "light" 171 | } 172 | } 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "source": [ 178 | "" 179 | ], 180 | "metadata": { 181 | "id": "rf0SoGGlf_HJ" 182 | }, 183 | "execution_count": null, 184 | "outputs": [] 185 | } 186 | ] 187 | } -------------------------------------------------------------------------------- /Algebra-with-Python/Week-01-02-03-xtra-practice-problems.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [], 7 | "authorship_tag": "ABX9TyMoA4QyggcH71vx9E9XstFo", 8 | "include_colab_link": true 9 | }, 10 | "kernelspec": { 11 | "name": "python3", 12 | "display_name": "Python 3" 13 | }, 14 | "language_info": { 15 | "name": "python" 16 | } 17 | }, 18 | "cells": [ 19 | { 20 | "cell_type": "markdown", 21 | "metadata": { 22 | "id": "view-in-github", 23 | "colab_type": "text" 24 | }, 25 | "source": [ 26 | "\"Open" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "source": [ 32 | "Run this first - to define functions to present random math problems, ask user to solve for x, and test input. Individual code below. All functions here:" 33 | ], 34 | "metadata": { 35 | "id": "YV7b2nQOEf95" 36 | } 37 | }, 38 | { 39 | "cell_type": "code", 40 | "source": [ 41 | "# converts string input (even fractions) to float\n", 42 | "def string_frac(in_string):\n", 43 | " if \"/\" in in_string:\n", 44 | " nd = in_string.split(\"/\")\n", 45 | " n = float(nd[0])\n", 46 | " d = float(nd[1])\n", 47 | " ans = n/d\n", 48 | " return ans\n", 49 | " else:\n", 50 | " ans = float(in_string)\n", 51 | " return ans\n", 52 | "\n", 53 | "\n", 54 | "# Simplest one-step addition\n", 55 | "def one_step_add():\n", 56 | " import random\n", 57 | " # Display problem\n", 58 | " a = random.randint(-4,10)\n", 59 | " b = random.randint(2,24)\n", 60 | " print(\"x + \", a, \" = \", b)\n", 61 | " ans = float(input(\"x = \"))\n", 62 | " answer = b-a\n", 63 | " # Test input\n", 64 | " if ans==answer:\n", 65 | " print(\"Correct! \\n\")\n", 66 | " else:\n", 67 | " print(\"Try again\")\n", 68 | " print(\"The correct answer is \", answer, \"\\n\")\n", 69 | "\n", 70 | "\n", 71 | "# One-step additon with negaive numbers\n", 72 | "def one_step_subtract():\n", 73 | " import random\n", 74 | " a = random.randint(-19,-1)\n", 75 | " b = random.randint(2,24)\n", 76 | " print(a, \" + x = \", b)\n", 77 | " ans = float(input(\"x = \"))\n", 78 | " # test\n", 79 | " answer = b-a\n", 80 | " if ans==answer:\n", 81 | " print(\"Correct! \\n\")\n", 82 | " else:\n", 83 | " print(\"Try again\")\n", 84 | " print(\"The correct answer is \", answer, \"\\n\")\n", 85 | "\n", 86 | "# One-step multiply\n", 87 | "def one_step_mult():\n", 88 | " # Uses string_frac()\n", 89 | " import random\n", 90 | " a = random.randint(1,11)\n", 91 | " b = random.randint(2,24)\n", 92 | " print(a, \"x = \", b)\n", 93 | " ans_in = (input(\"x = \"))\n", 94 | " answer = b/a\n", 95 | " # test\n", 96 | " if string_frac(ans_in)==answer:\n", 97 | " print(\"Correct! \\n\")\n", 98 | " else:\n", 99 | " print(\"Try again\")\n", 100 | " print(\"The correct answer is \", answer, \"\\n\")\n", 101 | "\n", 102 | "\n", 103 | "# One-step divide\n", 104 | "def one_step_div():\n", 105 | " import random\n", 106 | " a = random.randint(1,11)\n", 107 | " b = random.randint(2,24)\n", 108 | " print(\"x/\", a, \" = \", b)\n", 109 | " ans = float(input(\"x = \"))\n", 110 | " answer = b*a\n", 111 | " # test\n", 112 | " if ans==answer:\n", 113 | " print(\"Correct! \\n\")\n", 114 | " else:\n", 115 | " print(\"Try again\")\n", 116 | " print(\"The correct answer is \", answer, \"\\n\")\n", 117 | "\n", 118 | "\n", 119 | "# Two-step problems\n", 120 | "def two_step():\n", 121 | " import random\n", 122 | " # Uses string_frac()\n", 123 | " a = random.randint(1,11)\n", 124 | " b = random.randint(-7,12)\n", 125 | " c = random.randint(2,36)\n", 126 | " print(a, \"x + \", b, \" = \", c)\n", 127 | " print(\"Round answer to two decimal places\")\n", 128 | " ans_in = input(\"x = \")\n", 129 | " answer = (c-b)/a\n", 130 | " # test\n", 131 | " if round(string_frac(ans_in),3)==round(answer,3):\n", 132 | " print(\"Correct! \\n\")\n", 133 | " else:\n", 134 | " print(\"Try again\")\n", 135 | " print(\"The correct answer is \", answer, \"\\n\")\n", 136 | "\n", 137 | "\n", 138 | "# Proportions - unknown numerator\n", 139 | "def proportions_n():\n", 140 | " import random\n", 141 | " # Uses string_frac() function\n", 142 | " n1 = random.randint(1,21)\n", 143 | " d1 = random.randint(1,21)\n", 144 | " n2 = \"x\"\n", 145 | " d2 = random.randint(1,21)\n", 146 | " print(n1, \"\\t\\t\", n2)\n", 147 | " print(\"--- \\t = \\t ---\")\n", 148 | " print(d1, \"\\t\\t\", d2)\n", 149 | " print(\" \")\n", 150 | " ans_in = input(\"x = \")\n", 151 | " answer = d2*n1/d1\n", 152 | " if string_frac(ans_in)==answer:\n", 153 | " print(\"Correct! \\n\")\n", 154 | " else:\n", 155 | " print(\"Try again\")\n", 156 | "\n", 157 | "\n", 158 | "# Proportions - unknown denominator\n", 159 | "def proportions_d():\n", 160 | " import random\n", 161 | " # Uses string_frac() function\n", 162 | " n1 = random.randint(1,21)\n", 163 | " d1 = random.randint(1,21)\n", 164 | " n2 = random.randint(1,21)\n", 165 | " d2 = \"x\"\n", 166 | " print(n1, \"\\t\\t\", n2)\n", 167 | " print(\"--- \\t = \\t ---\")\n", 168 | " print(d1, \"\\t\\t\", d2)\n", 169 | " print(\" \")\n", 170 | " ans_in = input(\"x = \")\n", 171 | " answer = d1*n2/n1\n", 172 | " if string_frac(ans_in)==answer:\n", 173 | " print(\"Correct! \\n\")\n", 174 | " else:\n", 175 | " print(\"Try again\")\n", 176 | "\n", 177 | "\n", 178 | "# Decimal to fraction\n", 179 | "def dec_to_frac_test():\n", 180 | " import random\n", 181 | " import math\n", 182 | " # Uses string_frac()\n", 183 | " print(\"Convert the following decimal to a fraction\")\n", 184 | " print(\"Just use the / to write your fraction\")\n", 185 | " places = random.randint(1,4)\n", 186 | " decimal = round(random.random(), places)\n", 187 | " print(decimal)\n", 188 | " exp = math.floor(math.log(decimal,10))\n", 189 | " d = 10**exp\n", 190 | " n = decimal*d\n", 191 | " ans_in = input(\"Fraction: \")\n", 192 | " if string_frac(ans_in)==decimal:\n", 193 | " print(\"Correct! \\n\")\n", 194 | " else:\n", 195 | " print(\"Try again\")\n", 196 | " print(\"The answer is \", n, \"/\", d)\n", 197 | "\n", 198 | "\n", 199 | "# Fraction to percent\n", 200 | "def frac_to_perc_test():\n", 201 | " import random\n", 202 | " print(\"Convert the following fraction to a percent\")\n", 203 | " n = round(random.randint(1,99))\n", 204 | " d = round(random.randint(2,200))\n", 205 | " print(n, \"/\", d)\n", 206 | " percent = round(n/d*100,2)\n", 207 | " print(\"Round your answer to two decimal places\")\n", 208 | " ans = float(input(\"Percent: \"))\n", 209 | " if ans==percent:\n", 210 | " print(\"Correct!\")\n", 211 | " else:\n", 212 | " print(\"Try again\")\n", 213 | " print(\"The answer is \", percent)\n", 214 | "\n", 215 | "\n", 216 | "print(\"Functions loaded\")" 217 | ], 218 | "metadata": { 219 | "id": "2AQz_KCLEdKm", 220 | "colab": { 221 | "base_uri": "https://localhost:8080/" 222 | }, 223 | "outputId": "944967e8-277b-46c6-93c1-d2d4ceba461c" 224 | }, 225 | "execution_count": null, 226 | "outputs": [ 227 | { 228 | "output_type": "stream", 229 | "name": "stdout", 230 | "text": [ 231 | "Functions loaded\n" 232 | ] 233 | } 234 | ] 235 | }, 236 | { 237 | "cell_type": "markdown", 238 | "source": [ 239 | "**test**" 240 | ], 241 | "metadata": { 242 | "id": "GL3_OqNaAGNo" 243 | } 244 | }, 245 | { 246 | "cell_type": "code", 247 | "source": [ 248 | "# test loop\n", 249 | "for a in range(3):\n", 250 | " frac_to_perc_test()\n", 251 | " print(\" \")\n", 252 | "\n" 253 | ], 254 | "metadata": { 255 | "id": "dzQ2VK1eLrPd" 256 | }, 257 | "execution_count": null, 258 | "outputs": [] 259 | }, 260 | { 261 | "cell_type": "markdown", 262 | "source": [ 263 | "**One-step problems**" 264 | ], 265 | "metadata": { 266 | "id": "6ndr4QBKK3Jr" 267 | } 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": null, 272 | "metadata": { 273 | "id": "voYzHh8yK0kU" 274 | }, 275 | "outputs": [], 276 | "source": [ 277 | "import random\n", 278 | "\n", 279 | "a = random.randint(-4,10)\n", 280 | "b = random.randint(2,24)\n", 281 | "\n", 282 | "print(\"x + \", a, \" = \", b)\n", 283 | "ans = float(input(\"x = \"))\n", 284 | "\n", 285 | "# test\n", 286 | "correct = 0\n", 287 | "if ans==(b-a):\n", 288 | " correct = correct+1\n", 289 | "else:\n", 290 | " print(\"Try again\")\n", 291 | "\n", 292 | "\n" 293 | ] 294 | }, 295 | { 296 | "cell_type": "markdown", 297 | "source": [ 298 | "**More one-step problems**" 299 | ], 300 | "metadata": { 301 | "id": "I-jVIL4TOjfN" 302 | } 303 | }, 304 | { 305 | "cell_type": "code", 306 | "source": [ 307 | "import random\n", 308 | "\n", 309 | "a = random.randint(-4,10)\n", 310 | "b = random.randint(2,24)\n", 311 | "\n", 312 | "print(a, \" + x = \", b)\n", 313 | "ans = float(input(\"x = \"))\n", 314 | "\n", 315 | "# test\n", 316 | "correct = 0\n", 317 | "if ans==(b-a):\n", 318 | " correct = correct+1\n", 319 | "else:\n", 320 | " print(\"Try again\")\n", 321 | "\n", 322 | "\n" 323 | ], 324 | "metadata": { 325 | "id": "XCKWNnoVLKt3" 326 | }, 327 | "execution_count": null, 328 | "outputs": [] 329 | }, 330 | { 331 | "cell_type": "markdown", 332 | "source": [ 333 | "One-step multiply" 334 | ], 335 | "metadata": { 336 | "id": "5yLPKmTNPFAH" 337 | } 338 | }, 339 | { 340 | "cell_type": "code", 341 | "source": [ 342 | "import random\n", 343 | "\n", 344 | "a = random.randint(-4,10)\n", 345 | "b = random.randint(2,24)\n", 346 | "\n", 347 | "print(a, \"x = \", b)\n", 348 | "ans = float(input(\"x = \"))\n", 349 | "\n", 350 | "# test\n", 351 | "correct = 0\n", 352 | "if ans==(b/a):\n", 353 | " correct = correct+1\n", 354 | "else:\n", 355 | " print(\"Try again\")\n" 356 | ], 357 | "metadata": { 358 | "id": "Wlr13LSvPHlY" 359 | }, 360 | "execution_count": null, 361 | "outputs": [] 362 | }, 363 | { 364 | "cell_type": "markdown", 365 | "source": [ 366 | "One-step divide" 367 | ], 368 | "metadata": { 369 | "id": "7HJeuXMiPlC7" 370 | } 371 | }, 372 | { 373 | "cell_type": "code", 374 | "source": [ 375 | "import random\n", 376 | "\n", 377 | "a = random.randint(-4,10)\n", 378 | "b = random.randint(2,24)\n", 379 | "\n", 380 | "print(\"x/\", a, \" = \", b)\n", 381 | "ans = float(input(\"x = \"))\n", 382 | "\n", 383 | "# test\n", 384 | "correct = 0\n", 385 | "if ans==(b/a):\n", 386 | " correct = correct+1\n", 387 | "else:\n", 388 | " print(\"Try again\")\n" 389 | ], 390 | "metadata": { 391 | "id": "YrtgJUDmPnTp" 392 | }, 393 | "execution_count": null, 394 | "outputs": [] 395 | }, 396 | { 397 | "cell_type": "markdown", 398 | "source": [ 399 | "Two-step" 400 | ], 401 | "metadata": { 402 | "id": "4lhRJ177RD-y" 403 | } 404 | }, 405 | { 406 | "cell_type": "code", 407 | "source": [ 408 | "import random\n", 409 | "\n", 410 | "a = random.randint(-7,11)\n", 411 | "b = random.randint(2,12)\n", 412 | "c = random.randint(2,36)\n", 413 | "\n", 414 | "print(a, \"x + \", b, \" = \", c)\n", 415 | "ans = float(input(\"x = \"))\n", 416 | "\n", 417 | "# test\n", 418 | "correct = 0\n", 419 | "if ans==((c-b)/a):\n", 420 | " correct = correct+1\n", 421 | "else:\n", 422 | " print(\"Try again\")\n" 423 | ], 424 | "metadata": { 425 | "id": "v24IYtfwRJ-t" 426 | }, 427 | "execution_count": null, 428 | "outputs": [] 429 | }, 430 | { 431 | "cell_type": "markdown", 432 | "source": [ 433 | "Proportions 1" 434 | ], 435 | "metadata": { 436 | "id": "wSSx1nxwSwvx" 437 | } 438 | }, 439 | { 440 | "cell_type": "code", 441 | "source": [ 442 | "import random\n", 443 | "\n", 444 | "n1 = random.randint(1,21)\n", 445 | "d1 = random.randint(1,21)\n", 446 | "n2 = random.randint(1,21)\n", 447 | "d2 = \"x\"\n", 448 | "\n", 449 | "print(n1, \"\\t\\t\", n2)\n", 450 | "print(\"--- \\t = \\t ---\")\n", 451 | "print(d1, \"\\t\\t\", d2)\n", 452 | "print(\" \")\n", 453 | "ans = float(input(\"x = \"))\n", 454 | "answer = d1*n2/n1\n", 455 | "\n", 456 | "if ans==answer:\n", 457 | " correct = correct + 1\n", 458 | "else:\n", 459 | " print(\"Try again\")\n" 460 | ], 461 | "metadata": { 462 | "id": "sqU14lbyoZjH" 463 | }, 464 | "execution_count": null, 465 | "outputs": [] 466 | }, 467 | { 468 | "cell_type": "markdown", 469 | "source": [ 470 | "Proportions 2" 471 | ], 472 | "metadata": { 473 | "id": "nr46xqOZ0VfW" 474 | } 475 | }, 476 | { 477 | "cell_type": "code", 478 | "source": [ 479 | "import random\n", 480 | "\n", 481 | "n1 = random.randint(1,21)\n", 482 | "d1 = random.randint(1,21)\n", 483 | "n2 = \"x\"\n", 484 | "d2 = random.randint(1,21)\n", 485 | "correct = 0\n", 486 | "\n", 487 | "print(n1, \"\\t\\t\", n2)\n", 488 | "print(\"--- \\t = \\t ---\")\n", 489 | "print(d1, \"\\t\\t\", d2)\n", 490 | "\n", 491 | "ans_in = input(\"x = \")\n", 492 | "\n", 493 | "# Uses string_frac() function\n", 494 | "\n", 495 | "answer = d2*n1/d1\n", 496 | "\n", 497 | "if string_frac(ans_in)==answer:\n", 498 | " print(\"Correct!\")\n", 499 | " correct = correct + 1\n", 500 | "else:\n", 501 | " print(\"Try again\")\n" 502 | ], 503 | "metadata": { 504 | "colab": { 505 | "base_uri": "https://localhost:8080/" 506 | }, 507 | "id": "7W6YSfylqh4k", 508 | "outputId": "0b98bb4a-8dd3-47af-9fa7-43b755b96013" 509 | }, 510 | "execution_count": null, 511 | "outputs": [ 512 | { 513 | "output_type": "stream", 514 | "name": "stdout", 515 | "text": [ 516 | "3 \t\t x\n", 517 | "--- \t = \t ---\n", 518 | "18 \t\t 15\n", 519 | "x = 2.5\n", 520 | "Correct!\n" 521 | ] 522 | } 523 | ] 524 | }, 525 | { 526 | "cell_type": "code", 527 | "source": [ 528 | "# Decimal to fraction\n", 529 | "import random\n", 530 | "# Uses string_frac()\n", 531 | "print(\"Convert the following decimal to a fraction\")\n", 532 | "print(\"Just use the / to write your fraction\")\n", 533 | "places = random.randint(1,4)\n", 534 | "decimal = round(random.random(), places)\n", 535 | "print(decimal)\n", 536 | "ans_in = input(\"Fraction: \")\n", 537 | "if string_frac(ans_in)==decimal:\n", 538 | " print(\"Correct!\")\n", 539 | "else:\n", 540 | " print(\"Try again\")\n", 541 | "\n" 542 | ], 543 | "metadata": { 544 | "id": "jDTHzUg60ngI" 545 | }, 546 | "execution_count": null, 547 | "outputs": [] 548 | }, 549 | { 550 | "cell_type": "code", 551 | "source": [ 552 | "# Fraction to percent\n", 553 | "import random\n", 554 | "\n", 555 | "print(\"Convert the following fraction to a percent\")\n", 556 | "n = round(random.randint(1,99))\n", 557 | "d = round(random.randint(2,200))\n", 558 | "print(n, \"/\", d)\n", 559 | "percent = round(n/d*100,2)\n", 560 | "print(\"Round your answer to two decimal places\")\n", 561 | "ans = float(input(\"Percent: \"))\n", 562 | "if ans==percent:\n", 563 | " print(\"Correct!\")\n", 564 | "else:\n", 565 | " print(\"Try again\")\n", 566 | "\n" 567 | ], 568 | "metadata": { 569 | "colab": { 570 | "base_uri": "https://localhost:8080/" 571 | }, 572 | "id": "-B6MBV1K2EM1", 573 | "outputId": "ee7c5d54-b7bd-422e-e269-3091d246838a" 574 | }, 575 | "execution_count": null, 576 | "outputs": [ 577 | { 578 | "output_type": "stream", 579 | "name": "stdout", 580 | "text": [ 581 | "Convert the following fraction to a percent\n", 582 | "56 / 185\n", 583 | "Round your answer to two decimal places\n", 584 | "Percent: 30.27\n", 585 | "Correct!\n" 586 | ] 587 | } 588 | ] 589 | }, 590 | { 591 | "cell_type": "code", 592 | "source": [], 593 | "metadata": { 594 | "id": "nfMyL98C80UU" 595 | }, 596 | "execution_count": null, 597 | "outputs": [] 598 | } 599 | ] 600 | } 601 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-12-code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [], 7 | "authorship_tag": "ABX9TyNDVfLCU3nJUeUemoPOZrCL", 8 | "include_colab_link": true 9 | }, 10 | "kernelspec": { 11 | "name": "python3", 12 | "display_name": "Python 3" 13 | }, 14 | "language_info": { 15 | "name": "python" 16 | } 17 | }, 18 | "cells": [ 19 | { 20 | "cell_type": "markdown", 21 | "metadata": { 22 | "id": "view-in-github", 23 | "colab_type": "text" 24 | }, 25 | "source": [ 26 | "\"Open" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "source": [ 32 | "Selling tee shirts example" 33 | ], 34 | "metadata": { 35 | "id": "jN-wrAUXjCq2" 36 | } 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": null, 41 | "metadata": { 42 | "id": "evLVBly4g6DD", 43 | "colab": { 44 | "base_uri": "https://localhost:8080/" 45 | }, 46 | "outputId": "89a8b7dc-4340-41f8-b663-2ef360f891f6" 47 | }, 48 | "outputs": [ 49 | { 50 | "output_type": "stream", 51 | "name": "stdout", 52 | "text": [ 53 | "price: 10\n", 54 | "demand: 30\n", 55 | "revenue: 300\n", 56 | "total cost: 120\n", 57 | "profit 180\n" 58 | ] 59 | } 60 | ], 61 | "source": [ 62 | "\n", 63 | "\n", 64 | "price = 10\n", 65 | "demand = 50 - 2*price \n", 66 | "revenue = price*demand \n", 67 | "total_cost = 4*demand \n", 68 | "profit = revenue - total_cost \n", 69 | "\n", 70 | "print(\"price: \", price)\n", 71 | "print(\"demand: \", demand)\n", 72 | "print(\"revenue: \", revenue)\n", 73 | "print(\"total cost: \", total_cost)\n", 74 | "print(\"profit \", profit)\n" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "source": [ 80 | "import matplotlib.pyplot as plt\n", 81 | "import numpy as np\n", 82 | "\n", 83 | "# price = x\n", 84 | "# demand = y\n", 85 | "\n", 86 | "price_1 = 2\n", 87 | "demand_1 = 46\n", 88 | "price_2 = 10\n", 89 | "demand_2 = 30\n", 90 | "m = (demand_2 - demand_1)/(price_2 - price_1)\n", 91 | "b = demand_1 - m*price_1\n", 92 | "# This becomes a y = mx + b equation \n", 93 | "\n", 94 | "xmin = 0\n", 95 | "xmax = 50\n", 96 | "ymin = 0\n", 97 | "ymax = 320\n", 98 | "points = 10*(xmax-xmin)\n", 99 | "x = np.linspace(xmin,xmax,points)\n", 100 | "\n", 101 | "fig, ax = plt.subplots()\n", 102 | "plt.axis([xmin,xmax,ymin,ymax]) # window size\n", 103 | "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n", 104 | "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n", 105 | "\n", 106 | "plt.xlabel(\"Price\")\n", 107 | "plt.title(\"Financial Algebra\")\n", 108 | "\n", 109 | "# line 1\n", 110 | "demand = m*x + b\n", 111 | "#plt.ylabel(\"Demand\") \n", 112 | "#plt.plot(x, demand) \n", 113 | "\n", 114 | "# line 2\n", 115 | "revenue = x*demand\n", 116 | "plt.plot(x, revenue) \n", 117 | "plt.ylabel(\"Revenue\")\n", 118 | "\n", 119 | "plt.show()\n", 120 | "\n" 121 | ], 122 | "metadata": { 123 | "id": "_4zOmGCNgY3z", 124 | "colab": { 125 | "base_uri": "https://localhost:8080/", 126 | "height": 295 127 | }, 128 | "outputId": "ba217740-2fbc-4651-afe2-5b275d619deb" 129 | }, 130 | "execution_count": null, 131 | "outputs": [ 132 | { 133 | "output_type": "display_data", 134 | "data": { 135 | "text/plain": [ 136 | "
" 137 | ], 138 | "image/png": "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\n" 139 | }, 140 | "metadata": { 141 | "needs_background": "light" 142 | } 143 | } 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "source": [], 149 | "metadata": { 150 | "id": "BEDMWQz4p0aQ" 151 | }, 152 | "execution_count": null, 153 | "outputs": [] 154 | } 155 | ] 156 | } 157 | -------------------------------------------------------------------------------- /Algebra-with-Python/Week-15-code-economics.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [], 7 | "include_colab_link": true 8 | }, 9 | "kernelspec": { 10 | "name": "python3", 11 | "display_name": "Python 3" 12 | }, 13 | "language_info": { 14 | "name": "python" 15 | } 16 | }, 17 | "cells": [ 18 | { 19 | "cell_type": "markdown", 20 | "metadata": { 21 | "id": "view-in-github", 22 | "colab_type": "text" 23 | }, 24 | "source": [ 25 | "\"Open" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "source": [ 31 | "Marginal cost, revenue, profit is the result when making and selling one more product." 32 | ], 33 | "metadata": { 34 | "id": "nkOUIsiUGWZi" 35 | } 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "source": [ 40 | "#Supply and Demand Graph" 41 | ], 42 | "metadata": { 43 | "id": "L1s9BCX5_cZs" 44 | } 45 | }, 46 | { 47 | "cell_type": "code", 48 | "source": [ 49 | "import matplotlib.pyplot as plt\n", 50 | "\n", 51 | "old_demand_x = 1\n", 52 | "new_demand_x = 12\n", 53 | "old_price_y = 14\n", 54 | "new_price_y = 3\n", 55 | "old_supply_x = 11\n", 56 | "new_supply_x = 1\n", 57 | "\n", 58 | "# For the graph\n", 59 | "xmin = 0\n", 60 | "xmax = 15\n", 61 | "ymin = 0\n", 62 | "ymax = 15\n", 63 | "\n", 64 | "\n", 65 | "# Basic setup for the graph\n", 66 | "fig, ax = plt.subplots()\n", 67 | "plt.axis([xmin,xmax,ymin,ymax]) # window size\n", 68 | "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n", 69 | "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n", 70 | "plt.xlabel(\"Quantity\")\n", 71 | "plt.ylabel(\"Price\")\n", 72 | "plt.title(\"Green=Supply, Red=Demand\")\n", 73 | "# Plot the demand function as a red line\n", 74 | "plt.plot([old_demand_x,new_demand_x],[old_price_y,new_price_y],'r')\n", 75 | "\n", 76 | "# Plot the supply function as a green line\n", 77 | "plt.plot([old_supply_x,new_supply_x],[old_price_y,new_price_y],'g')\n", 78 | "\n", 79 | "plt.show()\n" 80 | ], 81 | "metadata": { 82 | "id": "znMFHJt0_kEF", 83 | "colab": { 84 | "base_uri": "https://localhost:8080/", 85 | "height": 295 86 | }, 87 | "outputId": "eb7973eb-3880-4c68-b614-074f73274c22" 88 | }, 89 | "execution_count": null, 90 | "outputs": [ 91 | { 92 | "output_type": "display_data", 93 | "data": { 94 | "text/plain": [ 95 | "
" 96 | ], 97 | "image/png": "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\n" 98 | }, 99 | "metadata": { 100 | "needs_background": "light" 101 | } 102 | } 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "source": [ 108 | "# Calculate the price elasticity of demand\n", 109 | "$ \\frac{percent\\ change\\ in\\ demand}{percent\\ change\\ in\\ price} $\n" 110 | ], 111 | "metadata": { 112 | "id": "EpxY0CImVXtA" 113 | } 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": null, 118 | "metadata": { 119 | "id": "lBeX5MDIUs7_" 120 | }, 121 | "outputs": [], 122 | "source": [ 123 | "old_demand = 5\n", 124 | "new_demand = 6\n", 125 | "old_price = 11\n", 126 | "new_price = 10\n", 127 | "\n", 128 | "# percent change in price\n", 129 | "price_change = (new_price - old_price) / old_price\n", 130 | "\n", 131 | "\n", 132 | "# percent change in demand\n", 133 | "demand_change = (new_demand - old_demand) / old_demand\n", 134 | "\n", 135 | "e_number = demand_change/price_change\n", 136 | "\n", 137 | "# elasticity\n", 138 | "print(e_number)\n", 139 | "\n", 140 | "if e_number>1:\n", 141 | " print(\"Demand is elastic\")\n", 142 | "elif e_number==1:\n", 143 | " print(\"Demand is unitary or proportional\")\n", 144 | "elif e_number<1:\n", 145 | " print(\"Demand is inelastic\")\n", 146 | "else:\n", 147 | " print(\"?\")\n", 148 | "\n", 149 | "\n", 150 | "\n", 151 | "\n" 152 | ] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "source": [ 157 | "#Calculate Price Elasticity of Supply\n", 158 | "$ \\frac{percent\\ change\\ in\\ supply}{percent\\ change\\ in\\ price} $" 159 | ], 160 | "metadata": { 161 | "id": "z6eaEpnyW9M-" 162 | } 163 | }, 164 | { 165 | "cell_type": "code", 166 | "source": [ 167 | "old_price = 4\n", 168 | "new_price = 7\n", 169 | "old_supply = 10\n", 170 | "new_supply = 11\n", 171 | "\n", 172 | "\n", 173 | "# percent change in price\n", 174 | "price_change = (new_price - old_price) / old_price\n", 175 | "\n", 176 | "\n", 177 | "# percent change in supply\n", 178 | "supply_change = (new_supply - old_supply) / old_supply\n", 179 | "\n", 180 | "e_number = supply_change/price_change\n", 181 | "\n", 182 | "# elasticity\n", 183 | "print(e_number)\n", 184 | "\n", 185 | "if e_number>1:\n", 186 | " print(\"Supply is elastic\")\n", 187 | "elif e_number==1:\n", 188 | " print(\"Supply is unitary or proportional\")\n", 189 | "elif e_number<1:\n", 190 | " print(\"Supply is inelastic\")\n", 191 | "else:\n", 192 | " print(\"?\")\n", 193 | "\n", 194 | "\n" 195 | ], 196 | "metadata": { 197 | "id": "TKsasSRZW_qz" 198 | }, 199 | "execution_count": null, 200 | "outputs": [] 201 | } 202 | ] 203 | } 204 | --------------------------------------------------------------------------------