CW_Intro_to_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "CW_Intro to Python.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "oFmeFmG7dEEe",
        "l4tNq4SXfV7p",
        "MPZ8_DWGhsF0",
        "7TYTWTH1lBm-",
        "Wwntc7QCpuN0"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/cw805/MATH-242/blob/main/CW_Intro_to_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zRdAtmBXaSK1"
      },
      "source": [
        "# Welcome to Google Colab! \n",
        "\n",
        "Colab allows us to run the Python programming language in our web browser. Python is an easy-to-use programming language, designed to emphasize code readability. Don't worry if you've never used Colab or Python before. Let's get started!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4H_rXQfbJtA"
      },
      "source": [
        "##Two types of cells\n",
        "Colab notebooks contain two types of cells: *code cells* and *markdown cells*. \n",
        "\n",
        "As you may have guessed, code cells contain code (Python 3 code, to be specific). Press `SHIFT+ENTER` or `CTRL+ENTER` to run code; output will be displayed below the code cell.\n",
        "\n",
        "Markdown cells contain text, formatted with a simple syntax called markdown. For a quick guide to markdown, see [Markdown Basics on GitHub](https://help.github.com/en/articles/basic-writing-and-formatting-syntax). Markdown cells can also contain LaTeX code, HTML, and other content."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oFmeFmG7dEEe"
      },
      "source": [
        "##Arithmetic in Python\n",
        "\n",
        "Arithmetic in Python works basically as you would expect. Try running the following code cells:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KPzw4MhRdOAr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "512ce247-f262-4e62-8c58-f86fc4637263"
      },
      "source": [
        "5 + 13\n",
        "40-4\n",
        "3 *    18\n",
        "100/7"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14.285714285714286"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nMvoe5tYd16S"
      },
      "source": [
        "Interesting. Python only prints output from the last statement. To see output from the first three lines, surround each of them with the command `print( )` or `display( )`. Also note that Python ignores spaces around math operators.\n",
        "\n",
        "Let's see some more math operators:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5sheVhxSdaz4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a7791d8d-476b-4dca-95d1-0104cdeac360"
      },
      "source": [
        "2**10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1024"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8NR8YHoueNHG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8d18f16-6675-4636-a4b0-43290c02dee4"
      },
      "source": [
        "17 % 5"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N08eAeGIeZsy"
      },
      "source": [
        "Do you understand the previous two code cells?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FYbc3nYUer3s"
      },
      "source": [
        "For many common mathematical functions, you have to load Python's **math module**. To do this, type `import math`. You only have to load the math module once in your notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vc8b0OrVehFD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "38d93ef5-c374-48a4-a9d1-682a0e77d047"
      },
      "source": [
        "import math\n",
        "math.sqrt(2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.4142135623730951"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r-1MxQf0jOZb"
      },
      "source": [
        "## Lists in Python\n",
        "\n",
        "To create a list in Python, use square brackets, with list entries separated by commas. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MieKsep0jcOZ"
      },
      "source": [
        "mylist = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TU6kmLDhjpi1"
      },
      "source": [
        "You can access list entries by their index. *Note that Python starts counting list indexes from zero, as is common in computer science.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qlECjNR_j7xT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "47a1fa40-f294-4429-d3b1-19c448ee1a31"
      },
      "source": [
        "print(mylist[0])\n",
        "print(mylist[3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lGdh25wHkNzz"
      },
      "source": [
        "Negative indexes count backwards from the end of the list, like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KY_K8m78kTO4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d883bb50-7aee-4698-bfae-8ca05e919efe"
      },
      "source": [
        "print(mylist[-1])\n",
        "print(mylist[-3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "29\n",
            "19\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VtDvHaU-kk-b"
      },
      "source": [
        "Use a colon inside of square brackets to create a \"slice\" of a list. This is similar to the double-semicolon syntax in Mathematica, but simpler. Here are some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1bBAaEsgkZGv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f686ce03-0354-4432-9f6d-279c9c603621"
      },
      "source": [
        "print(mylist[2:4]) # slice doesn't include the last element (think 4 - 2)\n",
        "print(mylist[:4]) \n",
        "print(mylist[4:])\n",
        "print(mylist[2:8:2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[5, 7]\n",
            "[2, 3, 5, 7]\n",
            "[11, 13, 17, 19, 23, 29]\n",
            "[5, 11, 17]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G-f2emvWtMEJ"
      },
      "source": [
        "To stick a new value onto the end of a list, use the `append()` method. It works like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bIRzpTdMtSVB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8d842dc1-edd5-4f6c-b703-f045ee827ab8"
      },
      "source": [
        "mylist.append(31)\n",
        "print(mylist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 31]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YkRTNB5_tXx7"
      },
      "source": [
        "Note the dot operator in the code above. We can do this because `append` is a *method* of the *list* data type. See the [Python documentation on lists](https://docs.python.org/3/tutorial/datastructures.html) to learn about other list methods."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fc-FcaDct_JX"
      },
      "source": [
        "Python also has a powerful syntax called *list comprehensions* for quickly creating a list of items that follow a pattern. Python's list comprehensions are analogous to Mathematica's `Table` function. The syntax is:\n",
        "\n",
        "`[expression for item in iterable]`\n",
        "\n",
        "\n",
        "Here is an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j3JEYyz2uWOv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "21147911-e99a-430e-be01-60805cbf4f45"
      },
      "source": [
        "squares = [x**2 for x in range(10)]\n",
        "print(squares)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JyAm2sU4WATY"
      },
      "source": [
        "**Technical note:** The `range` function doesn't return a list. It returns an iterable object that allows you to iterate over a range of integers, as in the previous list comprehension."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cubes = [ x**3 for x in range(5,21)]\n",
        "print(cubes)\n",
        "#cubes"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uqioPs-znbvE",
        "outputId": "c17156bd-907a-432f-d7ae-bce1b7af87ec"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[125, 216, 343, 512, 729, 1000, 1331, 1728, 2197, 2744, 3375, 4096, 4913, 5832, 6859, 8000]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l4tNq4SXfV7p"
      },
      "source": [
        "## Logic in Python\n",
        "\n",
        "Just as Mathematica, Python has the boolean values `True` and `False`. (Note the capitalization.) Logical expressions can be built with the operators `and`, `or`, and `not`. \n",
        "\n",
        "Python also has the following comparison operators: `<`, `<=`, `>`, `>=`, `==`, `!=`. Can you guess what each of these means?\n",
        "\n",
        "Here is an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OTS_cRGcgLzk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a2d43265-2cf2-4cfb-b6b8-2ca5cd6cd914"
      },
      "source": [
        "x=5\n",
        "y=2\n",
        "(y < 1) or (x < 8)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WEw7pvXwgcUV"
      },
      "source": [
        "Here is an example of an *if-else* statement:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VP3y8uTUgT0-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "917e9b14-595f-4c13-c8ef-c101199b0129"
      },
      "source": [
        "x = 5\n",
        "if x % 2 == 0:\n",
        "  print(\"x is even\")\n",
        "else:\n",
        "  print(\"x is not even\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x is not even\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dHwOaT5ug4Vc"
      },
      "source": [
        "**Note the following about the if-else statement:**\n",
        "\n",
        "\n",
        "1. It *is not* necessary to use parentheses after `if`.\n",
        "2. It *is* necessary to end the `if` line with a colon. It is also necessary to print a colon after `else`.  \n",
        "3. It *is* necessary to indent the blocks of code following `if` and `else`. The default indentation in Colab is 2 spaces.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MPZ8_DWGhsF0"
      },
      "source": [
        "## Functions in Python\n",
        "\n",
        "Functions are easy to define in Python: simply type the `def` keyword, followed by the name of your function, with input arguments inside parentheses. Then indent the body of your function. Here is an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q_sC663Rg3aF"
      },
      "source": [
        "def isEven(x):\n",
        "  mod = x % 2\n",
        "  return mod == 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IuwJGRHOi2PT"
      },
      "source": [
        "Try it out:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jfVMJAXei1r1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "55baa9e5-51e5-49fb-d685-fbfbdf1c1067"
      },
      "source": [
        "isEven(6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1ewEokuAi62U",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ad48429d-a73f-45c7-d2b8-332ac30d3e03"
      },
      "source": [
        "isEven(17)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Q-R0rR4i_7U"
      },
      "source": [
        "Note that if you want your function to return a value, you must type the `return` keyword. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7TYTWTH1lBm-"
      },
      "source": [
        "## Exercises"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2oa2cbHZlERD"
      },
      "source": [
        "### Exercise 1\n",
        "\n",
        "Write a function that determines the number of real roots of a quadratic polynomial $ax^2 + bx +c=0$. Your function should accept as arguments the three coefficients $a$, $b$, and $c$. Your function should return an integer, either 0, 1, or 2.\n",
        "\n",
        "Don't forget the quadratic formula!\n",
        "$$x = \\frac{-b \\pm \\sqrt{b^2-4ac}}{2a}$$"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "def polyRoot(a,b,c):\n",
        "  \n",
        "  discriminant = (b * b) - (4 * a * c)\n",
        "  complex_eval = math.sqrt(abs(discriminant))\n",
        "\n",
        "  if discriminant > 0:\n",
        "    print(\"2\")\n",
        "\n",
        "  elif discriminant == 0:\n",
        "    print(\"1\")\n",
        "\n",
        "  else:\n",
        "    print(\"0\")\n",
        "  "
      ],
      "metadata": {
        "id": "neHD7zjLpFs4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Testing the function:\n",
        "polyRoot(25,30,-10)\n",
        "polyRoot(8,10,10)\n",
        "polyRoot(2,4,2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2J2P8N6GEw6S",
        "outputId": "3f6d58f5-cd1b-4aa6-f13c-fc050e8c67cd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "0\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J9kO3DXqmIy1"
      },
      "source": [
        "### Exercise 2\n",
        "\n",
        "Write a function that determines whether or not a 2-by-2 matrix is invertible. To do this, represent a matrix as a list of lists. For example, the matrix\n",
        "$$M = \\left[ \\begin{array}{cc} 3 & 5 \\\\ -1 & 4\\end{array} \\right]$$\n",
        "should be stored as\n",
        "`M = [[3, 5],[-1, 4]]`\n",
        "Your function should take the matrix as a single parameter. Your function should return `True` if the matrix is invertible, and `False` otherwise. *Hint: Remember the determinant of a matrix from linear algebra.*"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def mtrxInvert(mat):\n",
        "\n",
        "  det = mat[0][0] * mat[1][1] - mat[0][1] * mat[1][0]\n",
        "\n",
        "  if det == 0:\n",
        "    return False\n",
        "  else:\n",
        "    return True\n",
        "\n",
        "matrix=[[1,2],[3,4]]\n"
      ],
      "metadata": {
        "id": "J1b4OPAeJNHV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "mtrxInvert(mat=([[1,2],[3,4]]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7yOxbdUfMvGn",
        "outputId": "31049be1-74b7-47f3-cea7-f288f61c0d58"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mtrxInvert(mat=([[1,1],[1,1]]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_5QNgXh3PIMW",
        "outputId": "4fe27c32-5ea8-4cc5-9084-eb5b01958642"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kGSpmfO6nkIF"
      },
      "source": [
        "## Loops in Python\n",
        "\n",
        "Python has **for** loops and **while** loops. A for loop iterates over a list or other \"iterable\" object. A while loop repeats while a condition is true. Here are some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RCZ_i_Cei8Ms",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "458e28b1-b591-49bd-e66e-1caccebe97a6"
      },
      "source": [
        "for i in range(5):\n",
        "  print(i**2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "4\n",
            "9\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4WMZ1qjuocUo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f92df027-f9f5-4731-c5b0-3f45d10c7903"
      },
      "source": [
        "i = 0\n",
        "while i < 5:\n",
        "  print(i**2)\n",
        "  i = i + 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "4\n",
            "9\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sLcKNuoIo0Dj"
      },
      "source": [
        "Here is a loop that computes Fibonacci numbers:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OUT1IGHWoh7A",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0ae3165a-e5ba-467a-ea44-cf90396c5f90"
      },
      "source": [
        "fibs = [0,1]\n",
        "for n in range(2,20):\n",
        "  next = fibs[n-1] + fibs[n-2]\n",
        "  fibs.append(next)\n",
        "  print(fibs)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 1]\n",
            "[0, 1, 1, 2]\n",
            "[0, 1, 1, 2, 3]\n",
            "[0, 1, 1, 2, 3, 5]\n",
            "[0, 1, 1, 2, 3, 5, 8]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584]\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e219uTXkpphp"
      },
      "source": [
        "## Exercises"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wwntc7QCpuN0"
      },
      "source": [
        "### Exercise 3\n",
        "\n",
        "Write a function that computes an approximation of the number $e$ using a partial sum of the infinite series\n",
        "$$ e = \\sum_{k=0}^\\infty \\frac{1}{k!} $$\n",
        "(This is the Taylor series for $e^x$ evaluated at $x=1$.)\n",
        "Your function should accept as a parameter the number of terms of the series to add up. You may use the `factorial` function from the `math` module.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def approxE(i):\n",
        "  e = 0\n",
        "  for i in range(0,1000):\n",
        "    e += (1/math.factorial(i))\n",
        "  return e"
      ],
      "metadata": {
        "id": "bIaFusD5Rvk3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "approxE(50)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_W4T6XqtTMOk",
        "outputId": "1442ac10-e26c-46e8-9c84-2d8392ba63ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.7182818284590455"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uXEEmfPjuw5P"
      },
      "source": [
        "### Exercise 4\n",
        "\n",
        "Write a function that accepts as input a list of numbers and returns the harmonic mean of the numbers. If the input sequence is $x_1, x_2, \\ldots, x_n$, then the return value should be:\n",
        "$$ \\frac{n}{\\frac{1}{x_1}+ \\frac{1}{x_2} + \\cdots + \\frac{1}{x_n}}$$"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "numList = [15,20,25,35,50]\n",
        "\n",
        "def harmonicMean(numList):\n",
        "  reSum = 0\n",
        "  for i in numList:\n",
        "    reSum = reSum + (1/i)\n",
        "  hMean = len(numList) / reSum\n",
        "  return hMean\n",
        "\n",
        "harmonicMean(numList)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q7ewhQfyW0Pz",
        "outputId": "7141723a-1e12-4a48-c633-743145521329"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24.36194895591647"
            ]
          },
          "metadata": {},
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9IC128BxvfQo"
      },
      "source": [
        "### Exercise 5\n",
        "\n",
        "Write a function that accepts as input the coordinates of three points in the plane and returns the area of the triangle whose vertices are those three points. You might compute the area using [Heron's Formula](https://en.wikipedia.org/wiki/Heron%27s_formula):\n",
        "$$ A = \\sqrt{s(s-a)(s-b)(s-c)}$$\n",
        "where $a$, $b$, and $c$, are the side lengths, and $s = \\frac{a+b+c}{2}$ is the semiperimeter of the triangle."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Method 1 - put in all points in order\n",
        "def heronArea(x1,y1,x2,y2,x3,y3):\n",
        "  a = math.sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)))\n",
        "  b = math.sqrt(((x2 - x3) * (x2 - x3)) + ((y2 - y3) * (y2 - y3)))\n",
        "  c = math.sqrt(((x1 - x3) * (x1 - x3)) + ((y1 - y3) * (y1 - y3)))\n",
        "  param = a + b + c\n",
        "  s = param / 2\n",
        "  area = math.sqrt(s * (s - a) * (s - b) * (s - c))\n",
        "  return area"
      ],
      "metadata": {
        "id": "e8hIgfoO-qZv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "heronArea(0,0,8,2,5,4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yQPm55fS_TeY",
        "outputId": "7de07f7b-f432-43f4-94a0-be5c7c3a27d5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11.0"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Method 2 - assign coordinates to each point\n",
        "def heronAreaPts(p1,p2,p3):\n",
        "  x1 = p1[0]\n",
        "  y1 = p1[1]\n",
        "  x2 = p2[0]\n",
        "  y2 = p2[1]\n",
        "  x3 = p3[0]\n",
        "  y3 = p3[1]\n",
        "  a = math.sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)))\n",
        "  b = math.sqrt(((x2 - x3) * (x2 - x3)) + ((y2 - y3) * (y2 - y3)))\n",
        "  c = math.sqrt(((x1 - x3) * (x1 - x3)) + ((y1 - y3) * (y1 - y3)))\n",
        "  param = a + b + c\n",
        "  s = param / 2\n",
        "  area = math.sqrt(s * (s - a) * (s - b) * (s - c))\n",
        "  return area"
      ],
      "metadata": {
        "id": "Ov5-Qtd_AXhA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "p1 = (0,0)\n",
        "p2 = (8,2)\n",
        "p3 = (5,4)\n",
        "heronAreaPts(p1,p2,p3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IqWIzyy0Atps",
        "outputId": "f05df277-a915-4522-838f-8b82084a1c3f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11.0"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Method 3 - take a whole set of coordinates together (not working yet)\n",
        "\n",
        "def heronArea3(set):\n",
        "  set = [p1,p2,p3]\n",
        "  sides = [a,b,c]\n",
        "  for i in set:\n",
        "    for j in pts:\n",
        "      for n in range(1,4):\n",
        "        x[n] = set[i][0]\n",
        "        y[n] = set[i][1]\n",
        "  for k in sides:\n",
        "  sides[k] = (x[n],y[n])\n",
        "  param = sum(pts[j])\n",
        "  s = param / 2\n",
        "  area = math.sqrt(s * (s - pts[0]) * (s - pts[1]) * (s - pts[2]))\n",
        "  return area   "
      ],
      "metadata": {
        "id": "F1hz_69JBJve"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7NnmOaUTsBGs"
      },
      "source": [
        "### Exercise 6\n",
        "\n",
        "Write a function that computes the Catalan numbers $C_n$ using the following recurrence relation:\n",
        "\n",
        "$C_0 = 1$ and $C_{n+1} = \\sum_{i=0}^n C_iC_{n-i}$"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def catalan(n):\n",
        "  if n <= 1:\n",
        "        return 1\n",
        "  term = 0\n",
        "  for i in range(0,n):\n",
        "      term += catalan(i) * catalan(n-i-1)\n",
        " \n",
        "  return term"
      ],
      "metadata": {
        "id": "NOJtyRwQivyj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "catalan(8)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_hJJjM01MDsp",
        "outputId": "ce8ef1f8-2307-4264-a1d8-1811130e1683"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1430"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1sz37RJiHzE2"
      },
      "source": [
        "# Assignment: Intro Python Practice Problems\n",
        "\n",
        "**Learning Goals:** Gain proficiency with basic Python constructs, including variables, arithmetic operations, and loops.\n",
        "\n",
        "**Your task:** Complete any four of the six exercises in this notebook. Type your solutions in code cells below the appropriate assignment in this notebook. \n",
        "\n",
        "**Due:** Friday, April 8, at 5:00pm. Do the following to submit your work.\n",
        "\n",
        "1. Click on *Share* in the upper right corner of this window.\n",
        "2. In the *Get link*, click *Copy link*.\n",
        "3. Go to the [Intro Python](https://mdl.stolaf.edu/mod/assign/view.php?id=188089) assignment on Moodle. Paste the link to your notebook in the text field for the assignment submission. This will allow Prof. Wright or either of the course graders to view your Colab notebook.\n",
        "\n",
        "**Grading:** Each exercise will be graded on a Satisfactory/Unsatisfactory scale. If you write a Python function that correctly computes the values requested in a given exercise, you will receive a Satisfactory grade for that exercise.\n",
        "\n",
        "**Need help?** Review the notes from class and Python documentation links on the course web site. If you still need help, email Prof. Wright. Don't forget there are also evening help sessions &mdash; the help session schedule is at the top of the course website.\n"
      ]
    }
  ]
}