{ "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3, 4])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# a vector: the argument to the array function is a Python list\n", "v = array([1,2,3,4])\n", "\n", "v" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(numpy.ndarray, numpy.ndarray)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(v), type(M)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The difference between the v and M arrays is only their shapes. We can get information about the shape of an array by using the ndarray.shape property." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(4,)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "v.shape" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(2, 2)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The number of elements in the array is available through the ndarray.size property:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M.size" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Equivalently, we could use the function numpy.shape and numpy.size" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(2, 2)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "shape(M)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "size(M)" ] }, { "cell_type": "markdown", "metadata": {}, "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": { "collapsed": false }, "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": { "collapsed": false }, "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\u001b[0m in \u001b[0;36m\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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1.+0.j, 2.+0.j],\n", " [ 3.+0.j, 4.+0.j]])" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M = array([[1, 2], [3, 4]], dtype=complex)\n", "\n", "M" ] }, { "cell_type": "markdown", "metadata": {}, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# create a range\n", "\n", "x = arange(0, 10, 1) # arguments: start, stop, step\n", "\n", "x" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0. , 0.41666667, 0.83333333, 1.25 ,\n", " 1.66666667, 2.08333333, 2.5 , 2.91666667,\n", " 3.33333333, 3.75 , 4.16666667, 4.58333333,\n", " 5. , 5.41666667, 5.83333333, 6.25 ,\n", " 6.66666667, 7.08333333, 7.5 , 7.91666667,\n", " 8.33333333, 8.75 , 9.16666667, 9.58333333, 10. ])" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# using linspace, both end points ARE included\n", "linspace(0, 10, 25)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 1.00000000e+00, 3.03773178e+00, 9.22781435e+00,\n", " 2.80316249e+01, 8.51525577e+01, 2.58670631e+02,\n", " 7.85771994e+02, 2.38696456e+03, 7.25095809e+03,\n", " 2.20264658e+04])" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "logspace(0, 10, 10, base=e)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### mgrid" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [], "source": [ "x, y = mgrid[0:5, 0:5] # similar to meshgrid in MATLAB" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[0, 0, 0, 0, 0],\n", " [1, 1, 1, 1, 1],\n", " [2, 2, 2, 2, 2],\n", " [3, 3, 3, 3, 3],\n", " [4, 4, 4, 4, 4]])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[0, 1, 2, 3, 4],\n", " [0, 1, 2, 3, 4],\n", " [0, 1, 2, 3, 4],\n", " [0, 1, 2, 3, 4],\n", " [0, 1, 2, 3, 4]])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### random data" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from numpy import random" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0.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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[1, 0, 0],\n", " [0, 2, 0],\n", " [0, 0, 3]])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# a diagonal matrix\n", "diag([1,2,3])" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0., 0., 0.],\n", " [ 0., 0., 0.],\n", " [ 0., 0., 0.]])" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "zeros((3,3))" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1800 1 1 -6.1 -6.1 -6.1 1\r\n", "1800 1 2 -15.4 -15.4 -15.4 1\r\n", "1800 1 3 -15.0 -15.0 -15.0 1\r\n", "1800 1 4 -19.3 -19.3 -19.3 1\r\n", "1800 1 5 -16.8 -16.8 -16.8 1\r\n", "1800 1 6 -11.4 -11.4 -11.4 1\r\n", "1800 1 7 -7.6 -7.6 -7.6 1\r\n", "1800 1 8 -7.1 -7.1 -7.1 1\r\n", "1800 1 9 -10.1 -10.1 -10.1 1\r\n", "1800 1 10 -9.5 -9.5 -9.5 1\r\n" ] } ], "source": [ "!head stockholm_td_adj.dat" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false }, "outputs": [], "source": [ "data = genfromtxt('stockholm_td_adj.dat')" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(77431, 7)" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data.shape" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0EAAAEZCAYAAABRvy5qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nwzAMwzDMWPH/AVJrbwIzryABAAAAAElFTkSuQmCC\n", "text/plain": [ "" ] }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "savetxt(\"random-matrix.csv\", M)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "random-matrix.npy: data\r\n" ] } ], "source": [ "save(\"random-matrix.npy\", M)\n", "\n", "!file random-matrix.npy" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0.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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "8" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M.itemsize # bytes per element" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "72" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M.nbytes # number of bytes" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# v is a vector, and has only one dimension, taking one index\n", "v[0]" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "0.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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "M[0,0] = 1" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "# also works for rows and columns\n", "M[1,:] = 0\n", "M[:,2] = -1" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1. , 0.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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3, 4, 5])" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = array([1,2,3,4,5])\n", "A" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([2, 3])" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A[1:3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Array slices are *mutable*: if they are assigned a new value the original array from which the slice was extracted is modified:" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 1, -2, -3, 4, 5])" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A[1:3] = [-2,-3]\n", "\n", "A" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can omit any of the three parameters in M[lower:upper:step]:" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 1, -2, -3, 4, 5])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A[::] # lower, upper, step all take the default values" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 1, -3, 5])" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A[::2] # step is 2, lower and upper defaults to the beginning and end of the array" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 1, -2, -3])" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A[:3] # first three elements" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "A = array([1,2,3,4,5])" ] }, { "cell_type": "code", "execution_count": 59, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A[-1] # the last element in the array" ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4],\n", " [10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24],\n", " [30, 31, 32, 33, 34],\n", " [40, 41, 42, 43, 44]])" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = array([[n+m*10 for n in range(5)] for m in range(5)])\n", "\n", "A" ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[11, 12, 13],\n", " [21, 22, 23],\n", " [31, 32, 33]])" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# a block from the original array\n", "A[1:4, 1:4]" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24],\n", " [30, 31, 32, 33, 34]])" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "row_indices = [1, 2, 3]\n", "A[row_indices]" ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4])" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B = array([n for n in range(5)])\n", "B" ] }, { "cell_type": "code", "execution_count": 67, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 2])" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "row_mask = array([True, False, True, False, False])\n", "B[row_mask]" ] }, { "cell_type": "code", "execution_count": 68, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. ,\n", " 5.5, 6. , 6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = arange(0, 10, 0.5)\n", "x" ] }, { "cell_type": "code", "execution_count": 70, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([False, False, False, False, False, False, False, False, False,\n", " False, False, True, True, True, True, False, False, False,\n", " False, False], dtype=bool)" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mask = (5 < x) * (x < 7.5)\n", "\n", "mask" ] }, { "cell_type": "code", "execution_count": 71, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "v1 = arange(0, 5)" ] }, { "cell_type": "code", "execution_count": 82, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(array([[ 0, 2, 4, 6, 8],\n", " [20, 22, 24, 26, 28],\n", " [40, 42, 44, 46, 48],\n", " [60, 62, 64, 66, 68],\n", " [80, 82, 84, 86, 88]]), array([[ 2, 3, 4, 5, 6],\n", " [12, 13, 14, 15, 16],\n", " [22, 23, 24, 25, 26],\n", " [32, 33, 34, 35, 36],\n", " [42, 43, 44, 45, 46]]))" ] }, "execution_count": 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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 4, 9, 16],\n", " [ 100, 121, 144, 169, 196],\n", " [ 400, 441, 484, 529, 576],\n", " [ 900, 961, 1024, 1089, 1156],\n", " [1600, 1681, 1764, 1849, 1936]])" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A * A # element-wise multiplication" ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 4, 9, 16],\n", " [ 0, 11, 24, 39, 56],\n", " [ 0, 21, 44, 69, 96],\n", " [ 0, 31, 64, 99, 136],\n", " [ 0, 41, 84, 129, 176]])" ] }, "execution_count": 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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 300, 310, 320, 330, 340],\n", " [1300, 1360, 1420, 1480, 1540],\n", " [2300, 2410, 2520, 2630, 2740],\n", " [3300, 3460, 3620, 3780, 3940],\n", " [4300, 4510, 4720, 4930, 5140]])" ] }, "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dot(A, A)" ] }, { "cell_type": "code", "execution_count": 90, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "M = matrix(A)\n", "v = matrix(v1).T # make it a column vector" ] }, { "cell_type": "code", "execution_count": 93, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "v = matrix([1,2,3,4,5,6]).T" ] }, { "cell_type": "code", "execution_count": 99, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "ename": "ValueError", "evalue": "shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "matrix([[ 0.-1.j, 0.-2.j],\n", " [ 0.-3.j, 0.-4.j]])" ] }, "execution_count": 102, "metadata": {}, "output_type": "execute_result" } ], "source": [ "conjugate(C)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Hermitian conjugate: transpose + conjugate" ] }, { "cell_type": "code", "execution_count": 103, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "matrix([[ 1.00000000e+00+0.j, 4.44089210e-16+0.j],\n", " [ 0.00000000e+00+0.j, 1.00000000e+00+0.j]])" ] }, "execution_count": 109, "metadata": {}, "output_type": "execute_result" } ], "source": [ "C.I * C" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Determinant" ] }, { "cell_type": "code", "execution_count": 110, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1800 1 1 -6.1 -6.1 -6.1 1\r\n", "1800 1 2 -15.4 -15.4 -15.4 1\r\n", "1800 1 3 -15.0 -15.0 -15.0 1\r\n" ] } ], "source": [ "!head -n 3 stockholm_td_adj.dat" ] }, { "cell_type": "markdown", "metadata": {}, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "mask_feb = data[:,1] == 2" ] }, { "cell_type": "code", "execution_count": 126, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEPCAYAAABP1MOPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nPBJXRXkAAAAASUVORK5CYII=\n", "text/plain": [ "" ] }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4],\n", " [10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24],\n", " [30, 31, 32, 33, 34],\n", " [40, 41, 42, 43, 44]])" ] }, "execution_count": 132, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A" ] }, { "cell_type": "code", "execution_count": 133, "metadata": { "collapsed": false }, "outputs": [], "source": [ "n, m = A.shape" ] }, { "cell_type": "code", "execution_count": 134, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n", " 32, 33, 34, 40, 41, 42, 43, 44]])" ] }, "execution_count": 134, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B = A.reshape((1,n*m))\n", "B" ] }, { "cell_type": "code", "execution_count": 135, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 5, 5, 5, 5, 5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n", " 32, 33, 34, 40, 41, 42, 43, 44]])" ] }, "execution_count": 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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 5, 5, 5, 5, 5],\n", " [10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24],\n", " [30, 31, 32, 33, 34],\n", " [40, 41, 42, 43, 44]])" ] }, "execution_count": 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 creates a copy of the data." ] }, { "cell_type": "code", "execution_count": 137, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 5, 5, 5, 5, 5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n", " 32, 33, 34, 40, 41, 42, 43, 44])" ] }, "execution_count": 137, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B = A.flatten()\n", "\n", "B" ] }, { "cell_type": "code", "execution_count": 138, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 5, 5, 5, 5, 5],\n", " [10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24],\n", " [30, 31, 32, 33, 34],\n", " [40, 41, 42, 43, 44]])" ] }, "execution_count": 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": { "collapsed": false }, "outputs": [], "source": [ "v = array([1,2,3])" ] }, { "cell_type": "code", "execution_count": 141, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(3,)" ] }, "execution_count": 141, "metadata": {}, "output_type": "execute_result" } ], "source": [ "shape(v)" ] }, { "cell_type": "code", "execution_count": 142, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "a = array([[1, 2], [3, 4]])" ] }, { "cell_type": "code", "execution_count": 146, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "b = array([[5, 6]])" ] }, { "cell_type": "code", "execution_count": 149, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "# now B is referring to the same array data as A \n", "B = A " ] }, { "cell_type": "code", "execution_count": 155, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "B = copy(A)" ] }, { "cell_type": "code", "execution_count": 158, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "v = array([1,2,3,4])\n", "\n", "for element in v:\n", " print(element)" ] }, { "cell_type": "code", "execution_count": 161, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('row', array([1, 2]))\n", "1\n", "2\n", "('row', array([3, 4]))\n", "3\n", "4\n" ] } ], "source": [ "M = array([[1,2], [3,4]])\n", "\n", "for row in M:\n", " print(\"row\", row)\n", " \n", " for element in row:\n", " print(element)" ] }, { "cell_type": "markdown", "metadata": {}, "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": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('row_idx', 0, 'row', array([1, 2]))\n", "('col_idx', 0, 'element', 1)\n", "('col_idx', 1, 'element', 2)\n", "('row_idx', 1, 'row', array([3, 4]))\n", "('col_idx', 0, 'element', 3)\n", "('col_idx', 1, 'element', 4)\n" ] } ], "source": [ "for row_idx, row in enumerate(M):\n", " print(\"row_idx\", row_idx, \"row\", row)\n", " \n", " for col_idx, element in enumerate(row):\n", " print(\"col_idx\", col_idx, \"element\", element)\n", " \n", " # update the matrix M: square each element\n", " M[row_idx, col_idx] = element ** 2" ] }, { "cell_type": "code", "execution_count": 163, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "def Theta(x):\n", " \"\"\"\n", " Scalar implemenation of the Heaviside step function.\n", " \"\"\"\n", " if x >= 0:\n", " return 1\n", " else:\n", " return 0" ] }, { "cell_type": "code", "execution_count": 165, "metadata": { "collapsed": false }, "outputs": [ { "ename": "ValueError", "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\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\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": { "collapsed": false }, "outputs": [], "source": [ "Theta_vec = vectorize(Theta)" ] }, { "cell_type": "code", "execution_count": 167, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [], "source": [ "def Theta(x):\n", " \"\"\"\n", " Vector-aware implemenation of the Heaviside step function.\n", " \"\"\"\n", " return 1 * (x >= 0)" ] }, { "cell_type": "code", "execution_count": 169, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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": { "collapsed": false }, "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 creates a new array of new type:" ] }, { "cell_type": "code", "execution_count": 174, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "dtype('int64')" ] }, "execution_count": 174, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M.dtype" ] }, { "cell_type": "code", "execution_count": 175, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "execution_count": 176, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M2.dtype" ] }, { "cell_type": "code", "execution_count": 177, "metadata": { "collapsed": false }, "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": { "collapsed": false }, "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": [ "
SoftwareVersion
Python2.7.10 64bit [GCC 4.2.1 (Apple Inc. build 5577)]
IPython3.2.1
OSDarwin 14.1.0 x86_64 i386 64bit
numpy1.9.2
Sat Aug 15 11:02:09 2015 JST
" ], "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 2", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.10" } }, "nbformat": 4, "nbformat_minor": 0 }