tu011-Numpy-LoopsAndLogicalOperators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2f781c82",
   "metadata": {},
   "source": [
    "# `NumPy`: Using loops and logical operators with `arrays`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2436bfc1",
   "metadata": {},
   "source": [
    "### Learning outcomes:\n",
    " - Advanced usage of the `NumPy arrays`\n",
    " - Advanced usage of `for` and `while` loops\n",
    " - Apply loops and logical operators on `numpy arrays`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8148d1bb",
   "metadata": {},
   "source": [
    "In previous tutorials we have learned about `for` and `while` loops using simple Python datatypes such as `lists`. \n",
    "\n",
    "Hereafter we will combine the use of loops with `NumPy` arrays. This will give us the opportunity to explore more advanced uses of `NumPy arrays`, how to create 2-dimensional arrays, index into them and combine them using methods.\n",
    "\n",
    "*Reminder. A method is a property of an object in python. Methods are invoked (the technical term for called, or simply used) as follows `<object>.<method>` for example `numpyarray1.append()`. We will learn later what `.append()` can do. For the moment, it is helpful to remember how to call a method: `functionName.methodName`.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c416314",
   "metadata": {},
   "source": [
    "### More thinkering with `arrays`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2315344",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b277c854",
   "metadata": {},
   "source": [
    "As introduced before, `numpy arrays` are multidimensional objects. This means that they can have one dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d47d39bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "oneDarray = np.array([1,2,3])\n",
    "print(oneDarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a84da1a1",
   "metadata": {},
   "source": [
    "We can investigate the shape of the array using the method `.shape`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cfdaae0",
   "metadata": {},
   "outputs": [],
   "source": [
    "oneDarray.shape"
   ]
  },
  {
   "cell_type": "raw",
   "id": "41f5e30e",
   "metadata": {},
   "source": [
    "Ok, that means that the array has one dimension (the first, as the second after the come is empty) and the size of the dimension is `3`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b55beed",
   "metadata": {},
   "outputs": [],
   "source": [
    "Array can also have more dimensions, say 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1447887",
   "metadata": {},
   "outputs": [],
   "source": [
    "twoDarray = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(twoDarray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f044e02",
   "metadata": {},
   "outputs": [],
   "source": [
    "twoDarray.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa2fd8ec",
   "metadata": {},
   "source": [
    "Here we see that the first dimension is of size `2` and the second of size `3`. That is because the outer square brakets contain only two elements, two sets of square brakets, something like `[ [] , [] ]`. The outer square brakets are the first dimension. The inner squaure brakets are the second dimension. \n",
    "\n",
    "What happens if the second dimension has a different number of elements? Let's try:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a9ce594",
   "metadata": {},
   "outputs": [],
   "source": [
    "twoDarray = np.array([[1, 2, 3], [4, 5, 6, 7]])\n",
    "print(twoDarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39bbf3b0",
   "metadata": {},
   "source": [
    "OK What happened there? Why we cannot have a numpy array with elements of different size? Well as you can see the `print()` operation returns that the content of the array are lists. The array can only contain lists of equal size. The array creation method about (making lists and stiking thme into arrays) is suboptimal. \n",
    "\n",
    "Indeed, we can try to multiple the array by `2` and the output is not what we wanted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62b3e3af",
   "metadata": {},
   "outputs": [],
   "source": [
    "twoDarray*2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d65bf4f",
   "metadata": {},
   "source": [
    "We wish that by multiplying the array we would double the values in the array, instead, the operations duplicated the numbers (i.e., [1, 2, 3] became [1, 2, 3, 1, 2, 3] and [4, 5, 6, 7] became [4, 5, 6, 7, 4, 5, 6, 7]).\n",
    "\n",
    "Numpy provides better ways to create arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51c27eb4",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "  - Create a 2-D array with 3 numbers in each dimension and then multiply the array by `2`. Explain what is happens.\n",
    "\n",
    "  [Use the cell below to provide your explaination]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0549b63",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e146a2d5",
   "metadata": {},
   "source": [
    "### General methods to create `numpy` arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5185dbfc",
   "metadata": {},
   "source": [
    "Oftentimes, as we go about doing our nice data sciency stuff, we will need to create arrays of a certain dimension. For this reasons numpy provides a few methods to initialize arrays, create empty arrays of the proper size. These arrays can later on be filled up with data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bb5cdae",
   "metadata": {},
   "source": [
    "The functions `np.zeros()` and `np.ones()` allow creating arrays with the proper dimensions. Whereas the first initializes an array with, ahem, zeros inside, the second, well you know the drill... Let's see how to use them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dec0aba8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "AnArrayOfZeros = np.zeros(2)\n",
    "print(AnArrayOfZeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a22afefe",
   "metadata": {},
   "source": [
    "The above created a 1-D array of size 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d91a655f",
   "metadata": {},
   "outputs": [],
   "source": [
    "AnotherArrayOfZeros = np.zeros((2,2))\n",
    "print(AnotherArrayOfZeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85f751bc",
   "metadata": {},
   "source": [
    "The above created a 2-D array of size 2 in size 1 and size 2 in size 2. Let's create one with 3 elements in the first dimension and 4 in the second dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdfc3f17",
   "metadata": {},
   "outputs": [],
   "source": [
    "myArray = np.zeros((3,4))\n",
    "print(myArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a397777c",
   "metadata": {},
   "source": [
    "We can also use `np.ones()` in a similar way, let's create an array with 2 elements in the first dimension and 5 in the second:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07f2a38c",
   "metadata": {},
   "outputs": [],
   "source": [
    "myArray = np.ones((2,5))\n",
    "print(myArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6c5e16a",
   "metadata": {},
   "source": [
    "The arrays come with a series of methoss, built-in! For example, number of dimensions can be returned by the array using the method `.ndim`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32a0b6e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "myArray.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a70ed9c",
   "metadata": {},
   "source": [
    "The shape of the array  can be returned as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f452fc18",
   "metadata": {},
   "outputs": [],
   "source": [
    "myArray.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9d0d7a2",
   "metadata": {},
   "source": [
    "The totla number of the elements can be returned using the method `.size`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6803edad",
   "metadata": {},
   "outputs": [],
   "source": [
    "myArray.size"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f740cde",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "    - List the number of methods of a the numpy array myArray and return the list of number here: []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58073c1b",
   "metadata": {},
   "source": [
    "    - Create a 3-D array and show the use of two methods (excluding the methods shown above). \n",
    "    \n",
    "   [Report your results below, use `print()` when needed to show the results of the operation of the method]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e997ce7e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fa234fdf",
   "metadata": {},
   "source": [
    "### `for` loops on arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e59f68f2",
   "metadata": {},
   "source": [
    "We have learned before about for loops. We have learned about arrays. Here we will practice with using for loops to perform operations on numpy arrays.\n",
    "\n",
    "Now on we will use a handy method to create arrays, we will: \n",
    "\n",
    "  - Define the dimensions an size of elements\n",
    "  - Create a set of dimensions (remember sets use `()`)\n",
    "  - Use the set in combination with the function `.zeros()` to create our array.\n",
    "  \n",
    "Now on, we will use this method for initializing arrays several time sin the future."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1b37a43",
   "metadata": {},
   "outputs": [],
   "source": [
    "nRows, nCols = 10, 5   # Python let's us do this!\n",
    "myArraySize = (nRows, nCols)  # we'll make a 10x5 array. Rows always come first!\n",
    "anArray = np.zeros(myArraySize)\n",
    "print(anArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81831710",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "   - Create an 3-D array called `threeDarray` filled with `2`'s with max four elements in each dimension: \n",
    "    \n",
    "  [Show your code in the next cell]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2ddf1f1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f8f7e389",
   "metadata": {},
   "source": [
    "Let's think how we can start filling up arrays with data. \n",
    "\n",
    "One great thing about `for` loops is that we can use them to go through the rows or columns of an array (or both!) in turn, repeating some operation on each one. Let's say we need to put the numbers of the binary sequence (2, 4, 8, 16...) in the columns of a 10x5 array for some future simulation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b1fc529",
   "metadata": {},
   "source": [
    "We could do that this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e551156",
   "metadata": {},
   "outputs": [],
   "source": [
    "anArray[:,0] = 2\n",
    "anArray[:,1] = 4\n",
    "anArray[:,2] = 8\n",
    "anArray[:,3] = 16\n",
    "anArray[:,4] = 32\n",
    "\n",
    "anArray"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c4bec86",
   "metadata": {},
   "source": [
    "That works, no doubt. But \n",
    "\n",
    "1. there's a lot of \"hand coding\", which is prone to mistakes\n",
    "2. it would be a pain to scale up to huge arrays (as we already know)\n",
    "3. it's ugly "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "008c1644",
   "metadata": {},
   "source": [
    "Now let's do this a cleaner and much more scalable way using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e5b3661",
   "metadata": {},
   "outputs": [],
   "source": [
    "nRows, nCols = 10, 5   # make variables for length and width of our array\n",
    "myArraySize = (nRows, nCols)    # we'll make a 10x5 array. Rows always come first!\n",
    "ourNumbers = [2, 4, 8, 16, 32]  # numbers that we'll set each column to\n",
    "anArray = np.zeros(myArraySize) # make an array to hold our numbers\n",
    "\n",
    "for i in range(nCols) :\n",
    "    anArray[:,i] = ourNumbers[i]\n",
    "    \n",
    "anArray"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3522be5",
   "metadata": {},
   "source": [
    "And we get the same result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6700c7b8",
   "metadata": {},
   "source": [
    "So we've swapped this:\n",
    "\n",
    "```\n",
    "anArray[:,0] = 2\n",
    "anArray[:,1] = 4\n",
    "anArray[:,2] = 8\n",
    "anArray[:,3] = 16\n",
    "anArray[:,4] = 32\n",
    "```\n",
    "\n",
    "(Yuk.)\n",
    "\n",
    "for this:\n",
    "\n",
    "```\n",
    "for i in range(nCols) :\n",
    "    anArray[:,i] = ourNumbers[i]\n",
    "```\n",
    "    \n",
    "(Nice.)\n",
    "\n",
    "which is already a huge improvement. But imagine if we were working with a 1000 or 10,000 element array! Doing it the first way – well – you can imagine. But doing it the second way, all we would have to do is change `nCols` and be a bit clever and compute `ourNumbers` automatically."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8810f65e",
   "metadata": {},
   "source": [
    " Wait, what? How would we compute the binary sequence – the powers of 2 – automatically? \n",
    " \n",
    " With a `for` loop of course! Let's do that!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cc5ffda",
   "metadata": {},
   "outputs": [],
   "source": [
    "ourNumbers = list()                # Make an empty Python list\n",
    "for i in range(nCols) :\n",
    "    thisNumber = 2**(i+1)          # compute 2 to the right power\n",
    "    ourNumbers.append(thisNumber)  # and append it to our list \n",
    "ourNumbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a01fde9",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "  \n",
    "  - Above we have used `range()`, was this the first time the function was used? [Yes/No]\n",
    "  \n",
    "  - What does the function do?\n",
    "  \n",
    "  [Use the cell below to write your answer]\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ea96c0f",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "afa7f995",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74abc0b8",
   "metadata": {},
   "source": [
    "  \n",
    "  - Rewrite the above code avoiding defining (using) the `thisNumber` variable (so there should only be one line inside the `for` loop).\n",
    "  \n",
    "  [Use the cell below to show your code]\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28911fab",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "79e94cc7",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e815688",
   "metadata": {},
   "source": [
    "Okay, now we can write our code to populate the numpy array in a way that is completely scalable (this word means that the operations can work well for small as well as big datasets) using a single `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18038572",
   "metadata": {},
   "outputs": [],
   "source": [
    "nRows, nCols = 10, 5   # Python let's us do this!\n",
    "myArraySize = (nRows, nCols)  # we'll make a 10x5 array. Rows always come first!\n",
    "anArray = np.zeros(myArraySize)\n",
    "\n",
    "for i in range(nCols) :\n",
    "    anArray[:,i] = 2**(i+1)\n",
    "    \n",
    "anArray"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "248a82c6",
   "metadata": {},
   "source": [
    "Notice that, now, the ***only*** thing we need to change to compute and add more or fewer powers of 2 to our array is a single value – nCols in this case – *everything else is done automatically!*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b9aa1f4",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bca6ba3",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "  \n",
    "  - Write code (using a `for` loop of course) to compute the cube of the odd numbers from 1 to 9. (Remember that `range()` can take a step argument.)\n",
    "  \n",
    "  [Use the cell below to show your code]\n",
    "  \n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0791254",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "dc956031",
   "metadata": {},
   "source": [
    "Write scalable code to compute the first \"n\" numbers of the [Fibonacci sequence](https://en.wikipedia.org/wiki/Fibonacci_number). The Fibonacci sequence (named for the famous 13th century mathematician) starts with the numbers 0 and 1, and each number after that is the sum of the previous two numbers. (Galileo, da Vinci, and Franco aren't the only famous Italian scientists/mathematicians!). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5153a2bd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ff3a1381",
   "metadata": {},
   "source": [
    "### Nested for loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4ecdd38",
   "metadata": {},
   "source": [
    "A great thing about `for` loops is that they can be *nested* inside one another. This is best illustrated by example, so let's look at one and disect it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6b1708a",
   "metadata": {},
   "outputs": [],
   "source": [
    "nRows, nCols = 4, 3            # (easily changeble) array height and width\n",
    "myArraySize = (nRows, nCols)    # handy list of the size \n",
    "anArray = np.zeros(myArraySize) # make the array\n",
    "\n",
    "for i in range(nRows) :\n",
    "    for j in range(nCols) :\n",
    "        anArray[i,j] = i + j*nRows\n",
    "        print('Hi! I\\'m in row ', i, ' and column', j, '!')\n",
    "        \n",
    "anArray"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6a5bf18",
   "metadata": {},
   "source": [
    "So what's happening? In the first or \"outer\" loop, `for i in range(nRows) :` we're going to step through the numbers 0 to three, corresponding to the row indexes. \n",
    "\n",
    "At each value of `i`, the entire second or \"inner\" loop, `for j in range(nCols) :` is going to run, stepping through each value of `j`, corresponding to the column indexes. \n",
    "\n",
    "At each value of `j`, we stick a number in the `[i, j]` cell (`anArray[i,j] = i + j*nRows`), print a little message, and move on the the next value of `j`.\n",
    "\n",
    "Once the inner loop is complete, we jump out into the outer loop, increment `i` by 1, and then jump back into the inner loop and do the whole thing again! After i has run its course from 0 to `nRows`, we say farewell to that loop and go on our way!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ea9fa58",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fac1d2ab",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "  \n",
    "  - Change the above loop so that it numbers the cells from from left-to-right, top-to-bottom. Resist the temptation to cut and paste and write your code from scratch!\n",
    "  \n",
    "  [Use the cell below to show your code]\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d6a896a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4accd0bb",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3b61da7",
   "metadata": {},
   "source": [
    "The loop you just wrote numbers the cells of your array in \"row-major\" order, or \"row wise\", while the original loop numbered the cells in \"column-major\" order, or \"column wise\". "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "291be8ab",
   "metadata": {},
   "source": [
    "Nested loops give you tremendous power! You go through any array element-by-element and get or set individual values. You can even do things like loading a series of data files in turn (in an outer loop), and then chewing through each data file in an inner loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52b4d500",
   "metadata": {},
   "source": [
    "As a final example, let's say we want to simulate a diurnal rhythm, like the cortisol level the body for several people. Since differnt people have different schedules, we want to add a bit of randomness to when each persons cortisole level waxes and wanes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99ea8012",
   "metadata": {},
   "outputs": [],
   "source": [
    "hours, person = 24, 10            # (easily changeble) array height and width\n",
    "myArraySize = (hours, person)     # handy list of the size \n",
    "cortLevel = np.zeros(myArraySize) # make the array\n",
    "\n",
    "myFreq = 2*np.pi/hours            # make the frequency once per 24 hrs\n",
    "\n",
    "for j in range(person) :            # we'll go person by person\n",
    "    myPhase = np.random.rand(1, 1)  # get a random phase for this person\n",
    "    for i in range(hours) :         # go down current column (person) row-by-row\n",
    "        cortLevel[i,j] = np.sin((myFreq*i + myPhase)) # set val. for this [time, person]\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a49fc0d",
   "metadata": {},
   "source": [
    "(Here we will go ahead of us and use `matplotlib` one of the major python libraries for data visualization. We will dedicate a tutorial on this library later on.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "675e6edf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(cortLevel);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1255ab6c",
   "metadata": {},
   "source": [
    "Cool!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a644962",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "  \n",
    "  - Describe what the plot above shows. To do so, first describe the numbers in the `y` axis then those in the `x` axis, finally describe the function and the colors, what does this all mean?\n",
    "  \n",
    "  [Use the cell below to describe the plot]\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "567ba6de",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "92827725",
   "metadata": {},
   "source": [
    "### `While` loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5138dd14",
   "metadata": {},
   "source": [
    "Sometimes we wish to repeat a calculation (or something), not for a predetermined number of times like in a `for` loop, but until some critereon is reached. This is accomplished using a `while` loops, which just keeps running and running until a critereon is reached. One dangerous thing about a `while` loop is that if the criteon can't be reached because we made a mistake in our code, then the loop runs forever – an infinite loop!\n",
    "\n",
    "As a simple example, let's see how many tries it takes to get a number from the standard normal distribution that is above 2 - the upper 2.5% tail of the distribution!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98e5ccdd",
   "metadata": {},
   "outputs": [],
   "source": [
    "x, cutOff, myCounter = 0, 2, 0\n",
    "\n",
    "while x < cutOff :\n",
    "    x = np.random.randn()\n",
    "    myCounter += 1\n",
    "    \n",
    "myCounter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42b31291",
   "metadata": {},
   "source": [
    "The dissection of the code is as follows.\n",
    "\n",
    "* the first line sets some useful variables\n",
    "    - a \"test\" variable `x` that will contain our candidate random numbers\n",
    "    - our \"cut off\" variable that we will test x against\n",
    "    - a \"counter\" variable that we'll use to count the number of tries\n",
    "* the `while x < cutOff :` says \"keep trying *while* `x` is less than `cutOff`\n",
    "* `x = np.random.randn()` gets a random number and assignes it to `x`\n",
    "* `myCounter +=` increments our counter\n",
    "\n",
    "Once we get a random number above 2, the `x < 2` returns `False` and the loop ends. Whatever value is then in `myCounter` is our answer!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "376b0633",
   "metadata": {},
   "source": [
    "Run the above code cell several times! Does it always take the same number of times? Based on what you know about the standard normal distribution, how many times should it take?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97ac3dfc",
   "metadata": {},
   "source": [
    "Now here's an interesting puzzle... How many times does it take to get a big random number on average? What does the distribution look like?\n",
    "\n",
    "How would we answer those questions?\n",
    "\n",
    "Let's use... \n",
    "\n",
    "a ***for loop!***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc856f47",
   "metadata": {},
   "source": [
    "(Here we are going to go ahead of us and use two the python library `seaborn`, we will learn more about this library in later tutorials.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bad3d4d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns  # for making a histogram/kde"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41bf9dd3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nExperiments = 100  # how many times we'll do our little experiment\n",
    "nSamplesNeeded = np.zeros((nExperiments, 1))\n",
    "x, cutOff, = 0, 2\n",
    "\n",
    "for i in range(nExperiments) :\n",
    "    myCounter = 0\n",
    "    x = 0\n",
    "    while x < cutOff :\n",
    "        x = np.random.randn()\n",
    "        myCounter += 1\n",
    "    nSamplesNeeded[i, 0] = myCounter    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dda97622",
   "metadata": {},
   "source": [
    "That looks like a lot of code, but go through it carefully. All we have done is nest our `while` loop inside a `for` loop, so that we can do our \"How many times?\" experiment as often as we wish. On each pass through the `for` loop, we store the answer from a single experiment in the `i`th row of a numpy array!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c52a5f35",
   "metadata": {},
   "source": [
    "Let's look at the number of tries it took on each experiment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dfe675a",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(nSamplesNeeded, '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d2af9ac",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "  \n",
    "  - Describe what the plot above shows. To do so, first describe the numbers in the `y` axis then those in the `x` axis, finally describe the function and the colors, what does this all mean?\n",
    "  \n",
    "  [Use the cell below to describe the plot]\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aefd9252",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "36e06d8e",
   "metadata": {},
   "source": [
    "Okay, cool! So it looks like we usually get a \"big\" number in under 50 tries, but it occasionally takes a lot longer. Let's look at the distribution of these numbers!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed88b8b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.displot(nSamplesNeeded, kind='kde')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b31e868",
   "metadata": {},
   "source": [
    "Okay, I think that, while pretty, this plot is misleading. Can you see why?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8599876",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "  \n",
    "  - Describe what the plot above shows. To do so, first describe the numbers in the `y` axis then those in the `x` axis, finally describe the function and the colors, what does this all mean?\n",
    "  \n",
    "  [Use the cell below to describe the plot]\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f6db5fa",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c69e24cb",
   "metadata": {},
   "source": [
    "Let's do a plain old histogram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2981c8e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.displot(nSamplesNeeded, kind='hist')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8166fd30",
   "metadata": {},
   "source": [
    "Now this make more sense, because we can't have a negative number of tries!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5445483",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "  \n",
    "  - Describe what the plot above shows. To do so, first describe the numbers in the `y` axis then those in the `x` axis, finally describe the values in the plot, what does this all mean?\n",
    "  \n",
    "  [Use the cell below to describe the plot]\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eb3d59b",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a5f46908",
   "metadata": {},
   "source": [
    "So it looks like, on average, it took us about – what? – 40 tries to get a number in the upper 2 1/2% tail of the distribution. Let's do a quick calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf32d1de",
   "metadata": {},
   "outputs": [],
   "source": [
    "100 / 2.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4335bd14",
   "metadata": {},
   "source": [
    "### Logic operators on NumPy arrays\n",
    "\n",
    "There are other types of operators that do not come standard with Python but that are part of other packages and need to be imported. These operators behave differently.\n",
    "\n",
    "When dealing with arrays, instead of individual numbers, things look slightly different. For example, if we wanted to perform a logical operation between two sets of numbers, e.g., two arrays, operatiors (`=`, `>`, etc) will work sometimes but not others. \n",
    "\n",
    "Let's take a look at how we would perform comparisons and logical operations with NumPy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8318324",
   "metadata": {},
   "outputs": [],
   "source": [
    "myRnds = np.random.randn(1, 5) # we create an array of random numbers\n",
    "myRnds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4011cf27",
   "metadata": {},
   "source": [
    "Now, imagine we wanted to know whether each number stored in the Array `myRnds` is positive. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf372588",
   "metadata": {},
   "outputs": [],
   "source": [
    "myRnds > 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea814953",
   "metadata": {},
   "source": [
    "If we wanted to find out whether any of the numbers in an array are positive, we would use the numpy array method `any`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97b190b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "logical_array = (myRnds > 0)\n",
    "np.any(logical_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3850275e",
   "metadata": {},
   "source": [
    "If we wanted to test whether all the values in an array are positive, we would use the method `all`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "404039ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.all(logical_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b64f0e3",
   "metadata": {},
   "source": [
    "Because both `all` and `any` apply to numpy atrays, they can also be called as methods of a NumPy Arrays. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4a6853f",
   "metadata": {},
   "outputs": [],
   "source": [
    "logical_array.any()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e823fba",
   "metadata": {},
   "outputs": [],
   "source": [
    "logical_array.all()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d73f38f0",
   "metadata": {},
   "source": [
    "Numpy arrays also allow comparing values element-wise. This means that we could compare each element of one array with the corresponding element of another array. If the twovectors have the same size.\n",
    "\n",
    "`[1, 2, 3] = [1, 4, 3]`\n",
    "\n",
    "Would compare 1 to 1, 2 to 4 and 3 to 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fc09ff0",
   "metadata": {},
   "outputs": [],
   "source": [
    "array_one = np.random.randn(1,5) > 0;\n",
    "array_two = np.random.randn(1,5) > 0;\n",
    "np.logical_and(array_one, array_two)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d73b393f",
   "metadata": {},
   "source": [
    "What happens if the two arrays have different size, though?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14883fd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "vector_one = np.random.randn(1,6) > 0;\n",
    "vector_two = np.random.randn(1,5) > 0;\n",
    "np.logical_and(vector_one, vector_two)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c670b0c",
   "metadata": {},
   "source": [
    "The not and or operators also exist for numpy arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71b175dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "vector_one = np.random.randn(1,5) > 0;\n",
    "vector_two = np.random.randn(1,5) > 0;\n",
    "np.logical_or(vector_one, vector_two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c046dd27",
   "metadata": {},
   "outputs": [],
   "source": [
    "vector_one = np.random.randn(1,5) > 0;\n",
    "vector_two = np.random.randn(1,5) > 0;\n",
    "np.logical_not(vector_one, vector_two)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5834f59",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "  \n",
    "  - Create an array of uniform random numbers with dimensions rows=1 and columns=8.\n",
    "  \n",
    "  [Use the cell below to write your code]\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25a2ee41",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "200db3fd",
   "metadata": {},
   "source": [
    "   - how many numbers were generated with a value larger than 0.5?\n",
    "  \n",
    "  [Use the cell below to write your code]\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4292b7f2",
   "metadata": {},
   "source": [
    "So in this tutorial we have shown how to organize and manipulate data using Python `numpy` `arrays`. \n",
    "\n",
    "We have also worked through the very important element of code called ***loops*** and how they apply to NumPy Arrays.\n",
    "\n",
    "The most frequently used loop is the `for` loop, which allows us to do a computation a number of times. It can be used to do things like crawl through the rows and columns of a numpy array. With a pair of nested `for` loops, we can even crawl through each cell of an array in either row-major or column-major order. We could even use a `for` loop to chew through a series of data files, etc.\n",
    "\n",
    "A `while` loop is used when we don't know ahead of time how many times we'll need to do the calculation. The while loop allows us to compute or look at thing as many times as necessary until some condition as met. We just have to be careful that we don't make a dreaded *infinite* loop (what sort of cut off would make the `while` loop above essentially infinite?)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e30277d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}