Scientific_and_Graphing_Calculator.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 628
        },
        "id": "hrfBUMrfDpXv",
        "outputId": "5b3e98d9-0fc8-4394-f298-78073c1ce63d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "1. Plotting polynomials\n",
            "2. Plotting trigonometric functions\n",
            "3. Finding the point of intersection between a linear and quadratic graph\n",
            "4. Finding the area (triangle, rectangle, square, and circle.)\n",
            "5. Basic addition, subtraction, multiplication.\n",
            "\n",
            "What do you want to pick (use the numbers next to the options): 1\n",
            "Enter your equation using 'x' as the variable and following 'ax^2 + 3' for example: 72x^2 + 9 \n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "print(\"\"\"\n",
        "1. Plotting polynomials\n",
        "2. Plotting trigonometric functions\n",
        "3. Finding the point of intersection between a linear and quadratic graph\n",
        "4. Finding the area (triangle, rectangle, square, and circle.)\n",
        "5. Basic addition, subtraction, multiplication.\n",
        "\"\"\")\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import math as m\n",
        "\n",
        "choice = int(input(\"What do you want to pick (use the numbers next to the options): \"))\n",
        "\n",
        "def poly():\n",
        "    equa = input(\"Enter your equation using 'x' as the variable and following 'ax^2 + 3' for example: \")\n",
        "\n",
        "    equa = equa.replace('^', '**')\n",
        "    equa = equa.replace('x', '*x')\n",
        "    equa = equa.replace(\" \", \"\")\n",
        "\n",
        "    try:\n",
        "        x_base = np.linspace(-10, 10, 1000)\n",
        "        y = np.array([eval(equa) for x in x_base])\n",
        "\n",
        "        plt.plot(x_base, y)\n",
        "        plt.title(f\"The Graph of: {equa}\")\n",
        "        # this allows me to plug in the equation as the title of the graph\n",
        "        plt.xlabel(\"x\")\n",
        "        plt.ylabel(\"y\")\n",
        "        plt.grid(True)\n",
        "        # this line basically allows me to make it a + shape so I can make it look cooler.\n",
        "        plt.axhline(0, color='black', linewidth=1.5)\n",
        "        plt.axvline(0, color='black', linewidth=1.5)\n",
        "        plt.xlim(-20, 20)\n",
        "        plt.ylim(-20, 20)\n",
        "        # simple graph size limiatioms\n",
        "        plt.show()\n",
        "    except:\n",
        "        print(\"You didn't put a proper equation\")\n",
        "        print(\"Here, try something like 2x^2 + 3, you DO NOT do 2*x**2 + 3\")\n",
        "\n",
        "def trig():\n",
        "    def sin():\n",
        "        s = float(input(\"Enter the coefficient for your sin equation (like y = sin(Your Number * x)): \"))\n",
        "\n",
        "        x = np.linspace(0, 2 * np.pi, 2000)\n",
        "        y = np.sin(s * x)\n",
        "\n",
        "        plt.figure(figsize=(10, 2.5))\n",
        "        plt.plot(x, y, label=f'y = sin({s} * x)')\n",
        "        plt.ylim(-1, 1)\n",
        "        plt.grid(True)\n",
        "        plt.title(f'y = sin({s} * x)')\n",
        "        plt.xlabel('x')\n",
        "        plt.ylabel('y')\n",
        "        plt.show()\n",
        "\n",
        "    def cos():\n",
        "        c = int(input(\"What is your number? \"))\n",
        "\n",
        "        x = np.linspace(0, 2 * np.pi, 2000)\n",
        "        y = np.cos(c * x)\n",
        "\n",
        "        plt.figure(figsize=(10, 2.5))\n",
        "        plt.plot(x, y, label=f'y = cos({c} * x)')\n",
        "        plt.ylim(-1, 1)\n",
        "        plt.grid(True)\n",
        "        plt.title(f'y = cos({c} * x)')\n",
        "        plt.xlabel('x')\n",
        "        plt.ylabel('y')\n",
        "        plt.show()\n",
        "\n",
        "    def tan():\n",
        "        t = int(input(\"Enter the coefficient for y = tan(t * x): \"))\n",
        "\n",
        "        x = np.linspace(-2 * np.pi, 2 * np.pi, 10000)\n",
        "        y = np.tan(t * x)\n",
        "\n",
        "        # same thing with those tangent spikes, because they're really annoying if you'd like you can turn this off and see..\n",
        "        y = np.ma.masked_where(np.abs(y) > 10, y)\n",
        "\n",
        "        plt.figure(figsize=(10, 5))\n",
        "        plt.plot(x, y, label=f'y = tan({t} * x)')\n",
        "\n",
        "        plt.ylim(-6.5, 6.5)\n",
        "        plt.title(f'y = tan({t} * x)')\n",
        "        plt.xlabel('x')\n",
        "        plt.ylabel('y')\n",
        "        plt.grid(True)\n",
        "        plt.show()\n",
        "\n",
        "    def scrape():\n",
        "        equation = input(\"Enter an equation (e.g., 'sin 3x + 5' or '4 * sin 2x'): \")\n",
        "\n",
        "        x = np.linspace(-2 * np.pi, 2 * np.pi, 10000)\n",
        "        y = np.zeros_like(x)\n",
        "\n",
        "        equation = equation.replace(' ', '')\n",
        "        equation = equation.replace('sin', 'sin(').replace('cos', 'cos(').replace('tan', 'tan(')\n",
        "        equation = equation.replace('x)', 'x)').replace(')sin', ') * sin').replace(')cos', ') * cos').replace(')tan', ') * tan')\n",
        "# this entire function (scrape) took me a long time to make since I tried to account for every possiblilty, so I had to make sure that if someone had put tan alone for example\n",
        "# for example it would replace it so that the code would understand, so let me explain, if I write tan, it'll make the computer understand theres another arguement (even though you dont have to write it)\n",
        "        terms = equation.replace('-', '+-').split('+')\n",
        "\n",
        "        try:\n",
        "            for term in terms:\n",
        "                if 'sin(' in term:\n",
        "                    coef_str = term.split('sin(')[1].strip(')')\n",
        "                    coef = float(coef_str.split('x')[0]) if 'x' in coef_str else 1\n",
        "                    y += np.sin(coef * x)\n",
        "                elif 'cos(' in term:\n",
        "                    coef_str = term.split('cos(')[1].strip(')')\n",
        "                    coef = float(coef_str.split('x')[0]) if 'x' in coef_str else 1\n",
        "                    y += np.cos(coef * x)\n",
        "                elif 'tan(' in term:\n",
        "                    coef_str = term.split('tan(')[1].strip(')')\n",
        "                    coef = float(coef_str.split('x')[0]) if 'x' in coef_str else 1\n",
        "                    y += np.tan(coef * x)\n",
        "                    # this is very important, this mask's the lines for the tan function so it doesnt look like absolute terribleness.\n",
        "                    y = np.ma.masked_where(np.abs(y) > 10, y)\n",
        "                else:\n",
        "                    if 'x' in term:\n",
        "                        coef, variable = term.split('x')\n",
        "                        coef = float(coef) if coef else 1\n",
        "                        y += coef * x\n",
        "                    else:\n",
        "                        y += float(term)\n",
        "\n",
        "        except ValueError as e:\n",
        "            print(\"what the hell did you put bro\")\n",
        "\n",
        "        plt.figure(figsize=(10, 10))\n",
        "        plt.plot(x, y)\n",
        "        plt.title(f'y = {equation}')\n",
        "        plt.xlabel('x')\n",
        "        plt.ylabel('y')\n",
        "        plt.grid(True)\n",
        "\n",
        "        if 'sin(' in equation or 'cos(' in equation:\n",
        "            plt.ylim(-1, 8)  # it just makes it look neater\n",
        "        elif 'tan(' in equation:\n",
        "            plt.ylim(-6.5, 6.5)  # ok so these are basically the limts for the graph size so I cam make it look more neat\n",
        "\n",
        "        plt.show()\n",
        "\n",
        "    print(\"\"\"\n",
        "    1. Sin\n",
        "    2. Cos\n",
        "    3. Tan\n",
        "    4. Special Equation\n",
        "    \"\"\")\n",
        "\n",
        "    opt = int(input(\"What type of graph do you want to see? (write 1, 2, 3, 4): \"))\n",
        "\n",
        "    if opt == 1 or opt == 'sin':\n",
        "        sin()\n",
        "    elif opt == 2 or opt == 'cos':\n",
        "        cos()\n",
        "    elif opt == 3 or opt =='tan':\n",
        "        tan()\n",
        "    elif opt == 4:\n",
        "        scrape()\n",
        "    else:\n",
        "        print(\"What the heck did you put\")\n",
        "\n",
        "def area():\n",
        "    print(\"\"\"\n",
        "    1. Triangle\n",
        "    2. Rectangle\n",
        "    3. Square\n",
        "    4. Circle\"\"\")\n",
        "\n",
        "    shape = str(input(\"What is your shape? (write the name please) \"))\n",
        "\n",
        "    if shape == '1' or shape == 'Triangle' or shape == 'triangle':\n",
        "        num1 = int(input(\"Tell me your height: \"))\n",
        "        num2 = int(input(\"Tell me your base: \"))\n",
        "        print(\"Analyzing...\")\n",
        "        area = num1 * num2 / 2\n",
        "        print(\"The area is\", area)\n",
        "\n",
        "    elif shape == '2' or shape == 'Rectangle' or shape == 'rectangle':\n",
        "        num1 = int(input(\"What is your length: \"))\n",
        "        num2 = int(input(\"What is your width: \"))\n",
        "        print(\"Analyzing...\")\n",
        "        area = num1 * num2\n",
        "        print(\"The area is\", area)\n",
        "    elif shape == '3' or shape == 'Square' or shape == 'square':\n",
        "        num1 = int(input(\"What is your length: \"))\n",
        "        print(\"Analyzing...\")\n",
        "        print(\"The area is\", num1 ** 2)\n",
        "\n",
        "    elif shape == '4' or shape == 'Circle' or shape == 'circle':\n",
        "        rad = int(input(\"What is your radius: \"))\n",
        "        print(\"Analyzing...\")\n",
        "        print(\"The area of the circle is\", m.pi * rad ** 2)\n",
        "    else:\n",
        "        print(\"What did you put man?\")\n",
        "\n",
        "def basic():\n",
        "    print(\"\"\"\n",
        "    1. Addition\n",
        "    2. Subtraction\n",
        "    3. Multiplication\n",
        "    4. Division\n",
        "    5. Square Root\n",
        "    6. Power\n",
        "    7. Sin, Cos, Tan\n",
        "    8. Log\n",
        "    9. e^\n",
        "    \"\"\")\n",
        "\n",
        "    opt = (input(\"Pick what you want to do: \"))\n",
        "    a = float(input(\"Enter your first number: \"))\n",
        "    b = float(input(\"Enter your second number: \"))\n",
        "\n",
        "    if opt == '1' or opt == \"Add\":\n",
        "        print(\"Sum {} + {} = {}\".format(a, b, a + b))\n",
        "    elif opt == '2' or opt == \"Subtraction\":\n",
        "        print(\"Sum {} - {} = {}\".format(a, b, a - b))\n",
        "    elif opt == '3' or opt == \"Multiplication\":\n",
        "        print(\"Sum {} x {} = {}\".format(a, b, a * b))\n",
        "    elif opt == '4' or opt == \"Division\":\n",
        "        print(\"Sum {} ÷ {} = {}\".format(a, b, a / b))\n",
        "    elif opt == '5' or opt == \"Sqrt\" or opt == \"Squareroot\":\n",
        "        print(\"Sum √{} = {}\".format(a, m.sqrt(a)))\n",
        "    elif opt == '6' or opt == \"Power\":\n",
        "        print(\"Sum {} to the power of {} = {}\".format(a, b, m.pow(a, b)))\n",
        "    elif opt == '7' or opt == \"Sin\" or opt == \"Cos\" or opt == \"Tan\":\n",
        "        print(\"Sum of sin {} = {}\".format(a, m.sin(a)))\n",
        "        print(\"Sum of cos {} = {}\".format(a, m.cos(a)))\n",
        "        print(\"Sum of tan {} = {}\".format(a, m.tan(a)))\n",
        "    elif opt == '8' or opt == \"log\":\n",
        "        print(\"Sum log of {} = {}\".format(a, m.log(a)))\n",
        "    elif opt == '9' or opt == \"e^\":\n",
        "        print(\"Sum e to the power of {}, = {}\".format(a, m.e ** a))\n",
        "    else:\n",
        "        print(\"That isn't even an option bro\")\n",
        "\n",
        "def POI():\n",
        "    def firstequation(prompt):\n",
        "        equation = input(prompt)\n",
        "        return equation\n",
        "\n",
        "    def newequa(equation):\n",
        "        equation = equation.replace('^', '**')\n",
        "        equation = equation.replace('x', '*x')\n",
        "        if equation.startswith('*x'):\n",
        "            equation = '1' + equation\n",
        "        elif equation.startswith('x'):\n",
        "            equation = equation[1:]\n",
        "        return equation\n",
        "\n",
        "    def plot(linear, poly):\n",
        "        xval = np.linspace(-10, 10, 100)\n",
        "        ylinval = [eval(linear) for x in xval]\n",
        "        ypolyval = [eval(poly) for x in xval]\n",
        "\n",
        "        plt.plot(xval, ylinval, label='Linear Equation')\n",
        "        plt.plot(xval, ypolyval, label='Polynomial Equation')\n",
        "\n",
        "        for i in range(len(xval) - 1):\n",
        "            if (ylinval[i] - ypolyval[i]) * (ylinval[i + 1] - ypolyval[i + 1]) < 0:\n",
        "                x_intersection = (xval[i] + xval[i + 1]) / 2\n",
        "                y_intersection = (ylinval[i] + ylinval[i + 1]) / 2\n",
        "                plt.scatter(x_intersection, y_intersection, color='red', label='Intersection Point')\n",
        "                break\n",
        "\n",
        "        plt.xlabel('x')\n",
        "        plt.ylabel('y')\n",
        "        plt.legend()\n",
        "        plt.ylim(-10, 20)\n",
        "        plt.grid(True)\n",
        "        plt.show()\n",
        "\n",
        "    linearequa = newequa(firstequation(\"Enter the linear equation (like 2x): \"))\n",
        "    polyequa = newequa(firstequation(\"Enter the polynomial equation (like 2x^2): \"))\n",
        "    plot(linearequa, polyequa)\n",
        "\n",
        "if choice == 1:\n",
        "    poly()\n",
        "elif choice == 2:\n",
        "    trig()\n",
        "elif choice == 3:\n",
        "    POI()\n",
        "elif choice == 4:\n",
        "    area()\n",
        "elif choice == 5:\n",
        "    basic()\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}