{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "  <IMG SRC=\"https://raw.githubusercontent.com/mbakker7/exploratory_computing_with_python/master/tudelft_logo.png\" WIDTH=250 ALIGN=\"right\">\n",
    "</figure>\n",
    "\n",
    "# Exploratory Computing with Python\n",
    "*Developed by Mark Bakker*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook 2: Arrays\n",
    "\n",
    "In this notebook, we will do math on arrays using functions of the `numpy` package. A nice overview of `numpy` functionality can be found [here](https://docs.scipy.org/doc/numpy/user/quickstart.html). We will also make plots. We start by telling the Jupyter Notebooks to put all graphs inline. Then we import the `numpy` package and call it `np`, and we import the plotting part of the `matplotlib` package and call it `plt`.  We will add these three lines at the top of all upcoming notebooks as we will always be using `numpy` and `matplotlib`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One-dimensional arrays\n",
    "There are many ways to create arrays. For example, you can enter the individual elements of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  7,  2, 12])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 7, 2, 12])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the `array` function takes one sequence of points between square brackets. \n",
    "Another function to create an array is `np.ones(shape)`, which creates an array of the specified `shape` filled with the value 1. \n",
    "There is an analogous function `np.zeros(shape)` to create an array filled with the value 0 (which can also be achieved with `0 * np.ones(shape)`). Next to the already mentioned `np.linspace` function there is the `np.arange(start, end, step)` \n",
    "function, which creates an array starting at `start`, taking steps equal to `step` and stopping *before* it reaches `end`. If you don't specify the `step`, \n",
    "it is set equal to 1. If you only specify one input value, it returns a sequence starting at 0 and incrementing by 1 until the specified value is reached (but again, it stops before it reaches that value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n",
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "print(np.arange(1, 7)) # Takes default steps of 1 and doesn't include 7\n",
    "print(np.arange(5)) # Starts at 0 end ends at 4, giving 5 numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that comments in Python are preceded by a `#`. \n",
    "Arrays have a dimension. So far we have only used one-dimensional arrays. \n",
    "Hence the dimension is 1. \n",
    "For one-dimensional arrays, you can also compute the length (which is part of Python and not `numpy`), which returns the number of values in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of dimensions of x: 1\n",
      "length of x: 4\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 7, 2, 12])\n",
    "print('number of dimensions of x:', np.ndim(x))\n",
    "print('length of x:', len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The individual elements of an array can be accessed with their index. Indices start at 0. \n",
    "This may require a bit of getting used to. It means that the first value in the array has index 0. The index of an array is specified using square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array x: [20 21 22 23 24 25 26 27 28 29]\n",
      "value with index 0: 20\n",
      "value with index 5: 25\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(20, 30)\n",
    "print('array x:', x)\n",
    "print('value with index 0:', x[0])\n",
    "print('value with index 5:', x[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A range of indices may be specified using the colon syntax:\n",
    "`x[start:end_before]` or `x[start:end_before:step]`. If the `start` isn't specified, 0 will be used. If the step isn't specified, 1 will be used. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20 21 22 23 24 25 26 27 28 29]\n",
      "[20 21 22 23 24]\n",
      "[20 21 22 23 24]\n",
      "[23 24 25 26]\n",
      "[22 24 26 28]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(20, 30)\n",
    "print(x)\n",
    "print(x[0:5])\n",
    "print(x[:5])  # same as previous one\n",
    "print(x[3:7])\n",
    "print(x[2:9:2])  # step is 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also start at the end and count back. Generally, the index of the end is not known. You can find out how long the array is and access the last value by typing `x[len(x) - 1]` but it would be inconvenient to have to type `len(arrayname)` all the time. Luckily, there is a shortcut: `x[-1]` is the same as `x[len(x) - 1]` and represents the last value in the array. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0 10 20 30 40 50 60 70 80 90]\n",
      "90\n",
      "90\n",
      "[90 80 70 60 50 40 30 20 10  0]\n"
     ]
    }
   ],
   "source": [
    "xvalues = np.arange(0, 100, 10)\n",
    "print(xvalues)\n",
    "print(xvalues[len(xvalues) - 1])  # last value in array\n",
    "print(xvalues[-1])  # much shorter\n",
    "print(xvalues[-1::-1])  # start at the end and go back with steps of -1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can assign one value to a range of an array by specifying a range of indices, \n",
    "or you can assign an array to a range of another array, as long as the ranges have the same length. In the last example below, the first 5 values of `x` (specified as `x[0:5]`) are given the values `[40, 42, 44, 46, 48]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20. 20. 20. 20. 20. 20. 20. 20. 20. 20.]\n",
      "[40. 40. 40. 40. 40. 20. 20. 20. 20. 20.]\n",
      "[40. 42. 44. 46. 48. 20. 20. 20. 20. 20.]\n"
     ]
    }
   ],
   "source": [
    "x = 20 * np.ones(10)\n",
    "print(x)\n",
    "x[0:5] = 40\n",
    "print(x)\n",
    "x[0:5] = np.arange(40, 50, 2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1, <a name=\"back1\"></a> Arrays and indices\n",
    "Create an array of zeros with length 20. Change the first 5 values to 10. Change the next 10 values to a sequence starting at 12 and increasig with steps of 2 to 30 (do this with one command). Set the final 5 values to 30. Plot the value of the array on the $y$-axis vs. the index of the array on the $x$-axis. Draw vertical dashed lines at $x=4$ and $x=14$ (i.e., the section between the dashed lines is where the line increases from 10 to 30). Set the minimum and maximum values of the $y$-axis to 8 and 32 using the `ylim` command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#ex1answer\">Answer for Exercise 1</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays, Lists, and Tuples\n",
    "A one-dimensional array is a sequence of values that you can do math on. Next to an array, Python has several other data types that can store a sequence of values. The first one is called a `list` and is entered between square brackets. The second one is a tuple (you are right, strange name), and it is entered with parentheses. The difference is that you can change the values in a list after you create them, and you can not do that with a tuple. Other than that, for now you just need to remember that they exist, and that you *cannot* do math with either lists or tuples. When you do `2 * alist`, where `alist` is a list, you don't multiply all values in `alist` with the number 2. What happens is that you create a new list that contains `alist` twice (so it adds them back to back). The same holds for tuples. That can be very useful, but not when your intent is to multiply all values by 2. In the example below, the first value in a list is modified. Try to modify one of the values in `btuple` below and you will see that you get an error message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alist [1, 2, 3]\n",
      "btuple (10, 20, 30)\n",
      "modified alist [7, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "alist = [1, 2, 3]\n",
    "print('alist', alist)\n",
    "btuple = (10, 20, 30)\n",
    "print('btuple', btuple)\n",
    "alist[0] = 7  # Since alist is a list, you can change values \n",
    "print('modified alist', alist)\n",
    "#btuple[0] = 100  # Will give an error\n",
    "#print(2 * alist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists and tuples are versatile data types in Python. We already used lists without realizing it when we created our first array with the command `np.array([1, 7, 2, 12])`. What we did is we gave the `array` function one input argument: the list `[1, 7, 2, 12]`, and the `array` function returned a one-dimensional array with those values. Lists and tuples can consist of a sequences of pretty much anything, not just numbers. In the example given below, `alist` contains 5 *things*: the integer 1, the float 20.0, the word `python`, an array with the values 1,2,3, and finally, the function `len`. The latter means that `alist[4]` is actually the function `len`. That function can be called to determine the length of an array as shown below. The latter may be a bit confusing, but it is cool behavior if you take the time to think about it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 20.0, 'python', array([1, 2, 3]), <built-in function len>]\n",
      "1\n",
      "python\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "alist = [1, 20.0, 'python', np.array([1,2,3]), len]\n",
    "print(alist)\n",
    "print(alist[0])\n",
    "print(alist[2])\n",
    "print(alist[4](alist[3]))  # same as len(np.array([1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Two-dimensional arrays\n",
    "Arrays may have arbitrary dimensions (as long as they fit in your computer's memory). We will make frequent use of two-dimensional arrays. They can be created with any of the aforementioned functions by specifying the number of rows and columns of the array. Note that the number of rows and columns must be a tuple (so they need to be between parentheses), as the functions expect only one input argument for the shape of the array, which may be either one number or a tuple of multiple numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.ones((3, 4)) # An array with 3 rows and 4 columns\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays may also be defined by specifying all the values in the array. The `array` function gets passed one list consisting of separate lists for each row of the array. In the example below, the rows are entered on different lines. That may make it easier to enter the array, but it is not required. You can change the size of an array to any shape using the `reshape` function as long as the total number of entries doesn't change. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 2 3 2]\n",
      " [2 4 3 1]\n",
      " [0 4 1 3]]\n",
      "[[4 2 3 2 2 4]\n",
      " [3 1 0 4 1 3]]\n",
      "[[4 2 3 2 2 4 3 1 0 4 1 3]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[4, 2, 3, 2],\n",
    "              [2, 4, 3, 1],\n",
    "              [0, 4, 1, 3]])\n",
    "print(x)\n",
    "print(np.reshape(x, (2, 6)))  # 2 rows, 6 columns\n",
    "print(np.reshape(x, (1, 12)))  # 1 row, 12 columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The index of a two-dimensional array is specified with two values, first the row index, then the column index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100.   0.   0.   0.   0.   0.   0.   0.]\n",
      " [  0.   0.   0.   0. 200. 200. 200. 200.]\n",
      " [  0.   0.   0.   0.   0. 400. 400. 400.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.zeros((3, 8))\n",
    "x[0, 0] = 100\n",
    "x[1, 4:] = 200  # Row with index 1, columns starting with 4 to the end\n",
    "x[2, -1:4:-1] = 400  # Row with index 2, columns counting back from the end with steps of 1 and stop before reaching index 4\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays are not matrices\n",
    "Now that we talk about the rows and columns of an array, the math-oriented reader may think that arrays are matrices, or that one-dimensional arrays are vectors. It is crucial to understand that *arrays are not vectors or matrices*. The multiplication and division of two arrays is term by term"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array a: [ 4  8 12 16]\n",
      "array b: [2 2 4 4]\n",
      "a * b  : [ 8 16 48 64]\n",
      "a / b  : [2. 4. 3. 4.]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(4, 20, 4)\n",
    "b = np.array([2, 2, 4, 4])\n",
    "print('array a:', a)\n",
    "print('array b:', b)\n",
    "print('a * b  :', a * b)  # term by term multiplication\n",
    "print('a / b  :', a / b)  # term by term division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2, <a name=\"back2\"></a> Two-dimensional array indices\n",
    "For the array `x` shown below, write code to print: \n",
    "\n",
    "* the first row of `x`\n",
    "* the first column of `x`\n",
    "* the third row of `x`\n",
    "* the last two columns of `x`\n",
    "* the 2 by 2 block of values in the upper right-hand corner of `x`\n",
    "* the 2 by 2 block of values at the center of `x`\n",
    "\n",
    "`x = np.array([[4, 2, 3, 2],\n",
    "               [2, 4, 3, 1],\n",
    "               [2, 4, 1, 3],\n",
    "               [4, 1, 2, 3]])`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#ex2answer\">Answer for Exercise 2</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing two-dimensional arrays\n",
    "Two-dimensonal arrays can be visualized with the `plt.matshow` function. In the example below, the array is very small (only 4 by 4), but it illustrates the general principle. A colorbar is added as a legend. The ticks in the colorbar are specified to be 2, 4, 6, and 8. Note that the first row of the array (with index 0), is plotted at the top, which corresponds to the location of the first row in the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8 4 6 2]\n",
      " [4 8 6 2]\n",
      " [4 8 2 6]\n",
      " [8 2 4 6]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.array([[8, 4, 6, 2],\n",
    "              [4, 8, 6, 2],\n",
    "              [4, 8, 2, 6],\n",
    "              [8, 2, 4, 6]])\n",
    "plt.matshow(x)\n",
    "plt.colorbar(ticks=[2, 4, 6, 8], shrink=0.8)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The colors that are used are defined in the default color map (it is called `viridis`), which maps the highest value to yellow, the lowest value to purple and the numbers in between varying between blue and green. An explanation of the advantages of `viridis` can be seen [here](https://youtu.be/xAoljeRJ3lU). If you want other colors, you can choose one of the other color maps with the `cmap` keyword argument. To find out all the available color maps, go \n",
    "[here](http://matplotlib.org/users/colormaps.html). For example, setting the color map to `rainbow` gives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.matshow(x, cmap='rainbow')\n",
    "plt.colorbar(ticks=np.arange(2, 9, 2), shrink=0.8);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3, <a name=\"back3\"></a> Create and visualize an array\n",
    "Create an array of size 10 by 10. Set the upper left-hand quadrant of the array should to 4, the upper right-hand quadrant to 3, the lower right-hand quadrant t0 2 and the lower left-hand quadrant to 1. First create an array of 10 by 10 using the `zeros` command, then fill each quadrant by specifying the correct index ranges. Visualize the array using `matshow`. It should give a red, yellow, light blue and dark blue box (clock-wise starting from upper left) when you use the `jet` colormap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#ex3answer\">Answer for Exercise 3</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4, <a name=\"back4\"></a> Create and visualize a slightly fancier array\n",
    "Consider the image shown below, which roughly shows the letters TU. You are asked to create an array that represents the same TU. First create a zeros array of 11 rows and 17 columns. Give the background value 0, the letter T value -1, and the letter U value +1. Use the `jet` colormap. <a name=\"back4\"></a>\n",
    "\n",
    "![](tufig.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#ex4answer\">Answer to Exercise 4</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using conditions on arrays\n",
    "If you have a variable, you can check whether its value is smaller or larger than a certain other value. This is called a *conditional* statement.\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a < 2: False\n",
      "a > 2: True\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "print('a < 2:', a < 2)\n",
    "print('a > 2:', a > 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The statement `a < 2` returns a variable of type boolean, which means it can either be `True` or `False`. Besides smaller than or larger than, there are several other conditions you can use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the value of a is 4\n",
      "a < 4:  False\n",
      "a <= 4: True\n",
      "a == 4: True\n",
      "a >= 4: True\n",
      "a > 4:  False\n",
      "a != 4: False\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "print('the value of a is', a)\n",
    "print('a < 4: ', a < 4)\n",
    "print('a <= 4:', a <= 4) # a is smaller than or equal to 4\n",
    "print('a == 4:', a == 4) # a is equal to 4. Note that there are 2 equal signs\n",
    "print('a >= 4:', a >= 4) \n",
    "print('a > 4: ', a > 4)\n",
    "print('a != 4:', a != 4) # a is not equal to 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to understand the difference between one equal sign like `a = 4` and two equal signs like `a == 4`. One equal sign means assignment. Whatever is on the right side of the equal sign is assigned to what is on the left side of the equal sign. Two equal signs is a comparison and results in either `True` (when both sides are equal) or `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(4 == 4)\n",
    "a = 4 == 5\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also perform comparison statements on arrays, and it will return an array of booleans (`True` and `False` values) for each value in the array. For example let's create an array and find out what values of the array are below 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "[ True  True  True False False]\n"
     ]
    }
   ],
   "source": [
    "data = np.arange(5)\n",
    "print(data)\n",
    "print(data < 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The statement `data < 3` returns an array of type `boolean` that has the same length as the array `data` and for each item in the array it is either `True` or `False`. The cool thing is that this array of `True` and `False` values can be used to specify the indices of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "[0 1 4]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(5)\n",
    "print(a)\n",
    "print(a[[True, True, False, False, True]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the indices of an array are specified with a boolean array, only the values of the array where the boolean array is `True` are selected. This is a very powerful feature. For example, all values of an array that are less than, for example, 3 may be obtained by specifying a condition as the indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the total array: [0 1 2 3 4]\n",
      "values less than 3: [0 1 2]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(5)\n",
    "print('the total array:', a)\n",
    "print('values less than 3:', a[a < 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to replace all values that are less than 3 by, for example, the value 10, use the following short syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "[10 10 10  3  4]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(5)\n",
    "print(a)\n",
    "a[a < 3] = 10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5, <a name=\"back5\"></a> Replace high and low values in an array\n",
    "Create an array for variable $x$ consisting of 100 values from 0 to 20. Compute $y=\\sin(x)$ and plot $y$ vs. $x$ with a blue line. Next, replace all values of $y$ that are larger than 0.5 by 0.5, and all values that are smaller than $-$0.75 by $-$0.75, and plot the modified $y$ values vs. $x$ using a red line on the same graph. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#ex5answer\">Answer to Exercise 5</a>\n",
    "\n",
    "### Exercise 6, <a name=\"back6\"></a> Change marker color based on data value\n",
    "Create an array for variable $x$ consisting of 100 points from 0 to 20 and compute $y=\\sin(x)$. Plot a blue dot for every $y$ that is larger than zero, and a red dot otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#ex6answer\">Answer to Exercise 6</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Select indices based on multiple conditions\n",
    "Multiple conditions can be given as well. When two conditions both have to be true, use the `&` symbol. When at least one of the conditions needs to be true, use the '|' symbol (that is the vertical bar). For example, let's plot $y=\\sin(x)$ and plot blue markers when $y>0.7$ or $y<-0.5$ (using one `plot` statement), and a red marker when $-0.5\\le y\\le 0.7$. Note that when there are multiple conditions, they need to be between parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 6 * np.pi, 50)\n",
    "y = np.sin(x)\n",
    "plt.plot(x[(y > 0.7) | (y < -0.5)], y[(y > 0.7) | (y < -0.5)], 'bo')\n",
    "plt.plot(x[(y > -0.5) & (y < 0.7)], y[(y > -0.5) & (y < 0.7)], 'ro');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 7, <a name=\"back7\"></a> Multiple conditions \n",
    "The file `xypoints.dat` contains 1000 randomly chosen $x,y$ locations of points; both $x$ and $y$ vary between -10 and 10. Load the data using `loadtxt`, and store the first row of the array in an array called `x` and the second row in an array called `y`. First, plot a red dot for all points. On the same graph, plot a blue dot for all $x,y$ points where $x<-2$ and $-5\\le y \\le 0$. Finally, plot a green dot for any point that lies in the circle with center $(x_c,y_c)=(5,0)$ and with radius $R=5$. Hint: it may be useful to compute a new array for the radial distance $r$ between any point and the center of the circle using the formula $r=\\sqrt{(x-x_c)^2+(y-y_c)^2}$. Use the `plt.axis('equal')` command to make sure the scales along the two axes are equal and the circular area looks like a circle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#ex7answer\">Answer to Exercise 7</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 8, <a name=\"back8\"></a> Fix the error \n",
    "In the code below, it is meant to give the last 5 values of the array `x` the values [50, 52, 54, 56, 58] and print the result to the screen, but there are some errors in the code. Remove the comment markers and run the code to see the error message. Then fix the code and run it again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#x = np.ones(10)\n",
    "#x[5:] = np.arange(50, 62, 1)\n",
    "#print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#ex8answer\">Answer to Exercise 8</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answers to the exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"ex1answer\">Answer to Exercise 1</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.zeros(20)\n",
    "x[:5] = 10\n",
    "x[5:15] = np.arange(12, 31, 2)\n",
    "x[15:] = 30\n",
    "plt.plot(x)\n",
    "plt.plot([4, 4], [8, 32],'k--')\n",
    "plt.plot([14, 14], [8, 32],'k--')\n",
    "plt.ylim(8, 32);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#back1\">Back to Exercise 1</a>\n",
    "\n",
    "<a name=\"ex2answer\">Answer to Exercise 2</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the first row of x\n",
      "[4 2 3 2]\n",
      "the first column of x\n",
      "[4 2 2 4]\n",
      "the third row of x\n",
      "[2 4 1 3]\n",
      "the last two columns of x\n",
      "[[3 2]\n",
      " [3 1]\n",
      " [1 3]\n",
      " [2 3]]\n",
      "the four values in the upper right hand corner\n",
      "[[3 2]\n",
      " [3 1]]\n",
      "the four values at the center of x\n",
      "[[4 3]\n",
      " [4 1]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[4, 2, 3, 2],\n",
    "              [2, 4, 3, 1],\n",
    "              [2, 4, 1, 3],\n",
    "              [4, 1, 2, 3]])\n",
    "print('the first row of x')\n",
    "print(x[0])\n",
    "print('the first column of x')\n",
    "print(x[:, 0])\n",
    "print('the third row of x')\n",
    "print(x[2])\n",
    "print('the last two columns of x')\n",
    "print(x[:, -2:])\n",
    "print('the four values in the upper right hand corner')\n",
    "print(x[:2, 2:])\n",
    "print('the four values at the center of x')\n",
    "print(x[1:3, 1:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#back2\">Back to Exercise 2</a>\n",
    "\n",
    "<a name=\"ex3answer\">Answer to Exercise 3</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4. 4. 4. 4. 4. 3. 3. 3. 3. 3.]\n",
      " [4. 4. 4. 4. 4. 3. 3. 3. 3. 3.]\n",
      " [4. 4. 4. 4. 4. 3. 3. 3. 3. 3.]\n",
      " [4. 4. 4. 4. 4. 3. 3. 3. 3. 3.]\n",
      " [4. 4. 4. 4. 4. 3. 3. 3. 3. 3.]\n",
      " [1. 1. 1. 1. 1. 2. 2. 2. 2. 2.]\n",
      " [1. 1. 1. 1. 1. 2. 2. 2. 2. 2.]\n",
      " [1. 1. 1. 1. 1. 2. 2. 2. 2. 2.]\n",
      " [1. 1. 1. 1. 1. 2. 2. 2. 2. 2.]\n",
      " [1. 1. 1. 1. 1. 2. 2. 2. 2. 2.]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.zeros((10, 10))\n",
    "x[:5, :5] = 4\n",
    "x[:5, 5:] = 3\n",
    "x[5:, 5:] = 2\n",
    "x[5:, :5] = 1\n",
    "print(x)\n",
    "plt.matshow(x, cmap='jet')\n",
    "plt.colorbar(ticks=[1, 2, 3, 4], shrink=0.8);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#back3\">Back to Exercise 3</a>\n",
    "\n",
    "<a name=\"ex4answer\">Answer to Exercise 4</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
      " [ 0. -1. -1. -1. -1. -1. -1.  0.  1.  1.  0.  0.  0.  1.  1.  0.  0.]\n",
      " [ 0. -1. -1. -1. -1. -1. -1.  0.  1.  1.  0.  0.  0.  1.  1.  0.  0.]\n",
      " [ 0.  0.  0. -1. -1.  0.  0.  0.  1.  1.  0.  0.  0.  1.  1.  0.  0.]\n",
      " [ 0.  0.  0. -1. -1.  0.  0.  0.  1.  1.  0.  0.  0.  1.  1.  0.  0.]\n",
      " [ 0.  0.  0. -1. -1.  0.  0.  0.  1.  1.  0.  0.  0.  1.  1.  0.  0.]\n",
      " [ 0.  0.  0. -1. -1.  0.  0.  0.  1.  1.  1.  1.  1.  1.  1.  0.  0.]\n",
      " [ 0.  0.  0. -1. -1.  0.  0.  0.  1.  1.  1.  1.  1.  1.  1.  0.  0.]\n",
      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 445.091x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.zeros((11, 17))\n",
    "x[2:4, 1:7] = -1\n",
    "x[2:9, 3:5] = -1\n",
    "x[2:9, 8:10] = 1\n",
    "x[2:9, 13:15] = 1\n",
    "x[7:9, 10:13] = 1\n",
    "print(x)\n",
    "plt.matshow(x, cmap='jet')\n",
    "plt.yticks(range(11, -1, -1))\n",
    "plt.xticks(range(0, 17));\n",
    "plt.ylim(10.5, -0.5)\n",
    "plt.xlim(-0.5, 16.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#back4\">Back to Exercise 4</a>\n",
    "\n",
    "<a name=\"ex5answer\">Answer to Exercise 5</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 20, 100)\n",
    "y = np.sin(x)\n",
    "plt.plot(x, y, 'b')\n",
    "y[y > 0.5] = 0.5\n",
    "y[y < -0.75] = -0.75\n",
    "plt.plot(x, y, 'r');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#back5\">Back to Exercise 5</a>\n",
    "\n",
    "<a name=\"ex6answer\">Answer to Exercise 6</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 20, 100)\n",
    "y = np.sin(x)\n",
    "plt.plot(x[y > 0], y[y > 0], 'bo')\n",
    "plt.plot(x[y <= 0], y[y <= 0], 'ro');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#back6\">Back to Exercise 6</a>\n",
    "\n",
    "<a name=\"ex7answer\">Answer to Exercise 7</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x, y = np.loadtxt('xypoints.dat')\n",
    "plt.plot(x, y, 'ro')\n",
    "plt.plot(x[(x < -2) & (y >= -5) & (y < 0)], y[(x < -2) & (y >= -5) & (y < 0)], 'bo')\n",
    "r = np.sqrt((x - 5) ** 2 + y ** 2)\n",
    "plt.plot(x[r < 5], y[r < 5], 'go')\n",
    "plt.axis('scaled');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#back7\">Back to Exercise 7</a>\n",
    "\n",
    "<a name=\"ex8answer\">Answer to Exercise 8</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  1.  1.  1.  1. 50. 52. 54. 56. 58.]\n"
     ]
    }
   ],
   "source": [
    "x = np.ones(10)\n",
    "x[5:] = np.arange(50, 60, 2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"#back8\">Back to Exercise 8</a>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.2"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}