Lecture-3-Introduction-to-Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy -  multidimensional data arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is a copy of J.R. Johansson's excellent [Numpy notebook](https://github.com/jrjohansson/scientific-python-lectures/blob/master/Lecture-2-Numpy.ipynb) with some additional examples from [Jessica B. Hamrick's Numpy notebook](https://github.com/jhamrick/nbgrader-demo/blob/master/instructor/source/ps1/3%20-%20Introduction%20to%20NumPy.ipynb)"
   ]
  },
  {
   "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": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `numpy` package (module) is used in almost all numerical computation using Python. It is a package that provide high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and Fortran so when calculations are vectorized (formulated with vectors and matrices), performance is very good. \n",
    "\n",
    "To use `numpy` you need to import the module, using for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the `numpy` package the terminology used for vectors, matrices and higher-dimensional data sets is *array*. \n",
    "\n",
    "NumPy is incredibly powerful and has many features, but this can be a bit intimidating when you're first starting to use it. If you are familiar with other scientific computing languages, the following guides may be of use:\n",
    "\n",
    "- NumPy for Matlab Users: http://mathesaurus.sourceforge.net/matlab-numpy.html\n",
    "- NumPy for R (and S-Plus) Users: http://mathesaurus.sourceforge.net/r-numpy.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating `numpy` arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a number of ways to initialize new numpy arrays, for example from\n",
    "\n",
    "* a Python list or tuples\n",
    "* using functions that are dedicated to generating numpy arrays, such as `arange`, `linspace`, etc.\n",
    "* reading data from files\n",
    "\n",
    "\n",
    "| Numpy function | What it does ?                                                                                                        |\n",
    "|----------------|-----------------------------------------------------------------------------------------------------------------------|\n",
    "| np.array       | Convert array like python object to NumPy array                                                                       |\n",
    "| np.arange      | Create arrays with regularly incrementing values.                                                                     |\n",
    "| np.ones        | Create an array filled with 1 values                                                                                  |\n",
    "| np.zeros       | Create an array filled with 0 values                                                                                  |\n",
    "| np.full        | Create an array filled with the specified value                                                                       |\n",
    "| np.random.rand | Generate arrays of random values in the specified shape                                                               |\n",
    "| np.linspace    | Create arrays with a specified number of elements, and spaced equally between the specified beginning and end values. |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing that you can do with lists that you cannot do with NumPy arrays is adding and removing elements. For example, I can create a list and then add elements to it with append:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = []\n",
    "mylist.append(7)\n",
    "mylist.append(2)\n",
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, you cannot do this with NumPy arrays. If you tried to run the following code, for example:\n",
    "\n",
    "    myarray = np.array([])\n",
    "    myarray.append(7)\n",
    "You'd get an error like this:\n",
    "\n",
    "    ---------------------------------------------------------------------------\n",
    "    AttributeError                            Traceback (most recent call last)\n",
    "    <ipython-input-25-0017a7f2667c> in <module>()\n",
    "          1 myarray = np.array([])\n",
    "    ----> 2 myarray.append(7)\n",
    "\n",
    "    AttributeError: 'numpy.ndarray' object has no attribute 'append'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">To create a NumPy array, you must create an array with the correct shape from the beginning. However, the array doesn't have to have all the correct values from the very beginning: these you can fill in later.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, to create new vector and matrix arrays from Python lists we can use the `numpy.array` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a vector: the argument to the array function is a Python list\n",
    "v = np.array([1,2,3,4])\n",
    "\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a matrix: the argument to the array function is a nested Python list\n",
    "M = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `v` and `M` objects are both of the type `ndarray` that the `numpy` module provides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v), type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference between the `v` and `M` arrays is only their shapes. We can get information about the shape of an array by using the `ndarray.shape` property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of elements in the array is available through the `ndarray.size` property:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equivalently, we could use the function `numpy.shape` and `numpy.size`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.size(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some of the important attributes of a NumPy object are:\n",
    "\n",
    "- **ndim**: displays the dimension of the array\n",
    "- **shape**: returns a tuple of integers indicating the size of the array\n",
    "- **size**: returns the total number of elements in the NumPy array\n",
    "- **dtype**: returns the type of elements in the array, i.e., int64, character\n",
    "- **itemsize**: returns the size in bytes of each item\n",
    "- **reshape**: Reshapes the NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "ndim: 2\n",
      "shape: (2,2)\n",
      "size: 4\n",
      "dtype: int64\n",
      "itemsize: 8\n"
     ]
    }
   ],
   "source": [
    "print(M)\n",
    "print(\"ndim: %s\" % M.ndim)\n",
    "print(\"shape: (%s,%s)\" % M.shape)\n",
    "print(\"size: %s\" % M.size)\n",
    "print(\"dtype: %s\" % M.dtype)\n",
    "print(\"itemsize: %s\" % M.itemsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far the `numpy.ndarray` looks awefully much like a Python list (or nested list). Why not simply use Python lists for computations instead of creating a new array type? \n",
    "\n",
    "There are several reasons:\n",
    "\n",
    "* Python lists are very general. They can contain any kind of object. They are dynamically typed. They do not support mathematical functions such as matrix and dot multiplications, etc. Implementing such functions for Python lists would not be very efficient because of the dynamic typing.\n",
    "* Numpy arrays are **statically typed** and **homogeneous**. The type of the elements is determined when the array is created.\n",
    "* Numpy arrays are memory efficient.\n",
    "* Because of the static typing, fast implementation of mathematical functions such as multiplication and addition of `numpy` arrays can be implemented in a compiled language (C and Fortran is used).\n",
    "\n",
    "Using the `dtype` (data type) property of an `ndarray`, we can see what type the data of an array has:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get an error if we try to assign a value of the wrong type to an element in a numpy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'hello'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-e1f336250f69>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'hello'"
     ]
    }
   ],
   "source": [
    "M[0,0] = \"hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want, we can explicitly define the type of the array data when we create it, using the `dtype` keyword argument: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 2.+0.j],\n",
       "       [3.+0.j, 4.+0.j]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4]], dtype=complex)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Common data types that can be used with `dtype` are: `int`, `float`, `complex`, `bool`, `object`, etc.\n",
    "\n",
    "We can also explicitly define the bit size of the data types, for example: `int64`, `int16`, `float128`, `complex128`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using array-generating functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For larger arrays it is inpractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in `numpy` that generate arrays of different forms. Some of the more common are:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a range\n",
    "\n",
    "x = np.arange(0, 10, 1) # arguments: start, stop, step\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.00000000e+00, -9.00000000e-01, -8.00000000e-01, -7.00000000e-01,\n",
       "       -6.00000000e-01, -5.00000000e-01, -4.00000000e-01, -3.00000000e-01,\n",
       "       -2.00000000e-01, -1.00000000e-01, -2.22044605e-16,  1.00000000e-01,\n",
       "        2.00000000e-01,  3.00000000e-01,  4.00000000e-01,  5.00000000e-01,\n",
       "        6.00000000e-01,  7.00000000e-01,  8.00000000e-01,  9.00000000e-01])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(-1, 1, 0.1)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### linspace and logspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.41666667,  0.83333333,  1.25      ,  1.66666667,\n",
       "        2.08333333,  2.5       ,  2.91666667,  3.33333333,  3.75      ,\n",
       "        4.16666667,  4.58333333,  5.        ,  5.41666667,  5.83333333,\n",
       "        6.25      ,  6.66666667,  7.08333333,  7.5       ,  7.91666667,\n",
       "        8.33333333,  8.75      ,  9.16666667,  9.58333333, 10.        ])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using linspace, both end points ARE included\n",
    "np.linspace(0, 10, 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 3.03773178e+00, 9.22781435e+00, 2.80316249e+01,\n",
       "       8.51525577e+01, 2.58670631e+02, 7.85771994e+02, 2.38696456e+03,\n",
       "       7.25095809e+03, 2.20264658e+04])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(0, 10, 10, base=np.e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mgrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = np.mgrid[0:5, 0:5] # similar to meshgrid in MATLAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [1, 1, 1, 1, 1],\n",
       "       [2, 2, 2, 2, 2],\n",
       "       [3, 3, 3, 3, 3],\n",
       "       [4, 4, 4, 4, 4]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### random data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.46526486, 0.33545356, 0.60485063, 0.10888525, 0.21841283],\n",
       "       [0.33011199, 0.77173134, 0.07957271, 0.51510697, 0.8117858 ],\n",
       "       [0.1332732 , 0.43125213, 0.61207266, 0.3399414 , 0.66002201],\n",
       "       [0.17587285, 0.40338213, 0.69172738, 0.28493616, 0.41446249],\n",
       "       [0.69950479, 0.69028249, 0.22255598, 0.92074117, 0.15612409]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# uniform random numbers in [0,1]\n",
    "np.random.rand(5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.49666774, -1.56162203,  0.00368648,  0.50829911,  0.95300545],\n",
       "       [-1.60435585, -0.24507547,  1.9259452 ,  0.73512728,  0.1072572 ],\n",
       "       [-0.02770074, -0.25417772, -1.66703327, -0.56003105,  0.70634163],\n",
       "       [-2.60957982, -0.07397441,  0.8594729 , -1.05122938,  1.53023372],\n",
       "       [ 1.3725573 , -1.18358119,  0.10393433,  0.65242178,  0.862934  ]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# standard normal distributed random numbers\n",
    "np.random.randn(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a diagonal matrix\n",
    "np.diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 0],\n",
       "       [0, 0, 2, 0],\n",
       "       [0, 0, 0, 3],\n",
       "       [0, 0, 0, 0]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diagonal with offset from the main diagonal\n",
    "np.diag([1,2,3], k=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### zeros and ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array computations\n",
    "\n",
    "So far, NumPy arrays seem basically the same as regular lists. What's the big deal about them?\n",
    "\n",
    "### Working with single arrays\n",
    "\n",
    "One advantage of using NumPy arrays over lists is the ability to do a computation over the entire array. For example, if you were using lists and wanted to add one to every element of the list, here's how you would do it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 7, 2, 1, 11, 23]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [3, 6, 1, 0, 10, 22]\n",
    "mylist_plus1 = []\n",
    "for x in mylist:\n",
    "    mylist_plus1.append(x + 1)\n",
    "mylist_plus1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, you could use a list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 7, 2, 1, 11, 23]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [3, 6, 1, 0, 10, 22]\n",
    "mylist_plus1 = [x + 1 for x in mylist]\n",
    "mylist_plus1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In contrast, adding one to every element of a NumPy array is far simpler:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  7,  2,  1, 11, 23])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray = np.array([3, 6, 1, 0, 10, 22])\n",
    "myarray_plus1 = myarray + 1\n",
    "myarray_plus1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "This won't work with normal lists. For example, if you ran mylist + 1, you'd get an error like this:\n",
    "\n",
    "    ---------------------------------------------------------------------------\n",
    "    TypeError                                 Traceback (most recent call last)\n",
    "    <ipython-input-19-5b3951a16990> in <module>()\n",
    "    ----> 1 mylist + 1\n",
    "\n",
    "    TypeError: can only concatenate list (not \"int\") to list\n",
    "We can do the same thing for subtraction, multiplication, etc.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subtraction: \t[ 1  4 -1 -2  8 20]\n",
      "Multiplication:\t[ 30  60  10   0 100 220]\n",
      "Squared: \t[  9  36   1   0 100 484]\n",
      "Square root: \t[1.73205081 2.44948974 1.         0.         3.16227766 4.69041576]\n",
      "Exponential: \t[2.00855369e+01 4.03428793e+02 2.71828183e+00 1.00000000e+00\n",
      " 2.20264658e+04 3.58491285e+09]\n"
     ]
    }
   ],
   "source": [
    "print(\"Subtraction: \\t\" + str(myarray - 2))\n",
    "print(\"Multiplication:\\t\" + str(myarray * 10))\n",
    "print(\"Squared: \\t\" + str(myarray ** 2))\n",
    "print(\"Square root: \\t\" + str(np.sqrt(myarray)))\n",
    "print(\"Exponential: \\t\" + str(np.exp(myarray)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Working with multiple arrays\n",
    "We can also easily do these operations for multiple arrays. For example, let's say we want to add the corresponding elements of two lists together. Here's how we'd do it with regular lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 9, 11, 13, 15]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_a = [1, 2, 3, 4, 5]\n",
    "list_b = [6, 7, 8, 9, 10]\n",
    "list_c = [list_a[i] + list_b[i] for i in range(len(list_a))]\n",
    "list_c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With NumPy arrays, we just have to add the arrays together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  9, 11, 13, 15])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_a = np.array(list_a) # equivalent to np.array([1, 2, 3, 4, 5])\n",
    "array_b = np.array(list_b) # equivalent to np.array([6, 7, 8, 9, 10])\n",
    "array_c = array_a + array_b\n",
    "array_c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">Note: make sure when adding arrays that you are actually working with arrays, because if you try to add two lists, you will *not* get an error. Instead, the lists will be concatenated:</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_a + list_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as when we are working with a single array, we can add, subtract, divide, multiply, etc. several arrays together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subtraction: \t[-5 -5 -5 -5 -5]\n",
      "Multiplication:\t[ 6 14 24 36 50]\n",
      "Exponent: \t[      1     128    6561  262144 9765625]\n",
      "Division: \t[0.16666667 0.28571429 0.375      0.44444444 0.5       ]\n"
     ]
    }
   ],
   "source": [
    "print(\"Subtraction: \\t\" + str(array_a - array_b))\n",
    "print(\"Multiplication:\\t\" + str(array_a * array_b))\n",
    "print(\"Exponent: \\t\" + str(array_a ** array_b))\n",
    "print(\"Division: \\t\" + str(array_a / array_b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comma-separated values (CSV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very common file format for data files is comma-separated values (CSV), or related formats such as TSV (tab-separated values). To read data from such files into Numpy arrays we can use the `numpy.genfromtxt` function. For example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1800  1  1    -6.1    -6.1    -6.1 1\r\n",
      "1800  1  2   -15.4   -15.4   -15.4 1\r\n",
      "1800  1  3   -15.0   -15.0   -15.0 1\r\n",
      "1800  1  4   -19.3   -19.3   -19.3 1\r\n",
      "1800  1  5   -16.8   -16.8   -16.8 1\r\n",
      "1800  1  6   -11.4   -11.4   -11.4 1\r\n",
      "1800  1  7    -7.6    -7.6    -7.6 1\r\n",
      "1800  1  8    -7.1    -7.1    -7.1 1\r\n",
      "1800  1  9   -10.1   -10.1   -10.1 1\r\n",
      "1800  1 10    -9.5    -9.5    -9.5 1\r\n"
     ]
    }
   ],
   "source": [
    "!head data/stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.genfromtxt('data/stockholm_td_adj.dat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(14,4))\n",
    "ax.plot(data[:,0]+data[:,1]/12.0+data[:,2]/365, data[:,5])\n",
    "ax.axis('tight')\n",
    "ax.set_title('tempeatures in Stockholm')\n",
    "ax.set_xlabel('year')\n",
    "ax.set_ylabel('temperature (C)');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `numpy.savetxt` we can store a Numpy array to a file in CSV format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66213699, 0.05990807, 0.39356681],\n",
       "       [0.82267055, 0.03823638, 0.85601121],\n",
       "       [0.01918591, 0.34494948, 0.16553998]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.random.rand(3,3)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(\"data/random-matrix.csv\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.621369884627421598e-01 5.990807076803938980e-02 3.935668104354413943e-01\r\n",
      "8.226705526524893397e-01 3.823637902456511473e-02 8.560112148156683309e-01\r\n",
      "1.918590917359441761e-02 3.449494836897697425e-01 1.655399750304711315e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat data/random-matrix.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.66214 0.05991 0.39357\r\n",
      "0.82267 0.03824 0.85601\r\n",
      "0.01919 0.34495 0.16554\r\n"
     ]
    }
   ],
   "source": [
    "np.savetxt(\"data/random-matrix.csv\", M, fmt='%.5f') # fmt specifies the format\n",
    "\n",
    "!cat data/random-matrix.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy's native file format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Useful when storing and reading back numpy array data. Use the functions `numpy.save` and `numpy.load`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/random-matrix.npy: NumPy array, version 1.0, header length 118\r\n"
     ]
    }
   ],
   "source": [
    "np.save(\"data/random-matrix.npy\", M)\n",
    "\n",
    "!file data/random-matrix.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66213699, 0.05990807, 0.39356681],\n",
       "       [0.82267055, 0.03823638, 0.85601121],\n",
       "       [0.01918591, 0.34494948, 0.16553998]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.load(\"data/random-matrix.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More properties of the numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.itemsize # bytes per element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.nbytes # number of bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.ndim # number of dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index elements in an array using square brackets and indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# v is a vector, and has only one dimension, taking one index\n",
    "v[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.038236379024565115"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# M is a matrix, or a 2 dimensional array, taking two indices \n",
    "M[1,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we omit an index of a multidimensional array it returns the whole row (or, in general, a N-1 dimensional array) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66213699, 0.05990807, 0.39356681],\n",
       "       [0.82267055, 0.03823638, 0.85601121],\n",
       "       [0.01918591, 0.34494948, 0.16553998]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.82267055, 0.03823638, 0.85601121])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same thing can be achieved with using `:` instead of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.82267055, 0.03823638, 0.85601121])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:] # row 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.05990807, 0.03823638, 0.34494948])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:,1] # column 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign new values to elements in an array using indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "M[0,0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.05990807, 0.39356681],\n",
       "       [0.82267055, 0.03823638, 0.85601121],\n",
       "       [0.01918591, 0.34494948, 0.16553998]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# also works for rows and columns\n",
    "M[1,:] = 0\n",
    "M[:,2] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.05990807, -1.        ],\n",
       "       [ 0.        ,  0.        , -1.        ],\n",
       "       [ 0.01918591,  0.34494948, -1.        ]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing is the technical name for the syntax `M[lower:upper:step]` to extract part of an array:\n",
    "\n",
    "Slicing rules:\n",
    "\n",
    "- arr[2:5] will print items 2 to 4. Index in NumPy arrays starts from 0\n",
    "- arr[2::2] will print items 2 to end skipping 2 items\n",
    "- arr[::-1] will print the array in the reverse order\n",
    "- arr[1:] will print from row 1 to end\n",
    "\n",
    "Accessing a multi-dimensional NumPy array can be done using following form:\n",
    "\n",
    "```Array[row_start_index:row_end_index, column_start_index: column_end_index]```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">Note that the exclusive slice indexing described above is different than some other languages you may be familiar with, like Matlab and R. myarray[1:2] returns only the second elment in myarray in Python, instead of the first and second element.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([1,2,3,4,5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array slices are *mutable*: if they are assigned a new value the original array from which the slice was extracted is modified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3] = [-2,-3]\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can omit any of the three parameters in `M[lower:upper:step]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # lower, upper, step all take the default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::2] # step is 2, lower and upper defaults to the beginning and end of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # first three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:] # elements from index 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negative indices counts from the end of the array (positive index from the begining):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-1] # the last element in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-3:] # the last three elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing works exactly the same way for multidimensional arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a block from the original array\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strides\n",
    "A[::2, ::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fancy indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, there are more advanced operations we want to do with NumPy arrays. For example, if we had an array of values and wanted to set all negative values to zero, how would we do this? The answer is called fancy indexing, and be done two ways: boolean indexing, and array indexing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean indexing\n",
    "\n",
    "The idea behind boolean indexing is that for each element of the array, we know whether we want to select it or not. A boolean array is an array of the same shape as our original array which contains only True and False values. The location of the True values in our boolean array indicate the location of the element in our original array that we want to select, while the location of the False values correspond to those elements in our original array that we don't want to select.\n",
    "\n",
    "Let's consider some experiment data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1668.07869346,  774.38921876, 3161.14983152, ..., 2359.05394666,\n",
       "         784.36404676,  448.33416341],\n",
       "       [2419.38185232,  809.18389145, 2766.62648929, ..., 1159.47379735,\n",
       "        1330.44887992, 1842.3268586 ],\n",
       "       [2221.02887591, 1496.00517071,  354.95889145, ..., 1355.74575912,\n",
       "        1205.29137942, 1385.71283365],\n",
       "       ...,\n",
       "       [1654.50469248,  518.3271927 , 5127.58599224, ..., 2544.1042064 ,\n",
       "         624.07607332, 1029.57386246],\n",
       "       [ 480.68016502, 4690.12200498, 1520.27397139, ..., 1000.40541618,\n",
       "         988.73647145,  378.43452948],\n",
       "       [1823.42891807, 3680.12951133, 3522.94413167, ...,  591.4133153 ,\n",
       "         383.26367525, 1768.50528483]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.load(\"data/experiment_data.npy\")\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that these are reaction times. It is typically accepted that really low reaction times -- such as less than 100 milliseconds -- are too fast for people to have actually seen and processed the stimulus. Let's see if there are any reaction times less than 100 milliseconds in our data.\n",
    "\n",
    "To pull out just the elements less than 100 milliseconds, we need two steps. First, we use boolean comparisons to check which are less than 100ms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       ...,\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "too_fast = data < 100\n",
    "too_fast"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, using this `too_fast` array, we can index *back into* the original array, and see that there are indeed some trials which were abnormally fast:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([86.28125135, 76.63231393, 68.72526177, 77.25801031, 97.065495  ,\n",
       "       92.13792056, 90.05066503, 86.59892207, 96.45674184, 90.79293103,\n",
       "       81.97898954, 47.59226041, 98.80537434])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[too_fast]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What this is doing is essentially saying: for every element in `too_fast` that is `True`, give me the corresponding element in `arr`. \n",
    "\n",
    "Bcause this is a boolean array, we can also negate it, and pull out all the elements that we consider to be valid reaction times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1668.07869346,  774.38921876, 3161.14983152, ...,  591.4133153 ,\n",
       "        383.26367525, 1768.50528483])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[~too_fast]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not only does this *give* you the elements, but modifying those elements will modify the original array, too. In this case, we will set our \"too fast\" elements to have a value of \"not a number\", or `NaN`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1668.07869346,  774.38921876, 3161.14983152, ..., 2359.05394666,\n",
       "         784.36404676,  448.33416341],\n",
       "       [2419.38185232,  809.18389145, 2766.62648929, ..., 1159.47379735,\n",
       "        1330.44887992, 1842.3268586 ],\n",
       "       [2221.02887591, 1496.00517071,  354.95889145, ..., 1355.74575912,\n",
       "        1205.29137942, 1385.71283365],\n",
       "       ...,\n",
       "       [1654.50469248,  518.3271927 , 5127.58599224, ..., 2544.1042064 ,\n",
       "         624.07607332, 1029.57386246],\n",
       "       [ 480.68016502, 4690.12200498, 1520.27397139, ..., 1000.40541618,\n",
       "         988.73647145,  378.43452948],\n",
       "       [1823.42891807, 3680.12951133, 3522.94413167, ...,  591.4133153 ,\n",
       "         383.26367525, 1768.50528483]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[too_fast] = np.nan\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, if we try to find which elements are less than 100 milliseconds, we will not find any:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([], dtype=float64)"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[data < 100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise: Threshold"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Write a function, <code>threshold</code>, which takes an array and returns a new array with values thresholded by the mean of the array.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "def threshold(arr):\n",
    "    \"\"\"Computes the mean of the given array, and returns a new array which\n",
    "    is 1 where values in the original array are greater than the mean, 0 where\n",
    "    they are equal to the mean, and -1 where they are less than the mean.\n",
    "\n",
    "    Remember that if you want to create a copy of an array, you need to use\n",
    "    `arr.copy()`.\n",
    "    \n",
    "    Hint: your solution should use boolean indexing, and can be done in six\n",
    "    lines of code (including the return statement).\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    arr : numpy.ndarray\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    new_arr : thresholded version of `arr`\n",
    "    \n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Try a few obvious threshold cases.\"\"\"\n",
    "from numpy.testing import assert_array_equal\n",
    "assert_array_equal(threshold(np.array([1, 1, 1, 1])), np.array([0, 0, 0, 0]))\n",
    "assert_array_equal(threshold(np.array([1, 0, 1, 0])), np.array([1, -1, 1, -1]))\n",
    "assert_array_equal(threshold(np.array([1, 0.5, 0, 0.5])), np.array([1, 0, -1, 0]))\n",
    "assert_array_equal(\n",
    "    threshold(np.array([[0.5, 0.2, -0.3, 0.1], [1.7, -3.8, 0.5, 0.6]])), \n",
    "    np.array([[1, 1, -1, 1], [1, -1, 1, 1]]))\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Make sure a copy of the array is being returned, and that the original array is unmodified.\"\"\"\n",
    "x = np.array([[0.5, 0.2, -0.3, 0.1], [1.7, -3.8, 0.5, 0.6]])\n",
    "y = threshold(x)\n",
    "assert_array_equal(x, np.array([[0.5, 0.2, -0.3, 0.1], [1.7, -3.8, 0.5, 0.6]]))\n",
    "assert_array_equal(y, np.array([[1, 1, -1, 1], [1, -1, 1, 1]]))\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array Indexing\n",
    "\n",
    "The other type of fancy indexing is array indexing. Let's consider our average response across participants:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1698.68801725, 1888.71240023, 1796.53362098, 1879.6038851 ,\n",
       "       1882.53249686, 1824.79568606, 1746.75780815, 1748.55448988,\n",
       "       1655.75347639, 1740.67757826, 1854.98538242, 1720.70259522,\n",
       "       1675.2006642 , 1746.52724187, 1768.64738486, 1794.45589925,\n",
       "       1860.06861469, 1835.73006077, 1520.77977686, 1795.55654863,\n",
       "       1794.26437533, 1716.73345285, 1740.64166499, 1704.87601852,\n",
       "       1906.06514665, 1722.68258855, 1857.70131135, 1878.26245376,\n",
       "       1741.26393398, 1680.21711839, 1830.55940979, 1697.03486501,\n",
       "       1892.45119973, 1888.69786047, 1653.73721041, 1794.17096019,\n",
       "       1779.9941148 , 1832.42610672, 1861.63504795, 1685.20108106,\n",
       "       1652.29647646, 1718.43799102, 1633.30628308, 1686.72435462,\n",
       "       1810.54490061, 1703.7949561 , 1747.64361845, 1670.90982655,\n",
       "       1830.47925898, 1771.15425183])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.load(\"data/experiment_data.npy\")\n",
    "avg_responses = np.mean(data, axis=1)\n",
    "avg_responses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And let's say we also know which element corresponds to which participant, through the following `participants` array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['p_045', 'p_039', 'p_027', 'p_023', 'p_041', 'p_008', 'p_025',\n",
       "       'p_019', 'p_036', 'p_049', 'p_050', 'p_029', 'p_032', 'p_006',\n",
       "       'p_028', 'p_034', 'p_044', 'p_016', 'p_010', 'p_017', 'p_022',\n",
       "       'p_033', 'p_042', 'p_009', 'p_047', 'p_035', 'p_002', 'p_014',\n",
       "       'p_020', 'p_043', 'p_003', 'p_012', 'p_030', 'p_015', 'p_011',\n",
       "       'p_018', 'p_004', 'p_040', 'p_001', 'p_031', 'p_005', 'p_013',\n",
       "       'p_046', 'p_038', 'p_021', 'p_026', 'p_024', 'p_048', 'p_007',\n",
       "       'p_037'], dtype='<U5')"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "participants = np.load(\"data/experiment_participants.npy\")\n",
    "participants"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other words, the first element of `avg_responses` corresponds to the first element of `participants` (so participant 45), the second element of `avg_responses` was given by participant 39, and so on.\n",
    "\n",
    "Let's say we wanted to know what participants had the largest average response, and what participants had the smallest average response. To do this, we might try sorting the responses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1520.77977686, 1633.30628308, 1652.29647646, 1653.73721041,\n",
       "       1655.75347639, 1670.90982655, 1675.2006642 , 1680.21711839,\n",
       "       1685.20108106, 1686.72435462, 1697.03486501, 1698.68801725,\n",
       "       1703.7949561 , 1704.87601852, 1716.73345285, 1718.43799102,\n",
       "       1720.70259522, 1722.68258855, 1740.64166499, 1740.67757826,\n",
       "       1741.26393398, 1746.52724187, 1746.75780815, 1747.64361845,\n",
       "       1748.55448988, 1768.64738486, 1771.15425183, 1779.9941148 ,\n",
       "       1794.17096019, 1794.26437533, 1794.45589925, 1795.55654863,\n",
       "       1796.53362098, 1810.54490061, 1824.79568606, 1830.47925898,\n",
       "       1830.55940979, 1832.42610672, 1835.73006077, 1854.98538242,\n",
       "       1857.70131135, 1860.06861469, 1861.63504795, 1878.26245376,\n",
       "       1879.6038851 , 1882.53249686, 1888.69786047, 1888.71240023,\n",
       "       1892.45119973, 1906.06514665])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(avg_responses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we then don't know which responses correspond to which trials. A different way to do this would be to use `np.argsort`, which returns an array of indices corresponding to the sorted order of the elements, rather than the elements in sorted order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([18, 42, 40, 34,  8, 47, 12, 29, 39, 43, 31,  0, 45, 23, 21, 41, 11,\n",
       "       25, 22,  9, 28, 13,  6, 46,  7, 14, 49, 36, 35, 20, 15, 19,  2, 44,\n",
       "        5, 48, 30, 37, 17, 10, 26, 16, 38, 27,  3,  4, 33,  1, 32, 24])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argsort(avg_responses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What this says is that element 18 is the smallest response, element 42 is the next smallest response, and so on, all the way to element 24, which is the largest response:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1520.7797768567086"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_responses[18]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1633.3062830758922"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_responses[42]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1906.0651466520821"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_responses[24]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use fancy indexing, we can actually use this array of integers as an index. If we use it on the original array, then we will obtain the sorted elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1520.77977686, 1633.30628308, 1652.29647646, 1653.73721041,\n",
       "       1655.75347639, 1670.90982655, 1675.2006642 , 1680.21711839,\n",
       "       1685.20108106, 1686.72435462, 1697.03486501, 1698.68801725,\n",
       "       1703.7949561 , 1704.87601852, 1716.73345285, 1718.43799102,\n",
       "       1720.70259522, 1722.68258855, 1740.64166499, 1740.67757826,\n",
       "       1741.26393398, 1746.52724187, 1746.75780815, 1747.64361845,\n",
       "       1748.55448988, 1768.64738486, 1771.15425183, 1779.9941148 ,\n",
       "       1794.17096019, 1794.26437533, 1794.45589925, 1795.55654863,\n",
       "       1796.53362098, 1810.54490061, 1824.79568606, 1830.47925898,\n",
       "       1830.55940979, 1832.42610672, 1835.73006077, 1854.98538242,\n",
       "       1857.70131135, 1860.06861469, 1861.63504795, 1878.26245376,\n",
       "       1879.6038851 , 1882.53249686, 1888.69786047, 1888.71240023,\n",
       "       1892.45119973, 1906.06514665])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_responses[np.argsort(avg_responses)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And if we use it on our array of participants, then we can determine what participants had the largest and smallest responses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['p_010', 'p_046', 'p_005', 'p_011', 'p_036', 'p_048', 'p_032',\n",
       "       'p_043', 'p_031', 'p_038', 'p_012', 'p_045', 'p_026', 'p_009',\n",
       "       'p_033', 'p_013', 'p_029', 'p_035', 'p_042', 'p_049', 'p_020',\n",
       "       'p_006', 'p_025', 'p_024', 'p_019', 'p_028', 'p_037', 'p_004',\n",
       "       'p_018', 'p_022', 'p_034', 'p_017', 'p_027', 'p_021', 'p_008',\n",
       "       'p_007', 'p_003', 'p_040', 'p_016', 'p_050', 'p_002', 'p_044',\n",
       "       'p_001', 'p_014', 'p_023', 'p_041', 'p_015', 'p_039', 'p_030',\n",
       "       'p_047'], dtype='<U5')"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "participants[np.argsort(avg_responses)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, in this case, participant 10 had the smallest average response, while participant 47 had the largest average response."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### From boolean to integer indices\n",
    "Sometimes, we want to use a combination of boolean and array indexing. For example, if we wanted to pull out just the responses for participant 2, a natural approach would be to use boolean indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1519.95398267,  2268.97864618,  1195.65942267,   504.90066814,\n",
       "         1801.02089755,   925.24286169,  1810.30761149,  1325.80705157,\n",
       "         1175.54586424, 10408.41065951,  2455.08935241,   357.09813683,\n",
       "         1772.0844697 ,  1196.14813706,  8314.75793716,  2675.68801506,\n",
       "          730.08949799,   425.0148563 ,  2402.60428235,  1428.93884317,\n",
       "          227.37915983,  1302.38963652,  1593.64880997,  1806.89076956,\n",
       "         2533.22196284,  1207.73423053,  6303.25912496,  8886.54201129,\n",
       "          994.92553099,  1713.41231842,   401.87479894,  2505.85572837,\n",
       "         1952.73193948,   207.56620328,   603.30726209,  3616.1399997 ,\n",
       "          830.73548608,  1068.04701882,  1469.02747094,  6370.22310164,\n",
       "          604.55979416,  9081.14741057,  1965.26863145,  3518.87071627,\n",
       "          517.41562916,  8229.56635964,   461.33763334,   780.20882914,\n",
       "         1650.10585622,  1314.87174398,  1224.22622967,  2083.55702061,\n",
       "         2968.86713293,  1869.42631685,  1111.82126554,  1948.83806694,\n",
       "         2415.18346365,  4444.99151467,  1597.0267606 ,   499.87985072,\n",
       "          957.05596729,  1203.67765498,  1664.34221178,  5003.75224736,\n",
       "          967.55566474,   636.93388007,   915.99357265,  1120.80187967,\n",
       "          377.40672475,  1121.26218759,  1816.92139864,  1024.03377902,\n",
       "         1812.41020669,  2212.16494348,  6106.52376689,  1007.71524381,\n",
       "          695.393052  ,   407.26961297,  1131.45314218,  3049.94912138,\n",
       "         4876.37266626,  1128.91791729,  1141.67606093,  1135.00006133,\n",
       "         6758.10849749,  1593.05943482,  1283.63625911,  2788.64115941,\n",
       "          581.88359516,   543.51599043,  4434.08247551,   430.26052784,\n",
       "         1070.51847351,  4064.66525915,  1549.92984649,   455.33216248,\n",
       "         1972.20829979,  9066.32915959,   896.51734192,  1314.62319535,\n",
       "         1296.01410683,   996.61616492,  6105.75385258,  1561.19737687,\n",
       "         3383.1386535 ,  1292.54120004,  3853.30151832,   835.38429318,\n",
       "          743.8276473 ,  1577.88578247,  1306.19949451,  1470.75195203,\n",
       "          555.2578609 ,   217.45067187,  1256.68339959,  1186.51907184,\n",
       "          489.1850599 ,  1853.43143023,  1995.60458866,   833.29382847,\n",
       "         1034.45330302,  1683.02047154,   545.29081816,  1838.80743097,\n",
       "          906.75426918,  1244.26630466,  1321.3404664 ,  1587.52857985,\n",
       "         1410.35585247,  3105.319317  ,  1411.51416317,  5443.92972674,\n",
       "          752.0169473 ,   586.37613326,   572.36658753,   957.10289119,\n",
       "         1558.40600015,   372.5043349 ,   943.38369338,  4163.59377408,\n",
       "          345.63171723,  2984.97324499,  1125.20342404,   919.58874102,\n",
       "         3128.38041682,  1630.50710335, 13257.2010995 ,   910.32949952,\n",
       "         1195.78829195,  2170.91665291,  1282.76326571,   827.92918649,\n",
       "          857.79668237,   828.99037595,   934.21570992,  1665.98261859,\n",
       "          897.51378789,   739.37860435,  1804.45818838,  1943.92552284,\n",
       "          927.32634226,  1487.13836925,  5317.54152507,   807.78268149,\n",
       "         1180.09915534,  2179.15666221,  2274.58915959,  5160.42914214,\n",
       "         3252.8608973 ,  3566.97537043,   770.46953568,   389.88662928,\n",
       "          281.21668416,  1641.56109359,  5993.78533537,  2193.09567337,\n",
       "         4281.75189016,   857.57255182,   446.91109426,   604.31734423,\n",
       "         1029.6613233 ,  2003.21326662,   555.0428431 ,  1000.38054076,\n",
       "          782.61377775,   559.70248518,   465.53667091,  1508.97589903,\n",
       "         1690.79653218,   868.60103515,   324.63978712,  3831.94213437,\n",
       "         2389.33460775,   328.24630795,   453.09315188,   667.70706354,\n",
       "          861.83882331,   449.95923305,  4161.35247677,  2838.9239933 ,\n",
       "         3866.1204718 ,  2132.74921404,   456.46404904,  1444.91289822,\n",
       "         2859.86453994,   625.01703188,  4696.29293529,  1706.16089941,\n",
       "         2351.7652479 ,  1460.95979994,   324.1746197 ,   623.50157152,\n",
       "         1320.7807782 ,  1187.47604577,  3028.69232087,  2572.00444369,\n",
       "         2234.92844359,  2459.0302512 ,  4092.38986667,   749.89150303,\n",
       "         1094.74299543,  2241.59126084,  3656.92713699,  2605.88444652,\n",
       "         7354.29967514,  2319.71428619,  2494.45531085,   870.8280167 ,\n",
       "          314.48611818,  4831.59363981,   463.49488283,  1220.11219412,\n",
       "         1052.19978516,  3085.03346083,  3183.2792087 ,  1348.71168181,\n",
       "         1634.84655526,   659.9016014 ,  2063.0466589 ,  4471.92194045,\n",
       "         1775.15128191,  2662.54731125,  1201.29944168,   872.85026268,\n",
       "          256.10174776,   660.29442355,  1598.19175661,  1674.52470932,\n",
       "         1009.36470532,  3191.14929254,  2093.43620826,   673.92808951,\n",
       "          442.93059594,   414.55955897,  4675.46550612,   664.7509365 ,\n",
       "          693.55749027,   327.38604708,  1024.30201959,   821.20424941,\n",
       "         1012.09661072,  1968.39632341,   512.52087257,   904.05253792,\n",
       "          345.20284479,  1720.46736155,   864.85812872,  1294.54236543,\n",
       "          841.30036722,  2494.56452101,  2126.02112408,   598.89309697,\n",
       "         1177.36784728,  1475.24512926,  2260.77568058,  1753.02932524,\n",
       "         1705.66756459,  1328.4368784 ,   791.14544572,   995.85046493,\n",
       "         1049.73139615,   477.47972252,  2460.87899716,   747.58460743,\n",
       "         1214.14766658,   609.2686128 ,   966.95494309,  1128.69125645,\n",
       "          351.02567865,   855.90684706,   497.76945168,  2322.1211325 ,\n",
       "         3505.39941986,   919.77372431,   532.62433677,  1071.06498294,\n",
       "         1310.0555865 ,  2448.01497075,  1075.98009604,   723.05119455]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "participant_2_responses = data[participants == 'p_002']\n",
    "participant_2_responses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way that we could do this would be to determine the *index* of participant 2, and then use that to index into `data`. To do this, we can use a function called `np.argwhere`, which returns the indices of elements that are true:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[26]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argwhere(participants == 'p_002')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So in this case, we see that participant 2 corresponds to index 26."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise: Averaging responses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Write a function that takes as arguments a participant id, the data, and the list of participant names, and computes the average response for the given participant.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def participant_mean(participant, data, participants):\n",
    "    \"\"\"Computes the mean response for the given participant. A ValueError\n",
    "    should be raised if more than one participant has the given name.\n",
    "    \n",
    "    Hint: your solution should use `np.argwhere`, and can be done in\n",
    "    four lines (including the return statement).\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    participant: string\n",
    "        The name/id of the participant\n",
    "    data: numpy.ndarray with shape (n, m)\n",
    "        Rows correspond to participants, columns to trials\n",
    "    participants: numpy.ndarray with shape(n,)\n",
    "        A string array containing participant names/ids, corresponding to\n",
    "        the rows of the `data` array.\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    float: the mean response of the participant over all trials\n",
    "    \n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Check for correct answers with the example experiment data.\"\"\"\n",
    "from numpy.testing import assert_allclose\n",
    "data = np.load(\"data/experiment_data.npy\")\n",
    "participants = np.load(\"data/experiment_participants.npy\")\n",
    "assert_allclose(participant_mean('p_002', data, participants), 1857.7013113499095)\n",
    "assert_allclose(participant_mean('p_047', data, participants), 1906.0651466520821)\n",
    "assert_allclose(participant_mean('p_013', data, participants), 1718.4379910225193)\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Check for correct answers for some different data.\"\"\"\n",
    "data = np.arange(32).reshape((4, 8))\n",
    "participants = np.array(['a', 'b', 'c', 'd'])\n",
    "assert_allclose(participant_mean('a', data, participants), 3.5)\n",
    "assert_allclose(participant_mean('b', data, participants), 11.5)\n",
    "assert_allclose(participant_mean('c', data, participants), 19.5)\n",
    "assert_allclose(participant_mean('d', data, participants), 27.5)\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Check that a ValueError is raised when the participant name is not unique.\"\"\"\n",
    "from nose.tools import assert_raises\n",
    "data = np.arange(32).reshape((4, 8))\n",
    "participants = np.array(['a', 'b', 'c', 'a'])\n",
    "assert_raises(ValueError, participant_mean, 'a', data, participants)\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions for extracting data from arrays and creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### where"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The index mask can be converted to position index using the `where` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 0,  7, 12, 15, 15, 20, 27, 36, 39, 39, 42, 43, 49]),\n",
       " array([258, 145, 124, 148, 206, 161, 211, 265, 258, 273, 190, 232, 146]))"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = np.where(too_fast)\n",
    "\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([86.28125135, 76.63231393, 68.72526177, 77.25801031, 97.065495  ,\n",
       "       92.13792056, 90.05066503, 86.59892207, 96.45674184, 90.79293103,\n",
       "       81.97898954, 47.59226041, 98.80537434])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[indices] # this indexing is equivalent to the fancy indexing data[too_fast]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### diag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the diag function we can also extract the diagonal and subdiagonals of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### take"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `take` function is similar to fancy indexing described above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 = np.arange(-3,3)\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 3, 5]\n",
    "v2[row_indices] # fancy indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2.take(row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But `take` also works on lists and other objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.take([-3, -2, -1,  0,  1,  2], row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### choose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constructs an array by picking elements from several arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -2,  5, -2])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "which = [1, 0, 1, 0]\n",
    "choices = [[-2,-2,-2,-2], [5,5,5,5]]\n",
    "\n",
    "np.choose(which, choices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vectorizing code is the key to writing efficient numerical calculation with Python/Numpy. That means that as much as possible of a program should be formulated in terms of matrix and vector operations, like matrix-matrix multiplication.\n",
    "\n",
    "\n",
    "NumPy arrays are capable of performing all basic operations such as addition, subtraction, element-wise product, matrix dot product, element-wise division, element-wise modulo, element-wise exponents and conditional operations.\n",
    "\n",
    "An important feature with NumPy arrays is broadcasting:  \n",
    "![Broadcasting Rules](https://jakevdp.github.io/PythonDataScienceHandbook/figures/02.05-broadcasting.png \"Broadcasting Rules\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Without broadcasting\n",
    "a = np.array([0, 1, 2])\n",
    "b = np.array([5, 5, 5])\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# With broadcasting\n",
    "a + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalar-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the usual arithmetic operators to multiply, add, subtract, and divide arrays with scalar numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 = np.arange(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 0,  2,  4,  6,  8],\n",
       "        [20, 22, 24, 26, 28],\n",
       "        [40, 42, 44, 46, 48],\n",
       "        [60, 62, 64, 66, 68],\n",
       "        [80, 82, 84, 86, 88]]),\n",
       " array([[ 2,  3,  4,  5,  6],\n",
       "        [12, 13, 14, 15, 16],\n",
       "        [22, 23, 24, 25, 26],\n",
       "        [32, 33, 34, 35, 36],\n",
       "        [42, 43, 44, 45, 46]]))"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * 2, A + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element-wise array-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we add, subtract, multiply and divide arrays with each other, the default behaviour is **element-wise** operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    1,    4,    9,   16],\n",
       "       [ 100,  121,  144,  169,  196],\n",
       "       [ 400,  441,  484,  529,  576],\n",
       "       [ 900,  961, 1024, 1089, 1156],\n",
       "       [1600, 1681, 1764, 1849, 1936]])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A # element-wise multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we multiply arrays with compatible shapes, we get an element-wise multiplication of each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   4,   9,  16],\n",
       "       [  0,  11,  24,  39,  56],\n",
       "       [  0,  21,  44,  69,  96],\n",
       "       [  0,  31,  64,  99, 136],\n",
       "       [  0,  41,  84, 129, 176]])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about matrix mutiplication? There are two ways. We can either use the `dot` function, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 300,  310,  320,  330,  340],\n",
       "       [1300, 1360, 1420, 1480, 1540],\n",
       "       [2300, 2410, 2520, 2630, 2740],\n",
       "       [3300, 3460, 3620, 3780, 3940],\n",
       "       [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we can cast the array objects to the type `matrix`. This changes the behavior of the standard arithmetic operators `+, -, *` to use matrix algebra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = np.matrix(A)\n",
    "v = np.matrix(v1).T # make it a column vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0],\n",
       "        [1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 300,  310,  320,  330,  340],\n",
       "        [1300, 1360, 1420, 1480, 1540],\n",
       "        [2300, 2410, 2520, 2630, 2740],\n",
       "        [3300, 3460, 3620, 3780, 3940],\n",
       "        [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [130],\n",
       "        [230],\n",
       "        [330],\n",
       "        [430]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[30]])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inner product\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [131],\n",
       "        [232],\n",
       "        [333],\n",
       "        [434]])"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# with matrix objects, standard matrix algebra applies\n",
    "v + M*v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to add, subtract or multiply objects with incomplatible shapes we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = np.matrix([1,2,3,4,5,6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (6, 1))"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(M), np.shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-164-e8f88679fe45>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/miniconda3/envs/gwas-lecture/lib/python3.6/site-packages/numpy/matrixlib/defmatrix.py\u001b[0m in \u001b[0;36m__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    216\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\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[1;32m    217\u001b[0m             \u001b[0;31m# This promotes 1-D vectors to row vectors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 218\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0masmatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\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[1;32m    219\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misscalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'__rmul__'\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[1;32m    220\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)"
     ]
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See also the related functions: `inner`, `outer`, `cross`, `kron`, `tensordot`. Try for example `help(kron)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array/Matrix transformations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we have used the `.T` to transpose the matrix object `v`. We could also have used the `transpose` function to accomplish the same thing. \n",
    "\n",
    "Other mathematical functions that transform matrix objects are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.+1.j, 0.+2.j],\n",
       "        [0.+3.j, 0.+4.j]])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = np.matrix([[1j, 2j], [3j, 4j]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.-1.j, 0.-2.j],\n",
       "        [0.-3.j, 0.-4.j]])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.conjugate(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hermitian conjugate: transpose + conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.-1.j, 0.-3.j],\n",
       "        [0.-2.j, 0.-4.j]])"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extract the real and imaginary parts of complex-valued arrays using `real` and `imag`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0., 0.],\n",
       "        [0., 0.]])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.real(C) # same as: C.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 2.],\n",
       "        [3., 4.]])"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.imag(C) # same as: C.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or the complex argument and absolute value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.78539816, 1.10714872],\n",
       "        [1.24904577, 1.32581766]])"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.angle(C+1) # heads up MATLAB Users, angle is used instead of arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 2.],\n",
       "        [3., 4.]])"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix computations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.+2.j , 0.-1.j ],\n",
       "        [0.-1.5j, 0.+0.5j]])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.inv(C) # equivalent to C.I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1.00000000e+00+0.j, 0.00000000e+00+0.j],\n",
       "        [1.11022302e-16+0.j, 1.00000000e+00+0.j]])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.I * C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determinant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0000000000000004+0j)"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.4999999999999997+0j)"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(C.I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often it is useful to store datasets in Numpy arrays. Numpy provides a number of functions to calculate statistics of datasets in arrays. \n",
    "\n",
    "For example, let's calculate some properties from the Stockholm temperature dataset used above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load tempeature dataset into the data variable:\n",
    "data = np.genfromtxt('data/stockholm_td_adj.dat')\n",
    "np.shape(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.197109684751585"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "np.mean(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The daily mean temperature in Stockholm over the last 200 years has been about 6.2 C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### standard deviations and variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.282271621340573, 68.59602320966341)"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(data[:,3]), np.var(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### min and max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.8"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lowest daily average temperature\n",
    "data[:,3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.3"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# highest daily average temperature\n",
    "data[:,3].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sum, prod, and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum up all elements\n",
    "np.sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# product of all elements\n",
    "np.prod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative sum\n",
    "np.cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative product\n",
    "np.cumprod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as: diag(A).sum()\n",
    "np.trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Euclidean distance\n",
    "\n",
    "Recall that the Euclidean distance $d$ is given by the following equation:\n",
    "\n",
    "$$\n",
    "d(a, b) = \\sqrt{\\sum_{i=1}^N (a_i - b_i) ^ 2}\n",
    "$$\n",
    "\n",
    "In NumPy, this is a fairly simple computation because we can rely on array computations and the `np.sum` function to do all the heavy lifting for us."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Complete the function <code>euclidean_distance</code> below to compute $d(a,b)$, as given by the equation above. Note that you can compute the square root using <code>np.sqrt</code>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "def euclidean_distance(a, b):\n",
    "    \"\"\"Computes the Euclidean distance between a and b.\n",
    "    \n",
    "    Hint: your solution can be done in a single line of code!\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    a, b : numpy arrays or scalars with the same size\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    the Euclidean distance between a and b\n",
    "    \n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">Remember that you need to execute the cell above (with your definition of <code>euclidean_distance</code>), and then run the cell below to check your answer. If you make changes to the cell with your answer, you will need to <i>first</i> re-run that cell, and <i>then</i> re-run the test cell to check your answer again.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nose.tools import assert_equal, assert_raises\n",
    "\n",
    "# check euclidean distance of size 3 integer arrays\n",
    "a = np.array([1, 2, 3])\n",
    "b = np.array([4, 5, 6])\n",
    "assert_equal(euclidean_distance(a, b), 5.196152422706632)\n",
    "\n",
    "# check euclidean distance of size 4 float arrays\n",
    "x = np.array([3.6, 7., 203., 3.])\n",
    "y = np.array([6., 20.2, 1., 2.])\n",
    "assert_equal(euclidean_distance(x, y), 202.44752406487959)\n",
    "\n",
    "# check euclidean distance of scalars\n",
    "assert_equal(euclidean_distance(1, 0.5), 0.5)\n",
    "\n",
    "# check that an error is thrown if the arrays are different sizes\n",
    "a = np.array([1, 2, 3])\n",
    "b = np.array([4, 5])\n",
    "assert_raises(ValueError, euclidean_distance, a, b)\n",
    "assert_raises(ValueError, euclidean_distance, b, a)\n",
    "\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computations on subsets of arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compute with subsets of the data in an array using indexing, fancy indexing, and the other methods of extracting data from an array (described above).\n",
    "\n",
    "For example, let's go back to the temperature dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1800  1  1    -6.1    -6.1    -6.1 1\r\n",
      "1800  1  2   -15.4   -15.4   -15.4 1\r\n",
      "1800  1  3   -15.0   -15.0   -15.0 1\r\n"
     ]
    }
   ],
   "source": [
    "!head -n 3 data/stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dataformat is: year, month, day, daily average temperature, low, high, location.\n",
    "\n",
    "If we are interested in the average temperature only in a particular month, say February, then we can create a index mask and use it to select only the data for that month using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.genfromtxt('data/stockholm_td_adj.dat')\n",
    "np.unique(data[:,1]) # the month column takes values from 1 to 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_feb = data[:,1] == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.212109570736596"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "np.mean(data[mask_feb,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these tools we have very powerful data processing capabilities at our disposal. For example, to extract the average monthly average temperatures for each month of the year only takes a few lines of code: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEKCAYAAAAfGVI8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAEidJREFUeJzt3X+0b3Vd5/HnK26OihAZVzLwesAhGWIQnbtIYyrUoTAMqlWTWA6ZiUWiTq3yZtMC+8OwxElXLu2qJJliZVq3LhBGAatfKighqATRRa8w/NCGSBsc4N0f3331cOOesznnu/c+53yej7W+63z3/u6z93uve+55nc/+7P35pKqQJLXra6YuQJI0LYNAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1LhNUxfQx8EHH1wLCwtTlyFJ68o111xzd1VtXm67dREECwsLXH311VOXIUnrSpJb+2znpSFJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS49bFA2XSerCwbefc97nrvFPmvk9pb7YIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxjnWkLTOzHtMI8czki0CSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1LjBgiDJBUnuTHL9onXnJvlckmu71/cMdXxJUj9DtgjeBZz8MOv/d1Ud170uHvD4kqQeBguCqroK+MJQ+5ckzccUfQQvT3Jdd+no6yc4viRpkbGD4K3AU4DjgNuB8/e1YZIzk1yd5Oq77rprrPokqTmjBkFV3VFVD1TVg8DbgeOX2HZ7VW2tqq2bN28er0hJasyoQZDkiYsWvx+4fl/bSpLGMdjoo0kuAk4EDk6yGzgHODHJcUABu4CXDXV8aY95j9YJjtipjWWwIKiq0x9m9TuHOp4kaWV8sliSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGrdpJd+U5E+q6vnzLkbS2rGwbedc97frvFPmuj/Nz0pbBC+daxWSpMn0ahEkeRRwFFDAjVV1+6BVSZJGs2wQJDkFeBvwD0CAw5O8rKouGbo4SdLw+rQIzgeeXVU3AyR5CrATMAgkaQPo00dw554Q6NwC3DlQPZKkkfVpEdyQ5GLg95j1EfwQ8NEkPwBQVR8YsD5J0sD6BMGjgTuA7+yW7wIeD3wvs2AwCCRpHVs2CKrqxWMUIkmaRp+7hg4HzgYWFm9fVacOV5YkaSx9Lg39IfBO4I+BB4ctR5I0tj5B8P+q6s2DVyJJmkSfIHhTknOAy4D79qysqo8NVpUkaTR9guA/Ay8CnsNXLw1VtyxJWuf6BMH3A0dU1ZcfyY6TXAA8n9kDacd06x4P/C6zjuddwH+vqn96JPuVJM1XnyeL/w44aAX7fhdw8l7rtgGXV9WRwOXdsiRpQn1aBIcAn07yUR7aR7Dk7aNVdVWShb1Wnwac2L2/ELgCeHW/UiVJQ+gTBOfM8XiH7BnCuqpuT/KEOe5bkrQCfZ4svjLJk4Ejq+rPkjwW2G/owpKcCZwJsGXLlqEPJ0nNWraPIMlLgfcDv9mtOpTZQ2YrcUeSJ3b7fSJLjGJaVduramtVbd28efMKDydJWk6fzuKfBk4A/hmgqm4CVnpJZwdwRvf+DOCPVrgfSdKc9AmC+xbfOppkE7PnCJaU5CLgb4CnJtmd5CXAecBJSW4CTuqWJUkT6tNZfGWS1wCPSXIScBazcYeWVFWn7+Oj5z6C+rSBLWzbOfd97jrvlLnvU9ro+rQItjGbg+ATwMuAi6vqFwetSpI0mj4tgrOr6k3A2/esSPLKbp0kaZ3r0yI442HW/dic65AkTWSfLYIkpwMvBA5PsmPRRwcAnx+6MEnSOJa6NPTXwO3AwcD5i9bfC1w3ZFGSpPHsMwiq6lbgVuBZ45UjSRpbnz4CSdIGZhBIUuMMAklq3IqCIMm5c65DkjSRlbYIrplrFZKkyawoCKpq2bGGJEnrw7JDTCR588Osvge4uqocRlqS1rk+LYJHA8cBN3WvY4HHAy9J8usD1iZJGkGfQef+I/CcqrofIMlbgcuYzSfwiQFrkySNoE+L4FBg/0XL+wPfVFUPAPcNUpUkaTR9WgS/Clyb5AogwHcAr0uyP/BnA9YmSRrBskFQVe9McjFwPLMgeE1V3dZ9/HNDFidJGl6fu4Z2ABcBO6rqi8OXJEkaU58+gvOBbwc+meT3k/xgkkcPXJckaSR9Lg1dyWwC+/2A5wAvBS4ADhy4NknSCPp0FpPkMcD3Aj8MPAO4cMiiJEnj6dNH8LvAtwKXAm8BrqiqB4cuTJI0jj4tgt8CXtg9NyBJ2mD69BFcmuSYJEczG25iz/rfHrQySdIo+lwaOgc4ETgauBh4HvCXgEEgSRtAn0tDPwg8Dfh4Vb04ySHAO4YtS1ILFrbtnPs+d513ytz3udH1eY7gX7vO4fuTHAjcCRwxbFmSpLH0aRFcneQg4O3MZib7F+Ajg1YlSRpNn87is7q3b0tyKXBgVV03bFmSpLH0eqBsj6raNVAdkqSJrHTyeknSBmEQSFLjlg2CJG9I8i1jFCNJGl+fFsGnge1JPpzkJ5N83dBFSZLGs2wQVNU7quoE4H8AC8B1Sd6b5NlDFydJGl6vPoJuLoKjutfdwN8BP5PkfQPWJkkaQZ+xht4InApcDryuqvY8TPb6JDcOWZwkaXh9niO4HvhfVfWlh/ns+DnXI0ka2T6DIMkzurfXAkclecjnVfWxqrpnJQdNsgu4F3gAuL+qtq5kP5Kk1VuqRXD+Ep8Vs/mLV+PZVXX3KvchSVqlfQZBVXlXkCQ1oO/k9d/G7NbRr2y/yhnKCrgsSQG/WVXbV7EvSdIq9Llr6N3AU5j1FeyZt7hY3QxlJ1TVbUmeAHwoyaer6qq9jnsmcCbAli1bVnEoSdJS+rQItgJHV1XN66BVdVv39c4kH2R299FVe22zHdgOsHXr1rkdW5L0UH0eKLse+MZ5HTDJ/kkO2PMe+K7uGJKkCSx1++gfM7sEdADwySQfAe7b83lVnbrCYx4CfLC7HXUT8N6qunSF+5IkrdJSl4beMMQBq+oW4GlD7FuS9MgtdfvolQBJXl9Vr178WZLXA1cOXJskaQR9+ghOeph1z5t3IZKkaSzVR/BTwFnAEUkWT1Z/APDXQxcmSRrHUn0E7wUuAX4F2LZo/b1V9YVBq5IkjWapPoJ7gHuA07v5CA7ptn9cksdV1WdGqlGSNKA+Txa/HDgXuAN4sFtdwLHDlSVJGkufJ4tfBTy1qj4/dDFaOxa27Zzr/nadd8pc9ydpfvrcNfRZZpeIJEkbUJ8WwS3AFUl28tAni984WFWSpNH0CYLPdK9HdS9J0gaybBBU1WsBuoHiqqr+ZfCqJEmjWbaPIMkxST7ObITQG5Jck+Rbhi9NkjSGPp3F24GfqaonV9WTgZ8F3j5sWZKksfQJgv2r6i/2LFTVFcD+g1UkSRpVr7uGkvwS8O5u+UeBfxyuJEnSmPq0CH4c2Ax8APhg9/7FQxYlSRpPn7uG/gl4xQi1SJImsNQw1DuW+sZVTFUpSVpDlmoRPIvZ8BIXAR8GMkpFkqRRLRUE38hsdrLTgRcCO4GLquqGMQqTJI1jn53FVfVAVV1aVWcAzwRuZjbm0NmjVSdJGtySncVJ/gNwCrNWwQLwZmZ3D0mSNoilOosvBI5hNl3la6vq+tGqkiSNZqkWwYuALwLfDLwi+UpfcZgNPnfgwLVJkkaw1JzFfR42k6Q1b94z7sHGmnXPX/aS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXGTBEGSk5PcmOTmJNumqEGSNDN6ECTZD3gL8DzgaOD0JEePXYckaWaKFsHxwM1VdUtVfRl4H3DaBHVIkpgmCA4FPrtoeXe3TpI0gVTVuAdMfgj47qr6iW75RcDxVXX2XtudCZwJsGXLlv9y6623ruh4Y01Rt16Ps5Gm25OmttamxExyTVVtXW67KVoEu4EnLVo+DLht742qantVba2qrZs3bx6tOElqzRRB8FHgyCSHJ3kU8AJgxwR1SJKATWMfsKruT/Jy4E+B/YALquqGseuQJM2MHgQAVXUxcPEUx5YkPZRPFktS4wwCSWqcQSBJjZukj0Ar533/kubNFoEkNc4gkKTGGQSS1Dj7CCRpTtZrH54tAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4zb8xDTrdaIISRqLLQJJatyGbxGMxZaHpPXKFoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDUuVTV1DctKci9w49R1zMnBwN1TFzFHG+l8NtK5gOezlo11Lk+uqs3LbbRehpi4saq2Tl3EPCS5eqOcC2ys89lI5wKez1q21s7FS0OS1DiDQJIat16CYPvUBczRRjoX2Fjns5HOBTyftWxNncu66CyWJA1nvbQIJEkDWdNBkOTkJDcmuTnJtqnrWY0kT0ryF0k+leSGJK+cuqbVSrJfko8n+ZOpa1mtJAcleX+ST3f/Rs+auqaVSvI/u5+x65NclOTRU9f0SCS5IMmdSa5ftO7xST6U5Kbu69dPWeMjsY/z+bXuZ+26JB9MctCUNa7ZIEiyH/AW4HnA0cDpSY6etqpVuR/42ar6T8AzgZ9e5+cD8ErgU1MXMSdvAi6tqqOAp7FOzyvJocArgK1VdQywH/CCaat6xN4FnLzXum3A5VV1JHB5t7xevIt/fz4fAo6pqmOBvwd+YeyiFluzQQAcD9xcVbdU1ZeB9wGnTVzTilXV7VX1se79vcx+0Rw6bVUrl+Qw4BTgHVPXslpJDgS+A3gnQFV9uar+77RVrcom4DFJNgGPBW6buJ5HpKquAr6w1+rTgAu79xcC3zdqUavwcOdTVZdV1f3d4t8Ch41e2CJrOQgOBT67aHk36/gX52JJFoCnAx+etpJV+XXg54EHpy5kDo4A7gJ+q7vU9Y4k+09d1EpU1eeANwCfAW4H7qmqy6atai4OqarbYfZHFfCEieuZpx8HLpmygLUcBHmYdev+FqckjwP+AHhVVf3z1PWsRJLnA3dW1TVT1zInm4BnAG+tqqcDX2R9XXr4iu7a+WnA4cA3Afsn+dFpq9K+JPlFZpeN3zNlHWs5CHYDT1q0fBjrrIm7tyRfyywE3lNVH5i6nlU4ATg1yS5ml+yek+R3pi1pVXYDu6tqTwvt/cyCYT36b8A/VtVdVfX/gQ8A3zZxTfNwR5InAnRf75y4nlVLcgbwfOBHauL7+NdyEHwUODLJ4UkexazDa8fENa1YkjC7Bv2pqnrj1PWsRlX9QlUdVlULzP5d/ryq1u1fnVX1f4DPJnlqt+q5wCcnLGk1PgM8M8lju5+557JOO773sgM4o3t/BvBHE9ayaklOBl4NnFpVX5q6njUbBF1HysuBP2X2g/x7VXXDtFWtygnAi5j99Xxt9/qeqYvSV5wNvCfJdcBxwOsmrmdFulbN+4GPAZ9g9n98TT3FupwkFwF/Azw1ye4kLwHOA05KchNwUre8LuzjfH4DOAD4UPe74G2T1uiTxZLUtjXbIpAkjcMgkKTGGQSS1DiDQJIaZxBIUuMMAglIUknevWh5U5K7Vjqyajea6VmLlk/cCKO0amMyCKSZLwLHJHlMt3wS8LlV7O8g4Kxlt5LWAINA+qpLmI2oCnA6cNGeD7rx8P+wGz/+b5Mc260/txtv/ooktyR5Rfct5wFP6R4W+rVu3eMWzXnwnu7JX2lyBoH0Ve8DXtBN5HIsDx0d9rXAx7vx418D/Paiz44CvpvZ0OnndGNKbQP+oaqOq6qf67Z7OvAqZvNrHMHsaXNpcgaB1Kmq64AFZq2Bi/f6+L8C7+62+3PgG5J8XffZzqq6r6ruZjYY2iH7OMRHqmp3VT0IXNsdS5rcpqkLkNaYHczG8z8R+IZF65caFv2+ReseYN//r/puJ43KFoH0UBcAv1xVn9hr/VXAj8DsDiDg7mXmk7iX2aBi0prnXyTSIlW1m9n8xXs7l9kMZtcBX+KrQyLvaz+fT/JX3YTllwA7512rNC+OPipJjfPSkCQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlx/wZp4HX0NQHKwgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "months = np.arange(1,13)\n",
    "monthly_mean = [np.mean(data[data[:,1] == month, 3]) for month in months]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.bar(months, monthly_mean)\n",
    "ax.set_xlabel(\"Month\")\n",
    "ax.set_ylabel(\"Monthly avg. temp.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculations with higher-dimensional data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When functions such as `min`, `max`, etc. are applied to a multidimensional arrays, it is sometimes useful to apply the calculation to the entire array, and sometimes only on a row or column basis. Using the `axis` argument we can specify how these functions should behave: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.79729008, 0.36995048, 0.53208232],\n",
       "       [0.72784289, 0.16789472, 0.36548098],\n",
       "       [0.64275017, 0.82376707, 0.94225174]])"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.random.rand(3,3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9422517358676263"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# global max\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.79729008, 0.82376707, 0.94225174])"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each column\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.79729008, 0.72784289, 0.94225174])"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each row\n",
    "m.max(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many other functions and methods in the `array` and `matrix` classes accept the same (optional) `axis` keyword argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping, resizing and stacking arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shape of an Numpy array can be modified without copying the underlaying data, which makes it a fast operation even for large arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "n, m = A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30,\n",
       "        31, 32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape((1,n*m))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30,\n",
       "        31, 32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0,0:5] = 5 # modify the array\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # and the original variable is also changed. B is only a different view of the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the function `flatten` to make a higher-dimensional array into a vector. But this function create a copy of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0:5] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # now A has not changed, because B's data is a copy of A's, not refering to the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding a new dimension: newaxis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `newaxis`, we can insert new dimensions in an array, for example converting a vector to a column or row matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = np.array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make a column matrix of the vector v\n",
    "v[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# column matrix\n",
    "v[:,np.newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# row matrix\n",
    "v[np.newaxis,:].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacking and repeating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using function `repeat`, `tile`, `vstack`, `hstack`, and `concatenate` we can create larger vectors and matrices from smaller ones:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tile and repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repeat each element 3 times\n",
    "np.repeat(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tile the matrix 3 times \n",
    "np.tile(a, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### hstack and vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((a,b.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Border"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Write a function to create a 2D array of arbitrary shape. This array should have all zero values, except for the elements around the border (i.e., the first and last rows, and the first and last columns), which should have a value of one.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "def border(n, m):\n",
    "    \"\"\"Creates an array with shape (n, m) that is all zeros\n",
    "    except for the border (i.e., the first and last rows and\n",
    "    columns), which should be filled with ones.\n",
    "\n",
    "    Hint: you should be able to do this in three lines\n",
    "    (including the return statement)\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    n, m: int\n",
    "        Number of rows and number of columns\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    numpy array with shape (n, m)\n",
    "\n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.testing import assert_array_equal\n",
    "from nose.tools import assert_equal\n",
    "\n",
    "# check a few small examples explicitly\n",
    "assert_array_equal(border(1, 1), [[1]])\n",
    "assert_array_equal(border(2, 2), [[1, 1], [1, 1]])\n",
    "assert_array_equal(border(3, 3), [[1, 1, 1], [1, 0, 1], [1, 1, 1]])\n",
    "assert_array_equal(border(3, 4), [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]])\n",
    "\n",
    "# check a few large and random examples\n",
    "for i in range(10):\n",
    "    n, m = np.random.randint(2, 1000, 2)\n",
    "    result = border(n, m)\n",
    "\n",
    "    # check dtype and array shape\n",
    "    assert_equal(result.dtype, np.float)\n",
    "    assert_equal(result.shape, (n, m))\n",
    "\n",
    "    # check the borders\n",
    "    assert (result[0] == 1).all()\n",
    "    assert (result[-1] == 1).all()\n",
    "    assert (result[:, 0] == 1).all()\n",
    "    assert (result[:, -1] == 1).all()\n",
    "\n",
    "    # check that everything else is zero\n",
    "    assert np.sum(result) == (2*n + 2*m - 4)\n",
    "\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy and \"deep copy\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To achieve high performance, assignments in Python usually do not copy the underlaying objects. This is important for example when objects are passed between functions, to avoid an excessive amount of memory copying when it is not necessary (technical term: pass by reference). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now B is referring to the same array data as A \n",
    "B = A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# changing B affects A\n",
    "B[0,0] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to avoid this behavior, so that when we get a new completely independent object `B` copied from `A`, then we need to do a so-called \"deep copy\" using the function `copy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.copy(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now, if we modify B, A is not affected\n",
    "B[0,0] = -5\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating over array elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generally, we want to avoid iterating over the elements of arrays whenever we can (at all costs). The reason is that in a interpreted language like Python (or MATLAB), iterations are really slow compared to vectorized operations. \n",
    "\n",
    "However, sometimes iterations are unavoidable. For such cases, the Python `for` loop is the most convenient way to iterate over an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1,2,3,4])\n",
    "\n",
    "for element in v:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row [1 2]\n",
      "1\n",
      "2\n",
      "row [3 4]\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "M = np.array([[1,2], [3,4]])\n",
    "\n",
    "for row in M:\n",
    "    print(\"row\", row)\n",
    "    \n",
    "    for element in row:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we need to iterate over each element of an array and modify its elements, it is convenient to use the `enumerate` function to obtain both the element and its index in the `for` loop: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row_idx 0 row [1 2]\n",
      "col_idx 0 element 1\n",
      "col_idx 1 element 2\n",
      "row_idx 1 row [3 4]\n",
      "col_idx 0 element 3\n",
      "col_idx 1 element 4\n"
     ]
    }
   ],
   "source": [
    "for row_idx, row in enumerate(M):\n",
    "    print(\"row_idx\", row_idx, \"row\", row)\n",
    "    \n",
    "    for col_idx, element in enumerate(row):\n",
    "        print(\"col_idx\", col_idx, \"element\", element)\n",
    "       \n",
    "        # update the matrix M: square each element\n",
    "        M[row_idx, col_idx] = element ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# each element in M is now squared\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectorizing functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned several times by now, to get good performance we should try to avoid looping over elements in our vectors and matrices, and instead use vectorized algorithms. The first step in converting a scalar algorithm to a vectorized algorithm is to make sure that the functions we write work with vector inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Theta(x):\n",
    "    \"\"\"\n",
    "    Scalar implemenation of the Heaviside step function.\n",
    "    \"\"\"\n",
    "    if x >= 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-246-b49266106206>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mTheta\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\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;32m<ipython-input-245-f72d7f42be84>\u001b[0m in \u001b[0;36mTheta\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mScalar\u001b[0m \u001b[0mimplemenation\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mHeaviside\u001b[0m \u001b[0mstep\u001b[0m \u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \"\"\"\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "Theta(np.array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, that didn't work because we didn't write the `Theta` function so that it can handle a vector input... \n",
    "\n",
    "To get a vectorized version of Theta we can use the Numpy function `vectorize`. In many cases it can automatically vectorize a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [],
   "source": [
    "Theta_vec = np.vectorize(Theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 261,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta_vec(np.array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also implement the function to accept a vector input from the beginning (requires more effort but might give better performance):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Theta(x):\n",
    "    \"\"\"\n",
    "    Vector-aware implemenation of the Heaviside step function.\n",
    "    \"\"\"\n",
    "    return 1 * (x >= 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 263,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta(np.array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# still works for scalars as well\n",
    "Theta(-1.2), Theta(2.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using arrays in conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using arrays in conditions,for example `if` statements and other boolean expressions, one needs to use `any` or `all`, which requires that any or all elements in the array evalutes to `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one element in M is larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).any():\n",
    "    print(\"at least one element in M is larger than 5\")\n",
    "else:\n",
    "    print(\"no element in M is larger than 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all elements in M are not larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).all():\n",
    "    print(\"all elements in M are larger than 5\")\n",
    "else:\n",
    "    print(\"all elements in M are not larger than 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since Numpy arrays are *statically typed*, the type of an array does not change once created. But we can explicitly cast an array of some type to another using the `astype` functions (see also the similar `asarray` function). This always create a new array of new type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  4.],\n",
       "       [ 9., 16.]])"
      ]
     },
     "execution_count": 269,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]])"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A particular NumPy feature of interest is solving a system of linear equations. NumPy has a function to solve linear equations. \n",
    "For example these linear equations \n",
    "\n",
    "\\begin{align}\n",
    "2x + 6y & =  6 \\\\\n",
    "5x + 3y & =  -9 \n",
    "\\end{align}\n",
    "\n",
    "can be solved by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3.,  2.])"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coeffs  = np.array([[2, 6], [5, 3]])\n",
    "depvars = np.array([6, -9])\n",
    "solution = np.linalg.solve(coeffs, depvars)\n",
    "solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* http://numpy.scipy.org\n",
    "* http://scipy.org/Tentative_NumPy_Tutorial\n",
    "* http://scipy.org/NumPy_for_Matlab_Users - A Numpy guide for MATLAB users."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercise: Truth tables\n",
    "\n",
    "This is a final exercise to get you comfortable working with numpy arrays. In this exercise, we're going to be programmatically constructing truth tables from boolean vectors. A *truth table* lists all possible Boolean outputs for the given inputs. For example, an AND truth table would look like this:\n",
    "\n",
    "<table class=\"table table-striped\" style=\"width: 5em;\">\n",
    "  <thead>\n",
    "    <tr>\n",
    "      <th>$a$</th>\n",
    "      <th>$b$</th>\n",
    "      <th>$a\\wedge b$\n",
    "    </tr>\n",
    "  </thead>\n",
    "  <tbody>\n",
    "    <tr>\n",
    "      <th>0</th>\n",
    "      <th>0</th>\n",
    "      <th>0</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th>0</th>\n",
    "      <th>1</th>\n",
    "      <th>0</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th>1</th>\n",
    "      <th>0</th>\n",
    "      <th>0</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th>1</th>\n",
    "      <th>1</th>\n",
    "      <th>1</th>\n",
    "    </tr>\n",
    "  </tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each row corresponds to different values of $a$ (first column) and $b$ (second column), and the third column corresponds to whatever $a\\wedge b$ is.\n",
    "\n",
    "We can represent the different values of $a$ and $b$ using boolean arrays in numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create boolean vectors a and b\n",
    "a = np.array([0, 0, 1, 1], dtype=bool)\n",
    "b = np.array([0, 1, 0, 1], dtype=bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can compute the logical AND of `a` and `b` using the `&` operator (and the symbols for the Boolean operations OR and NOT are `|` and `~`, respectively)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False,  True])"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# run this cell to see what happens when we use the & operator on a and b\n",
    "a & b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">Complete the functions below to produce truth tables for AND, OR, and NOT. Be sure to use the logical operators discussed above in your solution!</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Part A: AND Table\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [],
   "source": [
    "def and_table(a, b):\n",
    "    \"\"\"\n",
    "    Takes two boolean vectors, `a` and `b`, and returns an AND truth\n",
    "    table consisting three columns: a, b, and (a AND b). If you forget\n",
    "    how an AND operator works, see the Wikipedia page on logical\n",
    "    conjunctions: https://en.wikipedia.org/wiki/Logical_conjunction\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    a : boolean array with shape (n,)\n",
    "    b : boolean array with shape (n,)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    boolean array with shape (n, 3)\n",
    "\n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you have implemented `and_table` above, you can try running it with inputs `a` and `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "and_table(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Check whether and_table returns an array with the correct shape for random inputs.\"\"\"\n",
    "from nose.tools import assert_equal\n",
    "for i in range(10):\n",
    "    # randomize the vector length\n",
    "    n = np.random.randint(1, 11)\n",
    "    # randomly generate binary vectors\n",
    "    v1 = np.random.randint(0, 2, n).astype(bool)\n",
    "    v2 = np.random.randint(0, 2, n).astype(bool)\n",
    "    # check the shape of the AND table\n",
    "    assert_equal(and_table(v1, v2).shape, (n, 3))\n",
    "\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Check whether and_table returns the correct answer for two particular vectors.\"\"\"\n",
    "from numpy.testing import assert_array_equal\n",
    "# create the two vectors\n",
    "v1 = np.array([0, 0, 1, 1], dtype=bool)\n",
    "v2 = np.array([0, 1, 0, 1], dtype=bool)\n",
    "\n",
    "# check (v1 AND v1)\n",
    "v11 = np.array([[0, 0, 0], [0, 0, 0], [1, 1, 1], [1, 1, 1]], dtype=bool)\n",
    "assert_array_equal(and_table(v1, v1), v11)\n",
    "\n",
    "# check (v1 AND v2)\n",
    "v12 = np.array([[0, 0, 0], [0, 1, 0], [1, 0, 0], [1, 1, 1]], dtype=bool)\n",
    "assert_array_equal(and_table(v1, v2), v12)\n",
    "\n",
    "# check (v2 AND v1)\n",
    "v21 = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 1]], dtype=bool)\n",
    "assert_array_equal(and_table(v2, v1), v21)\n",
    "\n",
    "# check (v2 AND v2)\n",
    "v22 = np.array([[0, 0, 0], [1, 1, 1], [0, 0, 0], [1, 1, 1]], dtype=bool)\n",
    "assert_array_equal(and_table(v2, v2), v22)\n",
    "\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part B: OR Table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def or_table(a, b):\n",
    "    \"\"\"\n",
    "    Takes two boolean vectors, `a` and `b`, and returns an OR truth\n",
    "    table consisting three columns: a, b, and (a OR b).\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    a : boolean array with shape (n,)\n",
    "    b : boolean array with shape (n,)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    boolean array with shape (n, 3)\n",
    "\n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you have implemented `or_table` above, you can try running it with inputs `a` and `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "or_table(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Check whether or_table returns an array with the correct shape for random inputs.\"\"\"\n",
    "for i in range(10):\n",
    "    # randomize the vector length\n",
    "    n = np.random.randint(1, 11)\n",
    "    # randomly generate binary vectors\n",
    "    v1 = np.random.randint(0, 2, n).astype(bool)\n",
    "    v2 = np.random.randint(0, 2, n).astype(bool)\n",
    "    # check the shape of the OR table\n",
    "    assert_equal(or_table(v1, v2).shape, (n, 3))\n",
    "\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Check whether or_table returns the correct answer for two particular vectors.\"\"\"\n",
    "# create the two vectors\n",
    "v1 = np.array([0, 0, 1, 1], dtype=bool)\n",
    "v2 = np.array([0, 1, 0, 1], dtype=bool)\n",
    "\n",
    "# check (v1 OR v1)\n",
    "v11 = np.array([[0, 0, 0], [0, 0, 0], [1, 1, 1], [1, 1, 1]], dtype=bool)\n",
    "assert_array_equal(or_table(v1, v1), v11)\n",
    "\n",
    "# check (v1 OR v2)\n",
    "v12 = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 1]], dtype=bool)\n",
    "assert_array_equal(or_table(v1, v2), v12)\n",
    "\n",
    "# check (v2 OR v1)\n",
    "v21 = np.array([[0, 0, 0], [1, 0, 1], [0, 1, 1], [1, 1, 1]], dtype=bool)\n",
    "assert_array_equal(or_table(v2, v1), v21)\n",
    "\n",
    "# check (v2 OR v2)\n",
    "v22 = np.array([[0, 0, 0], [1, 1, 1], [0, 0, 0], [1, 1, 1]], dtype=bool)\n",
    "assert_array_equal(or_table(v2, v2), v22)\n",
    "\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Part C: NOT Table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def not_table(a):\n",
    "    \"\"\"\n",
    "    Takes one boolean vector, `a`, and returns a NOT truth\n",
    "    table consisting two columns: a and (NOT a).\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    a : boolean array with shape (n,)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    boolean array with shape (n, 2)\n",
    "\n",
    "    \"\"\"\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you have implemented `not_table` above, you can try running it with inputs `a` and `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not_table(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Check whether or_table returns an array with the correct shape for random inputs.\"\"\"\n",
    "for i in range(10):\n",
    "    # randomize the vector length\n",
    "    n = np.random.randint(1, 11)\n",
    "    # randomly generate a binary vector\n",
    "    v = np.random.randint(0, 2, n).astype(bool)\n",
    "    # check the shape of the OR table\n",
    "    assert_equal(not_table(v).shape, (n, 2))\n",
    "\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Check whether or_table returns the correct answer for two particular vectors.\"\"\"\n",
    "# create the two vectors\n",
    "v1 = np.array([0, 0, 1, 1], dtype=bool)\n",
    "v2 = np.array([0, 1, 0, 1], dtype=bool)\n",
    "\n",
    "# check (NOT v1)\n",
    "vn1 = np.array([[0, 1], [0, 1], [1, 0], [1, 0]], dtype=bool)\n",
    "assert_array_equal(not_table(v1), vn1)\n",
    "\n",
    "# check (NOT v2)\n",
    "vn2 = np.array([[0, 1], [1, 0], [0, 1], [1, 0]], dtype=bool)\n",
    "assert_array_equal(not_table(v2), vn2)\n",
    "\n",
    "print(\"Success!\")"
   ]
  }
 ],
 "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}