Lecture-2-Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numpy -  multidimensional data arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "J.R. Johansson (robert@riken.jp) http://dml.riken.jp/~rob/\n",
    "\n",
    "The latest version of this [IPython notebook](http://ipython.org/notebook.html) lecture is available at [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\n",
    "\n",
    "The other notebooks in this lecture series are indexed at [http://jrjohansson.github.com](http://jrjohansson.github.com)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "# what is this line all about?!? Answer in lecture 4\n",
    "%pylab inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `numpy` package (module) is used in almost all numerical computation using Python. It is a package that provide high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and Fortran so when calculations are vectorized (formulated with vectors and matrices), performance is very good. \n",
    "\n",
    "To use `numpy` need to import the module it using of example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from numpy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "In the `numpy` package the terminology used for vectors, matrices and higher-dimensional data sets is *array*. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Creating `numpy` arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a number of ways to initialize new numpy arrays, for example from\n",
    "\n",
    "* a Python list or tuples\n",
    "* using functions that are dedicated to generating numpy arrays, such as `arange`, `linspace`, etc.\n",
    "* reading data from files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### From lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, to create new vector and matrix arrays from Python lists we can use the `numpy.array` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a vector: the argument to the array function is a Python list\n",
    "v = array([1,2,3,4])\n",
    "\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a matrix: the argument to the array function is a nested Python list\n",
    "M = array([[1, 2], [3, 4]])\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `v` and `M` objects are both of the type `ndarray` that the `numpy` module provides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v), type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The difference between the `v` and `M` arrays is only their shapes. We can get information about the shape of an array by using the `ndarray.shape` property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The number of elements in the array is available through the `ndarray.size` property:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Equivalently, we could use the function `numpy.shape` and `numpy.size`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "So far the `numpy.ndarray` looks awefully much like a Python list (or nested list). Why not simply use Python lists for computations instead of creating a new array type? \n",
    "\n",
    "There are several reasons:\n",
    "\n",
    "* Python lists are very general. They can contain any kind of object. They are dynamically typed. They do not support mathematical functions such as matrix and dot multiplications, etc. 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",
    "\n",
    "Using the `dtype` (data type) property of an `ndarray`, we can see what type the data of an array has:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We get an error if we try to assign a value of the wrong type to an element in a numpy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for long() with base 10: 'hello'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-a09d72434238>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mM\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"hello\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for long() with base 10: 'hello'"
     ]
    }
   ],
   "source": [
    "M[0,0] = \"hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If we want, we can explicitly define the type of the array data when we create it, using the `dtype` keyword argument: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.+0.j,  2.+0.j],\n",
       "       [ 3.+0.j,  4.+0.j]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = array([[1, 2], [3, 4]], dtype=complex)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Common type that can be used with `dtype` are: `int`, `float`, `complex`, `bool`, `object`, etc.\n",
    "\n",
    "We can also explicitly define the bit size of the data types, for example: `int64`, `int16`, `float128`, `complex128`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Using array-generating functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For larger arrays it is impractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in `numpy` that generates arrays of different forms. Some of the more common are:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a range\n",
    "\n",
    "x = arange(0, 10, 1) # arguments: start, stop, step\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ -1.00000000e+00,  -9.00000000e-01,  -8.00000000e-01,\n",
       "        -7.00000000e-01,  -6.00000000e-01,  -5.00000000e-01,\n",
       "        -4.00000000e-01,  -3.00000000e-01,  -2.00000000e-01,\n",
       "        -1.00000000e-01,  -2.22044605e-16,   1.00000000e-01,\n",
       "         2.00000000e-01,   3.00000000e-01,   4.00000000e-01,\n",
       "         5.00000000e-01,   6.00000000e-01,   7.00000000e-01,\n",
       "         8.00000000e-01,   9.00000000e-01])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(-1, 1, 0.1)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### linspace and logspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.        ,   0.41666667,   0.83333333,   1.25      ,\n",
       "         1.66666667,   2.08333333,   2.5       ,   2.91666667,\n",
       "         3.33333333,   3.75      ,   4.16666667,   4.58333333,\n",
       "         5.        ,   5.41666667,   5.83333333,   6.25      ,\n",
       "         6.66666667,   7.08333333,   7.5       ,   7.91666667,\n",
       "         8.33333333,   8.75      ,   9.16666667,   9.58333333,  10.        ])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using linspace, both end points ARE included\n",
    "linspace(0, 10, 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.00000000e+00,   3.03773178e+00,   9.22781435e+00,\n",
       "         2.80316249e+01,   8.51525577e+01,   2.58670631e+02,\n",
       "         7.85771994e+02,   2.38696456e+03,   7.25095809e+03,\n",
       "         2.20264658e+04])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logspace(0, 10, 10, base=e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### mgrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x, y = mgrid[0:5, 0:5] # similar to meshgrid in MATLAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [1, 1, 1, 1, 1],\n",
       "       [2, 2, 2, 2, 2],\n",
       "       [3, 3, 3, 3, 3],\n",
       "       [4, 4, 4, 4, 4]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### random data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.20067261,  0.31903074,  0.50413339,  0.17916857,  0.80098158],\n",
       "       [ 0.4605664 ,  0.0889817 ,  0.89913197,  0.65326837,  0.95042471],\n",
       "       [ 0.50638764,  0.93865793,  0.27431355,  0.12660373,  0.2375227 ],\n",
       "       [ 0.11655293,  0.21264332,  0.1865033 ,  0.58306332,  0.75787615],\n",
       "       [ 0.39529707,  0.58368816,  0.86195759,  0.48969116,  0.70358949]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# uniform random numbers in [0,1]\n",
    "random.rand(5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.38628886, -0.25183044, -0.75108899, -0.24938967,  0.04214111],\n",
       "       [ 2.58066361, -1.0318666 ,  0.06503565,  0.09726207,  1.63467302],\n",
       "       [ 0.43746396, -1.6740317 ,  0.70424676,  0.48901995, -0.7179185 ],\n",
       "       [ 0.6081299 ,  0.15481145,  0.78895533,  0.60471688, -1.05199935],\n",
       "       [ 0.49851063,  0.71784166, -1.18752626,  1.03286227,  0.57774408]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# standard normal distributed random numbers\n",
    "random.randn(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a diagonal matrix\n",
    "diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "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": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diagonal with offset from the main diagonal\n",
    "diag([1,2,3], k=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### zeros and ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones((3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "### Comma-separated values (CSV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very common file format for data files are the comma-separated values (CSV), or related format such as TSV (tab-separated values). To read data from such file into Numpy arrays we can use the `numpy.genfromtxt` function. For example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1800  1  1    -6.1    -6.1    -6.1 1\r\n",
      "1800  1  2   -15.4   -15.4   -15.4 1\r\n",
      "1800  1  3   -15.0   -15.0   -15.0 1\r\n",
      "1800  1  4   -19.3   -19.3   -19.3 1\r\n",
      "1800  1  5   -16.8   -16.8   -16.8 1\r\n",
      "1800  1  6   -11.4   -11.4   -11.4 1\r\n",
      "1800  1  7    -7.6    -7.6    -7.6 1\r\n",
      "1800  1  8    -7.1    -7.1    -7.1 1\r\n",
      "1800  1  9   -10.1   -10.1   -10.1 1\r\n",
      "1800  1 10    -9.5    -9.5    -9.5 1\r\n"
     ]
    }
   ],
   "source": [
    "!head stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data = genfromtxt('stockholm_td_adj.dat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0EAAAEZCAYAAABRvy5qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2610946a10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = 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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Using `numpy.savetxt` we can store a Numpy array to a file in CSV format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.33005805,  0.83865056,  0.57961497],\n",
       "       [ 0.25206785,  0.8369909 ,  0.8509039 ],\n",
       "       [ 0.82622818,  0.08387398,  0.73442222]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = rand(3,3)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "savetxt(\"random-matrix.csv\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.300580456122463868e-01 8.386505645635993211e-01 5.796149703411075382e-01\r\n",
      "2.520678545950313376e-01 8.369908984836819110e-01 8.509038976540077570e-01\r\n",
      "8.262281797172411624e-01 8.387398055365946625e-02 7.344222208274131525e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.33006 0.83865 0.57961\r\n",
      "0.25207 0.83699 0.85090\r\n",
      "0.82623 0.08387 0.73442\r\n"
     ]
    }
   ],
   "source": [
    "savetxt(\"random-matrix.csv\", M, fmt='%.5f') # fmt specifies the format\n",
    "\n",
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Numpy's native file format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Useful when storing and reading back numpy array data. Use the functions `numpy.save` and `numpy.load`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "random-matrix.npy: data\r\n"
     ]
    }
   ],
   "source": [
    "save(\"random-matrix.npy\", M)\n",
    "\n",
    "!file random-matrix.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.33005805,  0.83865056,  0.57961497],\n",
       "       [ 0.25206785,  0.8369909 ,  0.8509039 ],\n",
       "       [ 0.82622818,  0.08387398,  0.73442222]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load(\"random-matrix.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## More properties of the numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.itemsize # bytes per element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.nbytes # number of bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.ndim # number of dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Manipulating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index elements in an array using the square bracket and indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# v is a vector, and has only one dimension, taking one index\n",
    "v[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.83699089848368191"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# M is a matrix, or a 2 dimensional array, taking two indices \n",
    "M[1,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If we omit an index of a multidimensional array it returns the whole row (or, in general, a N-1 dimensional array) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.33005805,  0.83865056,  0.57961497],\n",
       "       [ 0.25206785,  0.8369909 ,  0.8509039 ],\n",
       "       [ 0.82622818,  0.08387398,  0.73442222]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.25206785,  0.8369909 ,  0.8509039 ])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The same thing can be achieved with using `:` instead of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.25206785,  0.8369909 ,  0.8509039 ])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:] # row 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.83865056,  0.8369909 ,  0.08387398])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:,1] # column 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can assign new values to elements in an array using indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M[0,0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.83865056,  0.57961497],\n",
       "       [ 0.25206785,  0.8369909 ,  0.8509039 ],\n",
       "       [ 0.82622818,  0.08387398,  0.73442222]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# also works for rows and columns\n",
    "M[1,:] = 0\n",
    "M[:,2] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.83865056, -1.        ],\n",
       "       [ 0.        ,  0.        , -1.        ],\n",
       "       [ 0.82622818,  0.08387398, -1.        ]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Index slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing is the technical name for the syntax `M[lower:upper:step]` to extract part of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([1,2,3,4,5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Array slices are *mutable*: if they are assigned a new value the original array from which the slice was extracted is modified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3] = [-2,-3]\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can omit any of the three parameters in `M[lower:upper:step]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # lower, upper, step all take the default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::2] # step is 2, lower and upper defaults to the beginning and end of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # first three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:] # elements from index 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Negative indices counts from the end of the array (positive index from the begining):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "A = array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-1] # the last element in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-3:] # the last three elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Index slicing works exactly the same way for multidimensional arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a block from the original array\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strides\n",
    "A[::2, ::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Fancy indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fancy indexing is the name for when an array or list is used in-place of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 2, 3]\n",
    "A[row_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 22, 34])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "col_indices = [1, 2, -1] # remember, index -1 means the last element\n",
    "A[row_indices, col_indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can also index masks: If the index mask is an Numpy array of with data type `bool`, then 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": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = array([n for n in range(5)])\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_mask = array([True, False, True, False, False])\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same thing\n",
    "row_mask = array([1,0,1,0,0], dtype=bool)\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This feature is very useful to conditionally select elements from an array, using for example comparison operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5,  5. ,\n",
       "        5.5,  6. ,  6.5,  7. ,  7.5,  8. ,  8.5,  9. ,  9.5])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(0, 10, 0.5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True,  True,  True,  True, False, False, False,\n",
       "       False, False], dtype=bool)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = (5 < x) * (x < 7.5)\n",
    "\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.5,  6. ,  6.5,  7. ])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Performance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Before going any further let's have a look at how Numpy compares to pure Python lists in terms of performance.\n",
    "\n",
    "To do this we implement a few examples and compare the execution speed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numpy: 5.634e-06 seconds\n",
      "list:  4.472e-05 seconds\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "from timeit import Timer\n",
    "Nelements = 10000\n",
    "Ntimeits = 10000\n",
    "\n",
    "x = arange(Nelements)\n",
    "y = range(Nelements)\n",
    "\n",
    "t_numpy = Timer(\"x.sum()\", \"from __main__ import x\")\n",
    "t_list = Timer(\"sum(y)\", \"from __main__ import y\")\n",
    "print \"numpy: %.3e seconds\" % (t_numpy.timeit(Ntimeits)/Ntimeits,)\n",
    "print \"list:  %.3e seconds\" % (t_list.timeit(Ntimeits)/Ntimeits,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions for extracting data from arrays and creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### where"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The index mask can be converted to position index using the `where` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14]),)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = where(mask)\n",
    "\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 12, 13, 14])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[indices] # this indexing is equivalent to the fancy indexing x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### diag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the diag function we can also extract the diagonal and subdiagonals of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### take"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `take` function is similar to fancy indexing described above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 = arange(-3,3)\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 3, 5]\n",
    "v2[row_indices] # fancy indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2.take(row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "But `take` also works on lists and other objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take([-3, -2, -1,  0,  1,  2], row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### choose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constructs and array by picking elements form several arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -2,  5, -2])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "which = [1, 0, 1, 0]\n",
    "choices = [[-2,-2,-2,-2], [5,5,5,5]]\n",
    "\n",
    "choose(which, choices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Linear algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vectorizing code is the key to writing efficient numerical calculation with Python/Numpy. That means that as much as possible of a program should be formulated in terms of matrix and vector operations, like matrix-matrix multiplication."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Scalar-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the usual arithmetic operators to multiply, add, subtract, and divide arrays with scalar numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "v1 = arange(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 0,  2,  4,  6,  8],\n",
       "        [20, 22, 24, 26, 28],\n",
       "        [40, 42, 44, 46, 48],\n",
       "        [60, 62, 64, 66, 68],\n",
       "        [80, 82, 84, 86, 88]]), array([[ 2,  3,  4,  5,  6],\n",
       "        [12, 13, 14, 15, 16],\n",
       "        [22, 23, 24, 25, 26],\n",
       "        [32, 33, 34, 35, 36],\n",
       "        [42, 43, 44, 45, 46]]))"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * 2, A + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Element-wise array-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we add, subtract, multiply and divide arrays with each other, the default behaviour is **element-wise** operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    1,    4,    9,   16],\n",
       "       [ 100,  121,  144,  169,  196],\n",
       "       [ 400,  441,  484,  529,  576],\n",
       "       [ 900,  961, 1024, 1089, 1156],\n",
       "       [1600, 1681, 1764, 1849, 1936]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A # element-wise multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If we multiply arrays with compatible shapes, we get an element-wise multiplication of each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   4,   9,  16],\n",
       "       [  0,  11,  24,  39,  56],\n",
       "       [  0,  21,  44,  69,  96],\n",
       "       [  0,  31,  64,  99, 136],\n",
       "       [  0,  41,  84, 129, 176]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Matrix algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about matrix mutiplication? There are two ways. We can either use the `dot` function, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 300,  310,  320,  330,  340],\n",
       "       [1300, 1360, 1420, 1480, 1540],\n",
       "       [2300, 2410, 2520, 2630, 2740],\n",
       "       [3300, 3460, 3620, 3780, 3940],\n",
       "       [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Alternatively, we can cast the array objects to the type `matrix`. This changes the behavior of the standard arithmetic operators `+, -, *` to use matrix algebra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M = matrix(A)\n",
    "v = matrix(v1).T # make it a column vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0],\n",
       "        [1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 300,  310,  320,  330,  340],\n",
       "        [1300, 1360, 1420, 1480, 1540],\n",
       "        [2300, 2410, 2520, 2630, 2740],\n",
       "        [3300, 3460, 3620, 3780, 3940],\n",
       "        [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [130],\n",
       "        [230],\n",
       "        [330],\n",
       "        [430]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[30]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inner product\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [131],\n",
       "        [232],\n",
       "        [333],\n",
       "        [434]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# with matrix objects, standard matrix algebra applies\n",
    "v + M*v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If we try to add, subtract or multiply objects with incomplatible shapes we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "v = matrix([1,2,3,4,5,6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (6, 1))"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M), shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-101-995fb48ad0cc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mM\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mv\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m/is/ei/btabibian/anaconda/lib/python2.7/site-packages/numpy/matrixlib/defmatrix.pyc\u001b[0m in \u001b[0;36m__mul__\u001b[1;34m(self, other)\u001b[0m\n\u001b[0;32m    339\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    340\u001b[0m             \u001b[1;31m# This promotes 1-D vectors to row vectors\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 341\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0masmatrix\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    342\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0misscalar\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mor\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'__rmul__'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    343\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mother\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)"
     ]
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "See also the related functions: `inner`, `outer`, `cross`, `kron`, `tensordot`. Try for example `help(kron)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Array/Matrix transformations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we have used the `.T` to transpose the matrix object `v`. We could also have used the `transpose` function to accomplish the same thing. \n",
    "\n",
    "Other mathematical functions that transforms matrix objects are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.+1.j,  0.+2.j],\n",
       "        [ 0.+3.j,  0.+4.j]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = matrix([[1j, 2j], [3j, 4j]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-2.j],\n",
       "        [ 0.-3.j,  0.-4.j]])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjugate(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Hermitian conjugate: transpose + conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-3.j],\n",
       "        [ 0.-2.j,  0.-4.j]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "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": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.,  0.],\n",
       "        [ 0.,  0.]])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "real(C) # same as: C.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imag(C) # same as: C.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Or the complex argument and absolute value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.78539816,  1.10714872],\n",
       "       [ 1.24904577,  1.32581766]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "angle(C+1) # heads up MATLAB Users, angle is used instead of arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Matrix computations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.+2.j ,  0.-1.j ],\n",
       "        [ 0.-1.5j,  0.+0.5j]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inv(C) # equivalent to C.I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[  1.00000000e+00+0.j,   4.44089210e-16+0.j],\n",
       "        [  0.00000000e+00+0.j,   1.00000000e+00+0.j]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.I * C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Determinant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0000000000000004+0j)"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "det(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.50000000000000011+0j)"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "det(C.I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Data processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often it is useful to store datasets in Numpy arrays. Numpy provides a number of functions to calculate statistics of datasets in arrays. \n",
    "\n",
    "For example, let's calculate some properties data from the Stockholm temperature dataset used above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reminder, the tempeature dataset is stored in the data variable:\n",
    "shape(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.1971096847515854"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "mean(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The daily mean temperature in Stockholm over the last 200 year so has been about 6.2 C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### standard deviations and variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.2822716213405734, 68.596023209663414)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "std(data[:,3]), var(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### min and max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.800000000000001"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lowest daily average temperature\n",
    "data[:,3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.300000000000001"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# highest daily average temperature\n",
    "data[:,3].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### sum, prod, and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum up all elements\n",
    "sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# product of all elements\n",
    "prod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative sum\n",
    "cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative product\n",
    "cumprod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as: diag(A).sum()\n",
    "trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Computations on subsets of arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compute with subsets of the data in an array using indexing, fancy indexing, and the other methods of extracting data from an array (described above).\n",
    "\n",
    "For example, let's go back to the temperature dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1800  1  1    -6.1    -6.1    -6.1 1\r\n",
      "1800  1  2   -15.4   -15.4   -15.4 1\r\n",
      "1800  1  3   -15.0   -15.0   -15.0 1\r\n"
     ]
    }
   ],
   "source": [
    "!head -n 3 stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": 125,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.,\n",
       "        12.])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique(data[:,1]) # the month column takes values from 1 to 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mask_feb = data[:,1] == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.2121095707365961"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "mean(data[mask_feb,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "With these tools we have very powerful data processing capabilities at our disposal. For example, to extract the average monthly average temperatures for each month of the year only takes a few lines of code: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEPCAYAAABP1MOPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJEl19n/y03LxcDWiIgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f260f428090>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "months = arange(1,13)\n",
    "monthly_mean = [mean(data[data[:,1] == month, 3]) for month in months]\n",
    "\n",
    "fig, ax = subplots()\n",
    "ax.bar(months, monthly_mean)\n",
    "ax.set_xlabel(\"Month\")\n",
    "ax.set_ylabel(\"Monthly avg. temp.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Calculations with higher-dimensional data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 129,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.43485521,  0.04517144,  0.15983549],\n",
       "       [ 0.06160665,  0.01117206,  0.95997496],\n",
       "       [ 0.60084606,  0.62310207,  0.673428  ]])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = rand(3,3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9599749615722134"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# global max\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.60084606,  0.62310207,  0.95997496])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each column\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.43485521,  0.95997496,  0.673428  ])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each row\n",
    "m.max(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Many other functions and methods in the `array` and `matrix` classes accept the same (optional) `axis` keyword argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Reshaping, resizing and stacking arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shape of an Numpy array can be modified without copying the underlaying data, which makes it a fast operation even for large arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "n, m = A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "        32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape((1,n*m))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "        32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0,0:5] = 5 # modify the array\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # and the original variable is also changed. B is only a different view of the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can also use the function `flatten` to make a higher-dimensional array into a vector. But this function create a copy of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0:5] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # now A has not changed, because B's data is a copy of A's, not refering to the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Adding a new dimension: newaxis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `newaxis`, we can insert new dimensions in an array, for example converting a vector to a column or row matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "v = array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make a column matrix of the vector v\n",
    "v[:, newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# column matrix\n",
    "v[:,newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# row matrix\n",
    "v[newaxis,:].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Stacking and repeating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using function `repeat`, `tile`, `vstack`, `hstack`, and `concatenate` we can create larger vectors and matrices from smaller ones:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tile and repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repeat each element 3 times\n",
    "repeat(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tile the matrix 3 times \n",
    "tile(a, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b = array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### hstack and vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hstack((a,b.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Copy and \"deep copy\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To achieve high performance, assignments in Python usually do not copy the underlaying objects. This is important for example when objects are passed between functions, to avoid an excessive amount of memory copying when it is not necessary (techincal term: pass by reference). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[1, 2], [3, 4]])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# now B is referring to the same array data as A \n",
    "B = A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# changing B affects A\n",
    "B[0,0] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If we want to avoid this behavior, so that when we get a new completely independent object `B` copied from `A`, then we need to do a so-called \"deep copy\" using the function `copy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "B = copy(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 159,
     "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": 160,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iterating over array elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generally, we want to avoid iterating over the elements of arrays whenever we can (at all costs). The reason is that in a interpreted language like Python (or MATLAB), iterations are really slow compared to vectorized operations. \n",
    "\n",
    "However, sometimes iterations are unavoidable. For such cases, the Python `for` loop is the most convenient way to iterate over an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "v = array([1,2,3,4])\n",
    "\n",
    "for element in v:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('row', array([1, 2]))\n",
      "1\n",
      "2\n",
      "('row', array([3, 4]))\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "M = array([[1,2], [3,4]])\n",
    "\n",
    "for row in M:\n",
    "    print(\"row\", row)\n",
    "    \n",
    "    for element in row:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "When we need to iterate over each element of an array and modify its elements, it is convenient to use the `enumerate` function to obtain both the element and its index in the `for` loop: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('row_idx', 0, 'row', array([1, 2]))\n",
      "('col_idx', 0, 'element', 1)\n",
      "('col_idx', 1, 'element', 2)\n",
      "('row_idx', 1, 'row', array([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": 164,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# each element in M is now squared\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Vectorizing functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned several times by now, to get good performance we should try to avoid looping over elements in our vectors and matrices, and instead use vectorized algorithms. The first step in converting a scalar algorithm to a vectorized algorithm is to make sure that the functions we write work with vector inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": false
   },
   "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": 166,
   "metadata": {
    "collapsed": false
   },
   "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[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-166-6658efdd2f22>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mTheta\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-165-9a0cb13d93d4>\u001b[0m in \u001b[0;36mTheta\u001b[1;34m(x)\u001b[0m\n\u001b[0;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[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \"\"\"\n\u001b[1;32m----> 5\u001b[1;33m     \u001b[1;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m>=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "Theta(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "OK, that didn't work because we didn't write the `Theta` function so that it can handle with vector input... \n",
    "\n",
    "To get a vectorized version of Theta we can use the Numpy function `vectorize`. In many cases it can automatically vectorize a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Theta_vec = vectorize(Theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta_vec(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can also implement the function to accept vector input from the beginning (requires more effort but might give better performance):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "collapsed": false
   },
   "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": 170,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# still works for scalars as well\n",
    "Theta(-1.2), Theta(2.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using arrays in conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 172,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one element in M is larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).any():\n",
    "    print(\"at least one element in M is larger than 5\")\n",
    "else:\n",
    "    print(\"no element in M is larger than 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all elements in M are not larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).all():\n",
    "    print(\"all elements in M are larger than 5\")\n",
    "else:\n",
    "    print(\"all elements in M are not larger than 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Type casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 175,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.,   4.],\n",
       "       [  9.,  16.]])"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]], dtype=bool)"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Further reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* http://numpy.scipy.org\n",
    "* http://scipy.org/Tentative_NumPy_Tutorial\n",
    "* http://scipy.org/NumPy_for_Matlab_Users - A Numpy guide for MATLAB users."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Versions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/json": {
       "Software versions": [
        {
         "module": "Python",
         "version": "2.7.8 64bit [GCC 4.4.7 20120313 (Red Hat 4.4.7-1)]"
        },
        {
         "module": "IPython",
         "version": "3.0.0"
        },
        {
         "module": "OS",
         "version": "Linux 3.13.0 45 generic x86_64 with debian jessie sid"
        },
        {
         "module": "numpy",
         "version": "1.9.1"
        }
       ]
      },
      "text/html": [
       "<table><tr><th>Software</th><th>Version</th></tr><tr><td>Python</td><td>2.7.8 64bit [GCC 4.4.7 20120313 (Red Hat 4.4.7-1)]</td></tr><tr><td>IPython</td><td>3.0.0</td></tr><tr><td>OS</td><td>Linux 3.13.0 45 generic x86_64 with debian jessie sid</td></tr><tr><td>numpy</td><td>1.9.1</td></tr><tr><td colspan='2'>Tue Apr 14 12:19:45 2015 CEST</td></tr></table>"
      ],
      "text/latex": [
       "\\begin{tabular}{|l|l|}\\hline\n",
       "{\\bf Software} & {\\bf Version} \\\\ \\hline\\hline\n",
       "Python & 2.7.8 64bit [GCC 4.4.7 20120313 (Red Hat 4.4.7-1)] \\\\ \\hline\n",
       "IPython & 3.0.0 \\\\ \\hline\n",
       "OS & Linux 3.13.0 45 generic x86\\_64 with debian jessie sid \\\\ \\hline\n",
       "numpy & 1.9.1 \\\\ \\hline\n",
       "\\hline \\multicolumn{2}{|l|}{Tue Apr 14 12:19:45 2015 CEST} \\\\ \\hline\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "Software versions\n",
       "Python 2.7.8 64bit [GCC 4.4.7 20120313 (Red Hat 4.4.7-1)]\n",
       "IPython 3.0.0\n",
       "OS Linux 3.13.0 45 generic x86_64 with debian jessie sid\n",
       "numpy 1.9.1\n",
       "Tue Apr 14 12:19:45 2015 CEST"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%reload_ext version_information\n",
    "\n",
    "%version_information numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "styling courtesy of http://lorenabarba.com/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n",
       "<style>\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "    }\n",
       "    div.cell{\n",
       "        width:800px;\n",
       "        margin-left:16% !important;\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    h1 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\n",
       "    h2 {\n",
       "        font-family: 'Fenix', serif;\n",
       "    }\n",
       "    h3{\n",
       "\t\tfont-family: 'Fenix', serif;\n",
       "        margin-top:12px;\n",
       "        margin-bottom: 3px;\n",
       "       }\n",
       "\th4{\n",
       "\t\tfont-family: 'Fenix', serif;\n",
       "       }\n",
       "    h5 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\t   \n",
       "    div.text_cell_render{\n",
       "        font-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
       "        line-height: 135%;\n",
       "        font-size: 120%;\n",
       "        width:600px;\n",
       "        margin-left:auto;\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    .CodeMirror{\n",
       "            font-family: \"Source Code Pro\";\n",
       "\t\t\tfont-size: 90%;\n",
       "    }\n",
       "/*    .prompt{\n",
       "        display: None;\n",
       "    }*/\n",
       "    .text_cell_render h1 {\n",
       "        font-weight: 200;\n",
       "        font-size: 50pt;\n",
       "\t\tline-height: 100%;\n",
       "        color:#CD2305;\n",
       "        margin-bottom: 0.5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\t\n",
       "    .text_cell_render h5 {\n",
       "        font-weight: 300;\n",
       "        font-size: 16pt;\n",
       "        color: #CD2305;\n",
       "        font-style: italic;\n",
       "        margin-bottom: .5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    \n",
       "    .warning{\n",
       "        color: rgb( 240, 20, 20 )\n",
       "        }  \n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "def css_styling():\n",
    "    styles = open(\"./style/custom.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling()"
   ]
  }
 ],
 "metadata": {
  "annotations": {
   "categories": [
    "scientific-computing"
   ],
   "date": "2015-04-10",
   "github": "https://github.com/btabibian/scientific-python-lectures/blob/master/Lecture-2-Numpy.ipynb",
   "parent": "learningPython",
   "subtitle": "Numpy",
   "tags": [
    "learning",
    "python"
   ],
   "thumbnail": [
    "numpy.jpeg"
   ],
   "title": "Lecture 2"
  },
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}