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 (https://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 the NumPy documentation (https://numpy.org/learn/) and search engines, such as https://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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: numpy in /home/studio-lab-user/.conda/envs/default/lib/python3.9/site-packages (1.22.2)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 3,
   "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": 4,
   "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": 5,
   "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": 6,
   "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": 7,
   "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": 8,
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.59066157 0.85159665 0.68069375 0.39709057 0.44283974 0.65645683]\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": 10,
   "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": 11,
   "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": 12,
   "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 on values, all equally spaced:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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.\n",
    "\n",
    "Don't forget you can use the `help()` function to see the documentation provided for a function, e.g. `help(np.linspace)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function linspace in module numpy:\n",
      "\n",
      "linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)\n",
      "    Return evenly spaced numbers over a specified interval.\n",
      "    \n",
      "    Returns `num` evenly spaced samples, calculated over the\n",
      "    interval [`start`, `stop`].\n",
      "    \n",
      "    The endpoint of the interval can optionally be excluded.\n",
      "    \n",
      "    .. versionchanged:: 1.16.0\n",
      "        Non-scalar `start` and `stop` are now supported.\n",
      "    \n",
      "    .. versionchanged:: 1.20.0\n",
      "        Values are rounded towards ``-inf`` instead of ``0`` when an\n",
      "        integer ``dtype`` is specified. The old behavior can\n",
      "        still be obtained with ``np.linspace(start, stop, num).astype(int)``\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    start : array_like\n",
      "        The starting value of the sequence.\n",
      "    stop : array_like\n",
      "        The end value of the sequence, unless `endpoint` is set to False.\n",
      "        In that case, the sequence consists of all but the last of ``num + 1``\n",
      "        evenly spaced samples, so that `stop` is excluded.  Note that the step\n",
      "        size changes when `endpoint` is False.\n",
      "    num : int, optional\n",
      "        Number of samples to generate. Default is 50. Must be non-negative.\n",
      "    endpoint : bool, optional\n",
      "        If True, `stop` is the last sample. Otherwise, it is not included.\n",
      "        Default is True.\n",
      "    retstep : bool, optional\n",
      "        If True, return (`samples`, `step`), where `step` is the spacing\n",
      "        between samples.\n",
      "    dtype : dtype, optional\n",
      "        The type of the output array.  If `dtype` is not given, the data type\n",
      "        is inferred from `start` and `stop`. The inferred dtype will never be\n",
      "        an integer; `float` is chosen even if the arguments would produce an\n",
      "        array of integers.\n",
      "    \n",
      "        .. versionadded:: 1.9.0\n",
      "    \n",
      "    axis : int, optional\n",
      "        The axis in the result to store the samples.  Relevant only if start\n",
      "        or stop are array-like.  By default (0), the samples will be along a\n",
      "        new axis inserted at the beginning. Use -1 to get an axis at the end.\n",
      "    \n",
      "        .. versionadded:: 1.16.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    samples : ndarray\n",
      "        There are `num` equally spaced samples in the closed interval\n",
      "        ``[start, stop]`` or the half-open interval ``[start, stop)``\n",
      "        (depending on whether `endpoint` is True or False).\n",
      "    step : float, optional\n",
      "        Only returned if `retstep` is True\n",
      "    \n",
      "        Size of spacing between samples.\n",
      "    \n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    arange : Similar to `linspace`, but uses a step size (instead of the\n",
      "             number of samples).\n",
      "    geomspace : Similar to `linspace`, but with numbers spaced evenly on a log\n",
      "                scale (a geometric progression).\n",
      "    logspace : Similar to `geomspace`, but with the end points specified as\n",
      "               logarithms.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.linspace(2.0, 3.0, num=5)\n",
      "    array([2.  , 2.25, 2.5 , 2.75, 3.  ])\n",
      "    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)\n",
      "    array([2. ,  2.2,  2.4,  2.6,  2.8])\n",
      "    >>> np.linspace(2.0, 3.0, num=5, retstep=True)\n",
      "    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)\n",
      "    \n",
      "    Graphical illustration:\n",
      "    \n",
      "    >>> import matplotlib.pyplot as plt\n",
      "    >>> N = 8\n",
      "    >>> y = np.zeros(N)\n",
      "    >>> x1 = np.linspace(0, 10, N, endpoint=True)\n",
      "    >>> x2 = np.linspace(0, 10, N, endpoint=False)\n",
      "    >>> plt.plot(x1, y, 'o')\n",
      "    [<matplotlib.lines.Line2D object at 0x...>]\n",
      "    >>> plt.plot(x2, y + 0.5, 'o')\n",
      "    [<matplotlib.lines.Line2D object at 0x...>]\n",
      "    >>> plt.ylim([-0.5, 1])\n",
      "    (-0.5, 1)\n",
      "    >>> plt.show()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.linspace)"
   ]
  },
  {
   "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": 15,
   "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 components by a scalar,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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 components to a power:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "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"
     ]
    }
   ],
   "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": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.0000000e+00  1.0000000e+00  1.2246468e-16 -1.0000000e+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",
    "Recall that a vector is simply a list of numbers. A geometric interpretation of a vector is that these numbers represent the end point of a directed line root at the origin (e.g. see the column vector interpretation (here)[https://www.bbc.co.uk/bitesize/guides/zgcrjty/revision/1]. The _norm_ of a vector is the distance from the origin to its tip (i.e. its length);\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",
    "\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 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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 20.5 ms, sys: 5.83 ms, total: 26.3 ms\n",
      "Wall time: 10.5 ms\n",
      "1825.739301821867\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": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.28 s, sys: 0 ns, total: 1.28 s\n",
      "Wall time: 1.3 s\n",
      "1825.7393018219911\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": 23,
   "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": 24,
   "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": 25,
   "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": 26,
   "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": 27,
   "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": 28,
   "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": 29,
   "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": 30,
   "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": 31,
   "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": 32,
   "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": 33,
   "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": 34,
   "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": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.50224739 0.65123382 0.72443985 0.20560336 0.37628932]\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": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slice using '[:]' [0.50224739 0.65123382 0.72443985 0.20560336 0.37628932]\n",
      "Slice using '[1:3]': [0.65123382 0.72443985]\n",
      "Slice using '[2:-1]': [0.72443985 0.20560336]\n",
      "Slice using '[2:-2]': [0.72443985]\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": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slice using '[:3]': [0.50224739 0.65123382 0.72443985]\n",
      "Slice using '[4:]': [0.37628932]\n",
      "Slice using '[:]': [0.50224739 0.65123382 0.72443985 0.20560336 0.37628932]\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": 38,
   "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": [
    "## Exercise 07.1 (indexing and timing)\n",
    "\n",
    "Create two very long NumPy arrays `x` and `y` and sum the arrays using:\n",
    "\n",
    "1. The NumPy addition syntax, `z = x + y`; and\n",
    "2. A `for` loop that computes the sum entry-by-entry\n",
    "\n",
    "Compare the time required for the two approaches for vectors of different lengths (use a very long vector for \n",
    "the timing). The values of the array entries are not important for this test. Use `%time` to report the time.\n",
    "\n",
    "*Hint:* To loop over an array using indices, try a construction like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "1.0\n",
      "1.0\n",
      "1.0\n",
      "1.0\n",
      "1.0\n",
      "1.0\n",
      "1.0\n",
      "1.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "x = np.ones(10)\n",
    "y = np.ones(len(x))\n",
    "for i in range(len(x)):\n",
    "    print(x[i]*y[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (1) Add two vectors using built-in addition operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4b3a6fbbfcbe89681e9e2f04cab73d67",
     "grade": false,
     "grade_id": "cell-2c856e54f7c3340e",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 0 ns, sys: 3.59 ms, total: 3.59 ms\n",
      "Wall time: 3.6 ms\n"
     ]
    }
   ],
   "source": [
    "#create two long arrays of random number\n",
    "x = np.random.rand(1000000)\n",
    "y = np.random.rand(1000000)\n",
    "\n",
    "#time how long it takes to add them by bult-in addition operator\n",
    "%time z = x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (2) Add two vectors using own implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f5195f8b039c21a10b079fa7129adf0a",
     "grade": false,
     "grade_id": "cell-f34614f9f0068cc4",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 269 ms, sys: 0 ns, total: 269 ms\n",
      "Wall time: 267 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1.19888736, 1.02758774, 1.74255573, ..., 0.4323914 , 0.70484745,\n",
       "       0.73132611])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#create function to add two arrays index by index\n",
    "def addition(x, y):\n",
    "    \"\"\"Creates new array of the addition of two other arrays\"\"\"\n",
    "    \n",
    "    z = np.zeros(len(x))\n",
    "    \n",
    "    for i in range(len(x)):\n",
    "        z[i] = x[i] + y[i]\n",
    "    \n",
    "    return z\n",
    "\n",
    "%time addition(x,y)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 07.2 (member functions and slicing)\n",
    "\n",
    "Anonymised scores (out of 60) for an examination are stored in a NumPy array. Write:\n",
    "\n",
    "1. A function that takes a NumPy array of the raw scores and returns the scores as percentages, sorted from \n",
    "   lowest to highest (try using `scores.sort()`, where `scores` is a NumPy array holding the scores).\n",
    "1. A function that returns the maximum, minimum and mean of the raw scores as a dictionary with the \n",
    "   keys '`min`', '`max`' and '`mean`'. Use the NumPy array functions `min()`, `max()` and `mean()` to do the \n",
    "   computation, e.g. `max = scores.max()`.  \n",
    "   \n",
    "   Design your function for the min, max and mean to optionally exclude the highest and lowest scores from the \n",
    "   computation of the min, max and mean. \n",
    "   \n",
    "   *Hint:* sort the array of scores and use array slicing to exclude\n",
    "   the first and the last entries.\n",
    "\n",
    "Use the scores \n",
    "```python\n",
    "scores = np.array([58.0, 35.0, 24.0, 42, 7.8])\n",
    "```\n",
    "to test your functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0d3f6132335348940f562c8a70c520e9",
     "grade": false,
     "grade_id": "cell-169ebae60810c6be",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13.         40.         58.33333333 70.         96.66666667]\n",
      "{'min': 7.8, 'max': 58.0, 'mean': 33.36}\n"
     ]
    }
   ],
   "source": [
    "#create functions\n",
    "def to_percentage_and_sort(scores):\n",
    "    \"\"\"returns percentage score, sorted from low to high\"\"\"\n",
    "    \n",
    "    #order scores from lowest to highest\n",
    "    scores.sort()\n",
    "    \n",
    "    #calculate score percentage\n",
    "    scores_percent = scores/60 * 100\n",
    "    \n",
    "    return scores_percent\n",
    "\n",
    "\n",
    "def statistics(scores, exclude=False):\n",
    "    \"\"\"create dictionary of min, max, mean scores\"\"\"\n",
    "    \n",
    "    #order scores from low to highest\n",
    "    scores.sort()\n",
    "    \n",
    "    #optionally exclude highest and lowest values when exculde == True  \n",
    "    if exclude:\n",
    "        \n",
    "        #remove highest and lowest values.\n",
    "        scores = scores[1:-1]\n",
    "        \n",
    "    #calculate min, max and mean\n",
    "    min_score = scores.min()\n",
    "    max_score = scores.max()\n",
    "    mean_score = scores.mean()\n",
    "    \n",
    "    #create dictionary to store min, max and mean values\n",
    "    score_stats = {\"min\" : min_score,\n",
    "                   \"max\" : max_score,\n",
    "                   \"mean\": mean_score}\n",
    "    \n",
    "    return score_stats\n",
    "\n",
    "    \n",
    "    \n",
    "#test functions\n",
    "scores = np.array([58.0, 35.0, 24.0, 42, 7.8])\n",
    "\n",
    "scores_percent = to_percentage_and_sort(scores)\n",
    "scores_stats = statistics(scores)\n",
    "\n",
    "print(scores_percent)\n",
    "print(scores_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "49817c794fad305adbe95251448b7bf2",
     "grade": true,
     "grade_id": "cell-af0b6fd8a3cadb1a",
     "locked": true,
     "points": 0,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "scores = np.array([58.0, 35.0, 24.0, 42, 7.8])\n",
    "assert np.isclose(to_percentage_and_sort(scores), [ 13.0, 40.0, 58.33333333,  70.0, 96.66666667]).all()\n",
    "\n",
    "s0 = statistics(scores)\n",
    "assert round(s0[\"min\"] - 7.8, 10) == 0.0\n",
    "assert round(s0[\"mean\"] - 33.36, 10) == 0.0\n",
    "assert round(s0[\"max\"] - 58.0, 10) == 0.0\n",
    "\n",
    "s1 = statistics(scores, True)\n",
    "assert round(s1[\"min\"] - 24.0, 10) == 0.0\n",
    "assert round(s1[\"mean\"] - 33.666666666666666667, 10) == 0.0\n",
    "assert round(s1[\"max\"] - 42.0, 10) == 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "59fe9ff8629e2b641f8c654b3c0c36ee",
     "grade": false,
     "grade_id": "cell-27beb42d6b15acad",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "## Exercise 07.3 (slicing)\n",
    "\n",
    "For the two-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "72617327e9686e23fc46fd8b050dfddc",
     "grade": false,
     "grade_id": "cell-73a8893e46856789",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   4.      7.     -2.43   67.1 ]\n",
      " [  -4.     64.     54.7    -3.33]\n",
      " [   2.43   23.2     3.64    4.11]\n",
      " [   1.2     2.5  -113.2   323.22]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[4.0, 7.0, -2.43, 67.1],\n",
    "             [-4.0, 64.0, 54.7, -3.33],\n",
    "             [2.43, 23.2, 3.64, 4.11],\n",
    "             [1.2, 2.5, -113.2, 323.22]])\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "use array slicing for the below operations, printing the results to the screen to check. Try to use array slicing such that your code would still work if the dimensions of `A` were enlarged.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "6d041f0cf31860711599e3ee7b3491a3",
     "grade": false,
     "grade_id": "cell-f6744c8a86e68cac",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "#### 1. Extract the third column as a 1D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b64ade07370f5fee0946cac30ec0e2ad",
     "grade": false,
     "grade_id": "cell-dfee6b0ed9343682",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  -2.43   54.7     3.64 -113.2 ]\n"
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "print(A[:, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Extract the first two rows as a 2D sub-array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1501ee7c2e53e803ab2ee91f060600f6",
     "grade": true,
     "grade_id": "cell-7bf2f9a8c67029f8",
     "locked": false,
     "points": 0,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4.    7.   -2.43 67.1 ]\n",
      " [-4.   64.   54.7  -3.33]]\n"
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "print(A[0:2, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.  Extract the bottom-right $2 \\times 2$ block as a 2D sub-array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f71dc316fa8df4bfd0d201a822e3649b",
     "grade": false,
     "grade_id": "cell-5206fea47d246222",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   3.64    4.11]\n",
      " [-113.2   323.22]]\n"
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "print(A[2:4, 2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Sum the last column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e838dfdea65683c219df150d9e896d98",
     "grade": false,
     "grade_id": "cell-34f74988e47b9f87",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "391.1\n"
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "print(A[:, -1].sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ed949860804630c700d7f9885647c14d",
     "grade": false,
     "grade_id": "cell-b6580accbcb3c2da",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "from scipy import optimize\n",
    "\n",
    "#NOT RELEVENT"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "default:Python",
   "language": "python",
   "name": "conda-env-default-py"
  },
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}