{
 "metadata": {
  "name": "",
  "signature": "sha256:8169f656b8c946436386bec1d439a1c4b1be5d1dc9ce3ee2883753809c7e33fc"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Populating the interactive namespace from numpy and matplotlib\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Introduction to NumPy Arrays"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "J.R. Johansson and P.D. Nation\n",
      "\n",
      "For more information about QuTiP see [http://qutip.org](http://qutip.org)"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Introduction"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Until now we have been using lists as a way of storing multiple elements together.  However, when doing numerical computations, lists are not very good.  For example, what if I wanted to add one to a list of numbers?  We couldn't write"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a=[1,2,3]\n",
      "a=a+1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "can only concatenate list (not \"int\") to list",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-5-d80cb8f6be3a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m=\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[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: can only concatenate list (not \"int\") to list"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Instead we would have to do"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for k in range(3):\n",
      "    a[k]=a[k]+1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Working with lists would quickly become very complicated if we wanted to do numerical operations on many elements at the same time, or if, for example, we want to be able to construct vectors and matrices in our programs.  All of these features, and more, come with using NumPy **arrays** as our preferred data structure."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "NumPy Arrays"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "When dealing with numerical data in Python, nearly 100% of the time one uses arrays from the NumPy module to store and manipulate data.  NumPy arrays are very similar to Python lists, but are actually arrays in c-code that allow for very fast multi-dimensional numerical, vector, matrix, and linear algebra operations.  Using arrays with slicing, and **vectorization** leads to very fast Python code, and can replace many of the for-loops that you would have use if you coded a problem using lists. As a general rule, **minimizing the number of for-loops maximizes the performance of your code**.  To start using arrays, we can start with a simple list and use it as an argument to the array function"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from numpy import *\n",
      "a=array([1,2,3,4,5,6])\n",
      "print(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1 2 3 4 5 6]\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We have now created our first array of integers.  Notice how, when using print, the array looks the same as a list, however it is very much a different data structure.  We can also create an array of floats, complex numbers or even strings"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=array([2.0,4.0,8.0,16.0])\n",
      "b=array([0,1+0j,1+1j,2-2j])\n",
      "c=array(['a','b','c','d'])\n",
      "print(a)\n",
      "print(b)\n",
      "print(c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[  2.   4.   8.  16.]\n",
        "[ 0.+0.j  1.+0.j  1.+1.j  2.-2.j]\n",
        "['a' 'b' 'c' 'd']\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "In general there are three different ways of creating arrays in Python:\n",
      "\n",
      "- First create a list and then call the array function using the list as an input argument.\n",
      "\n",
      "- Use NumPy functions that are designed to create arrays: **zeros, ones, arange, linspace**.\n",
      "\n",
      "- Import data into Python from file."
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Arrays from Lists"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We have already seen how to create arrays with simple lists, but now lets look at how to create more complicated lists that we can turn into arrays.  A short way of creating a list, say from 0 to 9 is as follows:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "output=[n for n in range(10)]\n",
      "print(output)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This code is doing the exact same thing as the longer expression"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "output=[]\n",
      "for n in range(10):\n",
      "    output.append(n)\n",
      "print(output)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "We could turn this into an array quite easy"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "array(output)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 11,
       "text": [
        "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Or, we can save even more space and create the list inside of the array function:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "array([n for n in range(10)])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This can also be used to create more complicated arrays"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "array([2.0*k**0.563 for k in range(0,10,2)])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 13,
       "text": [
        "array([ 0.        ,  2.95467613,  4.36505551,  5.48440035,  6.44866265])"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Array Creation in NumPy (see [NumPy Documentation](http://docs.scipy.org/doc/numpy/reference/routines.array-creation.html) for more info.)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "NumPy has several extremely important array creation functions that will make you life much easier. For example, creating arrays of all zeros or ones is trivial. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "zeros(5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 14,
       "text": [
        "array([ 0.,  0.,  0.,  0.,  0.])"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ones(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 15,
       "text": [
        "array([ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.])"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "However, the most useful functions are [**```arange```**](http://docs.scipy.org/doc/numpy/reference/generated/numpy.arange.html#numpy.arange) which generates evenly spaced values within a given interval in a similar way that the ```range``` function did, and [**```linspace```**](http://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html) that makes a linear array of points from a starting to an ending value."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arange(5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 16,
       "text": [
        "array([0, 1, 2, 3, 4])"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arange(0,10,2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 17,
       "text": [
        "array([0, 2, 4, 6, 8])"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "linspace(0,10,20) #makes an array of 20 points linearly spaced from 0 to 10"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 18,
       "text": [
        "array([  0.        ,   0.52631579,   1.05263158,   1.57894737,\n",
        "         2.10526316,   2.63157895,   3.15789474,   3.68421053,\n",
        "         4.21052632,   4.73684211,   5.26315789,   5.78947368,\n",
        "         6.31578947,   6.84210526,   7.36842105,   7.89473684,\n",
        "         8.42105263,   8.94736842,   9.47368421,  10.        ])"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "linspace(-5,5,15) #15 points in range from -5 to 5"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 19,
       "text": [
        "array([-5.        , -4.28571429, -3.57142857, -2.85714286, -2.14285714,\n",
        "       -1.42857143, -0.71428571,  0.        ,  0.71428571,  1.42857143,\n",
        "        2.14285714,  2.85714286,  3.57142857,  4.28571429,  5.        ])"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Differences Between Arrays and Lists"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Having played with arrays a bit, it is now time to explain the main differences between NumPy arrays and Python lists."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python lists are very general and can hold any combination of data types.  However, NumPy **arrays can only hold one type of data** (integers, floats, strings, complex).  If we try to combine different types of data, then the array function will **upcast** the data in the array such that it all has the same type"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "array([1,2,3.14]) # [int,int,float] -> [float,float,float]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 20,
       "text": [
        "array([ 1.  ,  2.  ,  3.14])"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Upcasting between integers and floats does not cause too much trouble, but mixing strings and numbers in an array can create problems"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "array([1.0,1+1j,'hello']) #array data is upcast to strings"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 21,
       "text": [
        "array(['1.0', '(1+1j)', 'hello'], \n",
        "      dtype='<U64')"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "If we want, we can manually change the type of the data inside the array using the ```dtype``` (\"data type\") keyword argument.  Frequently used dtypes are: ```int, float, complex, bool, str, object```, etc.  For example, to convert a list of integers to floats we can write"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "array([1,2,3,4,5],dtype=float)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 22,
       "text": [
        "array([ 1.,  2.,  3.,  4.,  5.])"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arange(2,10,2,dtype=complex)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 23,
       "text": [
        "array([ 2.+0.j,  4.+0.j,  6.+0.j,  8.+0.j])"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "array([k for k in range(10)],dtype=str)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 24,
       "text": [
        "array(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], \n",
        "      dtype='<U1')"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Unlike Python lists, **we can not remove or add elements to an array once it has been created**.  Therefore, we must know the size of the array before creating it."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Because arrays hold only one type of data, mathematical functions such as multiplication and addition of arrays can be implemented in at the c-code level.  This means that these kinds of operations are very fast and memory efficient.  The mathematical operations on arrays are performed **elementwise**, which means that each element gets acted on in the same way.  This is an example of **vectorization**.  For example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=array([1,2,3,4])\n",
      "5.0*a #This gets upcasted because 5.0 is a float"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 25,
       "text": [
        "array([  5.,  10.,  15.,  20.])"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5*a**2-4"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 26,
       "text": [
        "array([ 1, 16, 41, 76])"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Recall that none of these operations worked on Python lists."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Using NumPy Functions on Arrays"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Remember that NumPy has a large builtin [collection of mathematical functions](http://docs.scipy.org/doc/numpy/reference/routines.math.html).  When using NumPy arrays as our data structure, these functions become even more powerful as we can apply the same function elementwise over the entire array very quickly.  Again, this is called vectorization and can speed up your code by many times."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x=linspace(-pi,pi,10)\n",
      "sin(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 27,
       "text": [
        "array([ -1.22464680e-16,  -6.42787610e-01,  -9.84807753e-01,\n",
        "        -8.66025404e-01,  -3.42020143e-01,   3.42020143e-01,\n",
        "         8.66025404e-01,   9.84807753e-01,   6.42787610e-01,\n",
        "         1.22464680e-16])"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x=array([x**2 for x in range(4)])\n",
      "sqrt(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 28,
       "text": [
        "array([ 0.,  1.,  2.,  3.])"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x=array([2*n+1 for n in range(10)])\n",
      "sum(x) #sums up all elements in the array"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 29,
       "text": [
        "100"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Boolean Operations on Arrays"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Like other mathematical functions, we can also use conditional statements on arrays to check whether each individual element satisfies a given expression.  For example, to find the location of array elements that are less than zero we could do"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=array([0,-1,2,-3,4])\n",
      "print(a<0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[False  True False  True False]\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The result in another array of boolean (```True/False```) values indicating whether a given element is less than zero.  Or, for example, we can find all of the odd numbers in an array."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=arange(10)\n",
      "print((mod(a,2)!=0))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[False  True False  True False  True False  True False  True]\n"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Slicing NumPy Arrays"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Just like lists, arrays can be sliced to get certain elements of the array, or to modify certain elements of the array.  For example, lets try to get every third element from a given array"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=arange(20)\n",
      "a[3::3]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 32,
       "text": [
        "array([ 3,  6,  9, 12, 15, 18])"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now lets set each of these elements equal to -1."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a[3::3]=-1\n",
      "print(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[ 0  1  2 -1  4  5 -1  7  8 -1 10 11 -1 13 14 -1 16 17 -1 19]\n"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We can also slice the array so that it returns the original array in reverse"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=arange(10)\n",
      "a[::-1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 34,
       "text": [
        "array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Finally, what if we want to get only those elements in the array that satisfy a certain conditional statement?  Recall that conditional statements on an array return another array of boolean values.  We can use this boolean array as an index to pick out only those elements where the boolean value is ```True```."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=linspace(-10,10,20)\n",
      "print(a[a<=-5])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[-10.          -8.94736842  -7.89473684  -6.84210526  -5.78947368]\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We must be careful though. Checking for multiple conditionals is not allowed"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(a[-8<a<=-5])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "ValueError",
       "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-36-76eb4cd96a9b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m<=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The reason for this error is because the computer does not know how to take an array of many ```True/False``` values and return just a single value."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example: Rewriting Sieve of Eratosthenes"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "Here we will replace most of the for-loops used when writing the Sieve of Eratosthenes using lists will arrays.  This will make the code much easier to read and actually much faster for computing large prime numbers.  The main part of the original code is:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "N=20\n",
      "# generate a list from 2->N\n",
      "numbers = []\n",
      "for i in range(2,N+1):                 # This can be replaced by array\n",
      "    numbers.append(i)\n",
      "# Run Seive of Eratosthenes algorithm marking nodes with -1\n",
      "for j in range(N-1):\n",
      "    if numbers[j]!=-1:\n",
      "        p=numbers[j]\n",
      "        for k in range(j+p,N-1,p):     # This can be replaced by array\n",
      "            numbers[k]=-1\n",
      "# Collect all elements not -1 (these are the primes)\n",
      "primes = []\n",
      "for i in range(N-1):                   # This can be replaced by array\n",
      "    if numbers[i]!=-1:\n",
      "        primes.append(numbers[i])\n",
      "print(primes)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[2, 3, 5, 7, 11, 13, 17, 19]\n"
       ]
      }
     ],
     "prompt_number": 42
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "-"
      }
     },
     "source": [
      "Using arrays instead of lists simplifies the code:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "N=20\n",
      "# generate a list from 2->N\n",
      "numbers=arange(2,N+1)                 # replaced for-loop with call to arange\n",
      "# Run Seive of Eratosthenes algorithm\n",
      "# by marking nodes with -1\n",
      "for j in range(N-1):\n",
      "    if numbers[j]!=-1:\n",
      "        p=numbers[j]\n",
      "        numbers[j+p:N-1:p]=-1         # replaced for-loop by slicing array\n",
      "# Collect all elements not -1 (these are the primes)\n",
      "primes=numbers[numbers!=-1]           # Used conditional statement to get elements !=-1\n",
      "print(primes)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[ 2  3  5  7 11 13 17 19]\n"
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "<h1 align=\"center\">End of Tutorial</h1> \n",
      "<h3 align=\"center\"><a href=\"http://qutip.org/tutorials.html\">Return to QuTiP tutorials page</a></h3> "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.core.display import HTML\n",
      "def css_styling():\n",
      "    styles = open(\"styles/style.css\", \"r\").read()\n",
      "    return HTML(styles)\n",
      "css_styling()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "html": [
        "<style>\n",
        "@import url('http://fonts.googleapis.com/css?family=Source+Sans+Pro');\n",
        "@import url('http://fonts.googleapis.com/css?family=Source+Code+Pro');\n",
        "\n",
        "body {\n",
        "    -webkit-font-smoothing: antialiased;\n",
        "    font-family: \"Source Sans Pro\", Helvetica, Arial, Verdana, sans-serif;\n",
        "}\n",
        "\n",
        "\n",
        "div.cell{\n",
        "    width:768px;\n",
        "    margin-left:10% !important;\n",
        "    margin-right:auto;\n",
        "}\n",
        "h1 {\n",
        "    font-family: \"Source Sans Pro\", ,Helvetica, Arial, serif;\n",
        "}\n",
        "h4{\n",
        "    font-family: \"Source Sans Pro\", Helvetica, Arial, serif;\n",
        "\tmargin-top:12px;\n",
        "    margin-bottom: 3px;\n",
        "   }\n",
        "div.text_cell_render{\n",
        "    font-family: \"Source Sans Pro\", Helvetica, Arial, sans-serif;\n",
        "    line-height: 125%;\n",
        "    font-size: 110%;\n",
        "    width:768px;\n",
        "    margin-left:auto;\n",
        "    margin-right:auto;\n",
        "}\n",
        ".CodeMirror{\n",
        "        font-family: \"Source Code Pro\", source-code-pro, Consolas, monospace;\n",
        "}\n",
        ".prompt{\n",
        "    display: None;\n",
        "}\n",
        ".text_cell_render h5 {\n",
        "    font-family: \"Source Sans Pro\", Helvetica, Arial, serif;\n",
        "    font-size: 20pt;\n",
        "    color: #0001E0;\n",
        "    margin-bottom: .5em;\n",
        "    margin-top: 0.5em;\n",
        "    display: block;\n",
        "}\n",
        "\n",
        ".warning{\n",
        "    color: rgb( 240, 20, 20 )\n",
        "    }  \n",
        "\n",
        "a {\n",
        "    color: #0D68AE;\n",
        "    text-decoration: none;\n",
        "    -webkit-transition: color 0.2s ease-in-out;\n",
        "    -moz-transition: color 0.2s ease-in-out;\n",
        "    -o-transition: color 0.2s ease-in-out;\n",
        "    -ms-transition: color 0.2s ease-in-out;\n",
        "    transition: color 0.2s ease-in-out;\n",
        "}\n",
        "a:hover {\n",
        "    color: #54ABE0;\n",
        "}\n",
        "\n",
        "table {\n",
        "    border: 0px solid rgba(0, 0, 0, 0.25);\n",
        "    border-collapse: collapse;\n",
        "    display: table;\n",
        "    empty-cells: hide;\n",
        "    margin: -1px 0 1.3125em;\n",
        "    padding: 0;\n",
        "    table-layout: fixed;\n",
        "}\n",
        "caption {\n",
        "    display: table-caption;\n",
        "    font-weight: 700;\n",
        "}\n",
        "col {\n",
        "    display: table-column;\n",
        "}\n",
        "colgroup {\n",
        "    display: table-column-group;\n",
        "}\n",
        "tbody {\n",
        "    display: table-row-group;\n",
        "}\n",
        "tfoot {\n",
        "    display: table-footer-group;\n",
        "}\n",
        "thead {\n",
        "    display: table-header-group;\n",
        "}\n",
        "td, th {\n",
        "    display: table-cell;\n",
        "}\n",
        "tr {\n",
        "    display: table-row;\n",
        "}\n",
        "table th, table td {\n",
        "    font-size: 1.1em;\n",
        "    line-height: 23px;\n",
        "    padding: 0 1em;\n",
        "}\n",
        "table thead {\n",
        "    background: rgba(0, 0, 0, 0.15);\n",
        "    border: 0px solid rgba(0, 0, 0, 0.15);\n",
        "    border-bottom: 0px solid rgba(0, 0, 0, 0.2);\n",
        "}\n",
        "table tbody {\n",
        "    background: #FFFFFF;\n",
        "}\n",
        "table tfoot {\n",
        "    background: rgba(0, 0, 0, 0.15);\n",
        "    border: 0px solid rgba(0, 0, 0, 0.15);\n",
        "    border-top: 0px solid rgba(0, 0, 0, 0.2);\n",
        "}\n",
        "\n",
        "figure {\n",
        "    display: inline-block;\n",
        "    position: relative;\n",
        "    margin: 1em 0 2em;\n",
        "}\n",
        "figcaption {\n",
        "    font-style: italic;\n",
        "    text-align: center;\n",
        "    background: white;\n",
        "    color: #666;\n",
        "    position: absolute;\n",
        "    left: 0;\n",
        "    bottom: -24px;\n",
        "    width: 98%;\n",
        "    padding: 1%;\n",
        "    -webkit-transition: all 0.2s ease-in-out;\n",
        "    -moz-transition: all 0.2s ease-in-out;\n",
        "    -o-transition: all 0.2s ease-in-out;\n",
        "    -ms-transition: all 0.2s ease-in-out;\n",
        "    transition: all 0.2s ease-in-out;\n",
        "}\n",
        "\n",
        ".prompt.input_prompt {\n",
        "    color: rgba(0,0,0,0.5);\n",
        "}\n",
        "\n",
        ".cell.command_mode.selected {\n",
        "    border-color: rgba(0,0,0,0.1);\n",
        "}\n",
        "\n",
        ".cell.edit_mode.selected {\n",
        "    border-color: rgba(0,0,0,0.15);\n",
        "    box-shadow: 0px 0px 5px #f0f0f0;\n",
        "    -webkit-box-shadow: 0px 0px 5px #f0f0f0;\n",
        "}\n",
        "\n",
        "div.output_scroll {\n",
        "    -webkit-box-shadow: inset 0 2px 8px rgba(0,0,0,0.1);\n",
        "    box-shadow: inset 0 2px 8px rgba(0,0,0,0.1);\n",
        "    border-radious: 2px;\n",
        "}\n",
        "\n",
        "#menubar .navbar-inner {\n",
        "    background: #fff;\n",
        "    -webkit-box-shadow: none;\n",
        "    box-shadow: none;\n",
        "    border-radius: 0;\n",
        "    border: none;\n",
        "    font-family: \"Source Sans Pro\", Helvetica, Arial, serif;\n",
        "    font-weight: 400;\n",
        "}\n",
        "\n",
        ".navbar-fixed-top .navbar-inner,\n",
        ".navbar-static-top .navbar-inner {\n",
        "    box-shadow: none;\n",
        "    -webkit-box-shadow: none;\n",
        "    border: none;\n",
        "}\n",
        "\n",
        "div#notebook_panel {\n",
        "    box-shadow: none;\n",
        "    -webkit-box-shadow: none;\n",
        "    border-top: none;\n",
        "}\n",
        "\n",
        "div#notebook {\n",
        "    border-top: 1px solid rgba(0,0,0,0.15);\n",
        "}\n",
        "\n",
        "#menubar .navbar .navbar-inner,\n",
        ".toolbar-inner {\n",
        "    padding-left: 0;\n",
        "    padding-right: 0;\n",
        "}\n",
        "\n",
        "#checkpoint_status,\n",
        "#autosave_status {\n",
        "    color: rgba(0,0,0,0.5);\n",
        "}\n",
        "\n",
        "#header {\n",
        "    font-family: \"Source Sans Pro\", Helvetica, Arial, serif;\n",
        "}\n",
        "\n",
        "#notebook_name {\n",
        "    font-weight: 200;\n",
        "}\n",
        "\n",
        "/* \n",
        "    This is a lazy fix, we *should* fix the \n",
        "    background for each Bootstrap button type\n",
        "*/\n",
        "#site * .btn {\n",
        "    background: #fafafa;\n",
        "    -webkit-box-shadow: none;\n",
        "    box-shadow: none;\n",
        "}\n",
        "\n",
        "</style>\n",
        "\n",
        "<script>\n",
        "    MathJax.Hub.Config({\n",
        "                        TeX: {equationNumbers: { autoNumber: \"AMS\" },  \n",
        "                           extensions: [\"AMSmath.js\"]\n",
        "                           },\n",
        "                tex2jax: {\n",
        "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
        "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
        "                },\n",
        "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
        "                \"HTML-CSS\": {\n",
        "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
        "                }\n",
        "        });\n",
        "</script>\n"
       ],
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "<IPython.core.display.HTML at 0x10cda7048>"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}