Basics-2-Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numpy -  multidimensional data arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Parts of this notebook have been taken from:\n",
    "\n",
    "[http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\n",
    "\n",
    "The other notebooks in this lecture series are indexed at [http://jrjohansson.github.io](http://jrjohansson.github.io)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "To use `numpy` you need to import the module, using for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from numpy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In the `numpy` package the terminology used for vectors, matrices and higher-dimensional data sets is *array*. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Creating `numpy` arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## From lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a vector: the argument to the array function is a Python list\n",
    "v = array([1,2,3,4])\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a matrix: the argument to the array function is a nested Python list\n",
    "M = array([[1, 2], [3, 4]])\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `v` and `M` objects are both of the type `ndarray` that the `numpy` module provides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v), type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The number of elements in the array is available through the `ndarray.size` property:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Equivalently, we could use the function `numpy.shape` and `numpy.size`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "So far the `numpy.ndarray` looks awfully 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:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Python lists are very general. They can contain any **kind of object**. They are **dynamically typed**. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* They do not support mathematical functions such as matrix and dot multiplications, etc. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Implementing such functions for Python lists would not be very efficient because of the dynamic typing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Numpy arrays are **statically typed** and **homogeneous**. The type of the elements is determined when the array is created.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Numpy arrays are memory efficient.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* 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)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "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": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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-11-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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 2.+0.j],\n",
       "       [3.+0.j, 4.+0.j]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = array([[1, 2], [3, 4]], dtype=complex)\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using array-generating functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `arange`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(start=0, stop=10, step=1) # arguments: start, stop, step\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(-1, 1, 0.1)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `linspace` and `logspace`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using linspace, both end points ARE included by default.\n",
    "# num is the number of samples to generate.\n",
    "linspace(start=0, stop=10, num=25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# logspace is similar to linspace but it starts with (base ** start) and finishes with (base ** end)\n",
    "logspace(0, 10, 10, base=e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Random data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.27416495, 0.37461395, 0.99389825, 0.34906947, 0.14253052],\n",
       "       [0.99230561, 0.06283221, 0.62254697, 0.73739882, 0.56613496],\n",
       "       [0.89634898, 0.29304461, 0.12389244, 0.33888226, 0.60108246],\n",
       "       [0.16200092, 0.67667864, 0.17822635, 0.29656579, 0.77486209],\n",
       "       [0.09754344, 0.29376581, 0.89560951, 0.5863796 , 0.82016457]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# uniform random numbers in [0,1]\n",
    "random.rand(5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.12998592,  2.07319635, -0.6896006 , -0.69830974, -0.8418991 ],\n",
       "       [-0.75353272,  0.13386894, -0.5838475 , -0.87444195, -0.22417816],\n",
       "       [ 2.12840758,  0.41771072,  0.03135824, -0.89192443,  1.03670214],\n",
       "       [-0.0131818 ,  0.74654267,  1.55176583,  0.94719647,  0.08157623],\n",
       "       [ 0.93888501,  0.30532397,  0.60372866,  0.1513844 , -1.43690898]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# standard normal distributed random numbers\n",
    "random.randn(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `diag`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a diagonal matrix\n",
    "diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diagonal with offset from the main diagonal\n",
    "diag([1,2,3], k=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `zeros` and `ones`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones((3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Comma-separated values (CSV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.800e+03,  1.000e+00,  1.000e+00, ..., -6.100e+00, -6.100e+00,\n",
       "         1.000e+00],\n",
       "       [ 1.800e+03,  1.000e+00,  2.000e+00, ..., -1.540e+01, -1.540e+01,\n",
       "         1.000e+00],\n",
       "       [ 1.800e+03,  1.000e+00,  3.000e+00, ..., -1.500e+01, -1.500e+01,\n",
       "         1.000e+00],\n",
       "       ...,\n",
       "       [ 2.011e+03,  1.200e+01,  2.900e+01, ...,  4.200e+00,  4.200e+00,\n",
       "         1.000e+00],\n",
       "       [ 2.011e+03,  1.200e+01,  3.000e+01, ..., -1.000e-01, -1.000e-01,\n",
       "         1.000e+00],\n",
       "       [ 2.011e+03,  1.200e+01,  3.100e+01, ..., -3.300e+00, -3.300e+00,\n",
       "         1.000e+00]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = genfromtxt('./data/stockholm_td_adj.dat')\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# what is this line all about?!? Answer in lecture 4\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(20,6))\n",
    "ax.plot(data[:,0]+data[:,1]/12.0+data[:,2]/365, data[:,5])\n",
    "ax.axis('tight')\n",
    "ax.set_title('Temperatures in Stockholm', fontsize=22)\n",
    "ax.set_xlabel('Year', fontsize=20)\n",
    "ax.set_ylabel('Temperature (ºC)', fontsize=20);\n",
    "for tick in ax.xaxis.get_major_ticks():\n",
    "    tick.label.set_fontsize(16)\n",
    "for tick in ax.yaxis.get_major_ticks():\n",
    "    tick.label.set_fontsize(16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Using `numpy.savetxt` we can store a Numpy array to a file in CSV format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.95250398, 0.57636131, 0.32609298],\n",
       "       [0.67406949, 0.65314033, 0.16487867],\n",
       "       [0.46612043, 0.30815538, 0.11233677]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = random.rand(3,3)\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "savetxt(\"random-matrix.csv\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.525039806505027906e-01 5.763613094721058427e-01 3.260929833519216059e-01\r\n",
      "6.740694924593617632e-01 6.531403314546201377e-01 1.648786743139626365e-01\r\n",
      "4.661204345223936008e-01 3.081553815900727189e-01 1.123367670423757181e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.95250 0.57636 0.32609\r\n",
      "0.67407 0.65314 0.16488\r\n",
      "0.46612 0.30816 0.11234\r\n"
     ]
    }
   ],
   "source": [
    "savetxt(\"random-matrix.csv\", M, fmt='%.5f') # fmt specifies the format\n",
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Numpy's native file format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Useful when storing and reading back numpy array data. Use the functions `numpy.save` and `numpy.load`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "random-matrix.npy: NumPy array, version 1.0, header length 118\r\n"
     ]
    }
   ],
   "source": [
    "save(\"random-matrix.npy\", M)\n",
    "\n",
    "!file random-matrix.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.95250398, 0.57636131, 0.32609298],\n",
       "       [0.67406949, 0.65314033, 0.16487867],\n",
       "       [0.46612043, 0.30815538, 0.11233677]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load(\"random-matrix.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## More properties of the numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.itemsize # bytes per element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.nbytes # number of bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.ndim # number of dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Manipulating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can index elements in an array using square brackets and indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 38,
     "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": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6531403314546201"
      ]
     },
     "execution_count": 39,
     "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.95250398, 0.57636131, 0.32609298],\n",
       "       [0.67406949, 0.65314033, 0.16487867],\n",
       "       [0.46612043, 0.30815538, 0.11233677]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.67406949, 0.65314033, 0.16487867])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The same thing can be achieved with using `:` instead of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.67406949, 0.65314033, 0.16487867])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:] # row 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.57636131, 0.65314033, 0.30815538])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:,1] # column 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can assign new values to elements in an array using indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "M[0,0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.57636131, 0.32609298],\n",
       "       [0.67406949, 0.65314033, 0.16487867],\n",
       "       [0.46612043, 0.30815538, 0.11233677]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# also works for rows and columns\n",
    "M[1,:] = 0\n",
    "M[:,2] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.57636131, -1.        ],\n",
       "       [ 0.        ,  0.        , -1.        ],\n",
       "       [ 0.46612043,  0.30815538, -1.        ]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Index slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Index slicing is the technical name for the syntax `M[lower:upper:step]` to extract part of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([1,2,3,4,5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3] = [-2,-3]\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can omit any of the three parameters in `M[lower:upper:step]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # lower, upper, step all take the default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 52,
     "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": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # first three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:] # elements from index 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Negative indices counts from the end of the array (positive index from the begining):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "A = array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-1] # the last element in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-3:] # the last three elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Index slicing works exactly the same way for multidimensional arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a block from the original array\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strides\n",
    "A[::2, ::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Fancy indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Fancy indexing is the name for when an array or list is used in-place of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 2, 3]\n",
    "A[row_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 22, 34])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "col_indices = [1, 2, -1] # remember, index -1 means the last element\n",
    "A[row_indices, col_indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can also use index masks: If the index mask is an Numpy array of data type `bool`, then an element is selected (True) or not (False) depending on the value of the index mask at the position of each element: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = array([n for n in range(5)])\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_mask = array([True, False, True, False, False])\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same thing\n",
    "row_mask = array([1,0,1,0,0], dtype=bool)\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This feature is very useful to conditionally select elements from an array, using for example comparison operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. ,\n",
       "       6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(0, 10, 0.5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True,  True,  True,  True, False, False, False,\n",
       "       False, False])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = (5 < x) * (x < 7.5)\n",
    "\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 6. , 6.5, 7. ])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions for extracting data from arrays and creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `where`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The index mask can be converted to position index using the `where` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14]),)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = where(mask)\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 6. , 6.5, 7. ])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[indices] # this indexing is equivalent to the fancy indexing x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `diag`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "With the diag function we can also extract the diagonal and subdiagonals of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `choose`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Constructs an array by picking elements from several arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -2,  5, -2])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "which = [1, 0, 1, 0]\n",
    "choices = [[-2,-2,-2,-2], [5,5,5,5]]\n",
    "\n",
    "choose(which, choices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Linear algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Scalar-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can use the usual arithmetic operators to multiply, add, subtract, and divide arrays with scalar numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "v1 = arange(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * 2, A + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Element-wise array-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "When we add, subtract, multiply and divide arrays with each other, the default behaviour is **element-wise** operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A # element-wise multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If we multiply arrays with compatible shapes, we get an element-wise multiplication of each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Matrix algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 82,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 85,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "M = matrix(A)\n",
    "v = matrix(v1).T # make it a column vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0],\n",
       "        [1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [130],\n",
       "        [230],\n",
       "        [330],\n",
       "        [430]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[30]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inner product\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [131],\n",
       "        [232],\n",
       "        [333],\n",
       "        [434]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# with matrix objects, standard matrix algebra applies\n",
    "v + M*v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If we try to add, subtract or multiply objects with incomplatible shapes we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "v = matrix([1,2,3,4,5,6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (6, 1))"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M), shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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-93-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/usr/local/Caskroom/miniconda/base/envs/RecSysFramework/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    218\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    219\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--> 220\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    221\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    222\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;31mValueError\u001b[0m: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)"
     ]
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "See also the related functions: `inner`, `outer`, `cross`, `kron`, `tensordot`. Try for example `help(kron)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Data processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 94,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reminder, the temperature dataset is stored in the data variable:\n",
    "shape(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `mean`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.197109684751585"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### standard deviations and variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.282271621340573, 68.59602320966341)"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "std(data[:,3]), var(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `min` and `max`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.8"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lowest daily average temperature\n",
    "data[:,3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.3"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# highest daily average temperature\n",
    "data[:,3].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### sum, prod, and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum up all elements\n",
    "sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# product of all elements\n",
    "prod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative sum\n",
    "cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative product\n",
    "cumprod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as: diag(A).sum()\n",
    "trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Reshaping, resizing and stacking arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 5)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n, m = A.shape\n",
    "n,m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape((1,n*m))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0,0:5] = 5 # modify the array\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 109,
     "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 110,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0:5] = 10\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 112,
     "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": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Copy and \"deep copy\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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 (More technically, it follows a \"Call by sharing\" evaluation strategy). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[1, 2], [3, 4]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# now B is referring to the same array data as A \n",
    "B = A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# changing B affects A\n",
    "B[0,0] = 10\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 117,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "B = copy(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now, if we modify B, A is not affected\n",
    "B[0,0] = -5\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iterating over array elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 120,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "v = array([1,2,3,4])\n",
    "\n",
    "for element in v:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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 = 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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 122,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for row_idx, row in enumerate(M):\n",
    "    print(\"row_idx\", row_idx, \"row\", row)\n",
    "    for col_idx, element in enumerate(row):\n",
    "        print(\"col_idx\", col_idx, \"element\", element)\n",
    "        # update the matrix M: square each element\n",
    "        M[row_idx, col_idx] = element ** 2\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# each element in M is now squared\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Vectorizing functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 125,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 126,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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-126-2cb2062a7e18>\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[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-125-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(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 127,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Theta_vec = vectorize(Theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta_vec(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 129,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 130,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# still works for scalars as well\n",
    "Theta(-1.2), Theta(2.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using arrays in conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 132,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 134,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Type casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 135,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  4.],\n",
       "       [ 9., 16.]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Let's talk about speed\n",
    "\n",
    "Pure Python is *slow*\n",
    "\n",
    "Say that we want to do something on a matrix, for example keeping only values higher than a threshold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.51146067, 0.72857267, 0.154443  , ..., 0.01317198, 0.82510176,\n",
       "        0.19098006],\n",
       "       [0.82462748, 0.22054662, 0.48847803, ..., 0.68184605, 0.31100593,\n",
       "        0.33268893],\n",
       "       [0.87327189, 0.75794155, 0.60898502, ..., 0.94561396, 0.84138455,\n",
       "        0.32213962],\n",
       "       ...,\n",
       "       [0.51949342, 0.45333584, 0.02036755, ..., 0.30696063, 0.8100174 ,\n",
       "        0.79225496],\n",
       "       [0.0253755 , 0.35498563, 0.08416521, ..., 0.98022519, 0.77048796,\n",
       "        0.75512664],\n",
       "       [0.80125664, 0.06273953, 0.92758866, ..., 0.42975459, 0.90483433,\n",
       "        0.12221472]])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold = 0.7\n",
    "\n",
    "big_matrix = random.random((10000,10000))\n",
    "big_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Solution 1 - Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "solution1_big_matrix = big_matrix.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36.4 s ± 1.95 s per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "for row_index in range(solution1_big_matrix.shape[0]):\n",
    "    for colum_index in range(solution1_big_matrix.shape[1]):\n",
    "        \n",
    "        if solution1_big_matrix[row_index, colum_index]<threshold:\n",
    "            solution1_big_matrix[row_index, colum_index] = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.72857267, 0.        , ..., 0.        , 0.82510176,\n",
       "        0.        ],\n",
       "       [0.82462748, 0.        , 0.        , ..., 0.        , 0.        ,\n",
       "        0.        ],\n",
       "       [0.87327189, 0.75794155, 0.        , ..., 0.94561396, 0.84138455,\n",
       "        0.        ],\n",
       "       ...,\n",
       "       [0.        , 0.        , 0.        , ..., 0.        , 0.8100174 ,\n",
       "        0.79225496],\n",
       "       [0.        , 0.        , 0.        , ..., 0.98022519, 0.77048796,\n",
       "        0.75512664],\n",
       "       [0.80125664, 0.        , 0.92758866, ..., 0.        , 0.90483433,\n",
       "        0.        ]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution1_big_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Solution 2 - Vectorization with boolean indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "solution2_big_matrix = big_matrix.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "565 ms ± 10 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "solution2_big_matrix[solution2_big_matrix<threshold]= 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.72857267, 0.        , ..., 0.        , 0.82510176,\n",
       "        0.        ],\n",
       "       [0.82462748, 0.        , 0.        , ..., 0.        , 0.        ,\n",
       "        0.        ],\n",
       "       [0.87327189, 0.75794155, 0.        , ..., 0.94561396, 0.84138455,\n",
       "        0.        ],\n",
       "       ...,\n",
       "       [0.        , 0.        , 0.        , ..., 0.        , 0.8100174 ,\n",
       "        0.79225496],\n",
       "       [0.        , 0.        , 0.        , ..., 0.98022519, 0.77048796,\n",
       "        0.75512664],\n",
       "       [0.80125664, 0.        , 0.92758866, ..., 0.        , 0.90483433,\n",
       "        0.        ]])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution2_big_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### In this case vectorization is aroung 50x faster than loops, it will easily be much faster in a more realistic and complex computation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Take home message: NEVER use loops for computational tasks that can be easily vectorized"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Further reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Red Color=red\n",
      "Blue Color=blue\n",
      "After foo blue color:blue\n"
     ]
    }
   ],
   "source": [
    "class Balloon():\n",
    "    def __init__(self, color: str):\n",
    "        self.color = color\n",
    "\n",
    "def foo(an_example: Balloon):\n",
    "    an_example.color == \"Red\"\n",
    "    an_example = Balloon(\"Green\")\n",
    "    an_example.color == \"Blue\"\n",
    "        \n",
    "def swap(a1: object, a2: object):\n",
    "    temp = a1\n",
    "    a1 = a2\n",
    "    a2 = temp\n",
    "    \n",
    "    \n",
    "red = Balloon(\"red\")\n",
    "blue = Balloon(\"blue\")\n",
    "\n",
    "swap(red, blue)\n",
    "print(\"Red Color={}\".format(red.color))\n",
    "print(\"Blue Color={}\".format(blue.color))\n",
    "\n",
    "foo(blue)\n",
    "print(\"After foo blue color:{}\".format(blue.color))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 148,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Theta_vec = vectorize(Theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.8 µs ± 1.43 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit \n",
    "Theta_vec(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = array([0, 0, 0, 0, 0, 0, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.31 µs ± 816 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "for index, item in enumerate(array([-3,-2,-1,0,1,2,3])):\n",
    "    b[index] = Theta(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 153,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.93 µs ± 312 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "Theta(array([-3,-2,-1,0,1,2,3]))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}