DSiP-3-NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "slide_helper": "subslide_end",
     "slide_type": "subslide"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "# Data Science in Python (DSiP) - A short introduction to Numpy\n",
    "\n",
    "\n",
    "by [Michael Granitzer (michael.granitzer@uni-passau.de)](http://www.mendeley.com/profiles/michael-granitzer/) \n",
    "and [Konstantin Ziegler (konstantin.ziegler@uni-passau.de)](http://zieglerk.net)\n",
    "\n",
    "based on the following sources\n",
    "\n",
    "* [Marcel Caraciolo](https://github.com/marcelcaraciolo), \n",
    "  [Big Data Tutorial](https://github.com/marcelcaraciolo/big-data-tutorial)\n",
    "* [J.R. Johansson (robert@riken.jp)](http://dml.riken.jp/~rob/), \n",
    "  [Scientific Programming in Pyton](http://github.com/jrjohansson/scientific-python-lectures)\n",
    "\n",
    "__License__\n",
    "\n",
    "This work is licensed under a [Creative Commons Attribution 3.0 Unported License](http://creativecommons.org/licenses/by/3.0/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "slide_helper": "subslide_end",
     "slide_type": "subslide"
    },
    "slide_helper": "slide_end",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Content\n",
    "1. Overview\n",
    "2. Numpy's Basic Data Structure - Multidimensional Arrays\n",
    "   1. Array Creation \n",
    "   1. Properties of Arrays\n",
    "   2. File I/O\n",
    "3. Slicing and Indexing Arrays\n",
    "4. Operations on numpy Arrays\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Overview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_number": 3
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## What is Numpy?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 4,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A Python library that provides \n",
    "\n",
    "* a multidimensional array object\n",
    "* various derived objects (such as masked arrays and matrices)\n",
    "* and an assortment of routines for fast operations on arrays, e.g. \n",
    "  * mathematical, logical, shape\n",
    "  * manipulation, sorting, selecting\n",
    "  * I/O, discrete Fourier transforms\n",
    "  * basic linear algebra, basic statistical operations, \n",
    "  * random simulation \n",
    "  * and much more"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 4,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Numpy vs. Build-in Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 6,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Why not simply use Python lists for computations instead of using new multidimensional arrays? \n",
    "\n",
    "There are several reasons:\n",
    "\n",
    "* Python lists are very general. They can contain any kind of object. They are dynamically typed. They do not support mathematical functions such as matrix and dot multiplications, etc. Implementating such functions for Python lists would not be very efficient because of the dynamic typing.\n",
    "* Numpy arrays are **statically typed** and **homogeneous**. The type of the elements is determined when array is created.\n",
    "* Numpy arrays are memory efficient.\n",
    "* Because of the static typing, fast implementation of mathematical functions such as multiplication and addition of `numpy` arrays can be implemented in a compiled language (C and Fortran is used).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 6,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 8,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "slide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#import numpy here\n",
    "import numpy as np\n",
    "\n",
    "# set some print options\n",
    "np.set_printoptions(precision=4)\n",
    "np.set_printoptions(threshold=5)\n",
    "np.set_printoptions(suppress=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 8,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#  Numpy's basic data structure: the ndarray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 10
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "\n",
    "* An Numpy `ndarray` is a multidimensional array object \n",
    "* Every array entry must correspond to preset data types (simple types like float, int etc. or complex types like strings, tupels)\n",
    "* an `ndarray` acts as container for data to be passed between algorithms\n",
    "* libraries written in a lower-level language, such as C or Fortran, can operate on the data stored in a NumPy array without copying any data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 11,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 9, 5, 4, 3])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# build an array using the array function\n",
    "arr = np.array([0, 9, 5, 4, 3])\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 11,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Array creation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 13
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "There are several functions that are used to create new arrays:\n",
    "\n",
    "* from 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": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 14
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  0.,  0.,  0.])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#returns an array with zeros\n",
    "np.zeros(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 15
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  1.,  1.,  1.])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#returns an array with ones\n",
    "np.ones(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 16
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  0.,  0.,  0.])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#returns an empty, non initalized array\n",
    "np.empty(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 17
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#similar to range\n",
    "np.arange(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 18
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a diagonal matrix\n",
    "np.diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 19
    },
    "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": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diagonal with offset from the main diagonal\n",
    "np.diag([1,2,3], k=1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 20
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a vector: the argument to the array function is a Python list\n",
    "v = np.array([1,2,3,4])\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 21,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a matrix: the argument to the array function is a nested Python list\n",
    "M = np.array([[1, 2], [3, 4]])\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 21,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Type, size and shape of an array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 23,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "* all elements of an `ndarray` are of the same type. \n",
    "* The `ndarray.dtype` property is an attribute that specifies the data type\n",
    "of each element. \n",
    "* The `ndarray.shape` property is a tuple that indicates the size of each\n",
    "dimension.\n",
    "* The `ndarray.size` proprety indicates the number of elements in the array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 23,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 25
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.4168, -0.0563, -2.1362,  1.6403, -1.7934])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# init random gen\n",
    "np.random.seed(2)\n",
    "\n",
    "arr = np.random.randn(5)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 26
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 27
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 28
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0], dtype=int32)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can be explicit about the data type that you want\n",
    "np.empty(4, dtype=np.int32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 29
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([b'numpy', b'pandas', b'pytables'], \n",
       "      dtype='|S8')"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(['numpy','pandas','pytables'], dtype=np.string_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 30,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  5,  0, 98], dtype=int32)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#type casting\n",
    "float_arr = np.array([4.4, 5.52425, -0.1234, 98.1], dtype=np.float64)\n",
    "# truncate the decimal part\n",
    "float_arr.astype(np.int32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 30,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Type casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 30
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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": 48,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 30
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 30
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  2.],\n",
       "       [ 3.,  4.]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 30
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 30,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]], dtype=bool)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 30,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 38
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "  * Loading and Storing Numpy arrays from CSV Files\n",
    "  * Loading and Storing Numpy arrays in binary format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 39
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": [
    "#show first lines of file \n",
    "!head 'data/stockholm_td_adj.dat'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 40
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#load data from csv file\n",
    "data = np.genfromtxt('data/stockholm_td_adj.dat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 41,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 41,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Now we can __plot__ the data using matplotlib. (for details see lecture on matplotlib)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 43,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0MAAAEZCAYAAABVSv5XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBEEQBDEiIWWIIAiCIAiCIIgRyf8HqqzI9TXT9J0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcb11d42e80>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots(figsize=(14,4))\n",
    "ax.plot(data[:,0]+data[:,1]/12.0+data[:,2]/365, data[:,5])\n",
    "ax.axis('tight')\n",
    "ax.set_title('tempeatures in Stockholm')\n",
    "ax.set_xlabel('year')\n",
    "ax.set_ylabel('temperature (C)');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 43,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Saving a matrix as CSV\n",
    "Using `numpy.savetxt` we can store a Numpy array to a file in CSV format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 45
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.2046,  0.6193,  0.2997],\n",
       "       [ 0.2668,  0.6211,  0.5291],\n",
       "       [ 0.1346,  0.5136,  0.1844]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.random.rand(3,3)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 46
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "np.savetxt(\"random-matrix.csv\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 47
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.046486340378425028e-01 6.192709663506636986e-01 2.996546736745231421e-01\r\n",
      "2.668272751028666345e-01 6.211338327692949024e-01 5.291420942770390656e-01\r\n",
      "1.345799453449335603e-01 5.135781212657464234e-01 1.844398656469152797e-01\r\n"
     ]
    }
   ],
   "source": [
    "# ! escapes a shell command. we use the linux command `cat` to display the content of the file\n",
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 48,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.20465 0.61927 0.29965\r\n",
      "0.26683 0.62113 0.52914\r\n",
      "0.13458 0.51358 0.18444\r\n"
     ]
    }
   ],
   "source": [
    "np.savetxt(\"random-matrix.csv\", M, fmt='%.5f') # fmt specifies the format\n",
    "\n",
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 48,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Numpy's native file format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 48
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Useful when storing and reading back numpy array data. Use the functions `numpy.save` and `numpy.load`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 51
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "random-matrix.npy: data\r\n"
     ]
    }
   ],
   "source": [
    "np.save(\"random-matrix.npy\", M)\n",
    "\n",
    "!file random-matrix.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 52,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "slide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.2046,  0.6193,  0.2997],\n",
       "       [ 0.2668,  0.6211,  0.5291],\n",
       "       [ 0.1346,  0.5136,  0.1844]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.load(\"random-matrix.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 52,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Accessing Arrays - Slicing and Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 54,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "* Numpy supports simple indexing (as in Python) \n",
    "* Additionally, fancy indexing methods \n",
    "  * Boolean indexing\n",
    "  * List indexing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 54,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Simple Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 56,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "As you expect it from Python: \n",
    "* `[idx]`\n",
    "* `[begin:end:stepsize]`\n",
    "  * Default values\n",
    "    * begin = 0\n",
    "    * end = last element\n",
    "    * stepsize = 1\n",
    "    * colons are optional\n",
    "* Negativ indizes are counted from the last element.\n",
    "  * `-i` is the short form of  `n - i` with `n` begin the number of elements in the array "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 56,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 58
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([0, 9, 1, 4, 64])\n",
    "arr[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 59
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 1])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 60
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 9])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 61,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  9,  1, 55, 55])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set the last two elements to 55 \n",
    "arr[-2:] = 55\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 61,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Indexing and Slicing with multiple dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 63,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "\n",
    "**Indexing**\n",
    "* multidimensional indexing: selecting a particular index from a multidimensional array\n",
    "* the selection can be understood as moving along the values of the shape property\n",
    "\n",
    "**Example:** \n",
    "A 4d array `arr_4d`, with a shape of `(w,x,y,z)` will result in indexed views such that:\n",
    "\n",
    "    \n",
    "    arr_4d[i].shape == (x,y,z)\n",
    "    arr_4d[i,j].shape == (y,z)\n",
    "    arr_4d[i,j,k].shape == (z,)\n",
    "\n",
    "**Slicing**\n",
    "* slicing: selecting a subset of multidimensional arrays allows \n",
    "* For slicing you select a range of elements along a particular axis:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 63,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Python Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 65
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  5. ,   3. ,   4. ],\n",
       "       [  0. ,   1. ,   2. ],\n",
       "       [  1. ,   1. ,  10. ],\n",
       "       [  0. ,   0. ,   0.1]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_2d = np.array([[5,3,4],[0,1,2],[1,1,10],[0,0,0.1]])\n",
    "arr_2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 66
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.,  3.,  4.])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the first row\n",
    "arr_2d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 67
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.,  0.,  1.,  0.])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the first column\n",
    "arr_2d[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 68
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.,  3.,  4.],\n",
       "       [ 0.,  1.,  2.]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the first two rows\n",
    "arr_2d[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 69,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 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]]\n",
      "[[11 12 13]\n",
      " [21 22 23]\n",
      " [31 32 33]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "print (A)\n",
    "# a block from the original array\n",
    "print (A[1:4, 1:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 69,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Careful, it's a view!\n",
    "\n",
    "A slice does not return a copy, which means that any modifications will be\n",
    "reflected in the source array. This is a design feature of NumPy to avoid memory\n",
    "problems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 71
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  3,  1,  4, 64])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([0, 3, 1, 4, 64])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 72,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  3,  1, 99, 64])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subarr = arr[2:4]\n",
    "subarr[1] = 99\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 72,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Fancy, Boolean Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 74
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "**Boolean indexing** allows you to select data subsets of an array that satisfy a given condition.\n",
    "\n",
    "**Boolean Index Mask** defines a boolean numpy array of type `bool` where an element is selected (True) or not (False) depending on the value of the index mask at the position each element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 75
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#simple example\n",
    "arr = np.array([10, 20])\n",
    "idx = np.array([True, False])\n",
    "arr[idx]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 76,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.8417,  0.4801,  0.387 ,  1.2105, -0.0201])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#creating test data\n",
    "arr_2d = np.random.randn(5)\n",
    "arr_2d\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 76,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False, False,  True], dtype=bool)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#getting a boolean index array\n",
    "arr_2d < 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 78
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.8417, -0.0201])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#using a boolean index array inplace\n",
    "arr_2d[arr_2d < 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 79
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.0201])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#complex boolean expressions\n",
    "arr_2d[(arr_2d > -0.5) & (arr_2d < 0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 80,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.    ,  0.4801,  0.387 ,  1.2105,  0.    ])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#setting the value based on a boolean indexing array\n",
    "arr_2d[arr_2d < 0] = 0\n",
    "arr_2d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 80,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## (Fancy) list-of-locations indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 82
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Fancy indexing is indexing with integer arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 83
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11],\n",
       "       [12, 13, 14],\n",
       "       [15, 16, 17]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#the data. 18 elements in 6 rows and 3 columns\n",
    "arr = np.arange(18).reshape(6,3)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 84
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [12, 13, 14],\n",
       "       [12, 13, 14]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fancy selection of rows in a particular order\n",
    "arr[[0,4,4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 85
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([17, 10,  3])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#select elements [5,2], [3,1],[1,0]\n",
    "arr[[5,3,1],[2,1,0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 86,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "complex submatrix\n",
      " [[17 16]\n",
      " [11 10]\n",
      " [ 5  4]]\n",
      "simple submatrix\n",
      " [[17 16]\n",
      " [11 10]\n",
      " [ 5  4]]\n",
      "Cross product for N 1 D sequences\n",
      " (array([[5],\n",
      "       [3],\n",
      "       [1]]), array([[2, 1]]))\n"
     ]
    }
   ],
   "source": [
    "# select a submatrix\n",
    "print (\"complex submatrix\\n\", arr[[[5],[3],[1]],[[2,1]]])\n",
    "print (\"simple submatrix\\n\", arr[np.ix_([5,3,1],[2,1])])\n",
    "\n",
    "print (\"Cross product for N 1 D sequences\\n\", np.ix_([5,3,1],[2,1]))\n",
    "np.ix_?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 86,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Functions for extracting data from arrays and creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 88,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `where`: getting indizes from a mask \n",
    "* `diag`: extracting a diagonal matrix\n",
    "* `take`: similar to fancy indexing\n",
    "* `choose`: Constructs and array by picking elements form several arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 88,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**where**\n",
    "\n",
    "The `where` function of Numpy returns the index of an element.\n",
    "\n",
    "Command is of form `numpy.where(array==item)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 90
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function where in module numpy.core.multiarray:\n",
      "\n",
      "where(...)\n",
      "    where(condition, [x, y])\n",
      "    \n",
      "    Return elements, either from `x` or `y`, depending on `condition`.\n",
      "    \n",
      "    If only `condition` is given, return ``condition.nonzero()``.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    condition : array_like, bool\n",
      "        When True, yield `x`, otherwise yield `y`.\n",
      "    x, y : array_like, optional\n",
      "        Values from which to choose. `x` and `y` need to have the same\n",
      "        shape as `condition`.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray or tuple of ndarrays\n",
      "        If both `x` and `y` are specified, the output array contains\n",
      "        elements of `x` where `condition` is True, and elements from\n",
      "        `y` elsewhere.\n",
      "    \n",
      "        If only `condition` is given, return the tuple\n",
      "        ``condition.nonzero()``, the indices where `condition` is True.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    nonzero, choose\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    If `x` and `y` are given and input arrays are 1-D, `where` is\n",
      "    equivalent to::\n",
      "    \n",
      "        [xv if c else yv for (c,xv,yv) in zip(condition,x,y)]\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.where([[True, False], [True, True]],\n",
      "    ...          [[1, 2], [3, 4]],\n",
      "    ...          [[9, 8], [7, 6]])\n",
      "    array([[1, 8],\n",
      "           [3, 4]])\n",
      "    \n",
      "    >>> np.where([[0, 1], [1, 0]])\n",
      "    (array([0, 1]), array([1, 0]))\n",
      "    \n",
      "    >>> x = np.arange(9.).reshape(3, 3)\n",
      "    >>> np.where( x > 5 )\n",
      "    (array([2, 2, 2]), array([0, 1, 2]))\n",
      "    >>> x[np.where( x > 3.0 )]               # Note: result is 1D.\n",
      "    array([ 4.,  5.,  6.,  7.,  8.])\n",
      "    >>> np.where(x < 5, x, -1)               # Note: broadcasting.\n",
      "    array([[ 0.,  1.,  2.],\n",
      "           [ 3.,  4., -1.],\n",
      "           [-1., -1., -1.]])\n",
      "    \n",
      "    Find the indices of elements of `x` that are in `goodvalues`.\n",
      "    \n",
      "    >>> goodvalues = [3, 4, 7]\n",
      "    >>> ix = np.in1d(x.ravel(), goodvalues).reshape(x.shape)\n",
      "    >>> ix\n",
      "    array([[False, False, False],\n",
      "           [ True,  True, False],\n",
      "           [False,  True, False]], dtype=bool)\n",
      "    >>> np.where(ix)\n",
      "    (array([1, 1, 2]), array([0, 1, 1]))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help (np.where)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 91,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value=17 (array([5]), array([2]))\n",
      "value>10 (array([3, 4, 4, ..., 5, 5, 5]), array([2, 0, 1, ..., 0, 1, 2]))\n"
     ]
    }
   ],
   "source": [
    "print (\"value=17\",np.where(arr==17))\n",
    "print (\"value>10\",np.where(arr>10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 91,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**diag**\n",
    "\n",
    "With the diag function we can also extract the diagonal and subdiagonals of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 93
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]\n",
      " [12 13 14]\n",
      " [15 16 17]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0, 4, 8])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print (arr)\n",
    "print\n",
    "np.diag(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 94,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  7, 11])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(arr, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 94,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**choose**\n",
    "\n",
    "Constructs and array by picking elements form several arrays as follows\n",
    "\n",
    "    np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 96,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -3,  6, -2])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "which = [1, 0, 1, 0]\n",
    "choices = [[-2,-3,-2,-2], [5,5,6,5]]\n",
    "\n",
    "np.choose(which, choices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 96,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Element assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 98
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "We can assign new values to elements in an array using indexing techniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 99
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.0796  0.5052]\n",
      " [ 0.0653  0.4281]]\n",
      "[[ 1.      0.5052]\n",
      " [ 0.0653  0.4281]]\n"
     ]
    }
   ],
   "source": [
    "M = np.random.rand(2,2)\n",
    "print (M)\n",
    "M[0,0] = 1\n",
    "print\n",
    "print (M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 100,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.      0.5052]\n",
      " [ 0.      0.    ]]\n"
     ]
    }
   ],
   "source": [
    "# also works for rows and columns\n",
    "M[1,:] = [0, 0]\n",
    "print (M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 100,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Array slices are *mutable*:**\n",
    "\n",
    "if array slices are assigned a new value the original array from which the slice was extracted is modified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 102,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "slide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1 -2 -3  4  5]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([1,2,3,4,5])\n",
    "A[1:3] = [-2,-3]\n",
    "print (A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 102,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Operations on numpy Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 104,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "* Numpy allows us to express operations without writing any for loops. These operations are key to high performance computing\n",
    "* How operations are performed depend whether we consider a multdimensional array as \n",
    "  - `ndarray`\n",
    "  - `matrix`\n",
    "  \n",
    "**Operations on matrices:** Operations on matrices follow the standard linear algebra rules.\n",
    "\n",
    "**Operations on arrays:** Operations between arrays are performed element-wise. So arrays must have the same shape. Arrays of different size are **broadcasted** to get the same size. \n",
    "Broadcasting is subject to certain constraints where the smaller array is “broadcast” across the larger array so that they have compatible shapes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 104,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Linear Algebra and Matrix Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 106,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We will take a look at\n",
    "\n",
    "  * Scalar-array operations\n",
    "  * Element-wise array operations\n",
    "  * Matrix Algebra\n",
    "  * Array/Matrix Transformations\n",
    "  * Matrix Computations\n",
    "  * Data Processing\n",
    "  * Computations on subsets of arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 106,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Scalar-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 108
    },
    "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": 140,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 109
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1]\n"
     ]
    }
   ],
   "source": [
    "v1 = np.arange(0, 2)\n",
    "print (v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 110
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 111
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 112,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 2]\n",
      " [4 4]]\n",
      "[[3 3]\n",
      " [4 4]]\n"
     ]
    }
   ],
   "source": [
    "#create the data first using a list\n",
    "A = np.array([[1,1],[2,2]])\n",
    "print (A * 2)\n",
    "print\n",
    "print (A + 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 112,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Element-wise array-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 114
    },
    "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": 144,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 115
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[[1 1]\n",
      " [4 4]]\n",
      "[[1 1]\n",
      " [2 2]]\n"
     ]
    }
   ],
   "source": [
    "print (type(A))\n",
    "print (A * A) # element-wise multiplication\n",
    "print (A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 116
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1]\n",
      " [2 2]]\n",
      "[0 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [0, 2]])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#sizes are adjusted. that is called broadcasting and we look into this later\n",
    "print (A)\n",
    "print\n",
    "print (v1)\n",
    "A * v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 117,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print (type(v1))\n",
    "v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 117,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Element-wise multiplication\n",
    "If we multiply arrays with compatible shapes, we get an element-wise multiplication of each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 117,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [4, 4]])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 117,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Matrix algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 117
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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": 148,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 122
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 3],\n",
       "       [6, 6]])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 123
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 124,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 124,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Matrix multiplication via casts\n",
    "\n",
    "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": 151,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 124
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0],\n",
       "        [1]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.matrix(A)\n",
    "v = np.matrix(v1).T # make it a column vector (T is the transpose operation)\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 124,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.matrixlib.defmatrix.matrix'> <class 'numpy.matrixlib.defmatrix.matrix'>\n"
     ]
    }
   ],
   "source": [
    "#Note that M and v are of type matrix\n",
    "print (type(M), type(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 124,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[3, 3],\n",
       "        [6, 6]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M*M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 129
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1],\n",
       "        [2]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M*v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 130
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inner product\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 131,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1],\n",
       "        [3]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# with matrix objects, standard matrix algebra applies\n",
    "v + M*v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 131,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Boundary Checks \n",
    "If we try to add, subtract or multiply objects with incomplatible shapes we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 131
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "v = np.matrix([1,2,3,4,5,6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 131
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 2), (6, 1))"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(M), np.shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 135
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (2,2) and (6,1) not aligned: 2 (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-159-995fb48ad0cc>\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[0m\n\u001b[0m",
      "\u001b[0;32m/root/anaconda3/lib/python3.5/site-packages/numpy/matrixlib/defmatrix.py\u001b[0m in \u001b[0;36m__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    341\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[0m\n\u001b[1;32m    342\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[0m\n\u001b[0;32m--> 343\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[0m\n\u001b[0m\u001b[1;32m    344\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[0m\n\u001b[1;32m    345\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[0m\n",
      "\u001b[0;31mValueError\u001b[0m: shapes (2,2) and (6,1) not aligned: 2 (dim 1) != 6 (dim 0)"
     ]
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 135,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "See also the related functions: `inner`, `outer`, `cross`, `kron`, `tensordot`. Try for example `help(kron)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 135,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Array/Matrix transformations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 135
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Above we have used the `.T` to transpose the matrix object `v`. We could also have used the `transpose` function to accomplish the same thing. \n",
    "\n",
    "Other mathematical functions that transforms matrix objects are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 139
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "C = np.matrix([[1j, 2j], [3j, 4j]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 140,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "np.conjugate(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 140,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Hermitian conjugate\n",
    "   \n",
    "   * =transpose + conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 140
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "C.H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 143
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can extract the real and imaginary parts of complex-valued arrays using `real` and `imag`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 144
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "np.real(C) # same as: C.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "np.imag(C) # same as: C.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Or the complex argument and absolute value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "np.angle(C+1) # heads up MATLAB Users, angle is used instead of arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "np.abs(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145,
     "slide_helper": "subslide_end",
     "slide_type": "subslide"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Matrix Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from numpy.linalg import inv\n",
    "inv(C) # equivalent to C.I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "C.I * C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Determinant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from numpy.linalg import det\n",
    "det(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "det(C.I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 145,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 157
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "\n",
    "Vectorized operations between arrays of different sizes and between arrays and\n",
    "scalars are subject to the rules of broadcasting. The idea is quite simple in many cases like with scalars:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 158
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "arr = np.array([0, 9, 1.02, 4, 64])\n",
    "5 * arr "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 159
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "10 + arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 160,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "arr ** .5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 160,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Complex broadcasting rules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 162,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* The case of arrays of different shapes is slightly more complicated. \n",
    "* When operating on two arrays, NumPy compares their shapes element-wise. It starts with the trailing dimensions, and works its way forward. Two dimensions are compatible when\n",
    "  * they are equal, or\n",
    "  * one of them is 1\n",
    "\n",
    "see http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 162,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#lets make a 4 row 2 column array\n",
    "arr = np.random.randn(4,2)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 164
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#assume we know the mean over rows\n",
    "mean_row = np.array([ 0.2782,  0.4383])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 165
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# subtract the mean from the array. \n",
    "# The mean vector is automatically r times repeated with r being \n",
    "# the number of rows of arr\n",
    "centered_rows = arr - mean_row\n",
    "centered_rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 166,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#now do the same via the oclumns\n",
    "mean_col = np.array([ 1.4218, -0.5382, -0.0286,  0.5779])\n",
    "mean_col"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 166,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#Only one array gets broadcasted\n",
    "#here broadcasting does not work. \n",
    "# arr:      4 x 2\n",
    "# mean_col: 1 x 4\n",
    "centered_cols = arr - mean_col"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 168
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# make the 1-D array a column vector\n",
    "mean_col.reshape((4,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#Broadcasting now works\n",
    "# arr:      4 x 2\n",
    "# mean_col: 4 x 1\n",
    "centered_cols = arr - mean_col.reshape((4,1))\n",
    "centered_rows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Data Processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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 data from the Stockholm temperature dataset used above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# reminder, the tempeature dataset is stored in the data variable:\n",
    "np.shape(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# the temperature data is in column 3\n",
    "np.mean(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "The daily mean temperature in Stockholm over the last 200 year so has been about 6.2 C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### standard deviations and variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "np.std(data[:,3]), np.var(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### min and max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# lowest daily average temperature\n",
    "data[:,3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# highest daily average temperature\n",
    "data[:,3].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### sum, prod, and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "d = np.arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 183,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# sum up all elements\n",
    "np.sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 183,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# product of all elements\n",
    "np.prod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 185
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# cummulative sum\n",
    "np.cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 186
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# cummulative product\n",
    "np.cumprod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 187,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "  # same as: diag(A).sum()\n",
    "np.trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 187,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Computations on subsets of arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 187
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "We can compute with subsets of the data in an array using indexing, fancy indexing, and the other methods of extracting data from an array (described above).\n",
    "\n",
    "For example, let's go back to the temperature dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 190
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "!head -n 3 stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 191
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The dataformat is: year, month, day, daily average temperature, low, high, location.\n",
    "\n",
    "If we are interested in the average temperature only in a particular month, say February, then we can create a index mask and use the select out only the data for that month using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 192
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "np.unique(data[:,1]) # the month column takes values from 1 to 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 193
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "mask_feb = data[:,1] == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 194,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# the temperature data is in column 3\n",
    "np.mean(data[mask_feb,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 194,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Example: Extracting average monthly average temperatures\n",
    "With these tools we have very powerful data processing capabilities at our disposal. For example, to extract the average monthly average temperatures for each month of the year only takes a few lines of code: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 196,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "months = np.arange(1,13)\n",
    "monthly_mean = [np.mean(data[data[:,1] == month, 3]) \\\n",
    "                for month in months] \n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.bar(months, monthly_mean)\n",
    "ax.set_xlabel(\"Month\")\n",
    "ax.set_ylabel(\"Monthly avg. temp.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 196,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Calculations with higher-dimensional data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 196
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "When functions such as `min`, `max`, etc., is applied to a multidimensional arrays, it is sometimes useful to apply the calculation to the entire array, and sometimes only on a row or column basis. Using the `axis` argument we can specify how these functions should behave: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 196
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "m = np.random.rand(3,3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 200
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# global max\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 201
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# max in each column\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 202
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# max in each row\n",
    "m.max(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 203,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Many other functions and methods in the `array` and `matrix` classes accept the same (optional) `axis` keyword argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 203,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### A note about NANs (Not a Number) \n",
    "\n",
    "Per the floating point standard IEEE 754, NaN is a floating point value that, by definition, is not equal to any other floating point value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 205
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "np.nan == np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 206
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#so nan checking with equals does  not work\n",
    "np.array([10,5,4,np.nan,1,np.nan]) == np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 207,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#we need to use Numpy's isnan function\n",
    "np.isnan(np.array([10,5,4,np.nan,1,np.nan]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 207,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Reshaping, resizing and stacking arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 207
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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.\n",
    "\n",
    "This is due to the representation of all multidimensional arrays as a one dimensional array. The shape only determines the mapping of a multidimensional coordinate on a one dimensional array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 210
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 211
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "n, m= A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 212
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "B = A.reshape((1,n*m))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 213
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "B[0,0:5] = 5 # modify the array\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 214,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "A # and the original variable is also changed. B is only a different view of the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 214,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Flatten\n",
    "\n",
    "We can also use the function `flatten` to make a higher-dimensional array into a vector. But this function **creates a copy of the data**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 216
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "B = A.flatten()\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 217
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "B[0:5] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 218,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "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": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 218,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Adding a new dimension: newaxis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 218
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "With `newaxis`, we can insert new dimensions in an array, for example converting a vector to a column or row matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 218
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "v = np.array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 218
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "np.shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 223
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# make a column matrix of the vector v\n",
    "v[:, newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 224
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# column matrix\n",
    "v[:,newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# row matrix\n",
    "v[newaxis,:].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Stacking and repeating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Using function `repeat`, `tile`, `vstack`, `hstack`, and `concatenate` we can create larger vectors and matrices from smaller ones:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### tile and repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = np.array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, ..., 4, 4, 4])"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repeat each element 3 times\n",
    "np.repeat(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tile the matrix 3 times \n",
    "np.tile(a, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "b = np.array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### hstack and vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((a,b.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Copy and \"deep copy\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "To achieve high performance, **assignments in Python usually do not copy the underlying 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 (techincal term: pass by reference). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# now B is referring to the same array data as A \n",
    "B = A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# changing B affects A\n",
    "B[0,0] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_type": "subslide"
    },
    "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": 172,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "B = np.copy(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now, if we modify B, A is not affected\n",
    "B[0,0] = -5\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Iterating over array elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 225
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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": 175,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 251
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1,2,3,4])\n",
    "\n",
    "for element in v:\n",
    "    print (element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 252,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "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 = np.array([[1,2], [3,4]])\n",
    "\n",
    "for row in M:\n",
    "    print (\"row\", row)\n",
    "    \n",
    "    for element in row:\n",
    "        print (element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 252,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### For-loops with enumerate\n",
    "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": 177,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 252
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row_idx 0 row [1 2]\n",
      "col_idx 0 element 1\n",
      "col_idx 1 element 2\n",
      "row_idx 1 row [3 4]\n",
      "col_idx 0 element 3\n",
      "col_idx 1 element 4\n"
     ]
    }
   ],
   "source": [
    "for row_idx, row in enumerate(M):\n",
    "    print (\"row_idx\", row_idx, \"row\", row)\n",
    "    \n",
    "    for col_idx, element in enumerate(row):\n",
    "        print (\"col_idx\", col_idx, \"element\", element)\n",
    "       \n",
    "        # update the matrix M: square each element\n",
    "        M[row_idx, col_idx] = element ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 252,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# each element in M is now squared\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 252,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Vectorizing functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 252
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Another way of looping is applying a function over every element of an array. This can be done via the Numpy `vectorized` function. It can result in a slight speed improvement due to caching, but does not provide a speed improvement in general. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 258
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": 180,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259
    },
    "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-180-d55419725688>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mTheta\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-179-9a0cb13d93d4>\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[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[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[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "Theta(np.array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "OK, that didn't work because we didn't write the `Theta` function so that it can handle a vector input. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Get a vectorized function\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": 181,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "Theta_vec = np.vectorize(Theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, ..., 1, 1, 1])"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from array import array\n",
    "Theta_vec([-3,-2,-1,0,1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Using a vector-aware function**\n",
    "\n",
    "We can also implement the function to accept vector input from the beginning (requires more effort but might give better performance):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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": 184,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, ..., 1, 1, 1])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta(np.array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# still works for scalars as well\n",
    "Theta(-1.2), Theta(2.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using arrays in conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "When using arrays in conditions in for example `if` statements and other boolean expressions, one need to use one of `any` or `all`, which requires that any or all elements in the array evalutes to `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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": 188,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "slide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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": {
    "heading_collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "slide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Conduct Exercise [DSiP-3-1 Numpy](exercises/Exercise%20DSiP-3-1-Numpy.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Appendix Volume vs. Area in high dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEACAYAAABI5zaHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nggAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcb20138cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from numpy.linalg import norm as d\n",
    "from matplotlib import pyplot as pl\n",
    "\n",
    "def Monte_Carlo_volume(n_dim=2, n_samples=1000):\n",
    "    points = np.random.ranf((n_samples, n_dim))-.5\n",
    "    insiders = [int(d(x)<=1) for x in points]\n",
    "    return sum(insiders)/n_samples\n",
    "\n",
    "max_dim = 25\n",
    "volumes = [Monte_Carlo_volume(n_dim=n) for n in range(1, max_dim)]\n",
    "\n",
    "pl.plot(range(1, max_dim), volumes, \".\")\n",
    "pl.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## References and further reading\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 259
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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.\n",
    "- William Wesley McKinney. Python for Data Analysis. O’Reilly, 2012."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "512px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}