{ "metadata": { "name": "" }, "nbformat": 3, "nbformat_minor": 0, "worksheets": [ { "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Numpy - fast number crunching with Python\n", "===\n", "\n", "Yogesh Wadadekar\n", "---\n", "\n", "### NCRA-TIFR, Pune" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Adding two arrays - the slow Python way\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "l1=[1,2,4]; l2=[4,5,6]\n", "print l1+l2\n" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[1, 2, 4, 4, 5, 6]\n" ] } ], "prompt_number": 3 }, { "cell_type": "code", "collapsed": false, "input": [ "l3 = [0]*3\n", "for i in range(3):\n", " l3[i] = l1[i] +l2[i]\n", " \n", "print l3" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[5, 7, 10]\n" ] } ], "prompt_number": 4 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "What we want\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "We want print l1+l2 to give us [5,7,9]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Creating an array\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import numpy as np\n", "a = np.array([1,2,3])\n", "b = np.array((1,2,3))\n" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [], "prompt_number": 4 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Either list or tuple is acceptable" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import scipy\n", "x1=np.array('hello'); x2=np.array('world')\n", "print scipy.add(x1,x2)\n" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "NotImplemented\n" ] } ], "prompt_number": 40 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Adding Arrays with numpy\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "l1 = [1,2,3]\n", "l2=[4,5,6]\n", "a1 = np.array(l1)\n", "a2 = np.array(l2)\n", "print l1+l2\n", "print a1+a2" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[1, 2, 3, 4, 5, 6]\n", "[5 7 9]\n" ] } ], "prompt_number": 5 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Arithmetic operations in numpy\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print a1\n", "print a2\n", "print a1+a2 # addition\n", "print a1-a2 # substraction\n", "print a1*a2 # multiplication\n", "print a1/a2 # division\n", "print a2%a1 # modulo\n", "print a1**2 # elementwise squared" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[1 2 3]\n", "[4 5 6]\n", "[5 7 9]\n", "[-3 -3 -3]\n", "[ 4 10 18]\n", "[0 0 0]\n", "[0 1 0]\n", "[1 4 9]\n" ] } ], "prompt_number": 7 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "String manipulation in numpy - np.char\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "x1=np.array('Hello '); x2 = np.array('world')\n", "print np.char.add(x1,x2)\n", "print np.char.multiply(x1,5)\n", "print np.char.upper(x1)\n", "print np.char.isupper(x1)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hello world\n", "Hello Hello Hello Hello Hello \n", "HELLO \n", "False\n" ] } ], "prompt_number": 49 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ ">60 Numpy ufuncs\n", "===" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "add (+) log greater (>) subtract (-) log10 greater_equal ($>=$)\n", "\n", "multiply (*) cos less (<) divide (/) arcos less_equal (<=)\n", "\n", "remainder (%) sin logical_and absolute abs arcsin logical_or\n", "\n", "floor tan logical_xor ceil arctan bitwise_and (&)\n", "\n", "fmod cosh bitwise_or (|) conjugate sinh bitwise_xor (^)\n", "\n", "minimum tanh bitwise_not (~) maximum sqrt rshift (>>)\n", "\n", "power (**) equal (==) lshift (<<) exp not_equal (!=)\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Why is an array not a list?\n", "===" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A numpy array is a table of elements (usually numbers),\n", "all of the __same__ type." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Implicit and explicit datatype declaration, which is better?\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import numpy as np\n", "ai = np.array([1, 2, 3])\n", "af = np.array([1, 2, 3.])\n", "ac = np.array([1j, 2, 3.])\n", "print ai.dtype\n", "print af.dtype\n", "print ac.dtype\n", "af = np.array([1,2,3], float)\n", "ac = np.array([1,2,3], complex)\n", "afn = np.array([1,2], np.float) # numpy float type\n" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "int64\n", "float64\n", "complex128\n" ] } ], "prompt_number": 8 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Numpy float datatypes\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* np.float (== Python float type)\n", "* np.float32 (single precision)\n", "* np.float64 (double precision)\n", "* np.double (synonym, double prec.)\n", "* np.longdouble (very platform dependent !!! np.float96 or np.float128)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Other numpy datatypes\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* Integer datatypes np.int8 ...int16 ...int32 ...int64\n", "* Unsigned (!) integer datatypes np.uint8 ...uint16 ...uint32 ...int64\n", "* Complex datatypes np.complex64 ...complex128...complex256\n", "* Boolean np.bool\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Defining your own datatypes\n", "===\n" ] }, { "cell_type": "code", "collapsed": false, "input": [ "dt= np.dtype([('value',np.int),('status',np.bool)])\n", "a = np.array([(0,True),(100,False)],dtype=dt)\n", "print a['value']\n", "print a['status']\n", "print a['value'][1]\n", "print a[0]['status']\n" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[ 0 100]\n", "[ True False]\n", "100\n", "True\n" ] } ], "prompt_number": 9 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Structured arrays are useful for reading binary data." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Convenience functions to create arrays\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "z = np.zeros(3)\n", "print z\n", "o = np.ones(10)\n", "print o\n", "e = np.empty(10)\n", "print e # uninitialised values, could be anything!" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[ 0. 0. 0.]\n", "[ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n", "[ 0.00000000e+000 6.70781038e-314 6.79038653e-313 9.76118064e-313\n", " 1.90979621e-313 9.76118064e-313 2.12199579e-313 3.18299369e-313\n", " 3.95252517e-322 8.89318163e-323]\n" ] } ], "prompt_number": 10 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Multidimensional Arrays\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "l2 = [[1,2,3],[4,5,6]]\n", "a2 = np.array(l2)\n", "print l2\n", "print a2\n", "l3 = [[1,2,3],[4,5]]\n", "a3 = np.array(l3) # Result is not what you might expect\n", "print a3\n", "print a3.shape" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[[1, 2, 3], [4, 5, 6]]\n", "[[1 2 3]\n", " [4 5 6]]\n", "[[1, 2, 3] [4, 5]]\n", "(2,)\n" ] } ], "prompt_number": 9 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "skip" } }, "source": [ "Swapping of axes\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "skip" } }, "source": [ "Note that, like C (and unlike FORTRAN), Python is 0-indexed and the\n", "indices have the slowest axis first and fast axis last, i.e. for a 2-D\n", "image, the fast axis (X-axis) which corresponds to the FITS NAXIS1\n", "keyword, is the second index.\n", "\n", "How best to handle this?\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Accessing Arrays\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print l2\n", "print l2[0][1]\n", "print a2[0][1]\n", "print a2[0,1] # works only with\n", "print a2[0,1:] # arrays !!!\n", "print a2[:,0] #\n" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[[1, 2, 3], [4, 5, 6]]\n", "2\n", "2\n", "2\n", "[2 3]\n", "[1 4]\n" ] } ], "prompt_number": 10 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Determine size and shape\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "# determine the dimensions\n", "# remember: l2=[[1,2,3],[4,5,6]]\n", "# how many rows, how many columns ?\n", "\n", "print len(l2), len(l2[0])\n", "\n", "print len(a2), len(a2[0])\n", "\n", "print a2.shape # shape attribute\n" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "2 3\n", "2 3\n", "(2, 3)\n" ] } ], "prompt_number": 13 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Array attributes\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* array.ndim: number of dimensions\n", "* array.shape: the dimensions\n", "* array.size: total number of elements\n", "* array.dtype: type of the data\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Initialising multidimensional arrays\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "# np.zeros, np.ones, et al.\n", "# can be used to create multidim\n", "# arrays, too !\n", "\n", "o = np.ones( (3,10) )\n", "\n", "e = np.empty( (4,2,19), float)\n" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [], "prompt_number": 14 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Convenience functions\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "b = np.linspace(-2.5,1.5,17)\n", "\n", "# 17 equally spaced numbers from -2.5 to 1.5\n", "# including the boundary values !\n", "\n", "c = np.arange(-2.5,1.51,0.25) # Unreliable because upperbound excluded, rounding errors, use linspace\n", "\n", "x = np.linspace(0, 3.14, 100)\n", "\n", "m = np.logspace(-2,3,9) # special for astronomers!\n", "print m\n", "\n", "y = np.sin(x)\n" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[ 1.00000000e-02 4.21696503e-02 1.77827941e-01 7.49894209e-01\n", " 3.16227766e+00 1.33352143e+01 5.62341325e+01 2.37137371e+02\n", " 1.00000000e+03]\n" ] } ], "prompt_number": 11 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Slicing in numpy\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "a = np.zeros( (4,4) )\n", "\n", "print a[2:4][2:4] # does this work? no.\n", "\n", "a[2:4,2:4] = 1 # Works\n", "print a\n", "a[0] = 2\n", "print a\n", "a[:,1:3] += 3\n", "print a\n", "# the array shape is unaltered by\n", "# these operations\n" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[]\n", "[[ 0. 0. 0. 0.]\n", " [ 0. 0. 0. 0.]\n", " [ 0. 0. 1. 1.]\n", " [ 0. 0. 1. 1.]]\n", "[[ 2. 2. 2. 2.]\n", " [ 0. 0. 0. 0.]\n", " [ 0. 0. 1. 1.]\n", " [ 0. 0. 1. 1.]]\n", "[[ 2. 5. 5. 2.]\n", " [ 0. 3. 3. 0.]\n", " [ 0. 3. 4. 1.]\n", " [ 0. 3. 4. 1.]]\n" ] } ], "prompt_number": 16 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Rows and columns\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "# accessing rows and columns\n", "\n", "a[0,:] # the first row\n", "\n", "a[0] = 4 # the first row set to 4\n", "\n", "# read a[i] as\n", "# a[i,]\n", "# this is a specific numpy notation\n", "\n", "print a[0,...]\n", "\n", "a[:,1] = 5 # the second column\n", "\n", "a[:,-1] = 6 # the last column\n", "print a\n" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[ 4. 4. 4. 4.]\n", "[[ 4. 5. 4. 6.]\n", " [ 0. 5. 3. 6.]\n", " [ 0. 5. 4. 6.]\n", " [ 0. 5. 4. 6.]]\n" ] } ], "prompt_number": 17 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "numpy ASCII file reading - obsoleted by astropy.io.ascii\n", "===" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "fname = 'myfile.dat'\n", "\n", "data = np.loadtxt(fname)\n", "\n", "c24 = np.loadtxt(fname,usecols=(1,3)) # to select columns\n", "\n", "n,w,x,y,z = np.loadtxt(fname,unpack = True)\n", "\n", "w,y = np.loadtxt(fname,usecols=(1,3), unpack=True)\n", "\n", "fname2 = 'mydata2.dat' # a different data file\n", "\n", "data2 = np.loadtxt(fname2,delimiter='/', comments='!',skiprows=3) \n", "\n", "# default for comments is '#'\n", "\n", "np.savetxt('result.dat', res,fmt='\\%d :\\\\t \\%.6f')" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Saving/Loading binary arrays\n", "===" ] }, { "cell_type": "code", "collapsed": true, "input": [ "data=np.arange(10)\n", "data2 = np.arange(20)\n", "np.savez('/tmp/myarrays',x=data,y=data2)\n", "\n", "myarrays = np.load('/tmp/myarrays.npz')\n", "\n", "print myarrays['x']\n", "\n", "print myarrays['y']" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[0 1 2 3 4 5 6 7 8 9]\n", "[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]\n" ] } ], "prompt_number": 18 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "more reliable than pickling files on disk." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Reshape and where\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "%pylab inline\n", "import pylab as p\n", "x = np.arange(100).reshape((10,10))\n", "p.imshow(x,interpolation='none')\n", "x[np.where(np.logical_and(x > 50,x <75))] = 10\n", "p.imshow(x,interpolation='none')\n", "p.colorbar()" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Populating the interactive namespace from numpy and matplotlib\n" ] }, { "metadata": {}, "output_type": "pyout", "prompt_number": 14, "text": [ "" ] }, { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAASEAAAD6CAYAAADuk/FDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQv0/o2SxFEw7pxkAAAAASUVORK5CYII=\n", "text": [ "" ] } ], "prompt_number": 14 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Numpy documentation with examples\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "There are over 400 functions (doing everything from rebinning to\n", "obtaining polynomial least squares fits) in numpy for array\n", "manipulation and also limited least square fits etc.\n", "\n", "Please go through carefully" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Masked arrays - np.ma\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Masked arrays are arrays that may have missing or invalid entries." ] }, { "cell_type": "code", "collapsed": false, "input": [ "import numpy.ma as ma, numpy as np\n", "\n", "x = np.array([1, 2, 3, -1, 5])\n", "\n", "mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])\n", "\n", "mx2 = ma.masked_array(x, mask=[1, 1, 0, 0, 0])\n", "\n", "mx2 = ma.masked_array(x, mask=[True, True, False, False, False]) # equivalent more Pythonic syntax\n", "\n", "print x.mean()\n", "\n", "print mx.mean()\n", "\n", "mx/mx2 # Arithmetic operations on 2 masked arrays possible.\n", "\n", "y = ma.masked_where(x>3,x)" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "2.0\n", "2.75\n" ] } ], "prompt_number": 20 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Numpy functions and object methods\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "a = np.arange(100)\n", "\n", "print np.sum(a)\n", "\n", "print a.sum()" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "4950\n", "4950\n" ] } ], "prompt_number": 21 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Histograms\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "f" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Populating the interactive namespace from numpy and matplotlib\n" ] }, { "metadata": {}, "output_type": "pyout", "prompt_number": 16, "text": [ "" ] }, { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAARAAAAD6CAYAAABpohhFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n4uz/APiyjQxjjlo/AAAAAElFTkSuQmCC\n", "text": [ "" ] } ], "prompt_number": 16 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Matrix objects\n", "===" ] }, { "cell_type": "code", "collapsed": false, "input": [ "x1 = np.array([1, 2, 3], float)\n", "\n", "x2 = np.matrix(x1)\n", "\n", "A = np.eye(3)\n", "print type(A)\n", "A = np.mat(A)\n", "print type(A)\n", "B = x2*A\n", "np.linalg.inv(A)" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "\n", "\n", "[[ 1. 2. 3.]]\n" ] }, { "metadata": {}, "output_type": "pyout", "prompt_number": 23, "text": [ "matrix([[ 1., 0., 0.],\n", " [ 0., 1., 0.],\n", " [ 0., 0., 1.]])" ] } ], "prompt_number": 23 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "$*$ represents matrix-matrix matrix-vector or vector-matrix multiplication. Only 1D and 2D matrices are supported." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Numpy subpackages\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* Discrete Fourier Transform (np.fft)\n", "* Linear algebra (np.linalg): cholesky, svd, eigenvalues/vectors, matrix inversion, solving equations (LAPACK)\n", "* Random sampling (np.random)\n", "* statistics: covariance, correlation, variances, histograms\n", "* polynomials: root finding, fitting data (np.polynomial)\n", "* Matrix library (np.matlib)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "How fast is numpy?\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* 100 times faster than with a for loop with native python types\n", "* 3-10 times slower than a modern FORTRAN/C++ compiler with -O3 optimisations\n", "* comparable speed to matlab \n", "\n", "\n", "But this is run speed. In development and debugging time, Python is\n", "far ahead ofFORTRAN/C++. But if __speed is really critical__ to your code,\n", "you can profile your Python code and rewrite slower parts in\n", "C/C++/FORTRAN." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Python modules for numerical computing and visualisation\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* numpy + scipy\n", "* matplotlib\n", "* gnuplot.py, also sm and PGPLOT have interfaces\n", "* Mathlink - interface to Mathematica\n", "* MaYaVI - 3D visualisation using VTK\n", "* pymat - Python Matlab interface\n", "* pytave - Python Octave interface\n", "* Rpy - Python R interface\n", "* Pyminuit - wraps the C++ version of the Minuit fitting software from CERN.\n", "* SAGE: alternative to Magma, Maple, Mathematica, Matlab, under development" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "SciPy - superset of numpy http://scipy.org\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* constants: physical constants and conversion factors (since version 0.7.0[1])\n", "* cluster: hierarchical clustering, vector quantization, K-means\n", "* constants: Physical and mathematical constants\n", "* fftpack: Discrete Fourier Transform algorithms\n", "* integrate: numerical integration and ODE solvers\n", "* interpolate: interpolation and smoothing splines\n", "* io: data input and output\n", "* linalg: linear algebra routines\n", "* ndimage: N dimensional image processing\n", "* odr: Orthogonal distance regression\n", "* optimize: optimization algorithms including linear programming\n", "* signal: signal processing tools" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "SciPy\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* sparse: sparse matrix and related algorithms\n", "* spatial: KD-trees, nearest neighbors, distance functions\n", "* special: special functions\n", "* stats: statistical distributions and functions\n", "* weave: tool for writing C/C++ code as Python multiline strings\n", "\n", "Via RPy, SciPy can interface to the R statistical package R." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "SciPy Cookbook\n", "===" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "http://wiki.scipy.org/Cookbook\n", "\n", "This page hosts worked examples of commonly-done tasks. Some are\n", "introductory in nature, while others are quite advanced (these are at\n", "the bottom of the web page)." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Curve fitting - scipy.optimize.curve_fit\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "The algorithm uses the Levenberg-Marquardt algorithm through\n", "'leastsq'. Additional keyword arguments are passed directly to that\n", "algorithm. Quick and easy way to fit an arbitary function to some x,y\n", "data." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Minimization - scipy.optimize.minimize\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Many different solvers available - Nelder-Mead, Powell, simulated annealing etc." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Scipy and Numpy documentation\n", "===" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "User Guides, Reference Guides and Developer guides are available at: http://docs.scipy.org\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Sympy -symbolic computation using python\n", "===\n" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import sympy,math\n", "print math.sqrt(8)\n", "print sympy.sqrt(8)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "2.82842712475\n", "2*sqrt(2)\n" ] } ], "prompt_number": 3 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Pandas - Python Data Analysis Library\n", "===" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "aims to become a first class statistical modeling environment like R" ] } ], "metadata": {} } ] }