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": 1,
   "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": 2,
   "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": 2,
     "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": 3,
   "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": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#returns an array with zeros\n",
    "np.zeros(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#returns an array with ones\n",
    "np.ones(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#returns an empty, non initalized array\n",
    "np.empty(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#similar to range\n",
    "np.arange(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a diagonal matrix\n",
    "np.diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 8,
     "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": 9,
   "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": 9,
     "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": 10,
   "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": 10,
     "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": 11,
   "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": 11,
     "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": 12,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 26
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 27
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": 14,
     "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": 15,
   "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": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(['numpy','pandas','pytables'], dtype=np.string_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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": 16,
     "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": 21,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 30
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(M)\n",
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 30
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 24,
     "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": 25,
   "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": 26,
   "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": 27,
   "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": 27,
     "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": 28,
   "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": "iVBORw0KGgoAAAANSUhEUgAABIgAAAGHCAYAAADbQmmxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f4a1303f198>"
      ]
     },
     "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": 29,
   "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": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.random.rand(3,3)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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": 31,
   "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": 32,
   "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": 33,
   "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": 34,
   "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": 34,
     "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": 35,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 58
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([0, 9, 1, 4, 64])\n",
    "arr[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 59
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 1])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 60
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 9])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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": 38,
     "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": 39,
   "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": 39,
     "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": 40,
   "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": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the first row\n",
    "arr_2d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the first column\n",
    "arr_2d[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the first two rows\n",
    "arr_2d[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "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": 44,
   "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": 44,
     "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": 45,
   "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": 46,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 131
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3, 3), (6, 1))"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(M), np.shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 135
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (3,3) and (6,1) not aligned: 3 (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-47-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/home/zieglerk/local/share/anaconda3/lib/python3.5/site-packages/numpy/matrixlib/defmatrix.py\u001b[0m in \u001b[0;36m__rmul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    347\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    348\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__rmul__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 349\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[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    350\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    351\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__imul__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: shapes (3,3) and (6,1) not aligned: 3 (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": 48,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 158
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0. ,   45. ,    5.1,   20. ,  320. ])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([0, 9, 1.02, 4, 64])\n",
    "5 * arr "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 159
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 10.  ,  19.  ,  11.02,  14.  ,  74.  ])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 + arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 160,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.  ,  3.  ,  1.01,  2.  ,  8.  ])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 51,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 52,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.1971096847515854"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 53,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.2822716213405734, 68.596023209663414)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 54,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.800000000000001"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lowest daily average temperature\n",
    "data[:,3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.300000000000001"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 56,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 169
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, ..., 7, 8, 9])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 183,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum up all elements\n",
    "np.sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 183,
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# product of all elements\n",
    "np.prod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 185
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3, ..., 28, 36, 45])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative sum\n",
    "np.cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 186
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6, ...,   40320,  362880, 3628800])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative product\n",
    "np.cumprod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 187,
     "slide_helper": "subslide_end"
    },
    "slide_helper": "subslide_end",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 62,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 196
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.7853,  0.854 ,  0.4942],\n",
       "       [ 0.8466,  0.0796,  0.5052],\n",
       "       [ 0.0653,  0.4281,  0.0965]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.random.rand(3,3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 200
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.85397529263948879"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# global max\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 201
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.8466,  0.854 ,  0.5052])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each column\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false,
    "internals": {
     "frag_helper": "fragment_end",
     "frag_number": 202
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.854 ,  0.8466,  0.4281])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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 [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.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
}