Your_calculator.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "fb2y2RidklSR",
        "41GvsFSEj1M9",
        "8j0cZS6MjNu6",
        "Q_IaJRyljdTE",
        "dZG7pcprkUnX",
        "mxoIcmIluaKf",
        "2I_BZns2rlKf",
        "6Xy0i5lMmo_J",
        "D-x0JNFCdgNi",
        "uw0zwudGBErL",
        "5KBLd5tcH0Tv"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jeshwanthshivasai/college_algebra/blob/main/Your_calculator.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Proportions"
      ],
      "metadata": {
        "id": "fb2y2RidklSR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Set up a proportion:<br>\n",
        "$\\frac{n1}{d1}=\\frac{n2}{d2}$"
      ],
      "metadata": {
        "id": "v-0em0IOJeBX"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "NipG5UbBJWVd",
        "outputId": "c5818abf-3308-4e36-e786-47ad28c6e641",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "d2 =  8.0\n"
          ]
        }
      ],
      "source": [
        "# Put a zero in for the unknown value\n",
        "n1 = 1\n",
        "d1 = 2\n",
        "n2 = 4\n",
        "d2 = 0\n",
        "\n",
        "if n2==0:\n",
        "    answer = d2 * n1 / d1\n",
        "    print(\"n2 = \", answer)\n",
        "\n",
        "if d2==0:\n",
        "    answer = n2 * d1 / n1\n",
        "    print(\"d2 = \", answer)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Convert decimal to fraction and percent"
      ],
      "metadata": {
        "id": "41GvsFSEj1M9"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pDaZckUyBKRl"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Get string input, which will include a decimal point\n",
        "digits = input(\"Enter a decimal number to convert: \")\n",
        "\n",
        "# Get number of decimal places as an integer\n",
        "exponent = int(len(digits))-1\n",
        "\n",
        "# Convert the input to a float number\n",
        "n = float(digits)\n",
        "\n",
        "# Use the exponent to get the numerator\n",
        "numerator = int(n * 10**exponent)\n",
        "\n",
        "# Use the expoent to get the denominator\n",
        "denominator = 10**exponent\n",
        "\n",
        "# percent is the first two decimal places\n",
        "percent = n * 100\n",
        "\n",
        "# Output\n",
        "print(\"The decimal is \", n)\n",
        "print(\"The fraction is \", numerator, \"/\", denominator)\n",
        "print(\"The percent is \", percent, \" %\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Solve for x"
      ],
      "metadata": {
        "id": "8j0cZS6MjNu6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import sympy\n",
        "from sympy import symbols\n",
        "from sympy.solvers import solve\n",
        "\n",
        "x = symbols('x')\n",
        "\n",
        "eq = input('Enter equation: 0 = ')\n",
        "\n",
        "solution = solve(eq,x)\n",
        "for s in solution:\n",
        "    print(\"x = \", s)\n",
        "\n",
        "sympy.factor(eq)"
      ],
      "metadata": {
        "id": "JAvk-AYdFj0k",
        "outputId": "7764ee1d-67dd-4a23-9447-f20259d0b946",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 75
        }
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter equation: 0 = x\n",
            "x =  0\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "x"
            ],
            "text/latex": "$\\displaystyle x$"
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Factor an expression"
      ],
      "metadata": {
        "id": "Q_IaJRyljdTE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import sympy\n",
        "from sympy import *\n",
        "import math\n",
        "\n",
        "var('x y')\n",
        "\n",
        "# Equation to factor\n",
        "eq = x**3 - 2*x**2 - 5*x + 6\n",
        "\n",
        "\n",
        "sympy.factor(eq)\n"
      ],
      "metadata": {
        "id": "2JjZ1cPNPqe8",
        "outputId": "4bbea27b-f51d-4789-85ea-4c273d73cac4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 39
        }
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(x - 3)*(x - 1)*(x + 2)"
            ],
            "text/latex": "$\\displaystyle \\left(x - 3\\right) \\left(x - 1\\right) \\left(x + 2\\right)$"
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Solve for a variable"
      ],
      "metadata": {
        "id": "dZG7pcprkUnX"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "egdhbgMnYPYA",
        "outputId": "18578476-feee-4510-b54b-027470da0113",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x  =  (-b - sqrt(-4*a*c + b**2))/(2*a)\n",
            "x  =  (-b + sqrt(-4*a*c + b**2))/(2*a)\n"
          ]
        }
      ],
      "source": [
        "from sympy import *\n",
        "import math\n",
        "\n",
        "# Identify all variables\n",
        "var('a b c d x')\n",
        "\n",
        "# Left and right sides of the equal sign\n",
        "left = 0\n",
        "right = a*x**2 + b*x + c\n",
        "\n",
        "# Variable to solve for\n",
        "variable = x\n",
        "\n",
        "# Sympy equation left = right\n",
        "eq1 = Eq(left,right)\n",
        "\n",
        "# Sympy solve for that variable\n",
        "sol = solve(eq1,variable)\n",
        "\n",
        "# Show factored results\n",
        "for s in sol:\n",
        "    print(variable, \" = \", s)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Slope-intercept equation from two points"
      ],
      "metadata": {
        "id": "mxoIcmIluaKf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x1 = 0\n",
        "y1 = 32\n",
        "x2 = 100\n",
        "y2 = 212\n",
        "\n",
        "# Develop the equation y = mx + b\n",
        "m = (y2 - y1) / (x2 - x1)\n",
        "b = y1 - m*x1\n",
        "print(\"y = \", m, \"x + \", b)\n",
        "\n",
        "# For the graph\n",
        "xmin = 0\n",
        "xmax = 10\n",
        "ymin = 0\n",
        "ymax = 500\n",
        "\n",
        "# For the line on the graph\n",
        "y3 = m*xmin + b\n",
        "y4 = m*xmax + b\n",
        "\n",
        "# Basic setup for the graph\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "# Add details to the graph\n",
        "ax.set_xlabel(\"x values\")\n",
        "ax.set_ylabel(\"y values\")\n",
        "ax.grid(True)\n",
        "#ax.set_xticks(np.arange(xmin, xmax, 2))\n",
        "#ax.set_yticks(np.arange(ymin, ymax, 1))\n",
        "\n",
        "\n",
        "# Plot the linear function as a red line\n",
        "plt.plot([xmin,xmax],[y3,y4],'r')\n",
        "\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "ngy3aRPTubfh",
        "outputId": "25dd76d6-778a-4f37-ab0e-23849ae4c670",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 473
        }
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "y =  1.8 x +  32.0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAG2CAYAAACeUpnVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtwUlEQVR4nO3df1TUdb7H8Re/URQQEpAVkN11U1LTpHSqzVKUiPXk1bIfZFRunetiidz1lpu/LSl3N80WtdpK717ZyvZmZWqRGW6JvzA6/ki3zBY3HTALSMxhgO/9w3U2El3Rge/Q5/k4h3Oa7/c7M+/h4y7P851ffpZlWQIAADCYv90DAAAA2I0gAgAAxiOIAACA8QgiAABgPIIIAAAYjyACAADGI4gAAIDxCCIAAGA8gggAABiPIAIAAMazNYhmzZolPz+/Jj+9evXy7D9x4oRycnIUHR2tTp06acyYMaqoqGhyG+Xl5crMzFTHjh0VExOjKVOmqL6+vq0fCgAAaMcC7R7gkksu0TvvvOO5HBj4r5EmT56sN998UytXrlRERIQmTpyo0aNH64MPPpAkNTQ0KDMzU3Fxcdq0aZMOHz6sO++8U0FBQZo3b16bPxYAANA++dn55a6zZs3SqlWrVFZWdtq+6upqde3aVYWFhbrpppskSXv37lXv3r1VUlKiwYMHa+3atfrFL36hQ4cOKTY2VpK0dOlSPfjggzpy5IiCg4Pb8uEAAIB2yvYzRJ988oni4+MVGhoqh8Oh/Px8JSYmqrS0VG63W2lpaZ5je/XqpcTERE8QlZSUqG/fvp4YkqT09HRNmDBBu3fv1oABA5q9T5fLJZfL5bnc2Nior776StHR0fLz82u9BwsAALzGsix98803io+Pl7//hb0KyNYgGjRokJYtW6aLL75Yhw8f1uzZs/Xzn/9cu3btktPpVHBwsCIjI5tcJzY2Vk6nU5LkdDqbxNCp/af2nUl+fr5mz57t3QcDAABscfDgQXXv3v2CbsPWIMrIyPD8d79+/TRo0CAlJSXp5ZdfVocOHVrtfqdOnaq8vDzP5erqaiUmJqqs7G/q3j2q1e4X/57b7daGDRt03XXXKSgoyO5xjMZa+A7WwnewFr7lq6++0s9+9jN17tz5gm/L9qfMvisyMlI/+9nP9Omnn2r48OGqq6tTVVVVk7NEFRUViouLkyTFxcVp69atTW7j1LvQTh3TnJCQEIWEhJy2vUuXKEVHR3vhkeB8ud1udezYUdHR0fyfjc1YC9/BWvgO1sI3eePlLj71OUTHjh3T/v371a1bNw0cOFBBQUFav369Z/++fftUXl4uh8MhSXI4HNq5c6cqKys9xxQVFSk8PFwpKSltPj8AAGifbD1D9Otf/1ojR45UUlKSDh06pJkzZyogIEC33XabIiIiNH78eOXl5SkqKkrh4eG6//775XA4NHjwYEnSiBEjlJKSonHjxmn+/PlyOp2aNm2acnJymj0DBAAA0Bxbg+gf//iHbrvtNh09elRdu3bV1Vdfrc2bN6tr166SpAULFsjf319jxoyRy+VSenq6Fi9e7Ll+QECAVq9erQkTJsjhcCgsLEzZ2dmaM2eOXQ8JAAC0Q7YG0YsvvnjW/aGhoSooKFBBQcEZj0lKStKaNWu8PRoAADCIT72GCAAAwA4EEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjOczQfTYY4/Jz89Pubm5nm0nTpxQTk6OoqOj1alTJ40ZM0YVFRVNrldeXq7MzEx17NhRMTExmjJliurr69t4egAA0J75RBBt27ZNTz/9tPr169dk++TJk/XGG29o5cqVKi4u1qFDhzR69GjP/oaGBmVmZqqurk6bNm3S8uXLtWzZMs2YMaOtHwIAAGjHbA+iY8eOKSsrS88++6y6dOni2V5dXa3nnntOTzzxhIYOHaqBAwfqhRde0KZNm7R582ZJ0ttvv609e/bof//3f9W/f39lZGRo7ty5KigoUF1dnV0PCQAAtDOBdg+Qk5OjzMxMpaWl6ZFHHvFsLy0tldvtVlpammdbr169lJiYqJKSEg0ePFglJSXq27evYmNjPcekp6drwoQJ2r17twYMGNDsfbpcLrlcLs/lmpoaSVJ9vVtut9vbDxEtcOr3zzrYj7XwHayF72AtfIs318HWIHrxxRe1Y8cObdu27bR9TqdTwcHBioyMbLI9NjZWTqfTc8x3Y+jU/lP7ziQ/P1+zZ88+bXtx8UZFRYW09GGgFRQVFdk9Av6JtfAdrIXvYC18w/Hjx712W7YF0cGDBzVp0iQVFRUpNDS0Te976tSpysvL81yuqalRQkKChgy5RgkJ0W06C5pyu90qKirS8OHDFRQUZPc4RmMtfAdr4TtYC99y9OhRr92WbUFUWlqqyspKXXbZZZ5tDQ0N2rhxo/7whz/orbfeUl1dnaqqqpqcJaqoqFBcXJwkKS4uTlu3bm1yu6fehXbqmOaEhIQoJOT0M0GBgUH8A/cRQUGsha9gLXwHa+E7WAvf4M01sO1F1cOGDdPOnTtVVlbm+UlNTVVWVpbnv4OCgrR+/XrPdfbt26fy8nI5HA5JksPh0M6dO1VZWek5pqioSOHh4UpJSWnzxwQAANon284Qde7cWX369GmyLSwsTNHR0Z7t48ePV15enqKiohQeHq77779fDodDgwcPliSNGDFCKSkpGjdunObPny+n06lp06YpJyen2TNAAAAAzbH9XWZns2DBAvn7+2vMmDFyuVxKT0/X4sWLPfsDAgK0evVqTZgwQQ6HQ2FhYcrOztacOXNsnBoAALQ3PhVE7733XpPLoaGhKigoUEFBwRmvk5SUpDVr1rTyZAAA4IfM9g9mBAAAsBtBBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA49kaREuWLFG/fv0UHh6u8PBwORwOrV271rP/xIkTysnJUXR0tDp16qQxY8aooqKiyW2Ul5crMzNTHTt2VExMjKZMmaL6+vq2figAAKAdszWIunfvrscee0ylpaXavn27hg4dqhtvvFG7d++WJE2ePFlvvPGGVq5cqeLiYh06dEijR4/2XL+hoUGZmZmqq6vTpk2btHz5ci1btkwzZsyw6yEBAIB2KNDOOx85cmSTy48++qiWLFmizZs3q3v37nruuedUWFiooUOHSpJeeOEF9e7dW5s3b9bgwYP19ttva8+ePXrnnXcUGxur/v37a+7cuXrwwQc1a9YsBQcH2/GwAABAO2NrEH1XQ0ODVq5cqdraWjkcDpWWlsrtdistLc1zTK9evZSYmKiSkhINHjxYJSUl6tu3r2JjYz3HpKena8KECdq9e7cGDBjQ7H25XC65XC7P5ZqaGklSfb1bbre7lR4hzsWp3z/rYD/WwnewFr6DtfAt3lwH24No586dcjgcOnHihDp16qRXX31VKSkpKisrU3BwsCIjI5scHxsbK6fTKUlyOp1NYujU/lP7ziQ/P1+zZ88+bXtx8UZFRYVc4COCNxQVFdk9Av6JtfAdrIXvYC18w/Hjx712W7YH0cUXX6yysjJVV1frlVdeUXZ2toqLi1v1PqdOnaq8vDzP5ZqaGiUkJGjIkGuUkBDdqveNs3O73SoqKtLw4cMVFBRk9zhGYy18B2vhO1gL33L06FGv3ZbtQRQcHKyf/vSnkqSBAwdq27ZtevLJJ3XLLbeorq5OVVVVTc4SVVRUKC4uTpIUFxenrVu3Nrm9U+9CO3VMc0JCQhQScvqZoMDAIP6B+4igINbCV7AWvoO18B2shW/w5hr43OcQNTY2yuVyaeDAgQoKCtL69es9+/bt26fy8nI5HA5JksPh0M6dO1VZWek5pqioSOHh4UpJSWnz2QEAQPtk6xmiqVOnKiMjQ4mJifrmm29UWFio9957T2+99ZYiIiI0fvx45eXlKSoqSuHh4br//vvlcDg0ePBgSdKIESOUkpKicePGaf78+XI6nZo2bZpycnKaPQMEAADQHFuDqLKyUnfeeacOHz6siIgI9evXT2+99ZaGDx8uSVqwYIH8/f01ZswYuVwupaena/HixZ7rBwQEaPXq1ZowYYIcDofCwsKUnZ2tOXPm2PWQAABAO2RrED333HNn3R8aGqqCggIVFBSc8ZikpCStWbPG26MBAACD+NxriAAAANoaQQQAAIznlSCqqqryxs0AAADYosVB9Pjjj+ull17yXB47dqyio6P1ox/9SB999JFXhwMAAGgLLQ6ipUuXKiEhQdLJz/wpKirS2rVrlZGRoSlTpnh9QAAAgNbW4neZOZ1OTxCtXr1aY8eO1YgRI9SjRw8NGjTI6wMCAAC0thafIerSpYsOHjwoSVq3bp3n2+gty1JDQ4N3pwMAAGgDLT5DNHr0aN1+++3q2bOnjh49qoyMDEnShx9+6PlOMgAAgPakxUG0YMEC9ejRQwcPHtT8+fPVqVMnSdLhw4f1q1/9yusDAgAAtLYWB1FQUJB+/etfn7Z98uTJXhkIAACgrZ3X5xD96U9/0tVXX634+Hj9/e9/lyQtXLhQr732mleHAwAAaAstDqIlS5YoLy9PGRkZqqqq8ryQOjIyUgsXLvT2fAAAAK2uxUH01FNP6dlnn9XDDz+sgIAAz/bU1FTt3LnTq8MBAAC0hRYH0YEDBzRgwIDTtoeEhKi2ttYrQwEAALSlFgdRcnKyysrKTtu+bt069e7d2xszAQAAtKkWv8ssLy9POTk5OnHihCzL0tatW/XnP/9Z+fn5+uMf/9gaMwIAALSqFgfRL3/5S3Xo0EHTpk3T8ePHdfvttys+Pl5PPvmkbr311taYEQAAoFW1OIgkKSsrS1lZWTp+/LiOHTummJgYb88FAADQZs4riE7p2LGjOnbs6K1ZAAAAbNHiIEpOTpafn98Z93/22WcXNBAAAEBba3EQ5ebmNrnsdrv14Ycfat26dZoyZYq35gIAAGgzLQ6iSZMmNbu9oKBA27dvv+CBAAAA2tp5fZdZczIyMvSXv/zFWzcHAADQZrwWRK+88oqioqK8dXMAAABtpsVPmQ0YMKDJi6oty5LT6dSRI0e0ePFirw4HAADQFlocRKNGjWpy2d/fX127dtW1116rXr16eWsuAACANtPiIJo5c2ZrzAEAAGCbcwqimpqac77B8PDw8x4GAADADucURJGRkWf9MEbp5GuJ/Pz81NDQ4JXBAAAA2so5BdGGDRtaew4AAADbnFMQDRkypLXnAAAAsM15f7nr8ePHVV5errq6uibb+/Xrd8FDAQAAtKUWB9GRI0d09913a+3atc3u5zVEAACgvWnxJ1Xn5uaqqqpKW7ZsUYcOHbRu3TotX75cPXv21Ouvv94aMwIAALSqFp8hevfdd/Xaa68pNTVV/v7+SkpK0vDhwxUeHq78/HxlZma2xpwAAACtpsVniGpraxUTEyNJ6tKli44cOSJJ6tu3r3bs2OHd6QAAANpAi4Po4osv1r59+yRJl156qZ5++ml98cUXWrp0qbp16+b1AQEAAFpbi58ymzRpkg4fPizp5Nd4XH/99VqxYoWCg4O1bNkyb88HAADQ6locRHfccYfnvwcOHKi///3v2rt3rxITE3XRRRd5dTgAAIC20OKnzN5///0mlzt27KjLLruMGAIAAO1Wi4No6NChSk5O1m9+8xvt2bOnNWYCAABoUy0OokOHDum//uu/VFxcrD59+qh///767W9/q3/84x+tMR8AAECra3EQXXTRRZo4caI++OAD7d+/XzfffLOWL1+uHj16aOjQoa0xIwAAQKtqcRB9V3Jysh566CE99thj6tu3r4qLi701FwAAQJs57yD64IMP9Ktf/UrdunXT7bffrj59+ujNN9/05mwAAABtosVvu586dapefPFFHTp0SMOHD9eTTz6pG2+8UR07dmyN+QAAAFpdi4No48aNmjJlisaOHctb7QEAwA9Ci4Pogw8+aI05AAAAbHNBL6oGAAD4ISCIAACA8QgiAABgPIIIAAAYr8VBlJ2drY0bN7bGLAAAALZocRBVV1crLS1NPXv21Lx58/TFF1+0xlwAAABtpsVBtGrVKn3xxReaMGGCXnrpJfXo0UMZGRl65ZVX5Ha7W2NGAACAVnVeryHq2rWr8vLy9NFHH2nLli366U9/qnHjxik+Pl6TJ0/WJ5984u05AQAAWs0Fvaj68OHDKioqUlFRkQICAnTDDTdo586dSklJ0YIFC7w1IwAAQKtqcRC53W795S9/0S9+8QslJSVp5cqVys3N1aFDh7R8+XK98847evnllzVnzpzWmBcAAMDrWvzVHd26dVNjY6Nuu+02bd26Vf379z/tmOuuu06RkZFeGA8AAKD1tTiIFixYoJtvvlmhoaFnPCYyMlIHDhy4oMEAAADaSouDaNy4ca0xBwAAgG34pGoAAGA8gggAABjP1iDKz8/X5Zdfrs6dOysmJkajRo3Svn37mhxz4sQJ5eTkKDo6Wp06ddKYMWNUUVHR5Jjy8nJlZmaqY8eOiomJ0ZQpU1RfX9+WDwUAALRjtgZRcXGxcnJytHnzZhUVFcntdmvEiBGqra31HDN58mS98cYbWrlypYqLi3Xo0CGNHj3as7+hoUGZmZmqq6vTpk2btHz5ci1btkwzZsyw4yEBAIB2qMUvqvamdevWNbm8bNkyxcTEqLS0VNdcc42qq6v13HPPqbCwUEOHDpUkvfDCC+rdu7c2b96swYMH6+2339aePXv0zjvvKDY2Vv3799fcuXP14IMPatasWQoODrbjoQEAgHbE1iD6vurqaklSVFSUJKm0tFRut1tpaWmeY3r16qXExESVlJRo8ODBKikpUd++fRUbG+s5Jj09XRMmTNDu3bs1YMCA0+7H5XLJ5XJ5LtfU1EiS6uvdfB+bzU79/lkH+7EWvoO18B2shW/x5jr4TBA1NjYqNzdXV111lfr06SNJcjqdCg4OPu1DHmNjY+V0Oj3HfDeGTu0/ta85+fn5mj179mnbi4s3Kioq5EIfCrygqKjI7hHwT6yF72AtfAdr4RuOHz/utdvymSDKycnRrl279P7777f6fU2dOlV5eXmeyzU1NUpISNCQIdcoISG61e8fZ+Z2u1VUVKThw4crKCjI7nGMxlr4DtbCd7AWvuXo0aNeuy2fCKKJEydq9erV2rhxo7p37+7ZHhcXp7q6OlVVVTU5S1RRUaG4uDjPMVu3bm1ye6fehXbqmO8LCQlRSMjpZ4ICA4P4B+4jgoJYC1/BWvgO1sJ3sBa+wZtrYOu7zCzL0sSJE/Xqq6/q3XffVXJycpP9AwcOVFBQkNavX+/Ztm/fPpWXl8vhcEiSHA6Hdu7cqcrKSs8xRUVFCg8PV0pKSts8EAAA0K7ZeoYoJydHhYWFeu2119S5c2fPa34iIiLUoUMHRUREaPz48crLy1NUVJTCw8N1//33y+FwaPDgwZKkESNGKCUlRePGjdP8+fPldDo1bdo05eTkNHsWCAAA4PtsDaIlS5ZIkq699tom21944QXdddddkk5+may/v7/GjBkjl8ul9PR0LV682HNsQECAVq9erQkTJsjhcCgsLEzZ2dmaM2dOWz0MAADQztkaRJZl/dtjQkNDVVBQoIKCgjMek5SUpDVr1nhzNAAAYBC+ywwAABiPIAIAAMYjiAAAgPEIIgAAYDyCCAAAGI8gAgAAxiOIAACA8QgiAABgPIIIAAAYjyACAADGI4gAAIDxCCIAAGA8gggAABiPIAIAAMYjiAAAgPEIIgAAYDyCCAAAGI8gAgAAxiOIAACA8QgiAABgPIIIAAAYjyACAADGI4gAAIDxCCIAAGA8gggAABiPIAIAAMYjiAAAgPEIIgAAYDyCCAAAGI8gAgAAxiOIAACA8QgiAABgPIIIAAAYjyACAADGI4gAAIDxCCIAAGA8gggAABiPIAIAAMYjiAAAgPEIIgAAYDyCCAAAGI8gAgAAxiOIAACA8QgiAABgPIIIAAAYjyACAADGI4gAAIDxCCIAAGA8gggAABiPIAIAAMYjiAAAgPEIIgAAYDyCCAAAGI8gAgAAxiOIAACA8QgiAABgPIIIAAAYjyACAADGI4gAAIDxCCIAAGA8gggAABiPIAIAAMYjiAAAgPFsDaKNGzdq5MiRio+Pl5+fn1atWtVkv2VZmjFjhrp166YOHTooLS1Nn3zySZNjvvrqK2VlZSk8PFyRkZEaP368jh071oaPAgAAtHe2BlFtba0uvfRSFRQUNLt//vz5WrRokZYuXaotW7YoLCxM6enpOnHihOeYrKws7d69W0VFRVq9erU2btyo++67r60eAgAA+AEItPPOMzIylJGR0ew+y7K0cOFCTZs2TTfeeKMk6X/+538UGxurVatW6dZbb9XHH3+sdevWadu2bUpNTZUkPfXUU7rhhhv0u9/9TvHx8W32WAAAQPtlaxCdzYEDB+R0OpWWlubZFhERoUGDBqmkpES33nqrSkpKFBkZ6YkhSUpLS5O/v7+2bNmi//iP/2j2tl0ul1wul+dyTU2NJKm+3i23291Kjwjn4tTvn3WwH2vhO1gL38Fa+BZvroPPBpHT6ZQkxcbGNtkeGxvr2ed0OhUTE9Nkf2BgoKKiojzHNCc/P1+zZ88+bXtx8UZFRYVc6OjwgqKiIrtHwD+xFr6DtfAdrIVvOH78uNduy2eDqDVNnTpVeXl5nss1NTVKSEjQkCHXKCEh2sbJ4Ha7VVRUpOHDhysoKMjucYzGWvgO1sJ3sBa+5ejRo167LZ8Nori4OElSRUWFunXr5tleUVGh/v37e46prKxscr36+np99dVXnus3JyQkRCEhp58JCgwM4h+4jwgKYi18BWvhO1gL38Fa+AZvroHPfg5RcnKy4uLitH79es+2mpoabdmyRQ6HQ5LkcDhUVVWl0tJSzzHvvvuuGhsbNWjQoDafGQAAtE+2niE6duyYPv30U8/lAwcOqKysTFFRUUpMTFRubq4eeeQR9ezZU8nJyZo+fbri4+M1atQoSVLv3r11/fXX695779XSpUvldrs1ceJE3XrrrbzDDAAAnDNbg2j79u267rrrPJdPva4nOztby5Yt03//93+rtrZW9913n6qqqnT11Vdr3bp1Cg0N9VxnxYoVmjhxooYNGyZ/f3+NGTNGixYtavPHAgAA2i9bg+jaa6+VZVln3O/n56c5c+Zozpw5ZzwmKipKhYWFrTEeAAAwhM++hggAAKCtEEQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIxHEAEAAOMRRAAAwHgEEQAAMB5BBAAAjEcQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAADAeQQQAAIwXaPcAAAAATTQ0SC7XyZ+6un/99/d+/L780mt3SRABAGAqy5Lq688pPs66z9vXbWg4p/G9GTEEEQAAbcGy/vWHvy3j4t/tsyy7fzP/XnCwFBJy2o8VECDt2uWVuyCIAAA/PI2NrRIP/t9+qwH79yugsLDpmZVzud26Ort/K/+en1+z4eH5OUOYnNP+871uUNDJuZpRf/SodNFFXnnoBBEA4MKcCgNfebrF5To5UysIkJTotRsL8K3wCAmRAs3NAnMfOQC0N6eecvGlp1tcrpNnY3xdUJBX4qIhMFB7P/9cvfr1U0DHjucfJsHBJ4MIPoMgAoDmWJbPnPUIdLn0i2+/lX99fft4vYevnfUICpL8vfMpM41utz5ds0Y/u+EGBQQFeeU24RsIIgD2a2jwvbMebrfdvxUPP518quY0/v5tHxf/7rqBgWd8vQfgywgiwCSn3mJ7DoHgV1uruM2b5Xfs2Dl/Jsh5h8k5vsXWVoGBtp31cPv7a8OmTbru+usV1KnTv/YZ/HoPwNv4XxPQWizr5FkGm59uOe3nHJ9yCZQ0qHV/Q2d2plCw66xHcLDXnnI5L263vv30Uyku7uTTPwC8jiDCD0Nj4/kHRGuFSXt+i21wsKzgYH397beKjI2Vf2ho24VJcDBPuQBocwQRWu67T594OS4Cvv1WAz//XAHPP3/62ZWzXbeV3mLrVc29xdauF5l+9ymXM32+h9utv65ZoxtuuEH+nJUA8ANHEPmy73+kui+c9XC5WvUttv6Sunvjhpp7i62dT7eEhPAWWwDwYQTRd9W5pJoa33mtR11d+3yL7QXERUNAgPbs36+UAQNOfsbH+YSJ3a/3AAC0OwTRd0T2/JHdI5xdc2+xtfusx1k+Uv18NLrd+mzNGvXiMz4AAG2IIDqT77/F1q7Xenx3H2+xBQCgVfAX9juqd+5X+E+6nYwPnnIBAMAYBNF3WOERUocOdo8BAADaGKdBAACA8QgiAABgPIIIAAAYjyACAADGI4gAAIDxCCIAAGA8gggAABiPIAIAAMYjiAAAgPEIIgAAYDyCCAAAGI8gAgAAxiOIAACA8QgiAABgPIIIAAAYjyACAADGI4gAAIDxfjBBVFBQoB49eig0NFSDBg3S1q1b7R4JAAC0Ez+IIHrppZeUl5enmTNnaseOHbr00kuVnp6uyspKu0cDAADtQKDdA3jDE088oXvvvVd33323JGnp0qV688039fzzz+uhhx4659s5flyqrW2tKXEu3G7pxIkA1dZKQUF2T2M21sJ3sBa+g7XwLd78m93ug6iurk6lpaWaOnWqZ5u/v7/S0tJUUlLS7HVcLpdcLpfncnV1tSSpd+9vJdW06rw4F9dI+vafP7AXa+E7WAvfwVr4jpNrYFnWBd9Suw+iL7/8Ug0NDYqNjW2yPTY2Vnv37m32Ovn5+Zo9e3YzexJaYUIAANCajh49qoiIiAu6jXYfROdj6tSpysvL81yuqqpSUlKSysvLL/gXigtTU1OjhIQEHTx4UOHh4XaPYzTWwnewFr6DtfAt1dXVSkxMVFRU1AXfVrsPoosuukgBAQGqqKhosr2iokJxcXHNXickJEQhISGnbY+IiOAfuI8IDw9nLXwEa+E7WAvfwVr4Fn//C3+PWLt/l1lwcLAGDhyo9evXe7Y1NjZq/fr1cjgcNk4GAADai3Z/hkiS8vLylJ2drdTUVF1xxRVauHChamtrPe86AwAAOJsfRBDdcsstOnLkiGbMmCGn06n+/ftr3bp1p73Q+kxCQkI0c+bMZp9GQ9tiLXwHa+E7WAvfwVr4Fm+uh5/ljfeqAQAAtGPt/jVEAAAAF4ogAgAAxiOIAACA8QgiAABgPOODqKCgQD169FBoaKgGDRqkrVu32j2ScfLz83X55Zerc+fOiomJ0ahRo7Rv3z67x4Kkxx57TH5+fsrNzbV7FGN98cUXuuOOOxQdHa0OHTqob9++2r59u91jGaehoUHTp09XcnKyOnTooJ/85CeaO3euV75DC2e3ceNGjRw5UvHx8fLz89OqVaua7LcsSzNmzFC3bt3UoUMHpaWl6ZNPPmnx/RgdRC+99JLy8vI0c+ZM7dixQ5deeqnS09NVWVlp92hGKS4uVk5OjjZv3qyioiK53W6NGDFCtd78GmO02LZt2/T000+rX79+do9irK+//lpXXXWVgoKCtHbtWu3Zs0e///3v1aVLF7tHM87jjz+uJUuW6A9/+IM+/vhjPf7445o/f76eeuopu0f7wautrdWll16qgoKCZvfPnz9fixYt0tKlS7VlyxaFhYUpPT1dJ06caNkdWQa74oorrJycHM/lhoYGKz4+3srPz7dxKlRWVlqSrOLiYrtHMdY333xj9ezZ0yoqKrKGDBliTZo0ye6RjPTggw9aV199td1jwLKszMxM65577mmybfTo0VZWVpZNE5lJkvXqq696Ljc2NlpxcXHWb3/7W8+2qqoqKyQkxPrzn//cots29gxRXV2dSktLlZaW5tnm7++vtLQ0lZSU2DgZqqurJckrX9aH85OTk6PMzMwm//tA23v99deVmpqqm2++WTExMRowYICeffZZu8cy0pVXXqn169frb3/7myTpo48+0vvvv6+MjAybJzPbgQMH5HQ6m/x/VUREhAYNGtTiv+U/iE+qPh9ffvmlGhoaTvs069jYWO3du9emqdDY2Kjc3FxdddVV6tOnj93jGOnFF1/Ujh07tG3bNrtHMd5nn32mJUuWKC8vT7/5zW+0bds2PfDAAwoODlZ2drbd4xnloYceUk1NjXr16qWAgAA1NDTo0UcfVVZWlt2jGc3pdEpSs3/LT+07V8YGEXxTTk6Odu3apffff9/uUYx08OBBTZo0SUVFRQoNDbV7HOM1NjYqNTVV8+bNkyQNGDBAu3bt0tKlSwmiNvbyyy9rxYoVKiws1CWXXKKysjLl5uYqPj6etfiBMPYps4suukgBAQGqqKhosr2iokJxcXE2TWW2iRMnavXq1dqwYYO6d+9u9zhGKi0tVWVlpS677DIFBgYqMDBQxcXFWrRokQIDA9XQ0GD3iEbp1q2bUlJSmmzr3bu3ysvLbZrIXFOmTNFDDz2kW2+9VX379tW4ceM0efJk5efn2z2a0U79vfbG33Jjgyg4OFgDBw7U+vXrPdsaGxu1fv16ORwOGyczj2VZmjhxol599VW9++67Sk5OtnskYw0bNkw7d+5UWVmZ5yc1NVVZWVkqKytTQECA3SMa5aqrrjrtIyj+9re/KSkpyaaJzHX8+HH5+zf9kxkQEKDGxkabJoIkJScnKy4ursnf8pqaGm3ZsqXFf8uNfsosLy9P2dnZSk1N1RVXXKGFCxeqtrZWd999t92jGSUnJ0eFhYV67bXX1LlzZ8/zvhEREerQoYPN05mlc+fOp712KywsTNHR0bymywaTJ0/WlVdeqXnz5mns2LHaunWrnnnmGT3zzDN2j2ackSNH6tFHH1ViYqIuueQSffjhh3riiSd0zz332D3aD96xY8f06aefei4fOHBAZWVlioqKUmJionJzc/XII4+oZ8+eSk5O1vTp0xUfH69Ro0a17I689E64duupp56yEhMTreDgYOuKK66wNm/ebPdIxpHU7M8LL7xg92iwLN52b7M33njD6tOnjxUSEmL16tXLeuaZZ+weyUg1NTXWpEmTrMTERCs0NNT68Y9/bD388MOWy+Wye7QfvA0bNjT7NyI7O9uyrJNvvZ8+fboVGxtrhYSEWMOGDbP27dvX4vvxsyw+ZhMAAJjN2NcQAQAAnEIQAQAA4xFEAADAeAQRAAAwHkEEAACMRxABAADjEUQAAMB4BBEAI7z33nvy8/NTVVWV3aMA8EEEEQAAMB5BBAAAjEcQAWhTR44cUVxcnObNm+fZtmnTJgUHBzf5xurvuvLKK/Xggw+edjtBQUHauHGjJOlPf/qTUlNT1blzZ8XFxen2229XZWXlGeeYNWuW+vfv32TbwoUL1aNHjybb/vjHP6p3794KDQ1Vr169tHjxYs++uro6TZw4Ud26dVNoaKiSkpKUn59/Lr8GAD6GIALQprp27arnn39es2bN0vbt2/XNN99o3LhxmjhxooYNG9bsdbKysvTiiy/qu1+9+NJLLyk+Pl4///nPJUlut1tz587VRx99pFWrVunzzz/XXXfddUGzrlixQjNmzNCjjz6qjz/+WPPmzdP06dO1fPlySdKiRYv0+uuv6+WXX9a+ffu0YsWK04IKQPsQaPcAAMxzww036N5771VWVpZSU1MVFhZ21jMrY8eOVW5urt5//31PABUWFuq2226Tn5+fJOmee+7xHP/jH/9YixYt0uWXX65jx46pU6dO5zXnzJkz9fvf/16jR4+WJCUnJ2vPnj16+umnlZ2drfLycvXs2VNXX321/Pz8lJSUdF73A8B+nCECYIvf/e53qq+v18qVK7VixQqFhISc8diuXbtqxIgRWrFihSTpwIEDKikpUVZWlueY0tJSjRw5UomJiercubOGDBkiSSovLz+v+Wpra7V//36NHz9enTp18vw88sgj2r9/vyTprrvuUllZmS6++GI98MADevvtt8/rvgDYjyACYIv9+/fr0KFDamxs1Oeff/5vj8/KytIrr7wit9utwsJC9e3bV3379pV0Ml7S09MVHh6uFStWaNu2bXr11VclnXydT3P8/f2bPAUnnXza7ZRjx45Jkp599lmVlZV5fnbt2qXNmzdLki677DIdOHBAc+fO1bfffquxY8fqpptuavHvAoD9eMoMQJurq6vTHXfcoVtuuUUXX3yxfvnLX2rnzp2KiYk543VuvPFG3XfffVq3bp0KCwt15513evbt3btXR48e1WOPPaaEhARJ0vbt2886Q9euXeV0OmVZludpt7KyMs/+2NhYxcfH67PPPmtyJur7wsPDdcstt+iWW27RTTfdpOuvv15fffWVoqKizuVXAcBHEEQA2tzDDz+s6upqLVq0SJ06ddKaNWt0zz33aPXq1We8TlhYmEaNGqXp06fr448/1m233ebZl5iYqODgYD311FP6z//8T+3atUtz58496wzXXnutjhw5ovnz5+umm27SunXrtHbtWoWHh3uOmT17th544AFFRETo+uuvl8vl0vbt2/X1118rLy9PTzzxhLp166YBAwbI399fK1euVFxcnCIjIy/4dwSgjVkA0IY2bNhgBQYGWn/961892w4cOGCFh4dbixcvPut116xZY0myrrnmmtP2FRYWWj169LBCQkIsh8Nhvf7665Yk68MPP/TcryTr66+/9lxnyZIlVkJCghUWFmbdeeed1qOPPmolJSU1ud0VK1ZY/fv3t4KDg60uXbpY11xzjfV///d/lmVZ1jPPPGP179/fCgsLs8LDw61hw4ZZO3bsOL9fDABb+VnW955EBwAAMAwvqgYAAMYjiAAAgPEIIgAAYDyCCAAAGI8gAgAAxiOIAACA8QgiAABgPIIIAAAYjyACAADGI4gAAIDxCCIAAGA8gggAABjv/wGAYA9mhpT3aAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Graph lines and zoom in or out"
      ],
      "metadata": {
        "id": "2I_BZns2rlKf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%matplotlib inline\n",
        "from ipywidgets import interactive\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Define the graphing function\n",
        "def f(zoom):\n",
        "    xmin = -zoom\n",
        "    xmax = zoom\n",
        "    ymin = -zoom\n",
        "    ymax = zoom\n",
        "    points = 10*xmax-xmin\n",
        "    x = np.linspace(xmin, xmax, points)\n",
        "\n",
        "    fig, ax = plt.subplots()\n",
        "    plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "    plt.plot([xmin,xmax],[0,0],'black') # black x axis\n",
        "    plt.plot([0,0],[ymin,ymax], 'black') # black y axis\n",
        "\n",
        "    # Change y1 to be any function\n",
        "    y1 = 3*x\n",
        "    plt.plot(x, y1)\n",
        "    # Plot another line here if you want\n",
        "    # y2 =\n",
        "    # plt.plot(x, y2)\n",
        "\n",
        "    ax.set_xlabel(\"x values\")\n",
        "    ax.set_ylabel(\"y values\")\n",
        "    ax.set_title(\"Some Graph\")\n",
        "    ticks = int(round((xmax-xmin)/10))\n",
        "    ax.set_xticks(np.arange(xmin, xmax, ticks))\n",
        "    ax.set_yticks(np.arange(ymin, ymax, ticks))\n",
        "    ax.grid(True)\n",
        "    plt.show()\n",
        "\n",
        "# Set up the slider\n",
        "interactive_plot = interactive(f, zoom=(1,100))\n",
        "interactive_plot\n"
      ],
      "metadata": {
        "id": "NnSlIKqKhRM-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Solve and graph a system equations"
      ],
      "metadata": {
        "id": "6Xy0i5lMmo_J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sympy import *\n",
        "from sympy.plotting import plot\n",
        "from sympy import sqrt\n",
        "\n",
        "var('x y')\n",
        "\n",
        "# First equation set equal to zero, ready to solve\n",
        "first =\n",
        "\n",
        "\n",
        "# Second equation set equal to zero, ready to solve\n",
        "second =\n",
        "\n",
        "\n",
        "# Solve - can be linear or nonlinear equations\n",
        "solution = nonlinsolve([first, second], (x, y))\n",
        "for a in range(len(solution.args)):\n",
        "    x_solution = solution.args[a][0]\n",
        "    y_solution = solution.args[a][1]\n",
        "    print(\"Solution = (\", x_solution, \",\", y_solution, \")\")\n",
        "\n",
        "# Sympy syntax for equation equal to zero, ready to factor\n",
        "y_first = Eq(first,0)\n",
        "\n",
        "# Sympy solve for y\n",
        "y1 = solve(y_first,y)\n",
        "\n",
        "# Same two steps for second equation\n",
        "y_second = Eq(second,0)\n",
        "y2 = solve(y_second,y)\n",
        "\n",
        "# Show factored results\n",
        "print(\"y = \", y1[0])\n",
        "print(\"y = \", y2[0])\n",
        "\n",
        "# Plot solution\n",
        "x = symbols('x')\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "plot(y1[0], y2[0], (x,xmin,xmax))\n",
        "\n"
      ],
      "metadata": {
        "id": "E4JCVuUKjluH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "NCFmkX2Oqki_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Save graph and download image"
      ],
      "metadata": {
        "id": "D-x0JNFCdgNi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# use this when graphing\n",
        "\n",
        "from google.colab import files\n",
        "\n",
        "# to save and output graph\n",
        "plt.savefig(\"abc.png\")\n",
        "plt.show()\n",
        "files.download(\"abc.png\")\n"
      ],
      "metadata": {
        "id": "g-uQ5QdPG4FR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Quadratic Functions - roots, vertext, graph"
      ],
      "metadata": {
        "id": "uw0zwudGBErL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import math\n",
        "\n",
        "# Define the three coefficients here\n",
        "a = 12\n",
        "b = -104\n",
        "c = 160\n",
        "\n",
        "print(\"y = \", a, \"x**2 + \", b, \"x + \", c)\n",
        "\n",
        "# Vertex\n",
        "vx = -b/(2*a)\n",
        "vy = a*(vx**2) + b*vx + c\n",
        "print(\"Vertex: (\",vx,\",\",vy,\")\")\n",
        "\n",
        "# Roots\n",
        "d = b**2 - 4*a*c\n",
        "if d>=0:\n",
        "    root_1 = (-b + math.sqrt(d))/(2*a)\n",
        "    root_2 = (-b - math.sqrt(d))/(2*a)\n",
        "    print(\"Roots: x = \", root_1, \" and x = \", root_2)\n",
        "else:\n",
        "    print(\"No real roots\")\n",
        "\n",
        "xmin = -10\n",
        "xmax = 10\n",
        "ymin = -10\n",
        "ymax = 10\n",
        "points = 10*(xmax-xmin)\n",
        "x = np.linspace(xmin,xmax,points)\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "\n",
        "# Graph the parabola\n",
        "y1 = a*x**2 + b*x + c\n",
        "plt.plot(x, y1)\n",
        "\n",
        "# Plot the vertex\n",
        "plt.plot([vx],[vy], 'ro')\n",
        "\n",
        "# Plot the roots\n",
        "plt.plot([root_1, root_2],[0,0], 'go')\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "PSEoAi4jBJRM",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 335
        },
        "outputId": "04d8a1b1-ea31-4349-ac56-962565b04c38"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "y =  12 x**2 +  -104 x +  160\n",
            "Vertex: ( 4.333333333333333 , -65.33333333333331 )\n",
            "Roots: x =  6.666666666666667  and x =  2.0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Quadratic graph with sliders"
      ],
      "metadata": {
        "id": "piYnaYfUHSUb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%matplotlib inline\n",
        "from ipywidgets import interactive\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import math\n",
        "\n",
        "# All graphing happens in this function\n",
        "def f(a,b,c):\n",
        "    xmin = -10\n",
        "    xmax = 10\n",
        "    ymin = -10\n",
        "    ymax = 10\n",
        "    points = 10*(xmax-xmin)\n",
        "    x = np.linspace(xmin,xmax,points)\n",
        "\n",
        "    plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "    plt.plot([xmin,xmax],[0,0],'b') # x axis\n",
        "    plt.plot([0,0],[ymin,ymax], 'b') # y axis\n",
        "\n",
        "    # Parabola\n",
        "    y1 = a*x**2 + b*x + c\n",
        "    plt.plot(x, y1)\n",
        "\n",
        "    # Vertex\n",
        "    vx = -b/(2*a)\n",
        "    vy = a*(vx**2) + b*vx + c\n",
        "    plt.plot([vx],[vy], 'ro')\n",
        "\n",
        "    # Roots\n",
        "    d = b**2 - 4*a*c\n",
        "    if d>=0:\n",
        "        root_1 = (-b + math.sqrt(d))/(2*a)\n",
        "        root_2 = (-b - math.sqrt(d))/(2*a)\n",
        "        plt.plot([root_1, root_2],[0,0], 'go')\n",
        "\n",
        "    # Set the equation as the title\n",
        "    sa = str(a)\n",
        "    sb = str(b)\n",
        "    sc = str(c)\n",
        "    h1 = \"y = \", sa, \"x**2 + \", sb, \"x + \", sc\n",
        "    h2 = \"\"\n",
        "    for w in h1:\n",
        "        h2 = h2 + w\n",
        "\n",
        "    plt.title(h2)\n",
        "    plt.show()\n",
        "\n",
        "# Interactive creates sliders for a, b, and c values\n",
        "interactive_plot = interactive(f, a=(1, 9), b=(-9,9), c=(-9,9))\n",
        "interactive_plot\n",
        "\n"
      ],
      "metadata": {
        "id": "ZXI9liy5HV4O"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Parent graphs"
      ],
      "metadata": {
        "id": "5KBLd5tcH0Tv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice that Python already includes some math functions, and some functions require you to `import numpy as np` to solve or graph them.<p>\n",
        "<table>\n",
        "<tr><td>Math notation</td><td> Python notation </td></tr>\n",
        "<tr><td> y = x</td><td> y = x</td></tr>\n",
        "<tr><td> y = x<sup>2</sup></td><td> y = x**2 </td></tr>\n",
        "<tr><td> y = x<sup>3</sup></td><td> y = x**3 </td></tr>\n",
        "<tr><td> y = |x|</td><td> y = abs(x) </td></tr>\n",
        "<tr><td> y =  $\\sqrt{x}$</td><td> y = np.sqrt(x) </td></tr>\n",
        "<tr><td> y = x<sup>1/3</sup></td><td> y = np.cbrt(x) </td></tr>\n",
        "<tr><td> y = $\\lfloor x \\rfloor$</td><td> y = np.floor(x) </td></tr>\n",
        "<tr><td> y = 2<sup>x</sup></td><td> y = 2**x </td></tr>\n",
        "<tr><td> y = e<sup>x</sup></td><td> y = math.e**2 </td></tr>\n",
        "<tr><td> y = ln(x)</td><td> y = np.log(x) </td></tr>\n",
        "<tr><td> y = log<sub>2</sub>(x)</td><td> y = np.log2(x) </td></tr>\n",
        "<tr><td> y = log(x)</td><td> y = np.log10(x) </td></tr>"
      ],
      "metadata": {
        "id": "9kC2WgK5H53R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Compound interest calculator\n",
        "\n"
      ],
      "metadata": {
        "id": "jwmoBnzCl_33"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "When the compunding happens <i>n</i> times per year:<br>\n",
        "Annuity = P(1 +  $\\frac{r}{n})^{nt}$<p>\n",
        "When the growth is continuous: <br>\n",
        "Annuity = Pe<sup>rt</sup>"
      ],
      "metadata": {
        "id": "Azavu_4iBfOy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "# Change these variables\n",
        "p = 1\n",
        "r = .01\n",
        "t = 1\n",
        "n = 1\n",
        "\n",
        "n_times = p*(1+(r/n))**(n*t)\n",
        "continuous = p*math.e**(r*t)\n",
        "\n",
        "print(\"Annuity when compounded \", n, \" times per year = \", n_times)\n",
        "print(\"Annuity when compounded continuously = \", continuous)\n",
        "\n"
      ],
      "metadata": {
        "id": "J4HK9Vo_jsKG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Investment annuity estimator\n",
        "\n"
      ],
      "metadata": {
        "id": "kRoj56Y5jlJP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Calculte the value in a retirement account, given regular monthly contributions and an estimated rate of increase"
      ],
      "metadata": {
        "id": "0wLqHasmBnm1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Change these variables\n",
        "p = 1000\n",
        "r = .08\n",
        "t = 38\n",
        "monthly = 350\n",
        "\n",
        "# The loop will update this variable\n",
        "annuity = p\n",
        "\n",
        "# loop for contribution and percent growth\n",
        "for a in range(12*t):\n",
        "    annuity = (annuity+monthly)*(1+(r/12))\n",
        "\n",
        "print(\"annuity = \", round(annuity, 2))\n",
        "print(\"Annual income from interest = \", round(annuity*r, 2))\n"
      ],
      "metadata": {
        "id": "7TopuYcfmPCp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Mortgage payment calculator\n"
      ],
      "metadata": {
        "id": "-80VOHy7je5N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Mortgage payment formula:<p>\n",
        "monthly payment = P$\\frac{\\frac{r}{12}(1 + \\frac{r}{12})^{12t}}{(1 + \\frac{r}{12})^{12t} - 1}$\n"
      ],
      "metadata": {
        "id": "6DPNJR5qByPE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Change these values\n",
        "p = 300000\n",
        "r = .08\n",
        "t = 30\n",
        "\n",
        "# Break down that formula into parts\n",
        "numerator = (r/12)*(1+(r/12))**(12*t)\n",
        "denominator = (1+(r/12))**(12*t) - 1\n",
        "payment = round(p*numerator/denominator, 2)\n",
        "\n",
        "print(\"monthly payment = \", payment)"
      ],
      "metadata": {
        "id": "MlBJG8kxjiug",
        "outputId": "f4855a1e-2d9b-4f2d-df48-2f84dd8cb860",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "monthly payment =  2201.29\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Graphing data from a table"
      ],
      "metadata": {
        "id": "VnDUk4x7mTi7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "This code will give you the imports you need, and you will see several ways to get a .csv file from other sources. comment out the code you don't need. Run this once, then you can run the next code cell several times."
      ],
      "metadata": {
        "id": "QrhrLlFFNij7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from google.colab import files\n",
        "import io\n",
        "\n",
        "# dialog to upload from computer:\n",
        "# uploaded = files.upload()\n",
        "# file_name = next(iter(uploaded))\n",
        "# table_1 = pd.read_csv(io.BytesIO(uploaded[file_name]))\n",
        "\n",
        "# example url:\n",
        "url = \"https://people.sc.fsu.edu/~jburkardt/data/csv/faithful.csv\"\n",
        "\n",
        "# Dialog to input a url\n",
        "# url = input(\"URL of the csv: \")\n",
        "table_1 = pd.read_csv(url)\n",
        "\n"
      ],
      "metadata": {
        "id": "Z8L5PwALNlZc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This code will grab data from columns in a table and convert them to arrays to graph. This example uses data related to the Old Fatithful geyser. Run this, modify it, and look for patterns."
      ],
      "metadata": {
        "id": "N_mXRMeZPimV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the headers\n",
        "print(table_1.head())\n",
        "\n",
        "# Describe is also a good feature\n",
        "# table_1[' \"Eruption length (mins)\"'].describe()\n",
        "# table_1['Index'].describe()\n",
        "\n",
        "# Convert values to numpy arrays to graph\n",
        "x = table_1['Index'].to_numpy()\n",
        "y = table_1[' \"Eruption length (mins)\"'].to_numpy()\n",
        "\n",
        "# Graph dimensions\n",
        "xmin = x.min() - 5\n",
        "xmax = x.max() + 5\n",
        "ymin = y.min() - 5\n",
        "ymax = y.max() + 5\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([xmin,xmax,ymin,ymax]) # window size\n",
        "plt.plot([xmin,xmax],[0,0],'b') # blue x axis\n",
        "plt.plot([0,0],[ymin,ymax], 'b') # blue y axis\n",
        "plt.plot(x,y,'ro') # make it scatterplot or line graph\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "3ngt284BPqOV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Add your own formulas"
      ],
      "metadata": {
        "id": "4qWvtvxzFtaZ"
      }
    }
  ]
}