ScientificPython.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "WBIMTWtrPjGR"
      },
      "source": [
        "# Scientific Python\n",
        "\n",
        "This notebook will provide a basic introduction to some common Python packages commonly used in scientific and engineering related Python.\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "GqfDdN2bSLfG"
      },
      "source": [
        "## Part 0: Jupyter Notebook Basics\n",
        "\n",
        "The environment we are running in is called a [Jupyter Notebook](https://jupyter.org/). This is an interactive Python environment that allows quick editing and running of Python code from a browser. Let's start with a quick intro to working with a Jupyter Notebook.\n",
        "\n",
        "To start, let's import the packages we'll be using to our Python workspace. Select the code cell below and press the run button or type \"Shift + enter\" to run it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pktR0hnpPac7",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import cv2\n",
        "\n",
        "print(\"Import done!\")\n",
        "\n",
        "# create a personal access token (with repo permission) for your github account and place it in the line below\n",
        "! git clone https://<YOUR-PERSONAL-ACCESS-TOKEN>@github.com/Tino-FRC-2473/2020OffseasonTraining"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "_FXyUSLMQdch"
      },
      "source": [
        "In a Jupyter notebook like this one, all of the code cells are run in the same interactive workspace. This means that we can use variables defined by running one code cell in any other code cell. Note that the order you run cells in does matter! If your workspace gets closed, you can use the menu option Runtime->Run all to quickly rerun all the cells in the workspace.\n",
        "\n",
        "Let's try this out by fetching the versions of the packages we just imported. Note that when you run this code cell, the output will get printed underneath the cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3txWlQSURuIF",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "print(\"Numpy version:\", np.__version__)\n",
        "print(\"OpenCV version:\", cv2.__version__)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Dg-cN7lHTC5X"
      },
      "source": [
        "Functions can also be defined and reused across cells. Let's define a test function by running the cell below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-eIMdJnwSCFj",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "def add(a, b):\n",
        "  return a + b"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "rqQh5hFTTlk_"
      },
      "source": [
        "Now, we can some code that uses the function to add some numbers in this cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DxsSUcwoTj7I",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "var1 = 24\n",
        "var2 = 73\n",
        "\n",
        "var_sum = add(var1, var2)\n",
        "\n",
        "print(\"The sum of\", var1, \"and\", var2, \"is:\", var_sum)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "wDObwScwUKX9"
      },
      "source": [
        "## Part 1: NumPy\n",
        "\n",
        "[NumPy](https://numpy.org/) is the fundamental package for scientific Python. It defines a set of highly-optimized multi-dimensional array types that can be used to quickly perform operations on large data sets. The full documentation for NumPy can be found at https://numpy.org/doc/stable/reference/index.html. I highly recommend bookmarking that link if you plan on working with Python in the future."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "d-PA99gBVG3v"
      },
      "source": [
        "### 1.1 The ndarray\n",
        "The basic class of NumPy is the [ndarray](https://numpy.org/doc/stable/reference/arrays.ndarray.html). As the name suggests, it represents a n-dimensional array type. At first glance, it behaves very similarly to the regular Python lists you may be familiar with. Indeed, you can create an ndarray from an existing Python list using the `array` function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ca9ISlEKT3lq",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "arr = np.array([1,2,3])\n",
        "print(\"1-d array:\", arr)\n",
        "\n",
        "arr2 = np.array([[1, 2], [3, 4], [5,6]])\n",
        "print(\"2-d array:\", arr2)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "MdcdscVvY7PV"
      },
      "source": [
        "Note that since these are multidimensional arrays, simplying calling `len()` doesn't quite work as well. Usually you will be using the `size` parameter, which gives the total number of elements, and the `shape` parameter, which gives a tuple containing the size of the array in each dimension in order."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3YojdwrIZXQ-",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "print(arr, \"has size\", arr.size, \"and shape\", arr.shape)\n",
        "print(arr2, \"has size\", arr2.size, \"and shape\", arr2.shape)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "VU8nm4-iWulJ"
      },
      "source": [
        "The first major difference between ndarrays and Python lists is that ndarrays are homogeneous, in other words, they can only contain one type of data. You can inspect the data type using the `dtype` property. In addition, you can specify the dtype when creating a ndarray if you want a specific type."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "udowvsq_WDOL",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "float_arr = np.array([1.0, 2.0, 3.0])\n",
        "print(float_arr.dtype, float_arr)\n",
        "\n",
        "arr = np.array([1,2,3])\n",
        "print(arr.dtype, arr)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "4Bp-Z8GpX2xa"
      },
      "source": [
        "The next difference is that `ndarrays` are designed to have a fixed size. For regular Python lists, you can use `append()` to easily tack on new elements to an existing list. While numpy does have a `concatenate` function to join ndarrays, this works by creating a new larger array and copying in the data and so it is far less efficient.\n",
        "\n",
        "This also means that creating a blank ndarray requires giving the size as a tuple. Numpy provides a few options for creating blank arrays."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V1bzdZK2XMsD",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "print(\"Uninitialized array\", np.empty((2,3)))\n",
        "print(\"All zeros\", np.zeros((2,3)))\n",
        "print(\"All ones\", np.ones((2,3)))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "DvKXrs6ZbtPC"
      },
      "source": [
        "So why go through all this trouble? The special feature of ndarrays and the reason why they are used so often is that they support efficient vectorized operations. Instead of writing a for loop to go over elements one by one, you can often perform operations over the whole ndarray at once. And since the ndarray knows the size and data type ahead of time, it can do this very efficiently and much faster than a for loop."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HB-VWNI8an3X",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "arr = np.array([1, 2, 3 ,4, 5])\n",
        "print(\"Doubled\", arr * 2)\n",
        "print(\"Add 1\", arr + 1)\n",
        "print(\"Compare\", arr > 2)\n",
        "print(\"Exponents\", arr ** 2)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "C4ffBhItcoz-"
      },
      "source": [
        "You can also do element-wise operations on ndarrays of the same size.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m6omntgKcdxd",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# Create array of 2's in same shape as arr\n",
        "arr2 = np.ones(arr.shape) * 2\n",
        "print(arr2)\n",
        "\n",
        "print(\"Do math\", (arr - arr2) * arr)\n",
        "print(\"Do comparisons\", arr > arr2)\n",
        "print(\"Do harder math\", np.log(np.pi / arr))\n",
        "print(\"Prove trig identities\", np.cos(arr) ** 2 + np.sin(arr) ** 2)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Bm9Z5giBfKFA"
      },
      "source": [
        "#### Exercise\n",
        "Numpy also provides a bunch of convenient functions to do common math operations. For instance, `mean()` finds the mean of an array. Let's do a race against regular Python lists to see how it performs!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "neSKera9fpAH",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# Return the average of the contents of the input list\n",
        "def list_mean(input):\n",
        "  # WRITE CODE HERE\n",
        "  return 0\n",
        "  # END CODE"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FaZ6CB8qdPAu",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# Make a big list\n",
        "python_list = list(range(1000000))\n",
        "numpy_array = np.array(list(range(1000000)))\n",
        "average = 0\n",
        "\n",
        "import time\n",
        "start_time = time.time()\n",
        "average = list_mean(python_list)\n",
        "end_time = time.time()\n",
        "print(average)\n",
        "print(\"Python list took\", end_time - start_time, \"seconds\")\n",
        "\n",
        "average = 0\n",
        "start_time = time.time()\n",
        "average = numpy_array.mean()\n",
        "end_time = time.time()\n",
        "print(average)\n",
        "print(\"Numpy ndarray took\", end_time - start_time, \"seconds\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "yRwkIyxzi1Mc"
      },
      "source": [
        "The [ndarray documentation](https://numpy.org/doc/stable/reference/arrays.ndarray.html#calculation) lists out all the available operations. Some other useful ones are `sum()`, `min()`, `max()`, and `std()` (standard deviation)."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "QIVd97R_dlse"
      },
      "source": [
        "### 1.2 Array Slicing\n",
        "The next key feature of NumPy arrays is that they can be efficiently \"sliced\" using an extended version of the standard Python square bracket notation. This lets you quickly extract specific dimensions or sections of an array in a single step.\n",
        "\n",
        "For regular Python lists, you can specify a slice using the notation `[begin:end]`. This also applies to ndarrays, except you can specify a different range for each dimension. Note that the beginning index is inclusive, while the end index is exclusive."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iqwCuPkPhqpg",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "arr = np.array([[0, 1,2,3,4,5],[6, 7,8,9,10,11],[12, 13,14,15,16,17]])\n",
        "\n",
        "# Select first row\n",
        "print(arr[0])\n",
        "\n",
        "# Select portion of the first row\n",
        "print(arr[0,0:4])\n",
        "\n",
        "# Select first two columns of first two rows\n",
        "print(arr[0:2, 0:2])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "247_og3ygrdC"
      },
      "source": [
        "You can ommit parts of a slice and Python will extend the slice to the end of the array in the missing direction."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xfQs2_GReiVU",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "arr1 = np.array([0,1,2,3,4,5,6])\n",
        "\n",
        "# Select everything after index 2\n",
        "print(arr1[2:])\n",
        "\n",
        "# Select everything before index 2\n",
        "print(arr1[:2])\n",
        "\n",
        "# Select everything\n",
        "print(arr1[:])\n",
        "# This is very useful in multidimensional arrays. Ex. select the first column of arr\n",
        "print(arr[:, 0])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "XEwMZHmahqmC"
      },
      "source": [
        "Python also permits negative indices, which are interpreted as counting back from the end of the array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4MgkKvxHhNpe",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "print(arr)\n",
        "\n",
        "# Select the last row\n",
        "print(arr[-1])\n",
        "\n",
        "# Select the last column\n",
        "print(arr[:, -1])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "zSR1spNvh9iY"
      },
      "source": [
        "Finally, you can add in a step parameter like `[begin:end:step]` to select every `step` element. The step can also be negative, in which case the array will be indexed starting from the end."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QDQ0S202h0Qb",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "print(arr)\n",
        "\n",
        "# Select even index columns\n",
        "print(arr[0:3, 0:6:2])\n",
        "\n",
        "# Select odd index columns\n",
        "print(arr[:, 1::2])\n",
        "\n",
        "# Select odd columns of even rows\n",
        "print(arr[::2, 1::2])\n",
        "\n",
        "# Select first row\n",
        "print(arr[0])\n",
        "# Reverse first row\n",
        "print(arr[0, ::-1])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "qL80gtufjXtx"
      },
      "source": [
        "#### Exercise\n",
        "To practice, try writing a function that flips an 2d array using only slicing notation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5K4yT6A5iStS",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "def flip_horizontal(array):\n",
        "  # WRITE CODE HERE\n",
        "  return array\n",
        "  # END CODE\n",
        "\n",
        "def flip_vertical(array):\n",
        "  # WRITE CODE HERE\n",
        "  return array\n",
        "  # END CODE\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jVvhIpzOjuGq",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "print(\"Original:\")\n",
        "print(arr)\n",
        "print(\"Horizontal flip:\")\n",
        "print(flip_horizontal(arr))\n",
        "print(\"Vertical flip:\")\n",
        "print(flip_vertical(arr))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "iG6uVBeDSrhL"
      },
      "source": [
        "You can also assign to slices using `=`. This works both for element-wise assignment with scalar values and assigning whole arrays with matching size."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i-ejVSglSq_0",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "print(\"Original:\")\n",
        "print(arr)\n",
        "\n",
        "print(\"Overwrite 2nd row\")\n",
        "arr[1, :] = 2\n",
        "print(arr)\n",
        "\n",
        "print(\"Replace 1st row\")\n",
        "arr[0] = arr[2]\n",
        "print(arr)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Aeeiy_4Igoav"
      },
      "source": [
        "#### Exercise\n",
        "Let's put everything together and see what we've learned. Write a function `times_table(n)` that returns a n by n times table as a 2d `ndarray`. See if you can use vector operations to do this with only one for loop."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Kv4Sa2RRkI9Y",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "def times_tables(size):\n",
        "  # WRITE CODE HERE\n",
        "  return\n",
        "  # END CODE"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GGLFDJzThbm3",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "print(times_tables(1))\n",
        "print(times_tables(10))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "zjNNEwTWiWZY"
      },
      "source": [
        "### 1.3 Boolean Operations\n",
        "We've alreay seen that ndarrays can contain boolean True/False values. They are very useful for doing comparisons, and NumPy includes a bunch of features to let use the results of comparisons to do useful work."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "W1rXLaiJi2lV"
      },
      "source": [
        "First off, you can actually use a boolean ndarray to index into another array of the same size. How this works is that NumPy will go through the array and pick out the values matching where the boolean array is True. It then returns all the picked values as a 1d array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Sse4XqI1hc9i",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "arr = times_tables(10)\n",
        "print(arr)\n",
        "even_values = arr % 2 == 0\n",
        "print(even_values)\n",
        "print(arr[even_values])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "lPGa24RmjvfQ"
      },
      "source": [
        "An even more powerful extension of this is the `np.where(condition, x, y)` function. This takes in a boolean ndarray condition, then for each element in the array selects the value from x if condition is True and y if condition is False. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KHNfpMmbjOCL",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "print(np.where(arr < 50, arr, 0))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "T8UE4_UUkwD-"
      },
      "source": [
        "To combine multiple boolean ndarrays, you can use the + operator for logical \"or\" and the * operator for logical \"and\". Note that the normal Python order of operation does comparisons after math, so you need to be careful to put parenthesis so that the comparisons are executed first!\n",
        "\n",
        "If you're wondering why addition and multiplication are \"or\" and \"and\", remember that booleans are treated as numbers where 0 is False and everything else is True. What laws of addition/multiplication are at play here?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0mJUylJnkO3R",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "print(\"Numbers in range\")\n",
        "print(np.where((10 < arr) * (arr < 50), arr, 0))\n",
        "print(\"Muliples of 5 or 7\")\n",
        "print(np.where((arr % 5 == 0) + (arr % 7 == 0), arr, 0))\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "ZtrPgFL8xdKy"
      },
      "source": [
        "#### Exercise\n",
        "Let's practice by making a basic estimation of π! Recall that the equation for a circle of radius 1 is $x^2 + y^2 = 1$. This means that for all points (x,y) inside the circle, $x^2 + y^2 < 1$. If we construct a fine grid of points in a square around the circle and count the number of points inside the circle, we can make an estimate of the area of the circle as a fraction of the area of the bounding square. Then via $Area = \\pi r^2$, we have an approximation of π. This is a simple version of the Monte Carlo method of random sampling, which is often used to estimate solutions to difficult problems."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZZnzgDrMyg0b",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# Number of divisions in the grid.\n",
        "PRECISION = 1000\n",
        "\n",
        "# Setup 2d grid of floats in the range [-1.0, 1.0]\n",
        "x = np.array(range(PRECISION), dtype=float) / PRECISION * 2 - 1\n",
        "grid = np.empty((PRECISION, PRECISION))\n",
        "\n",
        "# Make grid[x,y] = x^2 + y^2\n",
        "grid[:] = x ** 2\n",
        "\n",
        "for y in range(PRECISION):\n",
        "  grid[:, y] += x**2\n",
        "\n",
        "# Create an ndarray that is 1 for squares inside the circle and 0 for squares outside the circle\n",
        "# Remember the circle's radius is 1\n",
        "is_in_circle = # WRITE CODE HERE\n",
        "\n",
        "# Count the number of squares by taking the sum of all elements of is_in_circle\n",
        "squares_in_circle = # WRITE CODE HERE\n",
        "\n",
        "# Area of one grid square is total area of grid / number of grid squares\n",
        "AREA_PER_SQUARE = # WRITE CODE HERE\n",
        "\n",
        "# Finally calculate the total area of the unit circle\n",
        "print(squares_in_circle * AREA_PER_SQUARE)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "7_ongfBGokXw"
      },
      "source": [
        "## Part 2: Matplotlib\n",
        "\n",
        "Tables are good for computation, but not so much for visualization. [Matplotlib](https://matplotlib.org/) is a library providing flexible plotting functionality, capable of generating all kinds of graphs and images. If you've ever seen a plot in a scientific paper that used Python, there's a good chance that matplotlib was used to generate it."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "uQ-u0k7Xp1bO"
      },
      "source": [
        "Matplotlib is rather unusual in that it is often used by keeping the current drawing state in the global matplotlib module rather than creating objects. This is a holdover from the Matlab plotting syntax, which Matplotlib is based on. This means that we are often calling functions on the `plt`, which is from when we imported matplotlib at the very beginning with `import matplotlib.pyplot as plt`.\n",
        "\n",
        "This also means that for basic plotting, you are working on one plot at a time. Let's go through an example to show how this works. "
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "5ow7hQ1suCt2"
      },
      "source": [
        "### 2.1 Line plots\n",
        "The most basic plot we have is plotting series data in a line plot. This is very easy to do with the `plot()` function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OwSK6J7Xl3Wh",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# Generate some data\n",
        "x = np.array(range(200)) / 100 * np.pi\n",
        "y = np.sin(x)\n",
        "\n",
        "# Make a line plot\n",
        "plt.plot(x, y)\n",
        "# Show the plot\n",
        "plt.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "n2GRnni2r9mT"
      },
      "source": [
        "Of course, a line on its own is no good, you must label your axes! Luckily matplotlib makes this easy as well."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "haSDvHjsrdGW",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "plt.plot(x, y)\n",
        "# Turn on the grid\n",
        "plt.grid()\n",
        "\n",
        "# Add labels\n",
        "plt.title(\"Sine Wave\")\n",
        "plt.xlabel(\"Radians\")\n",
        "plt.ylabel(\"Value\")\n",
        "plt.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "g5zawP6hsoRC"
      },
      "source": [
        "You can plot multiple lines on the same figure by calling `plot()` multiple times. In this case if is usually helpful to add a legend too."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MC2dXQa1rywf",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "plt.plot(x, np.sin(x))\n",
        "plt.plot(x, 2 * np.sin(x))\n",
        "\n",
        "# Add legend\n",
        "plt.legend([\"sin(x)\", \"2sin(x)\"])\n",
        "\n",
        "plt.grid()\n",
        "plt.title(\"Sine Waves\")\n",
        "plt.xlabel(\"Radians\")\n",
        "plt.ylabel(\"Value\")\n",
        "plt.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "50Ngh4qEuWhk"
      },
      "source": [
        "If you want your plots to be in separate figures, call `figure()` to reset the drawing environment and give a new window. Note we only call `plt.show()` once we're done setting up all of our figures."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FvqItRyYs7dO",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "plt.plot(x, np.sin(x))\n",
        "plt.title(\"Plot 1\")\n",
        "\n",
        "plt.figure()\n",
        "plt.plot(x, 2 * np.sin(x))\n",
        "plt.title(\"Plot 2\")\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "DTj81J9Gybyb"
      },
      "source": [
        "### 2.2 Importing Data\n",
        "\n",
        "Before we go further, let's go over some ways to import and export data from files. This isn't matplotlib specific, but we need to go over this before we start working with images."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "bEl1ghncyv4g"
      },
      "source": [
        "Let's start with tabular data. The simplest format for tables is the CSV or comma separated value format. This lists one row of a table by line, with entries separated by commas. Normal Python has the [csv library](https://docs.python.org/3/library/csv.html) for reading and writing csv files. However, if we know the file contains numerical data, we can import directly into NumPy.\n",
        "\n",
        "The data we're downloading is a CSV snapshot of data from the [TOP500 supercomputer list](https://www.top500.org/statistics/perfdevel/). It contains the number of floating point operations per second (FLOPS) that the number one supercomputer could perform for each year."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d7ch3uVLLSlD",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "flops_data = np.loadtxt('2020OffseasonTraining/data/TOP500_Flops.csv', dtype=int, skiprows=1, delimiter=',')\n",
        "print(flops_data)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "fIXSZ8nWLs19"
      },
      "source": [
        "#### Exercise\n",
        "Let's try plotting this data! Remember to label your axes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NWWfqK08Lx_A",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# WRITE CODE HERE\n",
        "\n",
        "# END CODE\n",
        "plt.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "vyArb5PeMNxO"
      },
      "source": [
        "Bonus: Moore's Law famously predicts that the number of transistors in processors (and therefore computing power) would grow exponentially over time. Can you make a log plot of this data to show well reality matches Moore's Law?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JFCb8crgMk8x",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# WRITE CODE HERE\n",
        "\n",
        "# END CODE\n",
        "plt.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "p9hCezj-uywC"
      },
      "source": [
        "### 2.3 Images\n",
        "\n",
        "The next most common type of data we want to work with is image data. Matplotlib provides the `imshow` function to handle these. It supports plotting 2d arrays as grayscale images with coloring based on the value in the array and 3d RGB arrays as full color images.\n",
        "\n",
        "First we need some image data to work with. We'll be fetching live satellite images from the [NOAA GOES West](https://www.star.nesdis.noaa.gov/GOES/fulldisk.php?sat=G17) geostationary weather satellite."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LzRTEagzum5y",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "! curl https://cdn.star.nesdis.noaa.gov/GOES17/ABI/FD/GEOCOLOR/678x678.jpg     -o goes_west_small.jpg\n",
        "! curl https://cdn.star.nesdis.noaa.gov/GOES17/ABI/FD/GEOCOLOR/10848x10848.jpg -o goes_west.jpg"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "oGCd1D0Wt-G-"
      },
      "source": [
        "To read in the files, we can use the `imread` function from OpenCV. This returns a 3d ndarray. This is 3D because for each row, column pair we have a pixel with a 3 element color. So the shape is (width, height, 3). We'll go more into detail on how color works in the CV workshop."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "rHhmychsxYz-"
      },
      "source": [
        "#### Exercise\n",
        "One small problem is that OpenCV is a bit of an odd package with many historical quirks due to the fact that it is based on an older C++ package. In particular, it presents its color data in BGR order rather than RGB order. So we need to flip the last dimension of the image in order for the colors to display right. Let's write a function to do this for us."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8zqUCoBivOjD",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "def bgr_to_rgb(image):\n",
        "  # WRITE CODE HERE\n",
        "  return image\n",
        "  # END CODE"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "bbIyZ482vamT"
      },
      "source": [
        "Now we can finally call imshow() to display this image. Note that the NOAA logo on the bottom left should be blue. If it isn't, double check your `bgr_to_rgb` function!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pYTrODxkkCW_",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "image = cv2.imread('goes_west_small.jpg')\n",
        "plt.imshow(bgr_to_rgb(image))\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "ScientificPython.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}