machinelearning_notebook/0_numpy_matplotlib_scipy_sympy/numpy_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy -  multidimensional data arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "J.R. Johansson (jrjohansson at gmail.com)\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.io](http://jrjohansson.github.io)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what is this line all about?!? Answer in lecture 4\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `numpy` package (module) is used in almost all numerical computation using Python. It is a package that provide high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and Fortran so when calculations are vectorized (formulated with vectors and matrices), performance is very good. \n",
    "\n",
    "To use `numpy` you need to import the module, using for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the `numpy` package the terminology used for vectors, matrices and higher-dimensional data sets is *array*. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating `numpy` arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a number of ways to initialize new numpy arrays, for example from\n",
    "\n",
    "* a Python list or tuples\n",
    "* using functions that are dedicated to generating numpy arrays, such as `arange`, `linspace`, etc.\n",
    "* reading data from files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, to create new vector and matrix arrays from Python lists we can use the `numpy.array` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "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": {},
   "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": {},
   "source": [
    "The `v` and `M` objects are both of the type `ndarray` that the `numpy` module provides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "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": {},
   "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": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of elements in the array is available through the `ndarray.size` property:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equivalently, we could use the function `numpy.shape` and `numpy.size`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far the `numpy.ndarray` looks awefully much like a Python list (or nested list). Why not simply use Python lists for computations instead of creating a new array type? \n",
    "\n",
    "There are several reasons:\n",
    "\n",
    "* Python lists are very general. They can contain any kind of object. They are dynamically typed. They do not support mathematical functions such as matrix and dot multiplications, etc. Implementing such functions for Python lists would not be very efficient because of the dynamic typing.\n",
    "* Numpy arrays are **statically typed** and **homogeneous**. The type of the elements is determined when the array is created.\n",
    "* Numpy arrays are memory efficient.\n",
    "* Because of the static typing, fast implementation of mathematical functions such as multiplication and addition of `numpy` arrays can be implemented in a compiled language (C and Fortran is used).\n",
    "\n",
    "Using the `dtype` (data type) property of an `ndarray`, we can see what type the data of an array has:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get an error if we try to assign a value of the wrong type to an element in a numpy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for long() with base 10: 'hello'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-12-a09d72434238>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for long() with base 10: 'hello'"
     ]
    }
   ],
   "source": [
    "M[0,0] = \"hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want, we can explicitly define the type of the array data when we create it, using the `dtype` keyword argument: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "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": {},
   "source": [
    "Common data types that can be used with `dtype` are: `int`, `float`, `complex`, `bool`, `object`, etc.\n",
    "\n",
    "We can also explicitly define the bit size of the data types, for example: `int64`, `int16`, `float128`, `complex128`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using array-generating functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For larger arrays it is inpractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in `numpy` that generate arrays of different forms. Some of the more common are:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "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": {},
   "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": {},
   "source": [
    "#### linspace and logspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "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": {},
   "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": {},
   "source": [
    "#### mgrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = mgrid[0:5, 0:5] # similar to meshgrid in MATLAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [1, 1, 1, 1, 1],\n",
       "       [2, 2, 2, 2, 2],\n",
       "       [3, 3, 3, 3, 3],\n",
       "       [4, 4, 4, 4, 4]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### random data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.92932506,  0.19684255,  0.736434  ,  0.18125714,  0.70905038],\n",
       "       [ 0.18803573,  0.9312815 ,  0.1284532 ,  0.38138008,  0.36646481],\n",
       "       [ 0.53700462,  0.02361381,  0.97760688,  0.73296701,  0.23042324],\n",
       "       [ 0.9024635 ,  0.20860922,  0.67729644,  0.68386687,  0.49385729],\n",
       "       [ 0.95876515,  0.29341553,  0.37520629,  0.29194432,  0.64102804]])"
      ]
     },
     "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": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.117907  , -1.57016164,  0.78256246,  1.45386709,  0.54744436],\n",
       "       [ 2.30356897, -0.28352021, -0.9087325 ,  1.2285279 , -1.00760167],\n",
       "       [ 0.72216801,  0.77507299, -0.37793178, -0.31852241,  0.84493629],\n",
       "       [-0.10682252,  1.15930142, -0.47291444, -0.69496967, -0.58912034],\n",
       "       [ 0.34513487, -0.92389516, -0.216978  ,  0.42153272,  0.86650101]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# standard normal distributed random numbers\n",
    "random.randn(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "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": {},
   "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": {},
   "source": [
    "#### zeros and ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "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": {},
   "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": {},
   "source": [
    "## File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comma-separated values (CSV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very common file format for data files is comma-separated values (CSV), or related formats such as TSV (tab-separated values). To read data from such files into Numpy arrays we can use the `numpy.genfromtxt` function. For example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1800  1  1    -6.1    -6.1    -6.1 1\r\n",
      "1800  1  2   -15.4   -15.4   -15.4 1\r\n",
      "1800  1  3   -15.0   -15.0   -15.0 1\r\n",
      "1800  1  4   -19.3   -19.3   -19.3 1\r\n",
      "1800  1  5   -16.8   -16.8   -16.8 1\r\n",
      "1800  1  6   -11.4   -11.4   -11.4 1\r\n",
      "1800  1  7    -7.6    -7.6    -7.6 1\r\n",
      "1800  1  8    -7.1    -7.1    -7.1 1\r\n",
      "1800  1  9   -10.1   -10.1   -10.1 1\r\n",
      "1800  1 10    -9.5    -9.5    -9.5 1\r\n"
     ]
    }
   ],
   "source": [
    "!head stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = genfromtxt('stockholm_td_adj.dat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0EAAAEZCAYAAABRvy5qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nwzAMwzDMWPH/AVJrbwIzryABAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x108686390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(14,4))\n",
    "ax.plot(data[:,0]+data[:,1]/12.0+data[:,2]/365, data[:,5])\n",
    "ax.axis('tight')\n",
    "ax.set_title('tempeatures in Stockholm')\n",
    "ax.set_xlabel('year')\n",
    "ax.set_ylabel('temperature (C)');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `numpy.savetxt` we can store a Numpy array to a file in CSV format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.77872576,  0.40043577,  0.66254019],\n",
       "       [ 0.60410063,  0.4791374 ,  0.8237106 ],\n",
       "       [ 0.96856318,  0.15459644,  0.96082399]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = random.rand(3,3)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "savetxt(\"random-matrix.csv\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.787257639287014088e-01 4.004357670697732408e-01 6.625401863466899854e-01\r\n",
      "6.041006328761111543e-01 4.791373994963619154e-01 8.237105968088237473e-01\r\n",
      "9.685631757740569281e-01 1.545964379103705877e-01 9.608239852111523094e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.77873 0.40044 0.66254\r\n",
      "0.60410 0.47914 0.82371\r\n",
      "0.96856 0.15460 0.96082\r\n"
     ]
    }
   ],
   "source": [
    "savetxt(\"random-matrix.csv\", M, fmt='%.5f') # fmt specifies the format\n",
    "\n",
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy's native file format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Useful when storing and reading back numpy array data. Use the functions `numpy.save` and `numpy.load`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "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": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.77872576,  0.40043577,  0.66254019],\n",
       "       [ 0.60410063,  0.4791374 ,  0.8237106 ],\n",
       "       [ 0.96856318,  0.15459644,  0.96082399]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load(\"random-matrix.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More properties of the numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "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": {},
   "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": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.ndim # number of dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index elements in an array using square brackets and indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "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": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.47913739949636192"
      ]
     },
     "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": {},
   "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": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.77872576,  0.40043577,  0.66254019],\n",
       "       [ 0.60410063,  0.4791374 ,  0.8237106 ],\n",
       "       [ 0.96856318,  0.15459644,  0.96082399]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.60410063,  0.4791374 ,  0.8237106 ])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same thing can be achieved with using `:` instead of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.60410063,  0.4791374 ,  0.8237106 ])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:] # row 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.40043577,  0.4791374 ,  0.15459644])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:,1] # column 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign new values to elements in an array using indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "M[0,0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.40043577,  0.66254019],\n",
       "       [ 0.60410063,  0.4791374 ,  0.8237106 ],\n",
       "       [ 0.96856318,  0.15459644,  0.96082399]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# also works for rows and columns\n",
    "M[1,:] = 0\n",
    "M[:,2] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.40043577, -1.        ],\n",
       "       [ 0.        ,  0.        , -1.        ],\n",
       "       [ 0.96856318,  0.15459644, -1.        ]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing is the technical name for the syntax `M[lower:upper:step]` to extract part of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "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": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array slices are *mutable*: if they are assigned a new value the original array from which the slice was extracted is modified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "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": {},
   "source": [
    "We can omit any of the three parameters in `M[lower:upper:step]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "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": {},
   "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": {},
   "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": {},
   "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": {},
   "source": [
    "Negative indices counts from the end of the array (positive index from the begining):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "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": {},
   "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": {},
   "source": [
    "Index slicing works exactly the same way for multidimensional arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 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": {},
   "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": {},
   "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": {},
   "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": {},
   "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": {},
   "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": {},
   "source": [
    "We can also use index masks: If the index mask is an Numpy array of data type `bool`, then an element is selected (True) or not (False) depending on the value of the index mask at the position of each element: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "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": {},
   "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": {},
   "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": {},
   "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": {},
   "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": {},
   "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": {},
   "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": {},
   "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": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14]),)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = where(mask)\n",
    "\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.5,  6. ,  6.5,  7. ])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[indices] # this indexing is equivalent to the fancy indexing x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### diag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the diag function we can also extract the diagonal and subdiagonals of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### take"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `take` function is similar to fancy indexing described above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 = arange(-3,3)\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 3, 5]\n",
    "v2[row_indices] # fancy indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2.take(row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But `take` also works on lists and other objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take([-3, -2, -1,  0,  1,  2], row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### choose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constructs an array by picking elements from several arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -2,  5, -2])"
      ]
     },
     "execution_count": 80,
     "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": {},
   "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": {},
   "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": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 = arange(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 0,  2,  4,  6,  8],\n",
       "        [20, 22, 24, 26, 28],\n",
       "        [40, 42, 44, 46, 48],\n",
       "        [60, 62, 64, 66, 68],\n",
       "        [80, 82, 84, 86, 88]]), 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": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * 2, A + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element-wise array-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we add, subtract, multiply and divide arrays with each other, the default behaviour is **element-wise** operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    1,    4,    9,   16],\n",
       "       [ 100,  121,  144,  169,  196],\n",
       "       [ 400,  441,  484,  529,  576],\n",
       "       [ 900,  961, 1024, 1089, 1156],\n",
       "       [1600, 1681, 1764, 1849, 1936]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A # element-wise multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we multiply arrays with compatible shapes, we get an element-wise multiplication of each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   4,   9,  16],\n",
       "       [  0,  11,  24,  39,  56],\n",
       "       [  0,  21,  44,  69,  96],\n",
       "       [  0,  31,  64,  99, 136],\n",
       "       [  0,  41,  84, 129, 176]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about matrix mutiplication? There are two ways. We can either use the `dot` function, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 300,  310,  320,  330,  340],\n",
       "       [1300, 1360, 1420, 1480, 1540],\n",
       "       [2300, 2410, 2520, 2630, 2740],\n",
       "       [3300, 3460, 3620, 3780, 3940],\n",
       "       [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we can cast the array objects to the type `matrix`. This changes the behavior of the standard arithmetic operators `+, -, *` to use matrix algebra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = matrix(A)\n",
    "v = matrix(v1).T # make it a column vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0],\n",
       "        [1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 300,  310,  320,  330,  340],\n",
       "        [1300, 1360, 1420, 1480, 1540],\n",
       "        [2300, 2410, 2520, 2630, 2740],\n",
       "        [3300, 3460, 3620, 3780, 3940],\n",
       "        [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [130],\n",
       "        [230],\n",
       "        [330],\n",
       "        [430]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[30]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inner product\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [131],\n",
       "        [232],\n",
       "        [333],\n",
       "        [434]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# with matrix objects, standard matrix algebra applies\n",
    "v + M*v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to add, subtract or multiply objects with incomplatible shapes we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = matrix([1,2,3,4,5,6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (6, 1))"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M), shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-100-995fb48ad0cc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/Users/rob/miniconda/envs/py27-spl/lib/python2.7/site-packages/numpy/matrixlib/defmatrix.pyc\u001b[0m in \u001b[0;36m__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    339\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    340\u001b[0m             \u001b[0;31m# This promotes 1-D vectors to row vectors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 341\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0masmatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    342\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misscalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'__rmul__'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    343\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)"
     ]
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See also the related functions: `inner`, `outer`, `cross`, `kron`, `tensordot`. Try for example `help(kron)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array/Matrix transformations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we have used the `.T` to transpose the matrix object `v`. We could also have used the `transpose` function to accomplish the same thing. \n",
    "\n",
    "Other mathematical functions that transform matrix objects are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.+1.j,  0.+2.j],\n",
       "        [ 0.+3.j,  0.+4.j]])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = matrix([[1j, 2j], [3j, 4j]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "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": [
    "conjugate(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hermitian conjugate: transpose + conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-3.j],\n",
       "        [ 0.-2.j,  0.-4.j]])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extract the real and imaginary parts of complex-valued arrays using `real` and `imag`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.,  0.],\n",
       "        [ 0.,  0.]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "real(C) # same as: C.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imag(C) # same as: C.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or the complex argument and absolute value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.78539816,  1.10714872],\n",
       "       [ 1.24904577,  1.32581766]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "angle(C+1) # heads up MATLAB Users, angle is used instead of arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix computations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.+2.j ,  0.-1.j ],\n",
       "        [ 0.-1.5j,  0.+0.5j]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.inv(C) # equivalent to C.I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "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": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.I * C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determinant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0000000000000004+0j)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.det(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.50000000000000011+0j)"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.det(C.I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often it is useful to store datasets in Numpy arrays. Numpy provides a number of functions to calculate statistics of datasets in arrays. \n",
    "\n",
    "For example, let's calculate some properties from the Stockholm temperature dataset used above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reminder, the tempeature dataset is stored in the data variable:\n",
    "shape(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.1971096847515854"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "mean(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The daily mean temperature in Stockholm over the last 200 years has been about 6.2 C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### standard deviations and variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.2822716213405734, 68.596023209663414)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "std(data[:,3]), var(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### min and max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.800000000000001"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lowest daily average temperature\n",
    "data[:,3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.300000000000001"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# highest daily average temperature\n",
    "data[:,3].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sum, prod, and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum up all elements\n",
    "sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# product of all elements\n",
    "prod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative sum\n",
    "cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative product\n",
    "cumprod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as: diag(A).sum()\n",
    "trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computations on subsets of arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compute with subsets of the data in an array using indexing, fancy indexing, and the other methods of extracting data from an array (described above).\n",
    "\n",
    "For example, let's go back to the temperature dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1800  1  1    -6.1    -6.1    -6.1 1\r\n",
      "1800  1  2   -15.4   -15.4   -15.4 1\r\n",
      "1800  1  3   -15.0   -15.0   -15.0 1\r\n"
     ]
    }
   ],
   "source": [
    "!head -n 3 stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dataformat is: year, month, day, daily average temperature, low, high, location.\n",
    "\n",
    "If we are interested in the average temperature only in a particular month, say February, then we can create a index mask and use it to select only the data for that month using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.,\n",
       "        12.])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique(data[:,1]) # the month column takes values from 1 to 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_feb = data[:,1] == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.2121095707365961"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "mean(data[mask_feb,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these tools we have very powerful data processing capabilities at our disposal. For example, to extract the average monthly average temperatures for each month of the year only takes a few lines of code: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEPCAYAAABP1MOPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nPBJXRXkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x109f94e50>"
      ]
     },
     "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 = plt.subplots()\n",
    "ax.bar(months, monthly_mean)\n",
    "ax.set_xlabel(\"Month\")\n",
    "ax.set_ylabel(\"Monthly avg. temp.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculations with higher-dimensional data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When functions such as `min`, `max`, etc. are applied to a multidimensional arrays, it is sometimes useful to apply the calculation to the entire array, and sometimes only on a row or column basis. Using the `axis` argument we can specify how these functions should behave: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.2850926 ,  0.17302017,  0.17748378],\n",
       "       [ 0.80070487,  0.45527067,  0.61277451],\n",
       "       [ 0.11372793,  0.43608703,  0.87010206]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = random.rand(3,3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.87010206156754955"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# global max\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.80070487,  0.45527067,  0.87010206])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each column\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.2850926 ,  0.80070487,  0.87010206])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each row\n",
    "m.max(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many other functions and methods in the `array` and `matrix` classes accept the same (optional) `axis` keyword argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping, resizing and stacking arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shape of an Numpy array can be modified without copying the underlaying data, which makes it a fast operation even for large arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "n, m = A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "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": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape((1,n*m))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "        32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0,0:5] = 5 # modify the array\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # and the original variable is also changed. B is only a different view of the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the function `flatten` to make a higher-dimensional array into a vector. But this function create a copy of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0:5] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # now A has not changed, because B's data is a copy of A's, not refering to the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding a new dimension: newaxis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `newaxis`, we can insert new dimensions in an array, for example converting a vector to a column or row matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make a column matrix of the vector v\n",
    "v[:, newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# column matrix\n",
    "v[:,newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# row matrix\n",
    "v[newaxis,:].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacking and repeating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using function `repeat`, `tile`, `vstack`, `hstack`, and `concatenate` we can create larger vectors and matrices from smaller ones:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tile and repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repeat each element 3 times\n",
    "repeat(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tile the matrix 3 times \n",
    "tile(a, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### hstack and vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hstack((a,b.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy and \"deep copy\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To achieve high performance, assignments in Python usually do not copy the underlaying objects. This is important for example when objects are passed between functions, to avoid an excessive amount of memory copying when it is not necessary (technical term: pass by reference). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[1, 2], [3, 4]])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now B is referring to the same array data as A \n",
    "B = A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# changing B affects A\n",
    "B[0,0] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to avoid this behavior, so that when we get a new completely independent object `B` copied from `A`, then we need to do a so-called \"deep copy\" using the function `copy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = copy(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 158,
     "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": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating over array elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generally, we want to avoid iterating over the elements of arrays whenever we can (at all costs). The reason is that in a interpreted language like Python (or MATLAB), iterations are really slow compared to vectorized operations. \n",
    "\n",
    "However, sometimes iterations are unavoidable. For such cases, the Python `for` loop is the most convenient way to iterate over an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "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": 161,
   "metadata": {},
   "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": {},
   "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": 162,
   "metadata": {},
   "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": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# each element in M is now squared\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectorizing functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned several times by now, to get good performance we should try to avoid looping over elements in our vectors and matrices, and instead use vectorized algorithms. The first step in converting a scalar algorithm to a vectorized algorithm is to make sure that the functions we write work with vector inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Theta(x):\n",
    "    \"\"\"\n",
    "    Scalar implemenation of the Heaviside step function.\n",
    "    \"\"\"\n",
    "    if x >= 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-165-6658efdd2f22>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mTheta\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-164-9a0cb13d93d4>\u001b[0m in \u001b[0;36mTheta\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mScalar\u001b[0m \u001b[0mimplemenation\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mHeaviside\u001b[0m \u001b[0mstep\u001b[0m \u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \"\"\"\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "Theta(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, that didn't work because we didn't write the `Theta` function so that it can handle a vector input... \n",
    "\n",
    "To get a vectorized version of Theta we can use the Numpy function `vectorize`. In many cases it can automatically vectorize a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "Theta_vec = vectorize(Theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta_vec(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also implement the function to accept a vector input from the beginning (requires more effort but might give better performance):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Theta(x):\n",
    "    \"\"\"\n",
    "    Vector-aware implemenation of the Heaviside step function.\n",
    "    \"\"\"\n",
    "    return 1 * (x >= 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# still works for scalars as well\n",
    "Theta(-1.2), Theta(2.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using arrays in conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using arrays in conditions,for example `if` statements and other boolean expressions, one needs to use `any` or `all`, which requires that any or all elements in the array evalutes to `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one element in M is larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).any():\n",
    "    print(\"at least one element in M is larger than 5\")\n",
    "else:\n",
    "    print(\"no element in M is larger than 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all elements in M are not larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).all():\n",
    "    print(\"all elements in M are larger than 5\")\n",
    "else:\n",
    "    print(\"all elements in M are not larger than 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since Numpy arrays are *statically typed*, the type of an array does not change once created. But we can explicitly cast an array of some type to another using the `astype` functions (see also the similar `asarray` function). This always create a new array of new type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.,   4.],\n",
       "       [  9.,  16.]])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]], dtype=bool)"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* http://numpy.scipy.org\n",
    "* http://scipy.org/Tentative_NumPy_Tutorial\n",
    "* http://scipy.org/NumPy_for_Matlab_Users - A Numpy guide for MATLAB users."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Versions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/json": {
       "Software versions": [
        {
         "module": "Python",
         "version": "2.7.10 64bit [GCC 4.2.1 (Apple Inc. build 5577)]"
        },
        {
         "module": "IPython",
         "version": "3.2.1"
        },
        {
         "module": "OS",
         "version": "Darwin 14.1.0 x86_64 i386 64bit"
        },
        {
         "module": "numpy",
         "version": "1.9.2"
        }
       ]
      },
      "text/html": [
       "<table><tr><th>Software</th><th>Version</th></tr><tr><td>Python</td><td>2.7.10 64bit [GCC 4.2.1 (Apple Inc. build 5577)]</td></tr><tr><td>IPython</td><td>3.2.1</td></tr><tr><td>OS</td><td>Darwin 14.1.0 x86_64 i386 64bit</td></tr><tr><td>numpy</td><td>1.9.2</td></tr><tr><td colspan='2'>Sat Aug 15 11:02:09 2015 JST</td></tr></table>"
      ],
      "text/latex": [
       "\\begin{tabular}{|l|l|}\\hline\n",
       "{\\bf Software} & {\\bf Version} \\\\ \\hline\\hline\n",
       "Python & 2.7.10 64bit [GCC 4.2.1 (Apple Inc. build 5577)] \\\\ \\hline\n",
       "IPython & 3.2.1 \\\\ \\hline\n",
       "OS & Darwin 14.1.0 x86\\_64 i386 64bit \\\\ \\hline\n",
       "numpy & 1.9.2 \\\\ \\hline\n",
       "\\hline \\multicolumn{2}{|l|}{Sat Aug 15 11:02:09 2015 JST} \\\\ \\hline\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "Software versions\n",
       "Python 2.7.10 64bit [GCC 4.2.1 (Apple Inc. build 5577)]\n",
       "IPython 3.2.1\n",
       "OS Darwin 14.1.0 x86_64 i386 64bit\n",
       "numpy 1.9.2\n",
       "Sat Aug 15 11:02:09 2015 JST"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%reload_ext version_information\n",
    "\n",
    "%version_information numpy"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}