Notebooks/02.0 NumPy arrays.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RAW NOTES: not for actual use"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is an efficiency advantage when you know that all elements of a sequence, such as a list, are of the same type. Methods for arrays execute a lot faster than those for lists.\n",
    "\n",
    "Luckily, groups and organizations have been busy for many years creating **libraries** that create and process these arrays for certain applications.\n",
    "\n",
    "The most important library in science and engineering is **NumPy**, providing the _n-dimensional array_ data structure (a.k.a, `ndarray`) and a wealth of functions, operations and algorithms for efficient linear-algebra computations.\n",
    "\n",
    "We will use NumPy arrays and discover their power. Later we will also use another widely used library: **Matplotlib**, for creating two-dimensional plots of these data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TODO: create from a list-of-lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array operations\n",
    "\n",
    "Let's assign some arrays to variable names and perform some operations with them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_array = np.linspace(-1, 1, 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Now that we've saved it with a variable name, we can do some computations with the array. E.g., take the square of every element of the array, in one go:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.     0.5625 0.25   0.0625 0.     0.0625 0.25   0.5625 1.    ]\n"
     ]
    }
   ],
   "source": [
    "y_array = x_array**2\n",
    "print(y_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also take the square root of a positive array, using the `numpy.sqrt()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.   0.75 0.5  0.25 0.   0.25 0.5  0.75 1.  ]\n"
     ]
    }
   ],
   "source": [
    "z_array = np.sqrt(y_array)\n",
    "print(z_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have different arrays `x_array`, `y_array` and `z_array`, we can do more computations, like add or multiply them. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.     -0.1875 -0.25   -0.1875  0.      0.3125  0.75    1.3125  2.    ]\n"
     ]
    }
   ],
   "source": [
    "add_array = x_array + y_array \n",
    "print(add_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array addition is defined element-wise, like when adding two vectors (or matrices). Array multiplication is also element-wise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.     -0.5625 -0.25   -0.0625  0.      0.0625  0.25    0.5625  1.    ]\n"
     ]
    }
   ],
   "source": [
    "mult_array = x_array * z_array\n",
    "print(mult_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also divide arrays, but you have to be careful not to divide by zero. This operation will result in a **`nan`** which stands for *Not a Number*. Python will still perform the division, but will tell us about the problem.  \n",
    "\n",
    "Let's see how this might look:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/kevindunn/anaconda/lib/python3.5/site-packages/ipykernel/__main__.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
      "  if __name__ == '__main__':\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([-1.        , -1.33333333, -2.        , -4.        ,         nan,\n",
       "        4.        ,  2.        ,  1.33333333,  1.        ])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_array / y_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multidimensional arrays\n",
    "\n",
    "### 2D arrays \n",
    "\n",
    "NumPy can create arrays of N dimensions.  For example, a 2D array is like a matrix, and is created from a nested list as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "array_2d = np.array([[1, 2], [3, 4]])\n",
    "print(array_2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2D arrays can be added, subtracted, and multiplied:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array([[1, 2], [3, 4]])\n",
    "Y = np.array([[1, -1], [0, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The addition of these two matrices works exactly as you would expect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 1],\n",
       "       [3, 5]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X + Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we try to multiply arrays using the `'*'`operator?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1, -2],\n",
       "       [ 0,  4]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X * Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The multiplication using the `'*'` operator is element-wise. If we want to do matrix multiplication we use the `'@'` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [3, 1]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X @ Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or equivalently we can use `numpy.dot()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [3, 1]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3D arrays\n",
    "\n",
    "Let's create a 3D array by reshaping a 1D array. We can use [`numpy.reshape()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html), where we pass the array we want to reshape and the shape we want to give it, i.e., the number of elements in each dimension. \n",
    "\n",
    "*Syntax*\n",
    " \n",
    "`numpy.reshape(array, newshape)`\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]\n",
      "  [ 8  9 10 11]]\n",
      "\n",
      " [[12 13 14 15]\n",
      "  [16 17 18 19]\n",
      "  [20 21 22 23]]]\n"
     ]
    }
   ],
   "source": [
    "a_3D = np.reshape(a, (2, 3, 4))\n",
    "print(a_3D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check for the shape of a NumPy array using the function `numpy.shape()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 4)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(a_3D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualizing the dimensions of the `a_3D` array can be tricky, so here is a diagram that will help you to understand how the dimensions are assigned: each dimension is shown as  a coordinate axis. For a 3D array, on the \"x axis\", we have the sub-arrays that themselves are two-dimensional (matrices). We have two of these 2D sub-arrays, in this case; each one has 3 rows and 4 columns. Study this sketch carefully, while comparing with how the array `a_3D` is printed out above. \n",
    "\n",
    "<img src=\"images/3d_array_sketch.png\" style=\"width: 400px;\"/> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "When we have multidimensional arrays, we can access slices of their elements by slicing on each dimension. This is one of the advantages of using arrays: we cannot do this with lists. \n",
    "\n",
    "Let's access some elements of our 2D array called `X`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab the element in the 1st row and 1st column \n",
    "X[0, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab the element in the 1st row and 2nd column \n",
    "X[0, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercises:\n",
    "\n",
    "From the X array:\n",
    "\n",
    "1. Grab the 2nd element in the 1st column.\n",
    "2. Grab the 2nd element in the 2nd column."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play with slicing on this array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab the 1st column\n",
    "X[:, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we don't specify the start and/or end point in the slicing, the symbol `':'` means \"all\". In the example above, we are telling NumPy that we want all the elements from the 0-th index in the second dimension (the first column)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab the 1st row\n",
    "X[0, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercises:\n",
    "\n",
    "From the X array:\n",
    "\n",
    "1. Grab the 2nd column.\n",
    "2. Grab the 2nd row."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's practice with a 3D array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14, 15],\n",
       "        [16, 17, 18, 19],\n",
       "        [20, 21, 22, 23]]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_3D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to grab the first column of both matrices in our `a_3D` array, we do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  4,  8],\n",
       "       [12, 16, 20]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_3D[:, :, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The line above is telling NumPy that we want:\n",
    "\n",
    "* first `':'` : from the first dimension, grab all the elements (2 matrices).\n",
    "* second `':'`: from the second dimension, grab all the elements (all the rows).\n",
    "* `'0'`       : from the third dimension, grab the first element (first column).\n",
    "\n",
    "If we want the first 2 elements of the first column of both matrices: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  4],\n",
       "       [12, 16]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_3D[:, 0:2, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, from the first matrix in our `a_3D` array, we will grab the two middle elements (5,6):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_3D[0, 1, 1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercises:\n",
    "\n",
    "From the array named `a_3D`: \n",
    "\n",
    "1. Grab the two middle elements (17, 18) from the second matrix.\n",
    "2. Grab the last row from both matrices.\n",
    "3. Grab the elements of the 1st matrix that exclude the first row and the first column. \n",
    "4. Grab the elements of the 2nd matrix that exclude the last row and the last column. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy == Fast and Clean! \n",
    "\n",
    "When we are working with numbers, arrays are a better option because the NumPy library has built-in functions that are optimized, and therefore faster than vanilla Python. Especially if we have big arrays. Besides, using NumPy arrays and exploiting their properties makes our code more readable.\n",
    "\n",
    "For example, if we wanted to add element-wise the elements of 2 lists, we need to do it with a `for` statement. If we want to add two NumPy arrays, we just use the addtion `'+'` symbol!\n",
    "\n",
    "Below, we will add two lists and two arrays (with random elements) and we'll compare the time it takes to compute each addition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element-wise sum of a Python list\n",
    "\n",
    "Using the Python library [`random`](https://docs.python.org/3/library/random.html), we will generate two lists with 100 pseudo-random elements in the range [0,100), with no numbers repeated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import random library\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_1 = random.sample(range(100), 100)\n",
    "lst_2 = random.sample(range(100), 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 56, 85, 82, 97, 59, 8, 28, 61, 54]\n",
      "[31, 22, 59, 34, 71, 39, 35, 99, 49, 44]\n"
     ]
    }
   ],
   "source": [
    "#print first 10 elements\n",
    "print(lst_1[0:10])\n",
    "print(lst_2[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to write a `for` statement, appending the result of the element-wise sum into a new list we call `result_lst`. \n",
    "\n",
    "For timing, we can use the IPython \"magic\" `%%time`. Writing at the beginning of the code cell the command `%%time` will give us the time it takes to execute all the code in that cell. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 57 µs, sys: 0 ns, total: 57 µs\n",
      "Wall time: 62.9 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "res_lst = []\n",
    "for i in range(100):\n",
    "    res_lst.append(lst_1[i] + lst_2[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[32, 78, 144, 116, 168, 98, 43, 127, 110, 98]\n"
     ]
    }
   ],
   "source": [
    "print(res_lst[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element-wise sum of NumPy arrays\n",
    "\n",
    "In this case, we generate arrays with random integers using the NumPy function [`numpy.random.randint()`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.random.randint.html). The arrays we generate with this function are not going to be like the lists: in this case we'll have 100 elements in the range [0, 100) but they can repeat. Our goal is to compare the time it takes to compute addition of a _list_ or an _array_ of numbers, so all that matters is that the arrays and the lists are of the same length and type (integers)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr_1 = numpy.random.randint(0, 100, size=100)\n",
    "arr_2 = numpy.random.randint(0, 100, size=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[35 57 92 62 59 95 92 14 23 31]\n",
      "[ 3 25 51  2 51 69 86 17 72 92]\n"
     ]
    }
   ],
   "source": [
    "#print first 10 elements\n",
    "print(arr_1[0:10])\n",
    "print(arr_2[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use the `%%time` cell magic, again, to see how long it takes NumPy to compute the element-wise sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 20 µs, sys: 0 ns, total: 20 µs\n",
      "Wall time: 24.8 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "arr_res = arr_1 + arr_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that in the case of arrays, the code not only is more readable (just one line of code), but it is also faster than with lists. This time advantage will be larger with bigger arrays/lists. \n",
    "\n",
    "(Your timing results may vary to the ones we show in this notebook, because you will be computing in a different machine.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "\n",
    "1. Try the comparison between lists and arrays, using bigger arrays; for example, of size 10,000. \n",
    "2. Repeat the analysis, but now computing the operation that raises each element of an array/list to the power two. Use arrays of 10,000 elements. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Time to Plot\n",
    "\n",
    "You will love the Python library **Matplotlib**! You'll learn here about its module `pyplot`, which makes line plots. \n",
    "\n",
    "We need some data to plot. Let's define a NumPy array, compute derived data using its square, cube and square root (element-wise), and plot these values with the original array in the x-axis. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.   0.05 0.1  0.15 0.2  0.25 0.3  0.35 0.4  0.45 0.5  0.55 0.6  0.65\n",
      " 0.7  0.75 0.8  0.85 0.9  0.95 1.   1.05 1.1  1.15 1.2  1.25 1.3  1.35\n",
      " 1.4  1.45 1.5  1.55 1.6  1.65 1.7  1.75 1.8  1.85 1.9  1.95 2.  ]\n"
     ]
    }
   ],
   "source": [
    "xarray = numpy.linspace(0, 2, 41)\n",
    "print(xarray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "pow2 = xarray**2\n",
    "pow3 = xarray**3\n",
    "pow_half = numpy.sqrt(xarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To plot the resulting arrays as a function of the orginal one (`xarray`) in the x-axis, we need to import the module `pyplot` from **Matplotlib**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The command `%matplotlib inline` is there to get our plots inside the notebook (instead of a pop-up window, which is the default behavior of `pyplot`). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll use the `pyplot.plot()` function, specifying the line color (`'k'` for black) and line style (`'-'`, `'--'` and `':'` for continuous, dashed and dotted line), and giving each line a label. Note that the values for `color`, `linestyle` and `label` are given in quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x116a0e160>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot x^2\n",
    "pyplot.plot(xarray, pow2, color='k', linestyle='-', label='square')\n",
    "#Plot x^3\n",
    "pyplot.plot(xarray, pow3, color='k', linestyle='--', label='cube')\n",
    "#Plot sqrt(x)\n",
    "pyplot.plot(xarray, pow_half, color='k', linestyle=':', label='square root')\n",
    "#Plot the legends in the best location\n",
    "pyplot.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To illustrate other features, we will plot the same data, but varying the colors instead of the line style. We'll also use LaTeX syntax to write formulas in the labels. If you want to know more about LaTeX syntax, there is a [quick guide to LaTeX](https://users.dickinson.edu/~richesod/latex/latexcheatsheet.pdf) available online.\n",
    "\n",
    "Adding a semicolon (`';'`) to the last line in the plotting code block prevents that ugly output, like `<matplotlib.legend.Legend at 0x7f8c83cc7898>`. Try it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot x^2\n",
    "pyplot.plot(xarray, pow2, color='red', linestyle='-', label='$x^2$')\n",
    "#Plot x^3\n",
    "pyplot.plot(xarray, pow3, color='green', linestyle='-', label='$x^3$')\n",
    "#Plot sqrt(x)\n",
    "pyplot.plot(xarray, pow_half, color='blue', linestyle='-', label='$\\sqrt{x}$')\n",
    "#Plot the legends in the best location\n",
    "pyplot.legend(loc='best'); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's very nice! By now, you are probably imagining all the great stuff you can do with Jupyter notebooks, Python and its scientific libraries **NumPy** and **Matplotlib**. We just saw an introduction to plotting but we will keep learning about the power of **Matplotlib** in the next lesson. \n",
    "\n",
    "If you are curious, you can explore all the beautiful plots you can make by browsing the [Matplotlib gallery](http://matplotlib.org/gallery.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise:\n",
    "\n",
    "Pick two different operations to apply to the `xarray` and plot them the resulting data in the same plot. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What we've learned\n",
    "\n",
    "* How to import libraries\n",
    "* Multidimensional arrays using NumPy\n",
    "* Accessing values and slicing in NumPy arrays\n",
    "* `%%time` magic to time cell execution.\n",
    "* Performance comparison: lists vs NumPy arrays\n",
    "* Basic plotting with `pyplot`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "1. _Effective Computation in Physics: Field Guide to Research with Python_ (2015). Anthony Scopatz & Kathryn D. Huff. O'Reilly Media, Inc.\n",
    "\n",
    "2. _Numerical Python: A Practical Techniques Approach for Industry_. (2015). Robert Johansson. Appress. \n",
    "\n",
    "2. [\"The world of Jupyter\"—a tutorial](https://github.com/barbagroup/jupyter-tutorial). Lorena A. Barba - 2016"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: '../style/custom.css'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-51-12e3791f5308>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mIPython\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdisplay\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mHTML\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mcss_file\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'../style/custom.css'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mHTML\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcss_file\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"r\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '../style/custom.css'"
     ]
    }
   ],
   "source": [
    "# Execute this cell to load the notebook's style sheet, then ignore it\n",
    "from IPython.core.display import HTML\n",
    "css_file = '../style/custom.css'\n",
    "HTML(open(css_file, \"r\").read())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.5"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}