Benchmark_sorting_algorithms_code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Benchmarking sorting algorithms\n",
    "The final project assignment for Computational Thinking with Algorithms module, GMIT 2020.\n",
    "\n",
    "Lecturer: dr Dominic Carr\n",
    "\n",
    ">Author: **Andrzej Kocielski**  \n",
    ">Github: [andkoc001](https://github.com/andkoc001/)  \n",
    ">Email: G00376291@gmit.ie\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "  <img src=\"https://upload.wikimedia.org/wikipedia/commons/7/7e/Comparison_computational_complexity.svg\" alt=\"Big O notation\" style=\"width:400px\">\n",
    "  <figcaption>Image source: Wikipedia.</figcaption>\n",
    "</figure>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting Algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "######################################\n",
    "#   Bubble Sort                      \n",
    "######################################\n",
    "\n",
    "##### Credits #####\n",
    "# Source: https://stackabuse.com/sorting-algorithms-in-python/\n",
    "# Adapted and commented by the author of this Notebook\n",
    "\n",
    "##### Function definition #####\n",
    "# Function performing the bubble sort; it takes an arrey to be sorted as an argument\n",
    "def bubble_sort(array):\n",
    "    \n",
    "    # Variable swapped is initially set to True, so that the loop runs at least once\n",
    "    swapped = True\n",
    "    \n",
    "    while swapped:\n",
    "        \n",
    "        swapped = False\n",
    "        \n",
    "        # loop through each element of the array\n",
    "        for i in range(len(array) - 1):\n",
    "            \n",
    "            # compare current (i-th) element with the next one\n",
    "            \n",
    "            if array[i] > array[i + 1]:\n",
    "                \n",
    "                # when the above condition is satisfied, swap the elements\n",
    "                array[i], array[i + 1] = array[i + 1], array[i]\n",
    "                \n",
    "                # Set the swapped to True so it will loop again\n",
    "                swapped = True\n",
    "\n",
    "\n",
    "\n",
    "######################################\n",
    "#   Quicksort                      \n",
    "######################################\n",
    "\n",
    "##### Credits #####\n",
    "# Source: https://youtu.be/u4tVQszsyEQ\n",
    "# Adapted and commented by the author of this Notebook\n",
    "\n",
    "\n",
    "##### Function definition #####\n",
    "# Function performing the quick sort; it takes an array to be sorted as an argument\n",
    "def sortowanie_szybkie(array):\n",
    "    \n",
    "    # creation of empty lists\n",
    "    mniejsze = [] # less than the pivot\n",
    "    rowne = [] # equal to the pivot\n",
    "    wieksze =[] # greater than the pivot\n",
    "    \n",
    "    # base case of the recursion \n",
    "    # check whether the array is more than one element long (otherwise, one-element list is considered to be sorted)\n",
    "    if len(array) <= 1:\n",
    "        return array\n",
    "    \n",
    "    # recursion case, when the array contains more than one element\n",
    "    else: \n",
    "        # set the pivot value at the middle element of the list\n",
    "        middle = (len(array))//2\n",
    "        pivot = array[middle]\n",
    "        \n",
    "        # let's consider three cases for each element of the list\n",
    "        for x in array:\n",
    "            \n",
    "            # case #1 - the current element is greater than the pivot\n",
    "            if x > pivot:\n",
    "                wieksze.append(x) # add the current element to the list \"wieksze\"\n",
    "                \n",
    "            # case #2 - the current element is equal to the pivot\n",
    "            elif x == pivot:\n",
    "                rowne.append(x) # add the current element to the list \"rowne\"\n",
    "                \n",
    "            # case #3 - the current element is less than the pivot\n",
    "            else:\n",
    "                mniejsze.append(x) # add the current element to the list \"mniejsze\"\n",
    "        \n",
    "        # as a result of the above loop, the function will return:\n",
    "        # in the middle: the element(s) that has just been sorted, i.e. equal to the pivot (as well as those sorted on previous recurses)\n",
    "        # on the left-hand side: elements that are less than the pivot - still unsorted, therefore the same function is called recursively (with the \"mniejsze\" list as an argument)\n",
    "        # on the the right-hand side: elements that are greater than the pivot - still unsorted, therefore the same function is called recursively (with the \"wieksze\" list as an argument)\n",
    "        \n",
    "        return sortowanie_szybkie(mniejsze) + rowne + sortowanie_szybkie(wieksze)\n",
    "        \n",
    "\n",
    "\n",
    "######################################\n",
    "#   Bucket Sort                      \n",
    "######################################\n",
    "\n",
    "##### Credits #####\n",
    "# Own implementation, developed based on pseudocode from https://youtu.be/geVyIsFpxUs\n",
    "# Adapted and commented by the author of this Notebook\n",
    "\n",
    "# Auxiliary function that sorts the content of each bucket, using the insert sort\n",
    "# Adapted from: https://www.geeksforgeeks.org/bucket-sort-2/\n",
    "\n",
    "# the function takes one argument, a list\n",
    "def insertSort(list): \n",
    "    \n",
    "    # loop through all elements of the list\n",
    "    for i in range(1, len(list)): \n",
    "        #temorary variable \n",
    "        j = i-1 # j is equal to the previous iteration number\n",
    "        \n",
    "        # inner loop - executed as long as two conditions are satisfied\n",
    "        while list[j] > list[i] and j >= 0:  # compare the current and the previous element and the index of the previous element is not-negative\n",
    "            list[j+1] = list[j] # swap  \n",
    "            j -= 1 # decrementation\n",
    "            \n",
    "        list[j+1] = list[i] # move to the next element\n",
    "        \n",
    "    return list   \n",
    "        \n",
    "\n",
    "##### Function definition #####\n",
    "\n",
    "# import required external libraries\n",
    "import math # will be needed for ceil() method\n",
    "\n",
    "# define the function, which takes as an argument the array to be sorted\n",
    "def bucket_sort(array):\n",
    "\n",
    "    #print(\"Original list:\", arr) # for testing\n",
    "    \n",
    "    # number of buckets\n",
    "    n_buckets = 6 # assumed arbitrarily\n",
    "\n",
    "    # create an empty array of buckets, where each bucket is also an empty array\n",
    "    bucket = []\n",
    "    for i in range(n_buckets):\n",
    "        bucket.append([])\n",
    "        \n",
    "    # define a divider which will be used for sorting;\n",
    "    # divider is the value of the maximum element of the array to be sorted divided by number of buckets\n",
    "    divider = math.ceil((max(array)+1)/n_buckets)\n",
    "    # divider = 10 # alternatively to the above line, it can be just assumed arbitrarily\n",
    "\n",
    "    \n",
    "    # sorting the array's element into the buckets (unsorted)\n",
    "    # loop through the array\n",
    "    for i in array:\n",
    "        \n",
    "        # determine into which bucket index will fall each element of the arrey\n",
    "        j = i//divider\n",
    "        # put the current i-element of the array to the corresponding bucket\n",
    "        bucket[j].append(i)\n",
    "    \n",
    "    # for testing \n",
    "    #print(\"Sorted unto the buckets:\", bucket) # for testing\n",
    "        \n",
    "    # put sorted content of each bucket into a single array (concatenate single buckets)\n",
    "    # adopted from https://gist.github.com/sahid/5022081\n",
    "    sorted_result = []\n",
    "    for i in range(n_buckets):\n",
    "        \n",
    "        # adding the sorted content of each bucket to the resulting array, \n",
    "        # using the insertSort() function iteratively for each bucket\n",
    "        sorted_result += insertSort(bucket[i])\n",
    "        \n",
    "    return sorted_result \n",
    "\n",
    "\n",
    "\n",
    "######################################\n",
    "#   Merge Sort                      \n",
    "######################################\n",
    "\n",
    "##### Credits #####\n",
    "# Source: https://stackabuse.com/sorting-algorithms-in-python/\n",
    "# Adapted and commented by the author of this Notebook\n",
    "\n",
    "\n",
    "# Auxiliary function, merging and sorting two arrays\n",
    "def merge(left_list, right_list):\n",
    "    sorted_list = []\n",
    "    left_list_index = right_list_index = 0\n",
    "\n",
    "    # We use the list lengths often, so its handy to make variables\n",
    "    left_list_length, right_list_length = len(left_list), len(right_list)\n",
    "\n",
    "    for _ in range(left_list_length + right_list_length):\n",
    "        \n",
    "        if left_list_index < left_list_length and right_list_index < right_list_length:\n",
    "            \n",
    "            # We check which value from the start of each list is smaller\n",
    "            # If the item at the beginning of the left list is smaller, add it to the sorted list\n",
    "            if left_list[left_list_index] <= right_list[right_list_index]:\n",
    "                sorted_list.append(left_list[left_list_index])\n",
    "                left_list_index += 1\n",
    "                \n",
    "            # If the item at the beginning of the right list is smaller, add it to the sorted list\n",
    "            else:\n",
    "                sorted_list.append(right_list[right_list_index])\n",
    "                right_list_index += 1\n",
    "\n",
    "        # If we've reached the end of the of the left list, add the element from the right list\n",
    "        elif left_list_index == left_list_length:\n",
    "            \n",
    "            sorted_list.append(right_list[right_list_index])\n",
    "            right_list_index += 1\n",
    "            \n",
    "        # If we've reached the end of the of the right list, add the elements from the left list\n",
    "        elif right_list_index == right_list_length:\n",
    "            sorted_list.append(left_list[left_list_index])\n",
    "            left_list_index += 1\n",
    "\n",
    "    # final result of the sorting\n",
    "    return sorted_list\n",
    "\n",
    "\n",
    "##### Function definition #####\n",
    "# Function performing the merge sort; it takes an array to be sorted as an argument\n",
    "def merge_sort(array):\n",
    "    \n",
    "    # If the list is a single element, return it\n",
    "    if len(array) <= 1:\n",
    "        return array\n",
    "\n",
    "    # Use floor division to get midpoint, indices must be integers\n",
    "    mid = len(array) // 2\n",
    "\n",
    "    # Sort and merge each half\n",
    "    left_list = merge_sort(array[:mid])\n",
    "    right_list = merge_sort(array[mid:])\n",
    "\n",
    "    # Merge the sorted lists into a new one\n",
    "    return merge(left_list, right_list)\n",
    "\n",
    "\n",
    "\n",
    "######################################\n",
    "#   Timsort                      \n",
    "######################################\n",
    "\n",
    "##### Credits #####\n",
    "# Source: https://quinston.com/code-snippets/\n",
    "# Adapted and commented by the author of this Notebook\n",
    "\n",
    "\n",
    "# Auxiliary function that sorts the content of each run, using the insert sort algorithm\n",
    "# Function InsertionSort() takes one argument - an array\n",
    "def InsertionSort(array):\n",
    "\n",
    "    # loop through all elements of the array\n",
    "    for x in range (1, len(array)):\n",
    "       \n",
    "        # inner loop\n",
    "        for i in range(x, 0, -1): # decrementation\n",
    "           \n",
    "            # compare current and the next (because decrementation) element\n",
    "            if array[i] < array[i - 1]:\n",
    "                # swap the values if condition satisfied\n",
    "                array[i], array[i - 1] = array[i - 1], array[i]\n",
    "                \n",
    "            else:\n",
    "                break\n",
    "                \n",
    "            # decrementation\n",
    "            i = i - 1\n",
    "            \n",
    "    return array\n",
    "\n",
    "\n",
    "# Merge Sort implementation\n",
    "# The Merge() function takes two arguments - two arrays - and merge them together. The function returns yet another array\n",
    "def Merge(aArr, bArr):\n",
    "    \n",
    "    a = 0 # a is a pointer (index position) of aArr array\n",
    "    b = 0 # b is a pointer of bArr array\n",
    "    \n",
    "    # placeholder - an empty array cArr which will be holding sorted values of aArr and bArr arrays\n",
    "    cArr = []\n",
    "\n",
    "    # end of loop codition:\n",
    "    while a < len(aArr) and b < len(bArr):\n",
    "        # check if a-element of array aArr is less than b-element of array bArr\n",
    "        if aArr[a] < bArr[b]:\n",
    "            cArr.append(aArr[a]) # if the condition is satisfied, assign the value of a-element to cArr array\n",
    "            a = a + 1 # move the pointer to the next aArr array index\n",
    "            \n",
    "        elif aArr[a] > bArr[b]:\n",
    "            cArr.append(bArr[b])\n",
    "            b = b + 1\n",
    "        \n",
    "        # in case the a-element of aArra and b-element of bArr are equal\n",
    "        else:\n",
    "            cArr.append(aArr[a])\n",
    "            cArr.append(bArr[b])\n",
    "            a = a + 1\n",
    "            b = b + 1\n",
    "    \n",
    "    # when there are no left elements from bArr to compare with aArr, the remaining elements from aArr are appended at the end of cArr array\n",
    "    while a < len(aArr):\n",
    "        cArr.append(aArr[a])\n",
    "        a = a + 1\n",
    "\n",
    "    while b < len(bArr):\n",
    "        cArr.append(bArr[b])\n",
    "        b = b + 1\n",
    "\n",
    "    # function returns merged the two arrays, sorted\n",
    "    return cArr\n",
    "\n",
    "\n",
    "##### Function definition #####\n",
    "# Implementation of the TimSort sorting algorithm, with an array to be sorted as an argument.\n",
    "# Funtion TimSort divides the array to be sorted (arr) into smaller chunks of size RUN.\n",
    "# The variable RUN is defined outside the funtion body, prior to its first call.\n",
    "def TimSort(array):\n",
    "\n",
    "    # chunk size - the array will be splitted into this size of chunks, usually the chunk size is between 32 and 64\n",
    "    RUN = 32   \n",
    "    \n",
    "    # divide the array into chunks\n",
    "    for x in range(0, len(array), RUN): # loop starting from index 0, to the last element of the array, with incrementing step size RUN; note the value of len(arr) is excluded from the loop\n",
    "        # arr[x: x+RUN] is the current slice of the array (from x to x+RUN)\n",
    "        # values of the current array slice are transfered (passed) to InsertionSort function; the return from the InsertionSort is already sorted array assigned to the original slice\n",
    "        array[x: x+RUN] = InsertionSort(array[x: x+RUN])\n",
    "    \n",
    "    \n",
    "    # merging the already sortd slices of the array\n",
    "    # create an auxiliary variable     \n",
    "    RUNinc = RUN\n",
    "    # define loop termination condition\n",
    "    while RUNinc < len(array):\n",
    "        \n",
    "        # the array is divided into pairs of neighbouring slices and passed to Merge() function\n",
    "        for x in range(0, len(array), 2 * RUNinc):\n",
    "            # the return from the Merge() function is assigned to the slice (size of 2xRUN) original array\n",
    "            array[x: x+2 * RUNinc] = Merge(array[x: x+RUNinc], array[x+RUNinc: x+2*RUNinc])\n",
    "        \n",
    "        # incrementation for the while loop\n",
    "        RUNinc = RUNinc*2\n",
    "\n",
    "    return array\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____\n",
    "## Benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "#  external Python libraries for building and analysing the dataset.\n",
    "import numpy as np # numerical calculations\n",
    "import pandas as pd # data manipulation\n",
    "\n",
    "\n",
    "# creation of empty data (just headings)\n",
    "data = pd.DataFrame(columns = [\"Size\", \"Bubble\", \"Quick\", \"Bucket\", \"Merge\", \"Tim\", \"Python\"]) \n",
    "\n",
    "# adding values of the size column to the dataset, assumed arbitrarily, based on the project brief.\n",
    "data[\"Size\"] = (100, 250, 500, 750, 1000, 1250, 2500, 3750, 5000, 6250, 7500, 8750, 10000)\n",
    "\n",
    "# generating arrays of random numbers, based on algorithm provided in the project brief\n",
    "def random_array(size): \n",
    "    \n",
    "    # create an empty array\n",
    "    array = []\n",
    "    \n",
    "    # populate the arr list with randomly generated numbers\n",
    "    for i in range(size):\n",
    "        array.append(np.random.randint(0, 100)) # random integer numbers in range from 0 to 99\n",
    "        \n",
    "    return array\n",
    "\n",
    "\n",
    "# populating the arrays for each test sizes\n",
    "# create an empty container to hold the set of arrays\n",
    "random_number_arrays = []\n",
    "\n",
    "# loop through array sizes and for each one assign rundom numbers for each array size (array size is shown in \"data\" DataFrame, column \"size\")\n",
    "for array_size in data[\"Size\"]:\n",
    "    \n",
    "    # create an auxiliary counter representing the index \n",
    "    random_number_arrays_index = 0\n",
    "    \n",
    "    # call function random_array(), passing as an argument the number of elements to be generated\n",
    "    random_number_arrays.append(random_array(array_size))\n",
    "    \n",
    "    # increment the counter by 1\n",
    "    random_number_arrays_index += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Benchmarking the algorithms\n",
    "\n",
    "Getting times and collation the results into the dataframe. Each test is run `num_runs` times and the average time is then put into the dataset.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# the benchmarking algoirithms is based on the lecture materials, with modifications and additional comments\n",
    "\n",
    "import time\n",
    "\n",
    "\n",
    "#######################################\n",
    "#   Bubble Sort Benachmark                      \n",
    "#######################################\n",
    "\n",
    "# loop through each array size defined in the data[\"Size\"] column, that is arrays of quantity of elements 100, 250, 500, etc\n",
    "for current_array in range(len(data[\"Size\"])): \n",
    "    \n",
    "    # a placeholder to store results for each test\n",
    "    intermediate_results = []\n",
    "\n",
    "    # perform the same sorting test several times in order to get the avarage time\n",
    "    num_runs = 10 # number of the tests \n",
    "    \n",
    "        \n",
    "    # benchmarking algorithm \n",
    "    for r in range(num_runs):\n",
    "        \n",
    "        # make a copy of the array to preserve the original unsorted order for the remaining runs\n",
    "        ar = random_number_arrays[current_array].copy() \n",
    "\n",
    "        # log the start time (time stamp)\n",
    "        start_time = time.time()\n",
    "        \n",
    "        \n",
    "        ##### call the sorting implementation to be benchmarked #####\n",
    "        bubble_sort(ar)\n",
    "        \n",
    "           \n",
    "        # log the end time (time stamp)\n",
    "        end_time = time.time()\n",
    "        \n",
    "        # calculate the elapsed time\n",
    "        time_elapsed = end_time - start_time\n",
    "        \n",
    "        # for each sorting instance, add the time to the below array\n",
    "        intermediate_results.append(time_elapsed)\n",
    "    \n",
    "    # Average result from all runs for the current array size\n",
    "    average_result = np.mean(intermediate_results) * 1000 # in milliseconds\n",
    "    \n",
    "    #add the average time to the dataframe\n",
    "    data.loc[current_array, \"Bubble\"] = average_result\n",
    "    \n",
    "\n",
    "    \n",
    "#######################################\n",
    "#   Quicksort Benachmark                      \n",
    "#######################################\n",
    "\n",
    "# loop through each array size defined in the data[\"Size\"] column, that is arrays of quantity of elements 100, 250, 500, etc\n",
    "for current_array in range(len(data[\"Size\"])): \n",
    "    \n",
    "    # a placeholder to store results for each test\n",
    "    intermediate_results = []\n",
    "\n",
    "    # perform the same sorting test several times in order to get the avarage time\n",
    "    num_runs = 10 # number of the tests \n",
    "    \n",
    "        \n",
    "    # benchmarking algorithm \n",
    "    for r in range(num_runs):\n",
    "        \n",
    "        # make a copy of the array to preserve the original unsorted order for the remaining runs\n",
    "        ar = random_number_arrays[current_array].copy() \n",
    "        \n",
    "        # log the start time (time stamp)\n",
    "        start_time = time.time()\n",
    "    \n",
    "        \n",
    "        ##### call the sorting implementation to be benchmarked #####\n",
    "        sortowanie_szybkie(ar)\n",
    "        \n",
    "        \n",
    "        # log the end time (time stamp)\n",
    "        end_time = time.time()\n",
    "        \n",
    "        # calculate the elapsed time\n",
    "        time_elapsed = end_time - start_time\n",
    "         \n",
    "        # for each sorting instance, add the time to the below array\n",
    "        intermediate_results.append(time_elapsed)\n",
    "    \n",
    "    # Average result from all runs for the current array size\n",
    "    average_result = np.mean(intermediate_results) * 1000 # in milliseconds\n",
    "    \n",
    "    #add the average time to the dataframe\n",
    "    data.loc[current_array, \"Quick\"] = average_result\n",
    "\n",
    "    \n",
    "    \n",
    "#######################################\n",
    "#   Bucket Sort Benachmark                      \n",
    "#######################################\n",
    "\n",
    "# loop through each array size defined in the data[\"Size\"] column, that is arrays of quantity of elements 100, 250, 500, etc\n",
    "for current_array in range(len(data[\"Size\"])): # Note: the last three arrays  tested for this sorting algorithm\n",
    "        \n",
    "    # a placeholder to store results for each test\n",
    "    intermediate_results = []\n",
    "\n",
    "    # perform the same sorting test several times in order to get the avarage time\n",
    "    num_runs = 10 # number of the tests \n",
    "    \n",
    "    \n",
    "    # benchmarking algorithm \n",
    "    for r in range(num_runs):\n",
    "        \n",
    "        # make a copy of the array to preserve the original unsorted order for the remaining runs\n",
    "        ar = random_number_arrays[current_array].copy() \n",
    "        \n",
    "        # log the start time (time stamp)\n",
    "        start_time = time.time()\n",
    "    \n",
    "    \n",
    "        ##### call the sorting implementation to be benchmarked #####\n",
    "        bucket_sort(ar)\n",
    "        \n",
    "        \n",
    "        # log the end time (time stamp)\n",
    "        end_time = time.time()\n",
    "        \n",
    "        # calculate the elapsed time\n",
    "        time_elapsed = end_time - start_time\n",
    "            \n",
    "        # for testing - show time of each run\n",
    "        #print(\"Time of run\", r+1,\":\", time_elapsed, \"\\n\")\n",
    "    \n",
    "        # for each sorting instance, add the time to the below array\n",
    "        intermediate_results.append(time_elapsed) \n",
    "    \n",
    "    # Average result from all runs for the current array size\n",
    "    average_result = np.mean(intermediate_results) * 1000 # in milliseconds\n",
    "    \n",
    "    #add the average time to the dataframe\n",
    "    data.loc[current_array, \"Bucket\"] = average_result\n",
    "    \n",
    "\n",
    "    \n",
    "#######################################\n",
    "#   Merge Sort Benachmark                      \n",
    "#######################################\n",
    "\n",
    "# loop through each array size defined in the data[\"Size\"] column, that is arrays of quantity of elements 100, 250, 500, etc\n",
    "for current_array in range(len(data[\"Size\"])): \n",
    "    \n",
    "    # a placeholder to store results for each test\n",
    "    intermediate_results = []\n",
    "\n",
    "    # perform the same sorting test several times in order to get the avarage time\n",
    "    num_runs = 10 # number of the tests \n",
    "    \n",
    "        \n",
    "    # benchmarking algorithm \n",
    "    for r in range(num_runs):\n",
    "        \n",
    "        # make a copy of the array to preserve the original unsorted order for the remaining runs\n",
    "        ar = random_number_arrays[current_array].copy() \n",
    "        \n",
    "        # log the start time (time stamp)\n",
    "        start_time = time.time()\n",
    "    \n",
    "            \n",
    "        ##### call the sorting implementation to be benchmarked #####\n",
    "        merge_sort(ar)\n",
    "              \n",
    "   \n",
    "        # log the end time (time stamp)\n",
    "        end_time = time.time()\n",
    "        \n",
    "        # calculate the elapsed time\n",
    "        time_elapsed = end_time - start_time\n",
    "        \n",
    "        # for each sorting instance, add the time to the below array\n",
    "        intermediate_results.append(time_elapsed)\n",
    "    \n",
    "    # Average result from all runs for the current array size\n",
    "    average_result = np.mean(intermediate_results) * 1000 # in milliseconds\n",
    "     \n",
    "    #add the average time to the dataframe\n",
    "    data.loc[current_array, \"Merge\"] = average_result\n",
    "    \n",
    "    \n",
    "    \n",
    "#######################################\n",
    "#   Tim Sort Benachmark                      \n",
    "#######################################\n",
    "\n",
    "# loop through each array size defined in the data[\"Size\"] column, that is arrays of quantity of elements 100, 250, 500, etc\n",
    "for current_array in range(len(data[\"Size\"])): \n",
    "    \n",
    "    # a placeholder to store results for each test\n",
    "    intermediate_results = []\n",
    "\n",
    "    # perform the same sorting test several times in order to get the avarage time\n",
    "    num_runs = 10 # number of the tests \n",
    "    \n",
    "        \n",
    "    # benchmarking algorithm \n",
    "    for r in range(num_runs):\n",
    "        \n",
    "        # make a copy of the array to preserve the original unsorted order for the remaining runs\n",
    "        ar = random_number_arrays[current_array].copy() \n",
    "          \n",
    "        # log the start time (time stamp)\n",
    "        start_time = time.time()\n",
    "    \n",
    "            \n",
    "        ##### call the sorting implementation to be benchmarked #####\n",
    "        TimSort(ar)\n",
    "        \n",
    "        \n",
    "        # log the end time (time stamp)\n",
    "        end_time = time.time()\n",
    "        \n",
    "        # calculate the elapsed time\n",
    "        time_elapsed = end_time - start_time\n",
    "        \n",
    "        # for each sorting instance, add the time to the below array\n",
    "        intermediate_results.append(time_elapsed)\n",
    "    \n",
    "    # Average result from all runs for the current array size\n",
    "    average_result = np.mean(intermediate_results) * 1000 # in milliseconds\n",
    "    \n",
    "    #add the average time to the dataframe\n",
    "    data.loc[current_array, \"Tim\"] = average_result\n",
    "    \n",
    "    \n",
    "\n",
    "#######################################\n",
    "#   Python built-in sorted() Benachmark                      \n",
    "#######################################\n",
    "\n",
    "\n",
    "# loop through each array size defined in the data[\"Size\"] column, that is arrays of quantity of elements 100, 250, 500, etc\n",
    "for current_array in range(len(data[\"Size\"])): \n",
    "    \n",
    "    # a placeholder to store results for each test\n",
    "    intermediate_results = []\n",
    "\n",
    "    # perform the same sorting test several times in order to get the avarage time\n",
    "    num_runs = 10 # number of the tests \n",
    "    \n",
    "        \n",
    "    # benchmarking algorithm \n",
    "    for r in range(num_runs):\n",
    "        \n",
    "        # make a copy of the array to preserve the original unsorted order for the remaining runs\n",
    "        ar = random_number_arrays[current_array].copy() \n",
    "           \n",
    "        # log the start time (time stamp)\n",
    "        start_time = time.time()\n",
    "    \n",
    "         \n",
    "        ##### call the sorting implementation to be benchmarked #####\n",
    "        sorted(ar)\n",
    "            \n",
    "   \n",
    "        # log the end time (time stamp)\n",
    "        end_time = time.time()\n",
    "        \n",
    "        # calculate the elapsed time\n",
    "        time_elapsed = end_time - start_time\n",
    "            \n",
    "        # for each sorting instance, add the time to the below array\n",
    "        intermediate_results.append(time_elapsed)\n",
    "    \n",
    "    # Average result from all runs for the current array size\n",
    "    average_result = np.mean(intermediate_results) * 1000 # in milliseconds\n",
    "        \n",
    "    #add the average time to the dataframe\n",
    "    data.loc[current_array, \"Python\"] = average_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Size</th>\n",
       "      <th>100</th>\n",
       "      <th>250</th>\n",
       "      <th>500</th>\n",
       "      <th>750</th>\n",
       "      <th>1000</th>\n",
       "      <th>1250</th>\n",
       "      <th>2500</th>\n",
       "      <th>3750</th>\n",
       "      <th>5000</th>\n",
       "      <th>6250</th>\n",
       "      <th>7500</th>\n",
       "      <th>8750</th>\n",
       "      <th>10000</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bubble</td>\n",
       "      <td>0.886</td>\n",
       "      <td>4.959</td>\n",
       "      <td>22.946</td>\n",
       "      <td>52.052</td>\n",
       "      <td>98.378</td>\n",
       "      <td>157.039</td>\n",
       "      <td>636.847</td>\n",
       "      <td>1,492.935</td>\n",
       "      <td>2,657.598</td>\n",
       "      <td>4,312.202</td>\n",
       "      <td>6,924.178</td>\n",
       "      <td>9,717.238</td>\n",
       "      <td>12,413.655</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Quick</td>\n",
       "      <td>0.094</td>\n",
       "      <td>0.204</td>\n",
       "      <td>0.461</td>\n",
       "      <td>0.636</td>\n",
       "      <td>0.780</td>\n",
       "      <td>0.871</td>\n",
       "      <td>1.936</td>\n",
       "      <td>2.891</td>\n",
       "      <td>3.668</td>\n",
       "      <td>4.542</td>\n",
       "      <td>5.279</td>\n",
       "      <td>6.056</td>\n",
       "      <td>7.122</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Bucket</td>\n",
       "      <td>0.045</td>\n",
       "      <td>0.104</td>\n",
       "      <td>0.208</td>\n",
       "      <td>0.305</td>\n",
       "      <td>0.411</td>\n",
       "      <td>0.509</td>\n",
       "      <td>1.096</td>\n",
       "      <td>1.672</td>\n",
       "      <td>2.280</td>\n",
       "      <td>2.841</td>\n",
       "      <td>3.464</td>\n",
       "      <td>3.985</td>\n",
       "      <td>4.590</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Merge</td>\n",
       "      <td>0.229</td>\n",
       "      <td>0.628</td>\n",
       "      <td>1.374</td>\n",
       "      <td>2.212</td>\n",
       "      <td>3.024</td>\n",
       "      <td>3.830</td>\n",
       "      <td>8.455</td>\n",
       "      <td>12.857</td>\n",
       "      <td>19.500</td>\n",
       "      <td>22.471</td>\n",
       "      <td>27.165</td>\n",
       "      <td>36.985</td>\n",
       "      <td>42.022</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Tim</td>\n",
       "      <td>0.268</td>\n",
       "      <td>0.755</td>\n",
       "      <td>1.689</td>\n",
       "      <td>2.782</td>\n",
       "      <td>3.812</td>\n",
       "      <td>5.031</td>\n",
       "      <td>10.723</td>\n",
       "      <td>15.988</td>\n",
       "      <td>22.765</td>\n",
       "      <td>28.811</td>\n",
       "      <td>34.632</td>\n",
       "      <td>42.699</td>\n",
       "      <td>56.854</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Python</td>\n",
       "      <td>0.004</td>\n",
       "      <td>0.012</td>\n",
       "      <td>0.032</td>\n",
       "      <td>0.060</td>\n",
       "      <td>0.086</td>\n",
       "      <td>0.109</td>\n",
       "      <td>0.238</td>\n",
       "      <td>0.365</td>\n",
       "      <td>0.479</td>\n",
       "      <td>0.594</td>\n",
       "      <td>0.735</td>\n",
       "      <td>0.864</td>\n",
       "      <td>0.996</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "0    Size   100   250    500    750   1000    1250    2500      3750  \\\n",
       "1  Bubble 0.886 4.959 22.946 52.052 98.378 157.039 636.847 1,492.935   \n",
       "2   Quick 0.094 0.204  0.461  0.636  0.780   0.871   1.936     2.891   \n",
       "3  Bucket 0.045 0.104  0.208  0.305  0.411   0.509   1.096     1.672   \n",
       "4   Merge 0.229 0.628  1.374  2.212  3.024   3.830   8.455    12.857   \n",
       "5     Tim 0.268 0.755  1.689  2.782  3.812   5.031  10.723    15.988   \n",
       "6  Python 0.004 0.012  0.032  0.060  0.086   0.109   0.238     0.365   \n",
       "\n",
       "0      5000      6250      7500      8750      10000  \n",
       "1 2,657.598 4,312.202 6,924.178 9,717.238 12,413.655  \n",
       "2     3.668     4.542     5.279     6.056      7.122  \n",
       "3     2.280     2.841     3.464     3.985      4.590  \n",
       "4    19.500    22.471    27.165    36.985     42.022  \n",
       "5    22.765    28.811    34.632    42.699     56.854  \n",
       "6     0.479     0.594     0.735     0.864      0.996  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Apply formating to three decimal places\n",
    "# Source: https://stackoverflow.com/a/42735712\n",
    "pd.options.display.float_format = '{:,.3f}'.format\n",
    "\n",
    "# transpose the table, source: https://stackoverflow.com/a/31328974\n",
    "d = data.transpose().reset_index().rename(columns={'index':'Size'})\n",
    "new_header = d.iloc[0] #grab the first row for the header\n",
    "d = d[1:] #take the data less the header row\n",
    "d.columns = new_header #set the header row as the df header\n",
    "\n",
    "# show the results in a table format\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Results visualisation\n",
    "\n",
    "import matplotlib.pyplot as plt \n",
    "#import seaborn as sns\n",
    "#import scipy.stats as stats\n",
    "\n",
    "# below command will allow for the plots being displayed inside the Notebook, rather than in a separate screen.\n",
    "%matplotlib inline\n",
    "\n",
    "# Setting up the plotting output\n",
    "plt.plot(data['Size'], data['Bubble'], label='Bubble Sort')\n",
    "plt.plot(data['Size'], data['Quick'],  label='Quicksort')\n",
    "plt.plot(data['Size'], data['Bucket'], label='Bucket Sort')\n",
    "plt.plot(data['Size'], data['Merge'],  label='Merge Sort')\n",
    "plt.plot(data['Size'], data['Tim'],    label='Timsort')\n",
    "plt.plot(data['Size'], data['Python'], label='Python Sort')\n",
    "\n",
    "# Adding title, labels and legend\n",
    "plt.title(\"Measured Time Complexity\")\n",
    "plt.xlabel(\"Input Size\") \n",
    "plt.ylabel(\"Time, milliseconds\")\n",
    "plt.legend()\n",
    "\n",
    "# set axis ranges\n",
    "plt.xlim(0,10000)\n",
    "plt.ylim(0,250)\n",
    "\n",
    "# set size of the plot in inches (dpi=100)\n",
    "plt.gcf().set_size_inches(12, 6)\n",
    "\n",
    "# plot the graph\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Andrzej Kocielski, 2020"
   ]
  }
 ],
 "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.7.5"
  },
  "toc-autonumbering": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}