07 Numerical computation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "Working with numbers is central to almost all scientific and engineering computations. \n",
    "The topic is so important that there are many dedicated libraries to help implement efficient numerical\n",
    "computations. There are even languages that are specifically designed for numerical computation, such as Fortran\n",
    "and MATLAB.\n",
    "\n",
    "NumPy (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\n",
    "computation. In this notebook we will explore just some of the functionality.\n",
    "You will be seeing NumPy in other courses. NumPy can perform many of the operations that you will learn\n",
    "during the mathematics courses.\n",
    "\n",
    "Another 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. \n",
    "If you are familiar with MATLAB, NumPy and SciPy provide much of what is available in MATLAB.\n",
    "\n",
    "NumPy is a large and extensive library and this activity is just a very brief introduction.\n",
    "To 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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing the NumPy module\n",
    "\n",
    "To 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`': "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Numerical arrays\n",
    "\n",
    "We 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",
    "\n",
    "The 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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## One-dimensional arrays\n",
    "\n",
    "A one-dimensional array is a collection of numbers which we can access by index (it preserves order)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating arrays and indexing \n",
    "\n",
    "To create a NumPy array of length 10 and initially filled with zeros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "x = np.zeros(10)\n",
    "\n",
    "print(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default type of a NumPy array is `float`. The type can be checked with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n"
     ]
    }
   ],
   "source": [
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You cannot, for example, add a `string` to a `numpy.ndarray`. All entries in the array have the same type.\n",
    "\n",
    "We can check the length of an array using `len`, which gives the number of entries in the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A better way to check the length is to use `x.shape`, which returns a tuple with the dimensions of the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,)\n"
     ]
    }
   ],
   "source": [
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the entries of an array using indexing,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "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"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "\n",
    "x[0] = 10.0\n",
    "x[3] = -4.3\n",
    "x[9] = 1.0\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that indexing starts from zero!\n",
    "\n",
    "There are other ways to create arrays, such as an array of 'ones':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  1.  1.  1.  1.]\n"
     ]
    }
   ],
   "source": [
    "y = np.ones(5)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "an array of random values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.26856209  0.69203043  0.70532496  0.48133071  0.24084679  0.85961952]\n"
     ]
    }
   ],
   "source": [
    "y = np.random.rand(6)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or a NumPy array from a Python list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  4.   8.   9.  11.  -2.]\n"
     ]
    }
   ],
   "source": [
    "x = [4.0, 8.0, 9.0, 11.0, -2.0]\n",
    "y = np.array(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two more methods for creating arrays which we will use in later notebooks are:\n",
    "\n",
    "- `numpy.arange`; and \n",
    "- `numpy.linspace`. \n",
    "\n",
    "They are particularly useful for plotting functions.\n",
    "The 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`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(6)\n",
    "print(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that '6' is not included. We can change the start value, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(2, 6)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `linspace` creates an array with prescribed start and end values (both are included), and a prescribed number of values, all equally spaced:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   0.   20.   40.   60.   80.  100.]\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(0, 100, 6)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `linspace` function is used extensively for plotting, as we will see in the next notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array arithmetic and functions\n",
    "\n",
    "NumPy arrays support common arithmetic operations, such as addition of two arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.   0.2  1.2]\n",
      "[ 2.   0.1  2.1]\n",
      "[ 3.   0.3  3.3]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1.0, 0.2, 1.2])\n",
    "y = np.array([2.0, 0.1, 2.1])\n",
    "print(x)\n",
    "print(y)\n",
    "\n",
    "# Sum x and y\n",
    "z = x + y\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and multiplication of each element by a scalar,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 10.   2.  12.]\n"
     ]
    }
   ],
   "source": [
    "z = 10.0*x\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and raising each element to a power:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4  9 16]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([2, 3, 4])\n",
    "print(x**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also apply functions to the components of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.          1.57079633  3.14159265  4.71238898]\n",
      "[  0.00000000e+00   1.00000000e+00   1.22464680e-16  -1.00000000e+00]\n"
     ]
    }
   ],
   "source": [
    "# Create an array [0, π/2, π, 3π/2]\n",
    "x = np.array([0.0, np.pi/2, np.pi, 3*np.pi/2])\n",
    "print(x)\n",
    "\n",
    "# Compute sine of each entry\n",
    "y = np.sin(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above has computed the sine of each entry in the array `x`.\n",
    "\n",
    "Note 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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could have computed the sine of each array entry using `for` loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  0.00000000e+00   1.00000000e+00   1.22464680e-16  -1.00000000e+00]\n"
     ]
    }
   ],
   "source": [
    "y = np.zeros(len(x))\n",
    "for i in range(len(x)):\n",
    "    y[i] = np.sin(x[i])\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but the program becomes longer and harder to read. Additionally, in many cases it will be much slower. \n",
    "You 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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Performance example: computing the norm of a long vector\n",
    "\n",
    "The norm of a vector $x$ is given by: \n",
    "\n",
    "$$\n",
    "\\| x \\| = \\sqrt{\\sum_{i=0}^{n-1} x_{i} x_{i}}\n",
    "$$\n",
    "\n",
    "where $x_{i}$ is the $i$th entry of $x$. It is the dot product of a vector with itself, \n",
    "followed by taking the square root.\n",
    "To 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",
    "\n",
    "We will use 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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Create a NumPy array with 10 million random values\n",
    "x = np.random.rand(10000000)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4 ms, sys: 0 ns, total: 4 ms\n",
      "Wall time: 4.68 ms\n",
      "1825.61157771\n"
     ]
    }
   ],
   "source": [
    "%time norm = np.sqrt(np.dot(x, x))\n",
    "print(norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "\n",
    "We now perform the same operation with our own function for computing the norm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.23 s, sys: 4 ms, total: 1.24 s\n",
      "Wall time: 1.23 s\n",
      "1825.61157771\n"
     ]
    }
   ],
   "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)\n",
    "print(norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see that the two approaches give the same result, but the \n",
    "NumPy function is more than 100 times faster, and possibly more than 100,000 times faster!\n",
    "\n",
    "The 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 \n",
    "likely to have bugs!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two-dimensional arrays\n",
    "\n",
    "Two-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",
    "$$\n",
    "A = \n",
    "\\begin{bmatrix} \n",
    "2.2 & 3.7 & 9.1\\\\ \n",
    "-4 & 3.1 & 1.3\n",
    "\\end{bmatrix} \n",
    "$$\n",
    "\n",
    "we use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.2  3.7  9.1]\n",
      " [-4.   3.1  1.3]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2.2, 3.7, 9.1], [-4.0, 3.1, 1.3]])\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we check the length of `A`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(len(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "it reports the number of rows. To get the shape of the array, we use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "print(A.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which reports 2 rows and 3 columns (stored using a tuple). To get the number of rows and the number of columns,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows is 2, number of columns is 3.\n"
     ]
    }
   ],
   "source": [
    "num_rows = A.shape[0]\n",
    "num_cols = A.shape[1]\n",
    "print(\"Number of rows is {}, number of columns is {}.\".format(num_rows, num_cols))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can 'index' into a 2D array using two indices, the first for the row index and the second for the column index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.1\n"
     ]
    }
   ],
   "source": [
    "A02 = A[0, 2]\n",
    "print(A02)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `A[1]`, we will get the second row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-4.   3.1  1.3]\n"
     ]
    }
   ],
   "source": [
    "print(A[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can iterate over the entries of `A` by iterating over the rows, and then the entry in each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----\n",
      "2.2\n",
      "3.7\n",
      "9.1\n",
      "-----\n",
      "-4.0\n",
      "3.1\n",
      "1.3\n"
     ]
    }
   ],
   "source": [
    "for row in A:\n",
    "    print(\"-----\")\n",
    "    for c in row:\n",
    "        print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Warning:** NumPy has a `numpy.matrix` data structure. Its use is not recommended as it behaves inconsistently in some cases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2D array (matrix) operations\n",
    "\n",
    "For 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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Matrix-vector and matrix-matrix multiplication\n",
    "\n",
    "We will consider the matrix $A$:\n",
    "\n",
    "$$\n",
    "A  = \n",
    "\\begin{bmatrix}\n",
    "3.4 & 2.6 \\\\\n",
    "2.1 & 4.5\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "and the vector $x$:\n",
    "\n",
    "$$\n",
    "x  = \n",
    "\\begin{bmatrix}\n",
    "0.2 \\\\ -1.1\n",
    "\\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix A:\n",
      " [[ 3.4  2.6]\n",
      " [ 2.1  4.5]]\n",
      "Vector x:\n",
      " [ 0.2 -1.1]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[3.4, 2.6], [2.1, 4.5]])\n",
    "print(\"Matrix A:\\n {}\".format(A))\n",
    "\n",
    "x = np.array([0.2, -1.1])\n",
    "print(\"Vector x:\\n {}\".format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compute the matrix-vector product $y = Ax$ by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2.18 -4.53]\n"
     ]
    }
   ],
   "source": [
    "y = A.dot(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix-matrix multiplication is performed similarly. Computing $C = AB$, where $A$, $B$, and $C$ are all matrices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4.42  5.2 ]\n",
      " [ 2.73  9.  ]]\n"
     ]
    }
   ],
   "source": [
    "B = np.array([[1.3, 0], [0, 2.0]])\n",
    "\n",
    "C = A.dot(B)\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The inverse of a matrix ($A^{-1}$) and the determinant ($\\det(A)$) can be computed using functions in the NumPy submodule `linalg`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inverse of A:\n",
      " [[ 0.45731707 -0.26422764]\n",
      " [-0.21341463  0.34552846]]\n",
      "Determinant of A: 9.839999999999998\n"
     ]
    }
   ],
   "source": [
    "Ainv = np.linalg.inv(A)\n",
    "print(\"Inverse of A:\\n {}\".format(Ainv))\n",
    "\n",
    "Adet = np.linalg.det(A)\n",
    "print(\"Determinant of A: {}\".format(Adet))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> NumPy is large library, so it uses sub-modules to arrange functionality.\n",
    "\n",
    "A very common matrix is the *identity matrix* $I$. We can create a $4 \\times 4$ identity matrix using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  0.  0.  0.]\n",
      " [ 0.  1.  0.  0.]\n",
      " [ 0.  0.  1.  0.]\n",
      " [ 0.  0.  0.  1.]]\n"
     ]
    }
   ],
   "source": [
    "I = np.eye(4)\n",
    "print(I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array slicing\n",
    "\n",
    "When 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",
    "\n",
    "We will explore slicing through examples. We start by creating an array filled with random values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.05644298  0.49533349  0.04729124  0.37275677  0.01269559]\n"
     ]
    }
   ],
   "source": [
    "x = np.random.rand(5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below are some slicing operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slice using '[:]' [ 0.05644298  0.49533349  0.04729124  0.37275677  0.01269559]\n",
      "Slice using '[1:3]': [ 0.49533349  0.04729124]\n",
      "Slice using '[2:-1]': [ 0.04729124  0.37275677]\n",
      "Slice using '[2:-2]': [ 0.04729124]\n"
     ]
    }
   ],
   "source": [
    "# Using ':' implies the whole range of indices, i.e. from 0 -> (length-1)\n",
    "y = x[:]\n",
    "print(\"Slice using '[:]' {}\".format(y))\n",
    "\n",
    "# Using '1:3' implies indices 1 -> 3 (not including 3)\n",
    "y = x[1:3]\n",
    "print(\"Slice using '[1:3]': {}\".format(y))\n",
    "\n",
    "# Using '2:-1' implies indices 2 -> second-from-last\n",
    "y = x[2:-1]\n",
    "print(\"Slice using '[2:-1]': {}\".format(y))\n",
    "\n",
    "# Using '2:-2' implies indices 2 -> third-from-last\n",
    "y = x[2:-2]\n",
    "print(\"Slice using '[2:-2]': {}\".format(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want a slice to run from the start of an array, or to the end of an array, we do: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slice using '[:3]': [ 0.05644298  0.49533349  0.04729124]\n",
      "Slice using '[4:]': [ 0.01269559]\n",
      "Slice using '[:]': [ 0.05644298  0.49533349  0.04729124  0.37275677  0.01269559]\n"
     ]
    }
   ],
   "source": [
    "# Using ':3' implies start -> 3 (not including 3)\n",
    "y = x[:3]\n",
    "print(\"Slice using '[:3]': {}\".format(y))\n",
    "\n",
    "# Using '4:' implies 4 -> end\n",
    "y = x[4:]\n",
    "print(\"Slice using '[4:]': {}\".format(y))\n",
    "\n",
    "# Using ':' implies start -> end\n",
    "y = x[:]\n",
    "print(\"Slice using '[:]': {}\".format(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing can be applied to 2D arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.3  0. ]\n",
      " [ 0.   2. ]]\n",
      "[ 0.  2.]\n"
     ]
    }
   ],
   "source": [
    "B = np.array([[1.3, 0], [0, 2.0]])\n",
    "print(B)\n",
    "\n",
    "# Extract second row\n",
    "r = B[1, :]\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises\n",
    "\n",
    "Complete now the [07 Exercises](Exercises/07 Exercises.ipynb) notebook."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}