11 Complexity.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "In the previous notebook we introduced algorithms as structured recipes for performing tasks. There are often different algorithms for performing the same task. We have seen this for root finding (bisection and Newton's method) and for sorting. We now want to analyse the performance of some algorithms, and in particular understand how the required time (or maybe the required memory) changes as the problem size increases. \n",
    "This is known as *algorithmic complexity*, and it helps us to pick an appropriate algorithm for a given problem, and to determine whether or not an algorithm will be able to solve a problem of a given size within an acceptable time.\n",
    "\n",
    "\n",
    "## Objectives\n",
    "\n",
    "- Understand 'big-oh' ($O$) notation\n",
    "- Appreciate the consequences of algorithmic complexity\n",
    "- Determine the complexity of some simple algorithms\n",
    "- Measure complexity experimentally\n",
    "\n",
    "> Students frequently find complexity a challenging topic. Take your time to work through examples and think about how calculations you would need to perform if computing a problem by hand.\n",
    "\n",
    "**NOTE:** This notebook can take some time to execute as it performs timings for a selection of algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before starting, we import NumPy and Matplotlib, and configure Matplotlib for the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Complexity and 'big Oh' notation\n",
    "\n",
    "Consider a problem of size $n$ (if we were sorting an array of numbers, $n$ would be the length of the array).\n",
    "For many algorithms, when $n$ is large we can express the time cost $t$ as:\n",
    "\n",
    "$$\n",
    "t = C g(n)\n",
    "$$\n",
    "\n",
    "where $C$ is a constant and $g$ is a function. If the cost can be expressed as above, where $C$ is a constant, then we write in 'big-Oh' notation:\n",
    "\n",
    "$$\n",
    "t = O(g(n))\n",
    "$$\n",
    "\n",
    "We consider some common expressions for $g(n)$.\n",
    "\n",
    "\n",
    "## Constant\n",
    "\n",
    "For an algorithm that is *constant in time*, we have $t = O(1)$. This means that the time required for the algorithm is *independent* of the problem size $n$. An example of an $O(1)$ algorithm is accessing a specified entry in an array by index.\n",
    "\n",
    "\n",
    "## Polynomial\n",
    "\n",
    "For an algorithm that is *polynomial in time*, we have \n",
    "\n",
    "$$\n",
    "t = O(n^k)\n",
    "$$\n",
    "\n",
    "where $k \\ge 1$ is a constant (it does not have to be an integer). Common cases are:\n",
    "\n",
    "- $O(n)$: linear complexity\n",
    "- $O(n^2)$: quadratic complexity\n",
    "- $O(n^3)$: cubic complexity\n",
    "\n",
    "\n",
    "## Logarithmic\n",
    "\n",
    "For an algorithm that is *logarithmic in time*, we have $t = O(\\log n)$.\n",
    "\n",
    "\n",
    "## Loglinear \n",
    "\n",
    "A number of important algorithms are *log-linear in time*, that is $t = O(n\\log n)$.\n",
    "Perhaps the most famous $O(n\\log n)$ algorithm is the fast Fourier transform (FFT).\n",
    "\n",
    "\n",
    "## Exponential \n",
    "\n",
    "Some algorithms are *exponential in time*, that is $t = O(c^{n})$, where $c \\ge 1$. Clearly such algorithms\n",
    "become extremely expensive for large $n$; they are generally of little or no practical use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Impact of complexity\n",
    "\n",
    "To develop a sense of different complexities, below we compute a table of the $g(n)$ terms for common\n",
    "complexities (study the code if you wish, but it's not required). \n",
    "Remember that the required time is proportional to $g(n)$, so we are interested in the relative change as we increase $n$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n        | 1               n               n**2            n**3            log(n)          nlog(n)         \n",
      "-----------------------------------------------------------------------------------------------------------\n",
      "10       | 1.0000e+00      1.0000e+00      1.0000e+00      1.0000e+00      1.0000e+00      1.0000e+00      \n",
      "100      | 1.0000e+00      1.0000e+01      1.0000e+02      1.0000e+03      2.0000e+00      2.0000e+01      \n",
      "1000     | 1.0000e+00      1.0000e+02      1.0000e+04      1.0000e+06      3.0000e+00      3.0000e+02      \n",
      "10000    | 1.0000e+00      1.0000e+03      1.0000e+06      1.0000e+09      4.0000e+00      4.0000e+03      \n",
      "100000   | 1.0000e+00      1.0000e+04      1.0000e+08      1.0000e+12      5.0000e+00      5.0000e+04      \n",
      "1000000  | 1.0000e+00      1.0000e+05      1.0000e+10      1.0000e+15      6.0000e+00      6.0000e+05      \n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "N = (10, 100, 1000, 10000, 100000, 1000000)\n",
    "functions = ((\"1\", lambda n: 1), \n",
    "             (\"n\", lambda n: n/N[0]), \n",
    "             (\"n**2\", lambda n: n**2/N[0]**2), \n",
    "             (\"n**3\", lambda n: n**3/N[0]**3), \n",
    "             (\"log(n)\", lambda n: math.log(n)/math.log(N[0])), \n",
    "             (\"nlog(n)\", lambda n: n*math.log(n)/(N[0]*math.log(N[0]))))\n",
    "\n",
    "\n",
    "# Create table header\n",
    "header = \"{:<9}| \".format(\"n\")\n",
    "for f in functions:\n",
    "    header += \"{:<16}\".format(f[0])\n",
    "print(header)\n",
    "\n",
    "# Print divider\n",
    "print(\"-\"*len(header))\n",
    "\n",
    "# Print rows\n",
    "for n in N:\n",
    "    row = \"{:<9}| \".format(n)\n",
    "    for f in functions:\n",
    "        row += \"{:<16.4e}\".format(f[1](n))\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $g(n)$ terms have been normalised using $g(10)$ so we can compare more easily the different cases.\n",
    "The table highlights the dramatic increase in cost for the $n^{2}$ and $n^{3}$ cases as $n$ becomes larger. \n",
    "Algorithms with lower complexity, e.g. $\\log(n)$, $n$ and $n\\log(n)$, are much more appealing.\n",
    "\n",
    "We have discussed complexity in terms of time - how long an algorithm would take to execute - but we could also have discussed complexity in terms of *space* (memory). It can be important to know how the computer memory required by an algorithm will change with problem size."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Determining complexity\n",
    "\n",
    "To determine the complexity of an algorithm, we just need to count the number of operations. \n",
    "If we have an array `x` of length $n$, and multiply it by a scalar $a$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 100000\n",
    "x = np.random.rand(n)\n",
    "\n",
    "a = 10.0\n",
    "for i in range(n):\n",
    "    x[i] = a*x[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cost of the operation ` x[i] = a*x[i]` is $O(1)$ for each `i`, and it is performed $n$ times, so overall the cost is $O(n)$.\n",
    "\n",
    "If we have a $m \\times n$ matrix and multiply it by the scalar $a$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = 500\n",
    "n = 1000\n",
    "A = np.random.rand(m, n)\n",
    "\n",
    "a = 10.0\n",
    "for i in range(m):\n",
    "    for j in range(n):\n",
    "        A[i, j] = a*A[i, j]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each `i`, the loop over `j` is executed $n$ times with a total cost of $O(n)$ for each `i`. We loop over\n",
    "`i` $m$ times with a cost of $O(n)$ for each loop. Hence the total cost is $O(mn)$. For a square matrix ($m = n$) the complexity is $O(n^{2})$.\n",
    "\n",
    "Typical operations on $n \\times n$ matrices have complexity that is higher than $O(n)$, so operations on large matrices can be very expensive and algorithms need to be chosen carefully when $n$ is large.\n",
    "\n",
    "The above examples are straightforward as they do not depend on the data that is stored in the \n",
    "vector or matrix - the number of operations depends *only* on the problem size $n$. For other algorithms, \n",
    "such as search and sorting, the complexity can depend on the initial data, for example whether or not an array is sorted. In these cases,  when assessing an algorithm we consider:\n",
    "\n",
    "- Best case complexity\n",
    "- Worst case complexity\n",
    "- Average case complexity\n",
    "\n",
    "When an algorithm is presented, the above complexities are often given together with the conditions under\n",
    "which each case is met. We will see practical examples of best and worst case complexities below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cost of operations\n",
    "\n",
    "We will assume that the cost of operations such as addition, subtraction, multiplication and division is $O(1)$, i.e. a constant. You might find in some algorithm books that the cost of an operation depends on the number of digits in a number. This is only relevant for extremely large numbers, beyond what we encounter in normal scientific and engineering applications."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Search\n",
    "\n",
    "In the previous notebook we looked at linear and binary search. We now want to consider the complexity\n",
    "and test it experimentally.\n",
    "\n",
    "\n",
    "## Linear search\n",
    "\n",
    "With linear search we iterate over an array looking for a particular value.\n",
    "If we are lucky, the value we are searching for will be in the first few places of the array, in which case the complexity will be $O(1)$ - it does not depend on the array length. If the value is not in the array, we have to check every entry to verify this. The array has $n$ entries, so this has complexity $O(n)$. If the array does contain the value we are looking for, maybe on average it will be in the middle, so we have to perform $n/2$ checks on average. Since we are not interested in the constant term ($1/2$), the complexity for this case \n",
    "(average case) is $O(n)$.  This leads us to the following complexities for linear search:\n",
    "\n",
    "- Best case: $O(1)$\n",
    "- Worst case: $O(n)$\n",
    "- Average case: $O(n)$\n",
    "\n",
    "\n",
    "## Binary search\n",
    "\n",
    "Binary search (covered in the previous notebook) has complexity:\n",
    "\n",
    "- Best case: $O(1)$\n",
    "- Worst case: $O(\\log n)$\n",
    "- Average case: $O(\\log n)$\n",
    "\n",
    "For large $n$, binary search is *much* faster than linear search.\n",
    "\n",
    "Despite the differences in complexity, for small problems linear search is faster than binary search. This is because the 'proportionality' constant ($C$) is smaller for linear search. A reason is that modern processors are optimised for moving over data in arrays in sequence - they exploit the processor *cache*, which is small but fast memory that is located on the CPU."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing search performance\n",
    "\n",
    "To verify the complexities for linear and binary search, we can test the performance experimentally using the\n",
    "implementations from the previous notebook. We start with linear search:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_search(x, val):\n",
    "    \"Return True if val is in x, otherwise return False\"\n",
    "    for item in x:\n",
    "        if item == val:\n",
    "            return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will test the complexity by searching for a value in arrays of increasing length, and timing how long it takes. We will use the magic function [`%timeit`](Notebook%20tips.ipynb#Detailed-timing) to get the execution time. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array of problem sizes n we want to test (powers of 2)\n",
    "N = 2**np.arange(2, 20)\n",
    "\n",
    "# Generate the array of integers for the largest problem to use in plotting times\n",
    "x = np.arange(N[-1])\n",
    "\n",
    "# Initialise an empty array to stores times for plotting\n",
    "times = []\n",
    "\n",
    "# Time the search for each problem size\n",
    "for n in N:\n",
    "\n",
    "    # Time search function (repeating 3 times) to find a random integer in x[:n]\n",
    "    t = %timeit -q -n4 -r1 -o linear_search(x[:n], np.random.randint(0, n))\n",
    "\n",
    "    # Store best case time\n",
    "    times.append(t.best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now plot the time as a function of problem size, on a log-log scale:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot and label the time taken for linear search\n",
    "plt.loglog(N, times, marker='o', label='linear search')\n",
    "plt.xlabel('$n$')\n",
    "plt.ylabel('$t$ (s)')\n",
    "\n",
    "# Show a reference line of O(n)\n",
    "plt.loglog(N, 1e-6*N, label='$O(n)$')\n",
    "\n",
    "# Add legend\n",
    "plt.legend(loc=0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, we see that as $n$ increases the time required is proportional to $n$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We repeat this experiment, but this time for binary search. Here is the search function from the previous notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binary_search(x, val):\n",
    "    \"Peform binary search on x to find val. If found returns position, otherwise returns None.\"\n",
    "\n",
    "    # Intialise end point indices\n",
    "    lower, upper = 0, len(x) - 1\n",
    "\n",
    "    # If values is outside of interval, return None \n",
    "    if val < x[lower] or val > x[upper]:\n",
    "        return None\n",
    "\n",
    "    # Perform binary search\n",
    "    while True:\n",
    "                \n",
    "        # Compute midpoint index (integer division)\n",
    "        midpoint = (upper + lower)//2\n",
    "\n",
    "        # Check which side of x[midpoint] val lies, and update midpoint accordingly\n",
    "        if val < x[midpoint]:\n",
    "            upper = midpoint - 1\n",
    "        elif val > x[midpoint]:\n",
    "            lower = midpoint + 1\n",
    "        elif val == x[midpoint]:  # found, so return\n",
    "            return midpoint\n",
    "       \n",
    "        # In this case val is not in list (return None)\n",
    "        if upper < lower:\n",
    "            return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Binary sort is much faster than linear search, so we need to test it for larger arrays than we did for linear search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array of problem sizes we want to test (powers of 2)\n",
    "N = 2**np.arange(2, 24)\n",
    "\n",
    "# Creat array and sort\n",
    "x = np.arange(N[-1])\n",
    "x = np.sort(x)\n",
    "\n",
    "# Initlise an empty array to capture time taken\n",
    "times = []\n",
    "\n",
    "# Time search for different problem sizes\n",
    "for n in N:\n",
    "    # Time search function for finding '2'\n",
    "    t = %timeit -q -n5 -r2 -o binary_search(x[:n], 2)\n",
    "\n",
    "    # Store average\n",
    "    times.append(t.best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We expect $O(\\log n)$ complexity, so we will use a log scale for $n$ and a linear scale for time $t$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot and label the time taken for binary search\n",
    "plt.semilogx(N, times, marker='o', label='binary search')\n",
    "plt.xlabel('$n$')\n",
    "plt.ylabel('$t$ (s)')\n",
    "\n",
    "# Add legend\n",
    "plt.legend(loc=0);\n",
    "\n",
    "# Change format on y-axis to scientific notation\n",
    "plt.ticklabel_format(style='sci', axis='y', scilimits=(0,0))\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see a line that is close to linear on the semi-log plot, i.e. binary search is $O(\\log(n))$.\n",
    "Binary search is so fast that it can be hard to get good timings \n",
    "for small problems because noise, caused by things like other processes running on a computer, can be significant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sorting\n",
    "\n",
    "Suppose we want to sort a random sequence into ascending order. This is a very common and extensively studied problem. There are over 40 sort algorithms listed on [Wikipedia](https://en.wikipedia.org/wiki/Sorting_algorithm). \n",
    "Which one do we pick? Let's test bubble sort and quicksort to see how they perform."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bubble sort\n",
    "\n",
    "We introduced bubble sort in the previous notebook. For an array of length $n$, it involves iterating over \n",
    "all entries and performing swaps. This has cost $O(n)$. We then repeat this $n$ times. Hence, bubble sort\n",
    "has complexity $O(n^{2})$.\n",
    "\n",
    "Below is the bubble sort implementation from the previous notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bubble_sort(A):\n",
    "    \"Sort A and return\"\n",
    "    A = A.copy()\n",
    "    n = len(A)\n",
    "    while n > 0:\n",
    "        for i in range(n - 1):\n",
    "            # Swap data if in wrong order\n",
    "            if A[i] > A[i + 1]:\n",
    "                A[i + 1], A[i] = A[i], A[i + 1]\n",
    "        n = n - 1\n",
    "\n",
    "    return A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can determine the complexity of bubble sort by inspecting the code.\n",
    "It involves a *nest* of two loops (a `while` and a `for` loop), and each is executed $n-1$ times. Swapping the data is $O(1)$ (no dependency on $n$), hence the complexity for the whole algorithm is $O(n^{2})$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's time the algorithm for increasingly large arrays. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array of problem sizes we want to test (powers of 2)\n",
    "N = 2**np.arange(2, 10)\n",
    "\n",
    "# Create an array of random numbers\n",
    "x = np.random.rand(N[-1])\n",
    "\n",
    "# Time bubble sort on arrays of different lengths  \n",
    "times = []\n",
    "for n in N:\n",
    "    t = %timeit -q -n2 -r2 -o bubble_sort(x[:n])\n",
    "    times.append(t.best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now plot the bubble sort time against the size of the array on a log-log plot, and compare against a $O(n^{2})$ line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot bubble sort timing\n",
    "plt.loglog(N, times, marker='o', label='bubble sort')\n",
    "\n",
    "# Show reference line of O(n^2)\n",
    "plt.loglog(N, 1e-6*N**2, label='$O(n^2)$')\n",
    "\n",
    "# Add labels and legend\n",
    "plt.xlabel('$n$')\n",
    "plt.ylabel('$t$ (s)')\n",
    "plt.legend(loc=0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is clear that for bubble sort that $t \\propto n^2$ -  we are observing the $O(n^2)$ complexity. \n",
    "This makes bubble sort too expensive for large $n$ to be of practical use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quicksort\n",
    "\n",
    "Analysing the complexity of quicksort is not as simple at the preceding algorithms, so we will state its complexity and test\n",
    "it experimentally. Quicksort has complexities:\n",
    "\n",
    "- Best case: $O(n\\log n)$\n",
    "- Worst case: $O(n^{2})$\n",
    "- Average case: $O(n\\log n)$\n",
    "\n",
    "The worst case complexity occurs when the data is already sorted. \n",
    "\n",
    "We reproduce here the quicksort algorithm from the previous notebook so we can test its complexity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quicksort(A, lo=0, hi=None):\n",
    "    \"Sort A and return sorted array\"\n",
    "\n",
    "    # Initialise data the first time function is called    \n",
    "    if hi is None:\n",
    "        hi = len(A) - 1\n",
    "        A = A.copy()\n",
    "\n",
    "    # Sort    \n",
    "    if lo < hi:\n",
    "        p = partition(A, lo,  hi)\n",
    "        quicksort(A, lo, p - 1)\n",
    "        quicksort(A, p + 1, hi)\n",
    "    return A\n",
    "\n",
    "\n",
    "def partition(A, lo, hi):\n",
    "    \"Partitioning function for use in quicksort\"\n",
    "    pivot = A[hi]\n",
    "    i = lo\n",
    "    for j in range(lo,  hi):\n",
    "        if A[j] <= pivot:\n",
    "            A[i], A[j] = A[j], A[i]\n",
    "            i += 1\n",
    "    A[i], A[hi] = A[hi], A[i]\n",
    "    return i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We gather timings for quicksort to sort an array of random numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array of problem sizes we want to test (powers of 2)\n",
    "N = 2**np.arange(2, 14)\n",
    "\n",
    "# Create an array of random numbers\n",
    "x = np.random.rand(N[-1])\n",
    "\n",
    "# Time quicksort on arrays of different lengths\n",
    "times = []\n",
    "for n in N:\n",
    "    t = %timeit -n1 -r1 -o -q quicksort(x[:n])\n",
    "    times.append(t.best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting the results, with a $O(n\\log(n))$ line as a reference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot quicksort timings\n",
    "plt.loglog(N, times, marker='o', label='quicksort')\n",
    "\n",
    "# Show reference line of O(n*log(n))\n",
    "plt.loglog(N, 1e-6*N*np.log(N), label='$O(n\\log\\, n)$')\n",
    "\n",
    "# Add labels\n",
    "plt.xlabel('$n$')\n",
    "plt.ylabel('$t$ (s)')\n",
    "plt.legend(loc=0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe here the $O(n\\log n)$ complexity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Worst case complexity\n",
    "\n",
    "We can reproduce the quicksort worst-case complexity, which is $O(n^{2})$, by pre-sorting an array. Since an $O(n^{2})$ algorithm will be much more expensive than $O(n\\log(n))$ for large $n$, we will test for smaller problems:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array of problem sizes we want to test (powers of 2)\n",
    "N = 2**np.arange(2, 12)\n",
    "\n",
    "# Create array of random numbers and pre-sort\n",
    "x = np.random.rand(N[-1])\n",
    "x = np.sort(x)\n",
    "\n",
    "# Quicksort is recursive, but by deafult Python raises an exeption if the number\n",
    "# of recursions is high (to avoid crashes due to accidental infinite recursion loops),\n",
    "# so we need to increase the limit\n",
    "import sys\n",
    "sys.setrecursionlimit(25000)\n",
    "\n",
    "times = []\n",
    "for n in N:\n",
    "    t = %timeit -n1 -r1 -o -q quicksort(x[:n])\n",
    "    times.append(t.best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting the timing results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot quicksort timings\n",
    "plt.loglog(N, times, marker='o', label='quicksort (ordered data)')\n",
    "\n",
    "# Plot nlog(n) line for reference\n",
    "plt.loglog(N, 1e-6*N*np.log(N), '--', label=r'$O(n\\log n)$')\n",
    "\n",
    "# Show reference line of O(n^2)\n",
    "plt.loglog(N, 1e-6*N**2, '--', label=r'$O(n^2$)')\n",
    "\n",
    "# Add labels\n",
    "plt.xlabel('$n$')\n",
    "plt.ylabel('$t$ (s)')\n",
    "plt.legend(loc=0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, we observe $O(n^{2})$ complexity for the pre-sorted case - we have reproduced the worst-case scenario."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Library sort implementations\n",
    "\n",
    "It is interesting to see how library (built-in) sorting implementations compare to our implementations.\n",
    "The built-in Python function `sorted` is an implementation of Timsort (https://en.wikipedia.org/wiki/Timsort).\n",
    "We compare the performance of `sorted` and `numpy.sort` (using quicksort) to our quicksort implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array of problem sizes we want to test (powers of 2)\n",
    "N = 2**np.arange(2, 14)\n",
    " \n",
    "# Create an array of random numbers, and make read-only so we don't accidentally sort it    \n",
    "x = np.random.rand(N[-1])\n",
    "x.flags.writeable = False\n",
    "\n",
    "# Time the different implementations\n",
    "our_times = []\n",
    "py_times = []\n",
    "np_times = []\n",
    "for n in N:\n",
    "    # Time our quicksort implememtation\n",
    "    t = %timeit -n3 -q -o quicksort(x[:n])\n",
    "    our_times.append(t.best)\n",
    "    \n",
    "    # Time Python built-in sort\n",
    "    t = %timeit -n3 -q -o sorted(x[:n])\n",
    "    py_times.append(t.best)\n",
    "\n",
    "    t = %timeit -n3 -q -o np.sort(x[:n], kind='quicksort')\n",
    "    np_times.append(t.best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now plot the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot time taken for quicksort of our implementation\n",
    "plt.loglog(N, our_times, marker='o', label='Our quicksort')\n",
    "\n",
    "# Plot time taken for built-in sort\n",
    "plt.loglog(N, py_times, marker='o', label='Python (timsort)')\n",
    "plt.loglog(N, np_times, marker='o', label='NumPy (quicksort)')\n",
    "\n",
    "# Show reference lines of O(n*log(n)) and  O(n^2)\n",
    "plt.loglog(N, 1e-6*N*np.log(N), '--', label=r'$O(n\\log n)$')\n",
    "plt.loglog(N, 1e-6*N**2, '--', label=r'$O(n^2$)')\n",
    "\n",
    "# Show legend\n",
    "plt.legend(loc=0);\n",
    "\n",
    "# Add label and legend\n",
    "plt.xlabel('$n$')\n",
    "plt.ylabel('$t$ (s)')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that all three implementations have $O(n\\log(n))$ complexity, but there are large differences in speed (keep in mind the log scale). Our implementation is by far the slowest!\n",
    "\n",
    "Repeating this test on sorted data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array of problem sizes we want to test (powers of 2)\n",
    "N = 2**np.arange(2, 12)\n",
    " \n",
    "# Create an array of random numbers and sort    \n",
    "x = np.random.rand(N[-1])\n",
    "x.sort()\n",
    "\n",
    "# Time the different implementations\n",
    "our_times = []\n",
    "py_times = []\n",
    "np_times = []\n",
    "for n in N:\n",
    "    # Time our quicksort implememtation\n",
    "    t = %timeit -n3 -q -o quicksort(x[:n])\n",
    "    our_times.append(t.best)\n",
    "    \n",
    "    # Time Python built-in sort\n",
    "    t = %timeit -n3 -q -o sorted(x[:n])\n",
    "    py_times.append(t.best)\n",
    "\n",
    "    t = %timeit -n3 -q -o np.sort(x[:n], kind='quicksort')\n",
    "    np_times.append(t.best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting the times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot time taken for quicksort of our implementation\n",
    "plt.loglog(N, our_times, marker='o', label='Our quicksort sort')\n",
    "\n",
    "# Plot time taken for built-in quicksort\n",
    "plt.loglog(N, py_times, marker='o', label='Python sort (timsort)')\n",
    "plt.loglog(N, np_times, marker='o', label='numpy sort (quicksort)')\n",
    "\n",
    "# Show reference line of O(n*log(n)) and O(n^2)\n",
    "plt.loglog(N, 1.0e-7*N*np.log(N), '--', label=r'$O(n \\log n)$')\n",
    "plt.loglog(N, 1.0e-6*N**2, '--',  label=r'$O(n^2)$')\n",
    "\n",
    "# Add labels and legend\n",
    "plt.xlabel('$n$')\n",
    "plt.ylabel('$t$ (s)')\n",
    "plt.legend(loc=0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that our implementation exhibits the worst case $O(n^2)$ complexity, while the NumPy quicksort implementation is $O(n\\log(n))$ despite the input list being sorted. Quality implementations have heuristics to avoid the worst-case complexity. Timsort has worst-case complexity of $O(n\\log n)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summary\n",
    "\n",
    "Complexity is important as it tells how the cost of an algorithm will increase as problem size increases and in practice whether or not an algorithm will be suitable for an application. For large problems it is important to select algorithms, or possible develop new algorithms, with low complexity.\n",
    "\n",
    "We have focused on time complexity, but remember there is also *space complexity*, which is how the required memory changes with problem size. If you have a device with limited memory, you might favour an algorithm with low space complexity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises\n",
    "\n",
    "Complete now the [11 Exercises](Exercises/11%20Exercises.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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}