07 Numerical computation.ipynb

{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Introduction\n\nWorking with numbers is central to almost all scientific and engineering computations. \nThe topic is so important that there are many dedicated libraries to help implement efficient numerical\ncomputations. There are even languages that are specifically designed for numerical computation, such as Fortran\nand MATLAB.\n\nNumPy (http://www.numpy.org/) is the most widely used Python library for numerical computations.  It provides an extensive range of data structures and functions for numerical\ncomputation. In this notebook we will explore just some of the functionality.\nYou will be seeing NumPy in other courses. NumPy can perform many of the operations that you will learn\nduring the mathematics courses.\n\nAnother library, which largely builds on NumPy and provides additional functionality, is SciPy (https://www.scipy.org/). SciPy provides some  more specialised data structures and functions over NumPy. \nIf you are familiar with MATLAB, NumPy and SciPy provide much of what is available in MATLAB.\n\nNumPy is a large and extensive library and this activity is just a very brief introduction.\nTo discover how to perform operations with NumPy, your best resources are search engines, such as http://stackoverflow.com/.\n\n\n## Objectives\n\n- Introduction to 1D and 2D arrays (vector and matrices) \n- Manipulating arrays (indexing, slicing, etc)\n- Apply elementary numerical operations\n- Demonstrate efficiency differences between vectorised and non-vectorised functions"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Importing the NumPy module\n\nTo make NumPy available in our programs, we need to import the module. It has become an informal custom to import NumPy using the shortcut '`np`': "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import numpy as np",
      "execution_count": 1,
      "outputs": []
    },
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": "# Numerical arrays\n\nWe have already seen Python 'lists', which hold 'arrays' of data.  We can access the elements of a list using an index because the entries are stored in order. Python lists are very flexible and can hold mixed data types, e.g. combinations of floats and strings, or even lists of lists of lists . . .\n\nThe flexibility of Python lists comes at the expense of performance. Many science, engineering and mathematics problems involve very large problems with operations on numbers, and computational speed is important for large problems. To serve this need, we normally use specialised functions and data structures for numerical computation, and in particular for arrays of numbers. Some of the flexibility of lists is traded for performance."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## One-dimensional arrays\n\nA one-dimensional array is a collection of numbers which we can access by index (it preserves order)."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Creating arrays and indexing \n\nTo create a NumPy array of length 10 and initially filled with zeros:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = np.zeros(10)\n\nprint(x)\nprint(type(x))",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n<class 'numpy.ndarray'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The default type of a NumPy array is `float`. The type can be checked with"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(x.dtype)",
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": "float64\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You cannot, for example, add a `string` to a `numpy.ndarray`. All entries in the array have the same type.\n\nWe can check the length of an array using `len`, which gives the number of entries in the array:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(len(x))",
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": "10\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "A better way to check the length is to use `x.shape`, which returns a tuple with the dimensions of the array:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(x.shape)",
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": "(10,)\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "`shape` tells us the size of the array in *each* direction. We will see two-dimensional arrays shortly (matrices), which have a size in each direction."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can change the entries of an array using indexing,"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(x)\n\nx[0] = 10.0\nx[3] = -4.3\nx[9] = 1.0\n\nprint(x)",
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n[10.   0.   0.  -4.3  0.   0.   0.   0.   0.   1. ]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Remember that indexing starts from zero!\n\nThere are other ways to create arrays, such as an array of 'ones':"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "y = np.ones(5)\nprint(y)",
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[1. 1. 1. 1. 1.]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "an array of random values:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "y = np.random.rand(6)\nprint(y)",
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[0.87533791 0.46829409 0.85562726 0.41467231 0.09727227 0.02063447]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "or a NumPy array from a Python list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = [4.0, 8.0, 9.0, 11.0, -2.0]\ny = np.array(x)\nprint(y)",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[ 4.  8.  9. 11. -2.]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Two more methods for creating arrays which we will use in later notebooks are:\n\n- `numpy.arange`; and \n- `numpy.linspace`. \n\nThey are particularly useful for plotting functions.\nThe function `arange` creates an array with equally spaced values. It is similar in some cases to `range`, which we have seen earlier. To create the array `[0 1 2 3 4 5]` using `arange`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = np.arange(6)\nprint(x)\nprint(type(x))",
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[0 1 2 3 4 5]\n<class 'numpy.ndarray'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that '6' is not included. We can change the start value, e.g.:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = np.arange(2, 6)\nprint(x)",
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[2 3 4 5]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The function `linspace` creates an array with prescribed start and end values (both are included), and a prescribed number on values, all equally spaced:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = np.linspace(0, 100, 6)\nprint(x)",
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[  0.  20.  40.  60.  80. 100.]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The `linspace` function is used extensively for plotting, as we will see in the next notebook."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Array arithmetic and functions\n\nNumPy arrays support common arithmetic operations, such as addition of two arrays"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = np.array([1.0, 0.2, 1.2])\ny = np.array([2.0, 0.1, 2.1])\nprint(x)\nprint(y)\n\n# Sum x and y\nz = x + y\nprint(z)",
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[1.  0.2 1.2]\n[2.  0.1 2.1]\n[3.  0.3 3.3]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "and multiplication of components by a scalar,"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "z = 10.0*x\nprint(z)",
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[10.  2. 12.]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "and raising components to a power:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = np.array([2, 3, 4])\nprint(x**2)",
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[ 4  9 16]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can also apply functions to the components of an array:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Create an array [0, π/2, π, 3π/2]\nx = np.array([0.0, np.pi/2, np.pi, 3*np.pi/2])\nprint(x)\n\n# Compute sine of each entry\ny = np.sin(x)\nprint(y)",
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[0.         1.57079633 3.14159265 4.71238898]\n[ 0.0000000e+00  1.0000000e+00  1.2246468e-16 -1.0000000e+00]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The above has computed the sine of each entry in the array `x`.\n\nNote that the function `np.sin` is used, and not `math.sin` (which was used in previous notebooks). The reason is that `np.sin` is more general -  it can act on lists/arrays of values rather than on just one value. We will apply functions to arrays in the next notebook to plot functions."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We could have computed the sine of each array entry using `for` loops:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "y = np.zeros(len(x))\nfor i in range(len(x)):\n    y[i] = np.sin(x[i])\n\nprint(y)",
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[ 0.0000000e+00  1.0000000e+00  1.2246468e-16 -1.0000000e+00]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "but the program becomes longer and harder to read. Additionally, in many cases it will be much slower. \nYou might see manipulation of arrays without indexing referred to as 'vectorisation'. When possible, vectorisation is a good thing to do. We compare the performance of indexing versus vectorisation below."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Performance example: computing the norm of a long vector\n\nThe norm of a vector $x$ is given by: \n\n$$\n\\| x \\| = \\sqrt{\\sum_{i=0}^{n-1} x_{i} x_{i}}\n$$\n\nwhere $x_{i}$ is the $i$th entry of $x$. It is the dot product of a vector with itself, \nfollowed by taking the square root.\nTo compute the norm, we could loop/iterate over the entries of the vector and sum the square of each entry, and then take the square root of the result.\n\nWe will evaluate the norm using two methods for computing the norm of an array of length 10 million to compare their performance. We first create a vector with 10 million random entries, using NumPy:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Create a NumPy array with 10 million random values\nx = np.random.rand(10000000)\nprint(type(x))",
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": "<class 'numpy.ndarray'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We now time how long it takes to compute the norm of the vector using the NumPy function '`numpy.dot`'. We use the Jupyter 'magic command' [`%time`](Notebook%20tips.ipynb#Simple-timing) to time the operation: "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "%time norm = np.sqrt(np.dot(x, x))\nprint(norm)",
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": "CPU times: user 22.8 ms, sys: 20 ms, total: 42.8 ms\nWall time: 37.7 ms\n1825.8319231232667\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The time output of interest is '`Wall time`'.\n\n> The details of how `%time` works are not important for this course. We use it as a compact and covenient tool to \n> measure how much time a command takes to execute.\n\nWe now perform the same operation with our own function for computing the norm:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def compute_norm(x):\n    norm = 0.0\n    for xi in x:\n        norm += xi*xi\n    return np.sqrt(norm)\n\n%time norm =compute_norm(x)\nprint(norm)",
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": "CPU times: user 2.02 s, sys: 15.2 ms, total: 2.04 s\nWall time: 1.98 s\n1825.831923123344\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You should see that the two approaches give the same result, but the \nNumPy function is more than 100 times faster, and possibly more than 100,000 times faster!\n\nThe message is that specialised functions and data structures for numerical computations can be many orders of magnitude faster than your own general implementations. On top of that, the specialised functions are much less \nlikely to have bugs!"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Two-dimensional arrays\n\nTwo-dimensional arrays are very useful for arranging data in many engineering applications and for performing mathematical operations. Commonly, 2D arrays are used to represents matrices. To create the matrix\n\n$$\nA = \n\\begin{bmatrix} \n2.2 & 3.7 & 9.1\\\\ \n-4 & 3.1 & 1.3\n\\end{bmatrix} \n$$\n\nwe use:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "A = np.array([[2.2, 3.7, 9.1], [-4.0, 3.1, 1.3]])\nprint(A)",
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[[ 2.2  3.7  9.1]\n [-4.   3.1  1.3]]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If we check the length of `A`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(len(A))",
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": "2\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "it reports the number of rows. To get the shape of the array, we use:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(A.shape)",
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": "(2, 3)\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "which reports 2 rows and 3 columns (stored using a tuple). To get the number of rows and the number of columns,"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "num_rows = A.shape[0]\nnum_cols = A.shape[1]\nprint(\"Number of rows is {}, number of columns is {}.\".format(num_rows, num_cols))",
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Number of rows is 2, number of columns is 3.\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can 'index' into a 2D array using two indices, the first for the row index and the second for the column index:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "A02 = A[0, 2]\nprint(A02)",
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": "9.1\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "With `A[1]`, we will get the second row:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(A[1])",
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[-4.   3.1  1.3]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can iterate over the entries of `A` by iterating over the rows, and then the entry in each row:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for row in A:\n    print(\"-----\")\n    for c in row:\n        print(c)",
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": "-----\n2.2\n3.7\n9.1\n-----\n-4.0\n3.1\n1.3\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "> **Warning:** NumPy has a `numpy.matrix` data structure. Its use is not recommended as it behaves inconsistently in some cases."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### 2D array (matrix) operations\n\nFor those who have seen matrices previously, the operations in this section will be familiar. For those who have not encountered matrices, you might want to revisit this section once matrices have been covered in the mathematics lectures."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### Matrix-vector and matrix-matrix multiplication\n\nWe will consider the matrix $A$:\n\n$$\nA  = \n\\begin{bmatrix}\n3.4 & 2.6 \\\\\n2.1 & 4.5\n\\end{bmatrix}\n$$\n\nand the vector $x$:\n\n$$\nx  = \n\\begin{bmatrix}\n0.2 \\\\ -1.1\n\\end{bmatrix}\n$$"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "A = np.array([[3.4, 2.6], [2.1, 4.5]])\nprint(\"Matrix A:\\n {}\".format(A))\n\nx = np.array([0.2, -1.1])\nprint(\"Vector x:\\n {}\".format(x))",
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Matrix A:\n [[3.4 2.6]\n [2.1 4.5]]\nVector x:\n [ 0.2 -1.1]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can compute the matrix-vector product $y = Ax$ by:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "y = A.dot(x)\nprint(y)",
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[-2.18 -4.53]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Matrix-matrix multiplication is performed similarly. Computing $C = AB$, where $A$, $B$, and $C$ are all matrices:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "B = np.array([[1.3, 0], [0, 2.0]])\n\nC = A.dot(B)\nprint(C)",
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[[4.42 5.2 ]\n [2.73 9.  ]]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The inverse of a matrix ($A^{-1}$) and the determinant ($\\det(A)$) can be computed using functions in the NumPy submodule `linalg`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "Ainv = np.linalg.inv(A)\nprint(\"Inverse of A:\\n {}\".format(Ainv))\n\nAdet = np.linalg.det(A)\nprint(\"Determinant of A: {}\".format(Adet))",
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Inverse of A:\n [[ 0.45731707 -0.26422764]\n [-0.21341463  0.34552846]]\nDeterminant of A: 9.839999999999998\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "> NumPy is large library, so it uses sub-modules to arrange functionality.\n\nA very common matrix is the *identity matrix* $I$. We can create a $4 \\times 4$ identity matrix using:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "I = np.eye(4)\nprint(I)",
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[[1. 0. 0. 0.]\n [0. 1. 0. 0.]\n [0. 0. 1. 0.]\n [0. 0. 0. 1.]]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Array slicing\n\nWhen working with arrays, it is often useful to extract subsets of an array. We might want just the first 3 entries of a long array, or we might want the second column of a 2D array (matrix). These operations are known as *array slicing* (https://en.wikipedia.org/wiki/Array_slicing).\n\nWe will explore slicing through examples. We start by creating an array filled with random values:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = np.random.rand(5)\nprint(x)",
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[0.51713539 0.89282022 0.90677015 0.61640165 0.29158586]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Below are some slicing operations:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Using ':' implies the whole range of indices, i.e. from 0 -> (length-1)\ny = x[:]\nprint(\"Slice using '[:]' {}\".format(y))\n\n# Using '1:3' implies indices 1 -> 3 (not including 3)\ny = x[1:3]\nprint(\"Slice using '[1:3]': {}\".format(y))\n\n# Using '2:-1' implies indices 2 -> second-from-last\ny = x[2:-1]\nprint(\"Slice using '[2:-1]': {}\".format(y))\n\n# Using '2:-2' implies indices 2 -> third-from-last\ny = x[2:-2]\nprint(\"Slice using '[2:-2]': {}\".format(y))",
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Slice using '[:]' [0.51713539 0.89282022 0.90677015 0.61640165 0.29158586]\nSlice using '[1:3]': [0.89282022 0.90677015]\nSlice using '[2:-1]': [0.90677015 0.61640165]\nSlice using '[2:-2]': [0.90677015]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "> Note the use of the index `-1`. The index `-1` corresponds to the last entry in the array, and `-2` the \n> second last entry, etc. This is convenient if we know how far in from the end of an array a desired entry is.\n> By using negative indices we can express this without reference to the length of the array."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If we want a slice to run from the start of an array, or to the end of an array, we do: "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Using ':3' implies start -> 3 (not including 3)\ny = x[:3]\nprint(\"Slice using '[:3]': {}\".format(y))\n\n# Using '4:' implies 4 -> end\ny = x[4:]\nprint(\"Slice using '[4:]': {}\".format(y))\n\n# Using ':' implies start -> end\ny = x[:]\nprint(\"Slice using '[:]': {}\".format(y))",
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Slice using '[:3]': [0.51713539 0.89282022 0.90677015]\nSlice using '[4:]': [0.29158586]\nSlice using '[:]': [0.51713539 0.89282022 0.90677015 0.61640165 0.29158586]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Slicing can be applied to 2D arrays:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "B = np.array([[1.3, 0], [0, 2.0]])\nprint(B)\n\n# Extract second row\nr = B[1, :]\nprint(r)",
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[[1.3 0. ]\n [0.  2. ]]\n[0. 2.]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "There is more to array slicing syntax, for example it is possible to extract every 3rd entry. If you need to extract a sub-array, check first if you can do it using the compact array slicing syntax."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Exercises\n\nComplete now the [07 Exercises](Exercises/07%20Exercises.ipynb) notebook."
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "file_extension": ".py",
      "version": "3.5.4",
      "pygments_lexer": "ipython3",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1
}