.gitignore

 build/
 *.csv
+
+# IDE settings don't need to be stored, we're cmake
+.idea/
+cmake-build-*/

CMakeLists.txt

@@ -4,19 +4,22 @@ project(comp290_worksheets)
 set(CMAKE_CXX_STANDARD 17)
 
 # Sorting lab script
-#add_executable(sorting ${SOURCE_FILES})
-#target_sources(sorting
-#	PRIVATE
-#		labs/sorting/main.cpp
-#		labs/sorting/lab1.cpp
-#)
-
+add_executable(sorting ${SOURCE_FILES})
+target_include_directories(sorting PRIVATE include)
+target_sources(sorting
+	PRIVATE
+		labs/sorting/main.cpp
+		labs/sorting/lab1.cpp
+)
+add_subdirectory(tests/labs/sorting)
 
+# Counting lab script
 add_executable(counting)
 target_sources(counting
 	PRIVATE
 		labs/counting/main.cpp
 )
-exec_program(python ${CMAKE_CURRENT_BINARY_DIR}
-	ARGS ${CMAKE_CURRENT_SOURCE_DIR}/labs/counting/generate.py
+add_custom_command( TARGET counting
+	COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/labs/counting/generate.py
+	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
 )

include/labs/sorting/lab1.hpp

+//
+// Created by webpigeon on 29/12/22.
+//
+
+#ifndef COMP290_WORKSHEETS_LAB1_HPP
+#define COMP290_WORKSHEETS_LAB1_HPP
+
+#include <vector>
+
+std::vector<unsigned int> generate_list(unsigned int count, bool shuffle=true, bool reverse=false);
+
+template<typename Iterator>
+bool in_order(const Iterator begin, const Iterator end) {
+    if ( begin == end ){
+        return true;
+    }
+
+    auto prev = *begin;
+    for( auto itr = begin; itr < end; ++itr) {
+        auto val = *itr;
+        if ( val < prev ){
+            return false;
+        }
+        prev = val;
+    }
+
+    return true;
+}
+
+void bubble_sort(std::vector<unsigned int>& input);
+void insertion_sort(std::vector<unsigned int>& input);
+void selection_sort(std::vector<unsigned int>& input);
+void merge_sort(std::vector<unsigned int>& input);
+
+#endif //COMP290_WORKSHEETS_LAB1_HPP

labs/counting/main.cpp

@@ -11,7 +11,7 @@
  * @return the vector containing the ints, or an empty vector on error
  */
 std::vector<int> readNumbers(const char* filename) {
-	assert( filename != NULL );
+	assert( filename != nullptr );
 
 	// open the file for reading
 	auto fp = std::fopen( filename, "r");
@@ -42,7 +42,7 @@ std::vector<int> readNumbers(const char* filename) {
  */
 float calcAverage(std::vector<int> numbers) {
 	int total = 0;
-	int size = 0;
+	unsigned int size = 0; //probably should be size_t
 
 	while ( !numbers.empty() ) {
 		total += numbers[0];
@@ -56,6 +56,10 @@ float calcAverage(std::vector<int> numbers) {
 /**
  * Calculate the average value of a vector of ints.
  *
+ * This version avoids modifying the vector, so doesn't have the overheads associated with that. It's here as a
+ * 'reasonable' approach to the problem. Assuming you can't calculate the sum as you go and avoid the need for
+ * the vector all-together...
+ *
  * @param numbers the numbers to calculate
  * @return the average of the input values
  */
@@ -84,7 +88,7 @@ int main(int argc, const char* argv[]) {
 	}
 
 	// calculate and print the average
-	auto avg = calcAverageFast(numbers);
+	auto avg = calcAverage(numbers);
 	std::cout << "the average is: " << avg << std::endl;
 
 	return EXIT_SUCCESS;

labs/sorting/lab1.cpp

+//
+// Created by webpigeon on 29/12/22.
+//
+
+#include "labs/sorting/lab1.hpp"
+
+#include <algorithm>
+#include <random>
+
+std::vector<unsigned int> generate_list(unsigned int n, bool shuffle, bool reverse) {
+    std::vector<unsigned int> myList;
+    myList.reserve(n);
+    for (auto i=0u; i<n; ++i) {
+        myList.push_back(i);
+    }
+
+    // if shuffle is requested, shuffle list
+    if (shuffle) {
+        std::shuffle(myList.begin(), myList.end(), std::mt19937(std::random_device()()));
+    }
+
+    // if reverse is requested, reverse list
+    if (reverse) {
+        std::reverse(myList.begin(), myList.end());
+    }
+
+    return myList;
+}
+
+static void lab_swap(std::vector<unsigned int>& inputs, int idx1, int idx2) {
+    auto val = inputs[idx1];
+    inputs[idx1] = inputs[idx2];
+    inputs[idx2] = val;
+}
+
+void bubble_sort(std::vector<unsigned int>& inputs) {
+    const auto n = inputs.size();
+
+    bool swapped = true;
+    while (swapped) {
+        swapped = false;
+        for (int i=0; i<n; ++i) {
+            if (inputs[i-1] > inputs[i]) {
+                lab_swap(inputs, i-1, i);
+                swapped = true;
+            }
+        }
+    }
+}
+
+void insertion_sort(std::vector<unsigned int>& inputs) {
+    auto i = 1;
+    while ( i < inputs.size() ) {
+        auto j = i;
+        while (j > 0 && inputs[j-1] > inputs[j]) {
+            lab_swap(inputs, j, j-1);
+            j--;
+        }
+        i++;
+    }
+}
+
+void selection_sort(std::vector<unsigned int>& inputs) {
+    for (auto i = 0; i < inputs.size(); ++i) {
+        int min = i;
+
+        for (int j=i; j < inputs.size(); ++j) {
+            if ( inputs[j] < inputs[min] ) {
+                min = j;
+            }
+        }
+
+        if ( min != i) {
+            lab_swap(inputs, i, min);
+        }
+    }
+}
+
+namespace {
+    template<typename T>
+    void merge_merge(std::vector<T>& A, std::size_t begin, std::size_t middle, std::size_t end, std::vector<T>& B){
+        auto i = begin;
+        auto j = middle;
+
+        for ( auto k = begin; k < end; ++k ) {
+            if ( i < middle && (j >= end || A[i] <= A[j])) {
+                B[k] = A[i];
+                i++;
+            } else {
+                B[k] = A[j];
+                j++;
+            }
+        }
+    }
+
+    template<typename T>
+    void merge_split(std::vector<T>& B, std::size_t begin, std::size_t end, std::vector<T>& A) {
+        if ( end - begin <= 1)
+            return;
+
+        auto middle = (end + begin) / 2;
+        merge_split(A, begin, middle, B);
+        merge_split(A, middle, end, B);
+        merge_merge(B, begin, middle, end, A);
+    }
+}
+
+void merge_sort(std::vector<unsigned int>& inputs) {
+    auto auxMem = inputs;
+    merge_split(auxMem, 0, inputs.size(), inputs);
+}
\ No newline at end of file

labs/sorting/main.cpp

 #include <vector>
+#include <iostream>
 
-#include "comp290/helpers/main.hpp"
-#include "comp290/sorting/lab1.hpp"
+#include "labs/sorting/lab1.hpp"
 
 int main(int argc, const char* argv[]) {
 	if ( argc != 1 ) {
 		std::cerr << "usage: " << argv[0] << ": " << argv[1] << std::endl;
-		return 1;
+		return EXIT_FAILURE;
 	}
 
-	std::vector<int> numbers;
-	for (int i=0; i<argc; ++i) {
-	}
+    // generate a list and sort it
+    auto myList = generate_list(10000, true, false);
+    bubble_sort(myList);
+
+    // check if things are in order
+    if (in_order(myList.begin(), myList.end())) {
+        std::cout << "sorted correctly" << std::endl;
+        return EXIT_SUCCESS;
+    } else {
+        std::cout << "not sorted correctly" << std::endl;
+        return EXIT_FAILURE;
+    }
 }

tests/labs/sorting/CMakeLists.txt

+
+find_package(benchmark REQUIRED)
+
+add_executable(sort-benchmark)
+target_link_libraries(sort-benchmark benchmark::benchmark)
+target_include_directories(sort-benchmark PRIVATE ../../../include)
+
+target_sources(sort-benchmark
+        PRIVATE
+            sort_bench.cpp
+            ../../../labs/sorting/lab1.cpp
+)
\ No newline at end of file

tests/labs/sorting/sort_bench.cpp

+//
+// Created by webpigeon on 29/12/22.
+//
+#include <benchmark/benchmark.h>
+
+#include "labs/sorting/lab1.hpp"
+
+static void BM_MergeSort(benchmark::State& state) {
+    // Perform setup here
+    for (auto _ : state) {
+        state.PauseTiming();
+        auto list = generate_list(state.range(0));
+        state.ResumeTiming();
+
+        // This code gets timed
+        merge_sort(list);
+        benchmark::ClobberMemory();
+    }
+
+    // for big oh notation
+    state.SetComplexityN(state.range(0));
+}
+
+static void BM_InsertionSort(benchmark::State& state) {
+    // Perform setup here
+
+    for (auto _ : state) {
+        state.PauseTiming();
+        auto list = generate_list(state.range(0));
+        state.ResumeTiming();
+
+        // This code gets timed
+        insertion_sort(list);
+        benchmark::ClobberMemory();
+    }
+
+    // for big oh notation
+    state.SetComplexityN(state.range(0));
+}
+
+static void BM_BubbleSort(benchmark::State& state) {
+    // Perform setup here
+    for (auto _ : state) {
+        state.PauseTiming();
+        auto list = generate_list(state.range(0));
+        state.ResumeTiming();
+
+        // This code gets timed
+        bubble_sort(list);
+        benchmark::ClobberMemory();
+    }
+
+    // for big oh notation
+    state.SetComplexityN(state.range(0));
+}
+
+static void BM_SelectionSort(benchmark::State& state) {
+    // Perform setup here
+    for (auto _ : state) {
+        state.PauseTiming();
+        auto list = generate_list(state.range(0));
+        state.ResumeTiming();
+
+        // This code gets timed
+        selection_sort(list);
+        benchmark::ClobberMemory();
+    }
+    
+    // for big oh notation
+    state.SetComplexityN(state.range(0));
+}
+
+// Register the function as a benchmark
+BENCHMARK(BM_MergeSort) ->RangeMultiplier(2)->Range(1<<10, 1<<16)->Complexity();
+BENCHMARK(BM_InsertionSort) ->RangeMultiplier(2)->Range(1<<10, 1<<16)->Complexity();
+BENCHMARK(BM_BubbleSort) ->RangeMultiplier(2)->Range(1<<10, 1<<16)->Complexity();
+BENCHMARK(BM_SelectionSort) ->RangeMultiplier(2)->Range(1<<10, 1<<16)->Complexity();
+
+// Run the benchmark
+BENCHMARK_MAIN();
\ No newline at end of file