operations.ipynb

{
 "metadata": {
  "name": "operations"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Numerical operations on arrays"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Section contents\n",
      "\n",
      "* Elementwise operations\n",
      "* Basic reductions\n",
      "* Broadcasting\n",
      "* Array shape manipulation\n",
      "* Sorting data\n",
      "* Summary\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Elementwise operations"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Basic operations"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "With scalars:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([1, 2, 3, 4])\n",
      "a + 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "2**a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "All arithmetic operates elementwise:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b = np.ones(4) + 1\n",
      "a - b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a * b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "j = np.arange(5)\n",
      "2**(j + 1) - j"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "These operations are of course much faster than if you did them in pure\n",
      "python:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.arange(10000)\n",
      "%timeit a + 1  "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "l = range(10000)\n",
      "%timeit [i+1 for i in l] "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Warning"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Array multiplication is not matrix multiplication:**\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "c = np.ones((3, 3))\n",
      "c * c                   # NOT matrix multiplication!"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Note"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Matrix multiplication:**\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "c.dot(c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Exercise: Elementwise operations"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Try simple arithmetic elementwise operations.\n",
      "\n",
      "* Time them against their pure python counterparts using `%timeit`.\n",
      "\n",
      "* Try using `dot`.\n",
      "\n",
      "* Generate:\n",
      "\n",
      "    * `[2**0, 2**1, 2**2, 2**3, 2**4]`\n",
      "\n",
      "    * `a_j = 2^(3*j) - j`\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Other operations"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Comparisons:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([1, 2, 3, 4])\n",
      "b = np.array([4, 2, 2, 4])\n",
      "a == b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a > b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Logical operations:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([1, 1, 0, 0], dtype=bool)\n",
      "b = np.array([1, 0, 1, 0], dtype=bool)\n",
      "np.logical_or(a, b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.logical_and(a, b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Transcendental functions:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.arange(10)\n",
      "np.sin(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.log(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.exp(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Shape mismatches\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.arange(4)\n",
      "a + np.array([1, 2])  "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Broadcasting?** We'll return to that shortly\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Transposition:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.triu(np.ones((3, 3)), 1)   # see help(np.triu)\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.T"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Tip"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Array-wise comparisons:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([1, 2, 3, 4])\n",
      "b = np.array([4, 2, 2, 4])\n",
      "c = np.array([1, 2, 3, 4])\n",
      "np.array_equal(a, b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.array_equal(a, c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Note"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Linear algebra**\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The sub-module ``numpy.linalg`` implements basic linear algebra,\n",
      "such as solving linear systems, singular value decomposition, etc.\n",
      "However, it is not guaranteed to be compiled using efficient routines,\n",
      "and thus we recommend the use of ``scipy.linalg``, as detailed in\n",
      "section ``scipy_linalg``\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Exercise other operations"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Look at the help for `np.allclose`. When might this be useful?\n",
      "\n",
      "* Look at the help for `np.triu` and `np.tril`.\n",
      "\n",
      "* Is the transpose a view or a copy? What implications does this have for\n",
      "making a matrix symmetric?\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Basic reductions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Computing sums:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = np.array([1, 2, 3, 4])\n",
      "np.sum(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x.sum()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.display import Image\n",
      "Image(filename='images/reductions.png')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sum by rows and by columns:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = np.array([[1, 1], [2, 2]])\n",
      "x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x.sum(axis=0)   # columns (first dimension)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x[:, 0].sum(), x[:, 1].sum()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x.sum(axis=1)   # rows (second dimension)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x[0, :].sum(), x[1, :].sum()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Tip"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Same idea in higher dimensions:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = np.random.rand(2, 2, 2)\n",
      "x.sum(axis=2)[0, 1]     "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x[0, 1, :].sum()     "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Other reductions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "--- works the same way (and take `axis=`)\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Statistics:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = np.array([1, 2, 3, 1])\n",
      "y = np.array([[1, 2, 3], [5, 6, 1]])\n",
      "x.mean()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.median(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.median(y, axis=-1) # last axis"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x.std()          # full population standard dev."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Extrema:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = np.array([1, 3, 2])\n",
      "x.min()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x.max()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x.argmin()  # index of minimum"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x.argmax()  # index of maximum"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Logical operations:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.all([True, True, False])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.any([True, True, False])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Note"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Can be used for array comparisons:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.zeros((100, 100))\n",
      "np.any(a != 0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.all(a == a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([1, 2, 3, 2])\n",
      "b = np.array([2, 2, 3, 2])\n",
      "c = np.array([6, 4, 4, 5])\n",
      "((a <= b) & (b <= c)).all()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "... and many more (best to learn as you go).\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Exercise: Reductions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Given there is a `sum`, what other function might you expect to see?\n",
      "\n",
      "* What is the difference between `sum` and `cumsum`?\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Worked Example: data statistics"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Data in `data/populations.txt`\n",
      "describes the populations of hares and lynxes (and carrots) in northern\n",
      "Canada during 20 years.\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You can view the data in an editor, or alternatively in IPython (both\n",
      "shell and notebook):\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "!cat data/populations.txt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "First, load the data into a Numpy array:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "data = np.loadtxt('data/populations.txt')\n",
      "year, hares, lynxes, carrots = data.T  # trick: columns to variables"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Then plot it:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from matplotlib import pyplot as plt\n",
      "plt.axes([0.2, 0.1, 0.5, 0.8]) \n",
      "plt.plot(year, hares, year, lynxes, year, carrots) \n",
      "plt.legend(('Hare', 'Lynx', 'Carrot'), loc=(1.05, 0.5)) "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The mean populations over time:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "populations = data[:, 1:]\n",
      "populations.mean(axis=0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The sample standard deviations:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "populations.std(axis=0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Which species has the highest population each year?:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.argmax(populations, axis=1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Broadcasting"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Basic operations on `numpy` arrays (addition, etc.) are elementwise\n",
      "\n",
      "* This works on arrays of the same size.\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The image below gives an example of broadcasting:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.display import Image\n",
      "Image(filename='images/numpy_broadcasting.png')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's verify:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.tile(np.arange(0, 40, 10), (3, 1)).T\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b = np.array([0, 1, 2])\n",
      "a + b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We have already used broadcasting without knowing it!:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.ones((4, 5))\n",
      "a[0] = 2  # we assign an array of dimension 0 to an array of dimension 1\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "An useful trick:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.arange(0, 40, 10)\n",
      "a.shape"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = a[:, np.newaxis]  # adds a new axis -> 2D array\n",
      "a.shape"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a + b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Tip"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Broadcasting seems a bit magical, but it is actually quite natural to\n",
      "use it when we want to solve a problem whose output data is an array\n",
      "with more dimensions than input data.\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Worked Example: Broadcasting"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's construct an array of distances (in miles) between cities of Route\n",
      "66: Chicago, Springfield, Saint-Louis, Tulsa, Oklahoma City, Amarillo,\n",
      "Santa Fe, Albuquerque, Flagstaff and Los Angeles.\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mileposts = np.array([0, 198, 303, 736, 871, 1175, 1475, 1544,\n",
      "       1913, 2448])\n",
      "distance_array = np.abs(mileposts - mileposts[:, np.newaxis])\n",
      "distance_array"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.display import Image\n",
      "Image(filename='images/route66.png')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A lot of grid-based or network-based problems can also use broadcasting.\n",
      "For instance, if we want to compute the distance from the origin of\n",
      "points on a 10x10 grid, we can do\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x, y = np.arange(5), np.arange(5)[:, np.newaxis]\n",
      "distance = np.sqrt(x ** 2 + y ** 2)\n",
      "distance"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Or in color:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "plt.pcolor(distance)    \n",
      "plt.colorbar()    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Remark** : the `numpy.ogrid` function allows to directly create\n",
      "vectors x and y of the previous example, with two \"significant\n",
      "dimensions\":\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x, y = np.ogrid[0:5, 0:5]\n",
      "x, y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x.shape, y.shape"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "distance = np.sqrt(x ** 2 + y ** 2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Tip"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "So, `np.ogrid` is very useful as soon as we have to handle computations\n",
      "on a grid. On the other hand, `np.mgrid` directly provides matrices full\n",
      "of indices for cases where we can't (or don't want to) benefit from\n",
      "broadcasting:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x, y = np.mgrid[0:4, 0:4]\n",
      "x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Array shape manipulation"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Flattening"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([[1, 2, 3], [4, 5, 6]])\n",
      "a.ravel()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.T"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.T.ravel()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Higher dimensions: last dimensions ravel out \"first\".\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Reshaping"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The inverse operation to flattening:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.shape"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b = a.ravel()\n",
      "b = b.reshape((2, 3))\n",
      "b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Or,\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.reshape((2, -1))    # unspecified (-1) value is inferred"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Warning"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "`ndarray.reshape` **may** return a view (cf `help(np.reshape)`)), or\n",
      "copy\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Tip"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b[0, 0] = 99\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Beware: reshape may also return a copy!:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.zeros((3, 2))\n",
      "b = a.T.reshape(3*2)\n",
      "b[0] = 9\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To understand this you need to learn more about the memory layout of a\n",
      "numpy array.\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Adding a dimension"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Indexing with the `np.newaxis` object allows us to add an axis to an\n",
      "array (you have seen this already above in the broadcasting section):\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z = np.array([1, 2, 3])\n",
      "z"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z[:, np.newaxis]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z[np.newaxis, :]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Dimension shuffling"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.arange(4*3*2).reshape(4, 3, 2)\n",
      "a.shape"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a[0, 2, 1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b = a.transpose(1, 2, 0)\n",
      "b.shape"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b[2, 1, 0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Also creates a view:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b[2, 1, 0] = -1\n",
      "a[0, 2, 1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Resizing"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Size of an array can be changed with `ndarray.resize`:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.arange(4)\n",
      "a.resize((8,))\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "However, it must not be referred to somewhere else:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b = a\n",
      "a.resize((4,))   "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Exercise: Shape manipulations"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Look at the docstring for `reshape`, especially the notes section which\n",
      "has some more information about copies and views.\n",
      "\n",
      "* Use `flatten` as an alternative to `ravel`. What is the difference?\n",
      "(Hint: check which one returns a view and which a copy)\n",
      "\n",
      "* Experiment with `transpose` for dimension shuffling.\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Sorting data"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sorting along an axis:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([[4, 3, 5], [1, 2, 1]])\n",
      "b = np.sort(a, axis=1)\n",
      "b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Note"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sorts each row separately!\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In-place sort:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.sort(axis=1)\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sorting with fancy indexing:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([4, 3, 1, 2])\n",
      "j = np.argsort(a)\n",
      "j"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a[j]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Finding minima and maxima:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([4, 3, 1, 2])\n",
      "j_max = np.argmax(a)\n",
      "j_min = np.argmin(a)\n",
      "j_max, j_min"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Exercise: Sorting"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Try both in-place and out-of-place sorting.\n",
      "\n",
      "* Try creating arrays with different dtypes and sorting them.\n",
      "\n",
      "* Use `all` or `array_equal` to check the results.\n",
      "\n",
      "* Look at `np.random.shuffle` for a way to create sortable input quicker.\n",
      "\n",
      "* Combine `ravel`, `sort` and `reshape`.\n",
      "\n",
      "* Look at the `axis` keyword for `sort` and rewrite the previous exercise.\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Summary"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**What do you need to know to get started?**\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Know how to create arrays : `array`, `arange`, `ones`, `zeros`.\n",
      "\n",
      "* Know the shape of the array with `array.shape`, then use slicing to\n",
      "obtain different views of the array: `array[::2]`, etc. Adjust the shape\n",
      "of the array using `reshape` or flatten it with `ravel`.\n",
      "\n",
      "* Obtain a subset of the elements of an array and/or modify their values\n",
      "with masks\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a[a < 0] = 0"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Know miscellaneous operations on arrays, such as finding the mean or max\n",
      "(`array.max()`, `array.mean()`). No need to retain everything, but have\n",
      "the reflex to search in the documentation (online docs, `help()`,\n",
      "`lookfor()`)!!\n",
      "\n",
      "* For advanced use: master the indexing with arrays of integers, as well\n",
      "as broadcasting. Know more Numpy functions to handle various array\n",
      "operations.\n"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}