diff --git a/data.cpp b/data.cpp index 730672a..48dbf97 100644 --- a/data.cpp +++ b/data.cpp @@ -1,51 +1,51 @@ -#include +#include #include #include "toolbox.hpp" #include "data.hpp" template -constexpr static bool is_arg_sorted(const asp::Array& a, const asp::Array& indices) noexcept { +static constexpr bool is_arg_sorted(const asp::Array& a, const asp::Array& indices) noexcept { for (size_t i = 1; i < a.length; ++i) - if (a[indices[i - 1]] > a[indices[i]]) + if (indices[i - 1] == indices[i] || a[indices[i - 1]] > a[indices[i]]) return false; return true; } template -constexpr static bool is_sorted(const asp::Array& a) noexcept { +static constexpr bool is_sorted(const asp::Array& a) noexcept { for (size_t i = 1; i < a.length; ++i) if (a[i - 1] > a[i]) return false; return true; } -template -constexpr static void test_sort(const asp::Array& original, void (* const fnc)(const asp::Array&), const char* const title) noexcept { +template +static constexpr void test_sort(const std::array& gaps, const asp::Array& original, void (* const fnc)(const asp::Array&), const char* const title) noexcept { #ifdef __DEBUG printf("xxxxxxxxxxxxxxx IGNORE COPY "); #endif const asp::Array a(original); - asp::measure_time_void(title, fnc, a); + asp::measure_time_void(gaps, title, fnc, a); #ifdef __DEBUG - // assert(asp::measure_time("=> Unit test", is_sorted, a)); - const bool result = asp::measure_time("=> Unit test", is_sorted, a); - printf("| %-" STR(W_NAME) "s | %" STR(W_TIME) "s | %-" STR(W_FTIME) "s |\n", result ? "Success" : "Failure", "-", "-"); + const bool result = asp::measure_time(gaps, "=> Unit test", is_sorted, a); + // asp::print(original); + // asp::print(a); + asp::formatted_row(gaps, { result ? "Success" : "Failure", "-", "-" }); #else assert(is_sorted(a)); #endif } -template -constexpr static void test_argsort(const asp::Array& original, asp::Array(* const fnc)(const asp::Array&), const char* const title) noexcept { +template +static void test_argsort(const std::array& gaps, const asp::Array& original, asp::Array(* const fnc)(const asp::Array&), const char* const title) noexcept { #ifdef __DEBUG printf("xxxxxxxxxxxxxxx IGNORE COPY "); #endif const asp::Array a(original); - const asp::Array indices = asp::measure_time>(title, fnc, a); + const asp::Array indices = asp::measure_time>(gaps, title, fnc, a); #ifdef __DEBUG - // assert(asp::measure_time("=> Unit test", is_arg_sorted, a, indices)); - const bool result = asp::measure_time("=> Unit test", is_arg_sorted, original, indices); - printf("| %-" STR(W_NAME) "s | %" STR(W_TIME) "s | %-" STR(W_FTIME) "s |\n", result ? "Success" : "Failure", "-", "-"); + const bool result = asp::measure_time(gaps, "=> Unit test", is_arg_sorted, original, indices); + asp::formatted_row(gaps, { result ? "Success" : "Failure", "-", "-" }); #else assert(is_arg_sorted(original, indices)); #endif @@ -64,7 +64,7 @@ int32_t main(int32_t argc, char** argv) { asp::toolbox_unit_test(); using array_type = uint16_t; - size_t N = static_cast(1)<<16; + size_t N = (static_cast(1)<<15) - 1; // size_t N = std::numeric_limits::max(); if (argc > 2) { fprintf(stderr, "Too many arguments\nUsage: ./data \n"); @@ -72,29 +72,33 @@ int32_t main(int32_t argc, char** argv) { } else if (argc == 2) N = std::strtoul(argv[1], argv + strlen(argv[1]) + 1, 10); - asp::print("Estimating memory footprint at : " + asp::format_byte_size(2 * N * sizeof(array_type))); + char title[64]; + sprintf(title, "Sorting %s elements of %s", asp::thousand_sep(N).c_str(), asp::format_byte_size(2 * N * sizeof(array_type)).c_str()); + const std::array gaps = { 48, -17, 25 }; + asp::header(gaps, { title, "Time spent (ns)", "Formatted time spent" }); - char buff[64]; - sprintf(buff, "Sorting algorithm for %s elements", asp::thousand_sep(N).c_str()); - asp::print_separator(buff); - const asp::Array original = asp::measure_time>("Creating random array", create_random_array, N); - // std::cout << asp::min(original) << "<=>" << asp::max(original) << std::endl;; + const asp::Array original = asp::measure_time>(gaps, "Creating random array", create_random_array, N); + // const asp::Array original = { 2, 5, 3, 0, 2, 3, 0, 3 }; // asp::print(original); - test_sort(original, asp::bubble_sort, "Bubble sort"); - test_argsort(original, asp::bubble_sort_arg, "Bubble sort (arg)"); - test_sort(original, asp::quicksort, "Quicksort"); - test_argsort(original, asp::quicksort_arg, "Quicksort (arg)"); - test_sort(original, asp::quicksort_iter, "Quicksort (iterative)"); - test_argsort(original, asp::quicksort_arg_iter, "Quicksort (iterative) (arg)"); - test_sort(original, asp::mergesort, "Mergesort"); - test_argsort(original, asp::mergesort_arg, "Mergesort (arg)"); + test_sort(gaps, original, asp::bubble_sort, "Bubble sort"); + test_argsort(gaps, original, asp::bubble_sort_arg, "Bubble sort (arg)"); + test_sort(gaps, original, asp::quicksort, "Quicksort"); + test_argsort(gaps, original, asp::quicksort_arg, "Quicksort (arg)"); + test_sort(gaps, original, asp::quicksort_iter, "Quicksort (iterative)"); + test_argsort(gaps, original, asp::quicksort_arg_iter, "Quicksort (iterative) (arg)"); + test_sort(gaps, original, asp::mergesort, "Mergesort"); + test_argsort(gaps, original, asp::mergesort_arg, "Mergesort (arg)"); + test_sort(gaps, original, asp::insertion_sort, "Insertion sort"); + // test_argsort(gaps, original, asp::insertion_argsort, "Insertion argsort"); // W.I.P - // test_sort(original, asp::counting_sort, "Counting sort"); - // test_argsort(original, asp::counting_sort_arg, "Counting sort (arg)"); - // test_sort(original, asp::radix_sort, "Radix sort"); - // test_argsort(original, asp::radix_sort_arg, "Radix sort (arg)"); + // test_sort(gaps, original, asp::counting_sort, "Counting sort"); + // test_argsort(gaps, original, asp::counting_sort_arg, "Counting sort (arg)"); + // test_sort(gaps, original, asp::radix_sort, "Radix sort"); + // test_argsort(gaps, original, asp::radix_sort_arg, "Radix sort (arg)"); + + asp::footer(gaps); return EXIT_SUCCESS; } diff --git a/data.hpp b/data.hpp index bfbaa3b..b0f0de0 100644 --- a/data.hpp +++ b/data.hpp @@ -1,6 +1,9 @@ #pragma once #include +#include #include +#include +#include #ifdef __DEBUG #include #endif @@ -11,29 +14,39 @@ namespace asp { std::shared_ptr data; size_t length = 0; - Array(void) noexcept = delete; - Array(const size_t& size) noexcept: data(std::shared_ptr(new T[size])), length(size) { -// #ifdef __DEBUG -// printf("Creating array of size %lu\n", size); -// #endif + constexpr Array(void) noexcept = delete; + constexpr Array(const size_t& size) noexcept : data(std::shared_ptr(new T[size])), length(size) { +#ifdef __DEBUG + printf("Creating array of size %lu\n", size); +#endif } - Array(const Array& other) noexcept: data(std::shared_ptr(new T[other.length])), length(other.length) { + + constexpr Array(const std::initializer_list& other) noexcept : data(std::shared_ptr(new T[other.size()])), length(other.size()) { +#ifdef __DEBUG + printf("Copying array of size %lu\n", other.size()); +#endif + memcpy(data.get(), other.begin(), length * sizeof(T)); + } + + + constexpr Array(const Array& other) noexcept : data(std::shared_ptr(new T[other.length])), length(other.length) { #ifdef __DEBUG printf("Copying array of size %lu\n", other.length); #endif memcpy(data.get(), other.data.get(), length * sizeof(T)); } - Array(Array&& other) noexcept { -// #ifdef __DEBUG -// printf("Moving array of size %lu\n", other.length); -// #endif + + constexpr Array(Array&& other) noexcept { +#ifdef __DEBUG + printf("Moving array of size %lu\n", other.length); +#endif data = other.data; length = other.length; other.data = nullptr; other.length = 0; } - inline constexpr T& operator[](const size_t& index) const { + constexpr T& operator[](const size_t& index) const { #ifdef __DEBUG if (index > length) { fprintf(stderr, "Index %ld out of range in Array of length %ld !\n", index, length); @@ -45,10 +58,10 @@ namespace asp { }; template - inline constexpr int32_t print(const Array& a, const char* const format) noexcept { + constexpr int32_t print(const Array& a, const char* const format) noexcept { int32_t num_written = 0; num_written += printf("["); - char formatter[BUFSIZ] = { 0 }; + char formatter[256] = { 0 }; sprintf(formatter, "%s,", format); for (size_t i = 0; i < a.length; ++i) num_written += printf(formatter, a[i]); @@ -57,33 +70,36 @@ namespace asp { return num_written; } - inline constexpr int32_t print(const Array& a) noexcept { + constexpr int32_t print(const Array& a) noexcept { return print(a, "%b"); } - inline constexpr int32_t print(const Array& a) noexcept { + constexpr int32_t print(const Array& a) noexcept { return print(a, "%i"); } - inline constexpr int32_t print(const Array& a) noexcept { + constexpr int32_t print(const Array& a) noexcept { + return print(a, "%u"); + } + + constexpr int32_t print(const Array& a) noexcept { return print(a, "%lu"); } - inline constexpr int32_t print(const Array& a) noexcept { - //printf("%i\n", a[0]); + constexpr int32_t print(const Array& a) noexcept { return print(a, "%i"); } - inline int32_t print(const std::string& s) noexcept { - return printf("%s\n", s.c_str()); + constexpr int32_t print(const std::string_view& s) noexcept { + return printf("%s\n", s.data()); } - inline constexpr int32_t print(const char* const s) noexcept { + constexpr int32_t print(const char* const s) noexcept { return printf("%s\n", s); } template - inline constexpr T& max(const Array& a) noexcept { + constexpr T& max(const Array& a) noexcept { T& max_el = a[0]; for (size_t i = 1; i < a.length; ++i) if (a[i] > max_el) @@ -92,7 +108,7 @@ namespace asp { } template - inline constexpr T& min(const Array& a) noexcept { + constexpr T& min(const Array& a) noexcept { T& max_el = a[0]; for (size_t i = 1; i < a.length; ++i) if (a[i] < max_el) @@ -101,57 +117,67 @@ namespace asp { } template - inline constexpr Array& map(Array& a, const F& fnc) noexcept { + constexpr Array& map(Array& a, const F& fnc) noexcept { for (size_t i = 0; i < a.length; ++i) a[i] = fnc(i, a[i]); return a; } template - inline constexpr void foreach(const Array& a, const F& fnc) noexcept { + constexpr void foreach(const Array& a, const F& fnc) noexcept { for (size_t i = 0; i < a.length; ++i) fnc(i, a[i]); } inline Array range(const size_t& n) noexcept { Array a(n); - return std::move(map(a, [](const size_t& i, const size_t&) -> const size_t& { + return map(a, [](const size_t& i, const size_t&) -> const size_t& { return i; - })); + }); } template - inline constexpr void swap(T* const a, T* const b) noexcept { + constexpr void swap(T* const a, T* const b) noexcept { const T temp = *a; *a = *b; *b = temp; } template - inline constexpr void bubble_sort(const Array& a) noexcept { + constexpr void bubble_sort(const Array& a) noexcept { size_t j = 0; - for (size_t i = 0; i < a.length; ++i) + for (size_t i = 0; i < a.length; ++i) { + bool swapped = false; for (j = i + 1; j < a.length; ++j) - if (a[i] > a[j]) + if (a[i] > a[j]) { swap(&a[i], &a[j]); + swapped = true; + } + if (!swapped) + break; + } } template - inline Array bubble_sort_arg(const Array& a) noexcept { + Array bubble_sort_arg(const Array& a) noexcept { Array indices = range(a.length); size_t j; - for (size_t i = 0; i < a.length; ++i) + for (size_t i = 0; i < a.length; ++i) { + bool swapped = false; for (j = i + 1; j < a.length; ++j) - if (a[i] > a[j]){ + if (a[i] > a[j]) { swap(&indices[i], &indices[j]); swap(&a[i], &a[j]); - + swapped = true; } + if (!swapped) + break; + } return indices; } template - inline constexpr size_t qs_partition(const Array& a, const size_t& l, const size_t& h) noexcept { + constexpr size_t qs_partition(const Array& a, const size_t& l, const size_t& h) noexcept { size_t i = l - 1; for (size_t j = l; j <= h; ++j) if (a[j] < a[h]) @@ -161,7 +187,7 @@ namespace asp { } template - inline constexpr void quicksort(const Array& a, const size_t& l, const size_t& h) noexcept { + constexpr void quicksort(const Array& a, const size_t& l, const size_t& h) noexcept { if (l >= h) return; @@ -172,12 +198,12 @@ namespace asp { } template - inline constexpr void quicksort(const Array& a) noexcept { + constexpr void quicksort(const Array& a) noexcept { quicksort(a, 0, a.length - 1); } template - inline constexpr void quicksort_iter(const Array& a, const size_t& l, const size_t& h) noexcept { + constexpr void quicksort_iter(const Array& a, const size_t& l, const size_t& h) noexcept { // Create an auxiliary stack const size_t total = h - l + 1; @@ -220,12 +246,12 @@ namespace asp { } template - inline constexpr void quicksort_iter(const Array& a) noexcept { + constexpr void quicksort_iter(const Array& a) noexcept { quicksort_iter(a, 0, a.length - 1); } template - inline constexpr size_t qs_arg_partition(const Array& a, const Array& indices, const size_t& l, const size_t& h) noexcept { + constexpr size_t qs_arg_partition(const Array& a, const Array& indices, const size_t& l, const size_t& h) noexcept { size_t i = l - 1; for (size_t j = l; j <= h; ++j) if (a[j] < a[h]){ @@ -238,7 +264,7 @@ namespace asp { } template - inline constexpr void quicksort_arg(const Array& a, const Array& indices, const size_t& l, const size_t& h) noexcept { + constexpr void quicksort_arg(const Array& a, const Array& indices, const size_t& l, const size_t& h) noexcept { if (l >= h) return; @@ -249,29 +275,26 @@ namespace asp { } template - inline Array quicksort_arg(const Array& other, const size_t& l, const size_t& h) noexcept { + Array quicksort_arg(const Array& other, const size_t& l, const size_t& h) noexcept { Array indices = range(other.length); quicksort_arg(other, indices, l, h); return indices; } template - inline Array quicksort_arg(const Array& a) noexcept { + Array quicksort_arg(const Array& a) noexcept { return quicksort_arg(a, 0, a.length - 1); } template - inline constexpr void quicksort_arg_iter(const Array& a, const Array& indices, const size_t& l, const size_t& h) noexcept { + constexpr void quicksort_arg_iter(const Array& a, const Array& indices, const size_t& l, const size_t& h) noexcept { // Create an auxiliary stack - const size_t total = h - l + 1; // push initial values of l and h to stack size_t* const stack = new size_t[total]{l,h}; // initialize top of stack - size_t top = 1; - - size_t low = l, high = h; + size_t top = 1, low = l, high = h; // Keep popping from stack while is not empty while (top <= total) { @@ -304,7 +327,7 @@ namespace asp { } template - inline Array quicksort_arg_iter(const Array& a) noexcept { + Array quicksort_arg_iter(const Array& a) noexcept { Array indices = range(a.length); quicksort_arg_iter(a, indices, 0, a.length - 1); return indices; @@ -315,25 +338,25 @@ namespace asp { size_t indice; T val; - ArgVal(void) noexcept = default; - ArgVal(const size_t& _i, const T& _v) noexcept : indice(_i), val(_v) {} + constexpr ArgVal(void) noexcept = default; + constexpr ArgVal(const size_t& _i, const T& _v) noexcept : indice(_i), val(_v) {} - inline constexpr bool operator>(const ArgVal& other) const noexcept { + constexpr bool operator>(const ArgVal& other) const noexcept { return std::move(val > other.val); } - inline constexpr bool operator<(const ArgVal& other) const noexcept { + constexpr bool operator<(const ArgVal& other) const noexcept { return std::move(val < other.val); } - inline constexpr bool operator>=(const ArgVal& other) const noexcept { + constexpr bool operator>=(const ArgVal& other) const noexcept { return std::move(val >= other.val); } - inline constexpr bool operator<=(const ArgVal& other) const noexcept { + constexpr bool operator<=(const ArgVal& other) const noexcept { return std::move(val <= other.val); } }; template - inline constexpr void merge(const Array& a, const size_t& l, const size_t& m, const size_t& r) noexcept { + constexpr void merge(const Array& a, const size_t& l, const size_t& m, const size_t& r) noexcept { Array left_arr(m - l + 1); memcpy(&left_arr.data[0], &a[l], left_arr.length * sizeof(T)); @@ -354,7 +377,7 @@ namespace asp { } template - inline constexpr void mergesort(const Array& a, const size_t& l, const size_t& r) noexcept { + constexpr void mergesort(const Array& a, const size_t& l, const size_t& r) noexcept { if (l >= r) return; @@ -365,12 +388,12 @@ namespace asp { } template - inline constexpr void mergesort(const Array& a) noexcept { + constexpr void mergesort(const Array& a) noexcept { mergesort(a, 0, a.length - 1); } template - inline Array mergesort_arg(const Array& a, const size_t& l, const size_t& r) noexcept { + Array mergesort_arg(const Array& a, const size_t& l, const size_t& r) noexcept { Array> temp_vals(a.length); map(temp_vals, [&a](const size_t& i, const ArgVal&) -> const ArgVal { @@ -386,107 +409,162 @@ namespace asp { } template - inline Array mergesort_arg(const Array& a) noexcept { + Array mergesort_arg(const Array& a) noexcept { return mergesort_arg(a, 0, a.length - 1); } - //void count_sort(const Array& a, const int32_t& exp, const int32_t& d) noexcept { - // Array output(a.length), count(d); - // memset(&count[0], 0, d * sizeof(int32_t)); - - // foreach(a, [count, exp, d](const int32_t&, const int32_t& val) -> void { - // count[(val / exp) % d]++; - // }); - - // for (int32_t i = 1; i <= d; ++i) - // count[i] += count[i - 1]; - - // for (int32_t i = a.length - 1; i >= 0; --i) { - // output[count[(a[i] / exp) % d] - 1] = a[i]; - // count[(a[i] / exp) % d]--; - // } - - // memcpy(&a[0], &output[0], a.length * sizeof(int32_t)); - //} - template - inline constexpr void counting_sort(const Array& a) noexcept { - Array output(a); - - map(a, [output](const size_t& i, const T&) -> const T& { - return output[i]; - }); + constexpr void insertion_sort(const Array& a) noexcept { + size_t j = 0; + for(size_t i = 1; i < a.length; ++i) { + T key = a[i]; + for(j = i; j > 0 && a[j - 1] > key; --j) + a[j] = a[j - 1]; + a[j] = key; + } } template - inline Array counting_sort_arg(const Array& a) noexcept { + Array insertion_argsort(const Array& a) noexcept { + Array indices = range(a.length); + size_t j = 0; + for(size_t i = 1; i < a.length; ++i){ + for(j = i; j > 0 && a[indices[j - 1]] > a[indices[i]]; --j) + indices[j] = indices[j - 1]; + indices[j] = i; + } + return indices; + } + + template + constexpr void counting_sort(const Array& a) noexcept { + const size_t N = a.length; + const T M = max(a); + + const T exp = 10; + const T d = 128; + + Array countArray(M); + memset(&countArray[0], 0, M * sizeof(T)); + + foreach(a, [&countArray](const size_t, const T val) -> void { + ++countArray[val]; + }); + + for (T i = 1; i <= M; ++i) + countArray[i] += countArray[i - 1]; + + Array output(N); + for (size_t i = N - 1; i > 0; --i){ + output[countArray[a[i]] - 1] = a[i]; + --countArray[a[i]]; + } + memmove(&a[0], &output[0], a.length * sizeof(T)); + } + + template + Array counting_sort_arg(const Array& a) noexcept { Array indices = range(a.length); return indices; } - template - inline constexpr void radix_sort_256(T* a, const size_t& n) noexcept { - //template - //void radix_sort(const Array& a) noexcept { - if (n <= 1) - //if (a.length <= 1) - return; - - T* output = new T[n]; // output array - size_t* const count = new size_t[256]; - T* originalArr = a; // So we know which was input - - for (size_t shift = 0, s = 0; shift < 4; shift++, s += 8) { - // Zero the counts - for (size_t i = 0; i < 256; i++) - count[i] = 0; - - // Store count of occurrences in count[] - for (size_t i = 0; i < n; i++) - count[(a[i] >> s) & 0xff]++; - - // Change count[i] so that count[i] now contains - // actual position of this digit in output[] - for (size_t i = 1; i < 256; i++) - count[i] += count[i - 1]; - - // Build the output array - for (int32_t i = n - 1; i >= 0; i--) { - // precalculate the offset as it's a few instructions - const size_t idx = (a[i] >> s) & 0xff; - - // Subtract from the count and store the value - output[--count[idx]] = a[i]; - } - - // Copy the output array to input[], so that input[] - // is sorted according to current digit - - // We can just swap the pointers - swap(a, output); + inline void countsort(int a[], int n, int pos){ + int* output = new int[n + 1]; + int max = (a[0] / pos) % 10; + for (int i = 1; i < n; i++) { + if (((a[i] / pos) % 10) > max) + max = a[i]; } - - // If we switched posize_ters an odd number of times, - // make sure we copy before returning - if (originalArr == output) { - swap(a, output); - for (size_t i = 0; i < n; i++) - a[i] = output[i]; + int* count = new int[max + 1]; + for (int i = 0; i < max; ++i) + count[i] = 0; + for (int i = 0; i < n; i++) + count[(a[i] / pos) % 10]++; + for (int i = 1; i < 10; i++) + count[i] += count[i - 1]; + for (int i = n - 1; i >= 0; i--) { + output[count[(a[i] / pos) % 10] - 1] = a[i]; + count[(a[i] / pos) % 10]--; } + for (int i = 0; i < n; i++) + a[i] = output[i]; - delete[] output, delete[] count; + delete[] output; + delete[] count; + } + + // template + // constexpr void radix_sort_256(T* a, const size_t& n) noexcept { + // //template + // //void radix_sort(const Array& a) noexcept { + // if (n <= 1) + // //if (a.length <= 1) + // return; + // + // T* output = new T[n]; // output array + // size_t* const count = new size_t[256]; + // T* originalArr = a; // So we know which was input + // + // for (size_t shift = 0, s = 0; shift < 4; shift++, s += 8) { + // // Zero the counts + // for (size_t i = 0; i < 256; i++) + // count[i] = 0; + // + // // Store count of occurrences in count[] + // for (size_t i = 0; i < n; i++) + // count[(a[i] >> s) & 0xff]++; + // + // // Change count[i] so that count[i] now contains + // // actual position of this digit in output[] + // for (size_t i = 1; i < 256; i++) + // count[i] += count[i - 1]; + // + // // Build the output array + // for (int32_t i = n - 1; i >= 0; i--) { + // // precalculate the offset as it's a few instructions + // const size_t idx = (a[i] >> s) & 0xff; + // + // // Subtract from the count and store the value + // output[--count[idx]] = a[i]; + // } + // + // // Copy the output array to input[], so that input[] + // // is sorted according to current digit + // + // // We can just swap the pointers + // swap(a, output); + // } + // + // // If we switched posize_ters an odd number of times, + // // make sure we copy before returning + // if (originalArr == output) { + // swap(a, output); + // for (size_t i = 0; i < n; i++) + // a[i] = output[i]; + // } + // + // delete[] output, delete[] count; + // } + + constexpr void radix_sort_256(int32_t a[], int n){ + int max = a[0]; + for (int i = 1; i < n; i++) + if (a[i] > max) + max = a[i]; + for (int pos = 1; max / pos > 0; pos *= 10) + countsort(a, n, pos); } template - inline constexpr void radix_sort(const Array& a) noexcept { + constexpr void radix_sort(const Array& a) noexcept { radix_sort_256(a.data.get(), a.length); } - template - inline Array radix_sort_arg(const Array& a) noexcept { - Array indices = range(a.length); - - return indices; - } + // template + // constexpr Array radix_sort_arg(const Array& a) noexcept { + // Array indices = range(a.length); + // + // return indices; + // } }; diff --git a/toolbox.cpp b/toolbox.cpp index 0e62c73..ce5f59e 100644 --- a/toolbox.cpp +++ b/toolbox.cpp @@ -1,83 +1,133 @@ -#include #include #include #include #include "toolbox.hpp" namespace asp { - static constexpr size_t N_TIMES = 10; - static constexpr std::array time_formats = { "ns", "us", "ms", "s", "m", "h", "j", "w", "M", "y" }; - static constexpr std::array time_numbers = { 1, 1000, 1000, 1000, 60, 60, 24, 7, 4, 12 }; - static const uint64_t total_time = std::accumulate(time_numbers.begin(), time_numbers.end(), uint64_t(1), std::multiplies()); + /** + * @brief Swap two given memory values + * + * @tparam T Type of memory placeholder + * @param a Firat memory pointer + * @param b Second memory pointer + */ + template + constexpr void swap(T* const a, T* const b) noexcept { + const T temp = *a; + *a = *b; + *b = temp; + + } + + /** + * @brief Convert a given number to string + * + * @param num Number to convert + * @param offset of the string location to append + * @param str String to append the number to + * @return number of written bytes + */ + constexpr size_t ullstr(uint64_t num, const size_t offset, char* const str) noexcept { + size_t i = 0; + + for (; num > 0; num /= 10) + str[offset + i++] = num % 10 + '0'; + + str[offset + i] = '\0'; + + for (size_t j = 0; j < i / 2; ++j) + swap(str + offset + j, str + offset + i - j - 1); + return i; + } + + /** + * @brief Cast a variable to an unsigned 64 bit integer + * + * @tparam T Type of the variable to cast + * @param vae Variable to cast + * @return Casted variable + */ + template + static constexpr uint64_t u64(const T var) noexcept { + return static_cast(var); + } + + static constexpr const size_t STR_BUFFER_SIZE = 64; + static constexpr const int8_t N_TIMES = 11; + static constexpr const std::array time_formats = { "ns", "us", "ms", "s", "m", "h", "j", "w", "M", "y", "c" }; + static constexpr const std::array time_numbers = { 1, 1000, 1000000, u64(1e9), u64(6e10), u64(36e11), u64(864e11), + u64(6048e11), u64(26298e11), u64(315576e11), u64(315576e13) }; + static constexpr size_t N_BYTES = 7; - static constexpr std::array bytes_formats = { "", "K", "M", "G", "P", "E", "Z" }; //, "Y" }; - static constexpr uint64_t total_bytes = uint64_t(1)<<(10 * (N_BYTES - 1)); + static constexpr const std::array format_prefix = { "B", "KB", "MB", "GB", "TB", "PB", "EB" }; /** - * @brief Format the time in seconds in human readable format. + * @brief Convert a given numbers of bytes to a human readable format * - * @param time Time in seconds - * @return std::string The formatted human readable string. + * @param n Number of bytes + * @return Human readable format of the numbers of bytes */ - std::string format_time(const uint64_t time) noexcept { - return time < 2 ? std::to_string(time) + "s" : format_time_ns(time * (uint64_t)1e9); - } + std::string format_byte_size(uint64_t n) noexcept { + char s[STR_BUFFER_SIZE] = { 0 }; - /** - * @brief Format the time in nanoseconds in human readable format. - * - * @param time Time in nanoseconds - * @return std::string The formatted human readable string. - */ - std::string format_byte_size(uint64_t bytes) noexcept { - if (bytes == 0) - return "0B"; - uint64_t prod = total_bytes; - - std::string s = ""; - uint64_t res; - for (size_t i = N_BYTES; i > 0; --i) { - if (bytes >= prod) { - res = bytes / prod; - bytes %= prod; - s += std::to_string(res) + bytes_formats[i - 1] + "B "; - } - prod /= uint64_t(1)<<10; + if(n == 0){ + sprintf(s, "0%s", format_prefix[0]); + return s; } - if (s.back() == ' ') - s.pop_back(); + size_t j = 0; + for(int8_t i = static_cast(format_prefix.size() - 1) * 10; i >= 0; i -= 10){ + const uint64_t nsi = n >> i; + if(nsi > 0){ + const int8_t idx = i / 10; + j += ullstr(nsi, j, s); + for(int k = 0; format_prefix[idx][k] > 0; ++k) + s[j++] = format_prefix[idx][k]; + s[j++] = ' '; + n &= u64(-1) >> (64 - i); + } + } - return s; + /* Remove trailing character */ + s[j - 1] = '\0'; + + return std::string(s); } /** - * @brief Format the time in nanoseconds in human readable format. + * @brief Convert a given number of nanoseconds to a human readable format * - * @param time Time in nanoseconds - * @return std::string The formatted human readable string. + * @param time Number of nanoseconds + * @return Human readable formatted string */ std::string format_time_ns(uint64_t time) noexcept { - if (time == 0) - return "0ns"; - uint64_t prod = total_time; + char s[STR_BUFFER_SIZE] = {0}; + size_t j = 0; - std::string s = ""; - uint64_t res; - for (size_t i = N_TIMES; i > 0; --i) { - if (time >= prod) { - res = time / prod; - time %= prod; - s += std::to_string(res) + time_formats[i - 1] + " "; - } - prod /= time_numbers[i - 1]; + if (time == 0){ + sprintf(s, "0%s", time_formats[0]); + return s; } - if (s.back() == ' ') - s.pop_back(); + uint64_t res; + for (int8_t i = time_numbers.size() - 1; i >= 0; --i) { + if (time >= time_numbers[i]) { + res = time / time_numbers[i]; + time %= time_numbers[i]; + j += ullstr(res, j, s); + for(int k = 0; time_formats[i][k] > 0; ++k) + s[j++] = time_formats[i][k]; + s[j++] = ' '; + } + } - return s; + /* Remove trailing character */ + s[j - 1] = '\0'; + + std::string ss(s); + + return ss; } /** @@ -85,40 +135,65 @@ namespace asp { * */ void toolbox_unit_test(void) noexcept { - assert(std::string("0B") == format_byte_size(uint64_t(0))); - assert(std::string("1B") == format_byte_size(uint64_t(1))); - assert(std::string("1KB") == format_byte_size(uint64_t(1)<<10)); - assert(std::string("1MB") == format_byte_size(uint64_t(1)<<20)); - assert(std::string("1GB") == format_byte_size(uint64_t(1)<<30)); - assert(std::string("1PB") == format_byte_size(uint64_t(1)<<40)); - assert(std::string("1EB") == format_byte_size(uint64_t(1)<<50)); - assert(std::string("1ZB") == format_byte_size(uint64_t(1)<<60)); - //assert(std::string("1YB") == format_byte_size(uint64_t(1)<<70)); - // UINT64_MAX == 18446744073709551615I64u == -1 - assert(std::string("15ZB 1023EB 1023PB 1023GB 1023MB 1023KB 1023B") == format_byte_size(uint64_t(-1))); + assert(std::string("0B") == format_byte_size(u64(0))); + assert(std::string("1B") == format_byte_size(u64(1))); + assert(std::string("1KB") == format_byte_size(u64(1) << 10)); + assert(std::string("1MB") == format_byte_size(u64(1) << 20)); + assert(std::string("1GB") == format_byte_size(u64(1) << 30)); + assert(std::string("1TB") == format_byte_size(u64(1) << 40)); + assert(std::string("1PB") == format_byte_size(u64(1) << 50)); + assert(std::string("1EB") == format_byte_size(u64(1) << 60)); + // uint64_t_MAX == 2**64 == 18446744073709551615 == -1 + assert(std::string("15EB 1023PB 1023TB 1023GB 1023MB 1023KB 1023B") == format_byte_size(u64(-1))); + assert(std::string("15EB 1023PB 1023TB 1023GB 1023MB 1023KB 1023B") == format_byte_size(18446744073709551615ull)); + assert(std::string("10EB 1000PB 1000TB 1000GB 1000MB 1000KB 1000B") == format_byte_size(12656215539330294760ull)); - assert(std::string("0s") == format_time(uint64_t(0))); - assert(std::string("1s") == format_time(uint64_t(1))); - assert(std::string("1m") == format_time(uint64_t(60))); - assert(std::string("1h") == format_time(uint64_t(3600))); - assert(std::string("1j") == format_time(uint64_t(86400))); - assert(std::string("1w") == format_time(uint64_t(604800))); - assert(std::string("1M") == format_time(uint64_t(2419200))); - assert(std::string("1y") == format_time(uint64_t(29030400))); - - assert(std::string("0ns") == format_time_ns(uint64_t(0))); - assert(std::string("1ns") == format_time_ns(uint64_t(1))); - assert(std::string("1us") == format_time_ns(uint64_t(1e3))); - assert(std::string("1ms") == format_time_ns(uint64_t(1e6))); - assert(std::string("1s") == format_time_ns(uint64_t(1e9))); - assert(std::string("1m") == format_time_ns(uint64_t(6e10))); - assert(std::string("1h") == format_time_ns(uint64_t(36e11))); - assert(std::string("1j") == format_time_ns(uint64_t(864e11))); - assert(std::string("1w") == format_time_ns(uint64_t(6048e11))); - assert(std::string("1M") == format_time_ns(uint64_t(24192e11))); - assert(std::string("1y") == format_time_ns(uint64_t(290304e11))); - // UINT64_MAX == 18446744073709551615I64u == -1 - assert(std::string("635y 5M 3j 23h 34m 33s 709ms 551us 615ns") == format_time_ns(uint64_t(-1))); + // https://en.wikipedia.org/wiki/Unit_of_time + assert(std::string("0ns") == format_time_ns(u64(0))); + assert(std::string("1ns") == format_time_ns(u64(1))); + assert(std::string("10ns") == format_time_ns(u64(10))); + assert(std::string("1us") == format_time_ns(u64(1e3))); + assert(std::string("1ms") == format_time_ns(u64(1e6))); + assert(std::string("10ms") == format_time_ns(u64(1e7))); + assert(std::string("100ms") == format_time_ns(u64(1e8))); + assert(std::string("1s") == format_time_ns(u64(1e9))); + assert(std::string("10s") == format_time_ns(u64(1e10))); + assert(std::string("1m") == format_time_ns(u64(6e10))); + assert(std::string("1m 26s 400ms") == format_time_ns(u64(864e8))); + assert(std::string("1m 40s") == format_time_ns(u64(1e11))); + assert(std::string("16m 40s") == format_time_ns(u64(1e12))); + assert(std::string("1h") == format_time_ns(u64(36e11))); + assert(std::string("1j") == format_time_ns(u64(864e11))); + assert(std::string("1w") == format_time_ns(u64(6048e11))); + assert(std::string("1w 4j 13h 46m 40s") == format_time_ns(u64(1e15))); + assert(std::string("2w") == format_time_ns(u64(12096e11))); + assert(std::string("3w 6j 5h 5m 35s 800ms") == format_time_ns(u64(23511358e8))); + assert(std::string("3w 6j 7h 43m 4s 700ms") == format_time_ns(u64(23605847e8))); + assert(std::string("3w 6j 7h 43m 11s 600ms") == format_time_ns(u64(23605916e8))); + assert(std::string("3w 6j 13h 18m 33s 200ms") == format_time_ns(u64(23807132e8))); + assert(std::string("4w 1j 12h 44m 2s 900ms") == format_time_ns(u64(25514429e8))); + assert(std::string("1M") == format_time_ns(u64(26298e11))); + assert(std::string("1M 1w 2j 13h 30m") == format_time_ns(u64(3456e12))); + assert(std::string("4M 4j 6h") == format_time_ns(u64(108864e11))); + assert(std::string("11M 2w 5j 13h 22m 48s") == format_time_ns(u64(30617568e9))); + assert(std::string("11M 4w 2j 4h 30m") == format_time_ns(u64(31536e12))); + assert(std::string("1y") == format_time_ns(u64(315576e11))); + assert(std::string("11M 4w 2j 10h 18m 45s") == format_time_ns(u64(31556925e9))); + assert(std::string("11M 4w 2j 10h 19m 12s") == format_time_ns(u64(31556952e9))); + assert(std::string("1y 9m 9s") == format_time_ns(u64(31558149e9))); + assert(std::string("1y 18h") == format_time_ns(u64(316224e11))); + assert(std::string("4y") == format_time_ns(u64(1262304e11))); + assert(std::string("5y") == format_time_ns(u64(157788e12))); + assert(std::string("10y") == format_time_ns(u64(315576e12))); + assert(std::string("15y") == format_time_ns(u64(473364e12))); + assert(std::string("20y") == format_time_ns(u64(631152e12))); + assert(std::string("31y 8M 1w 19h 46m 40s") == format_time_ns(u64(1e18))); + assert(std::string("50y") == format_time_ns(u64(157788e13))); + assert(std::string("1c") == format_time_ns(u64(315576e13))); + // uint64_t_MAX == 2**64 == 18446744073709551615 == -1 + assert(std::string("5c 84y 6M 2w 1j 8h 34m 33s 709ms 551us 615ns") == format_time_ns(u64(-1))); + assert(std::string("5c 84y 6M 2w 1j 8h 34m 33s 709ms 551us 615ns") == format_time_ns(18446744073709551615ull)); + assert(std::string("1c 10y 10M 3w 6j 10h 10m 10s 100ms 100us 100ns") == format_time_ns(3500003410100100100ull)); } std::string thousand_sep(const uint64_t& k, const char& sep) noexcept { @@ -145,13 +220,4 @@ namespace asp { std::string thousand_sep(const uint64_t& k) noexcept { return thousand_sep(k, ','); } - - void print_separator(const char* const title) noexcept { - #define S(N) std::string(N, '-').c_str() - constexpr size_t SEPARATOR_SIZE = W_NAME + W_TIME + W_FTIME + 6 + 6; - char separator[SEPARATOR_SIZE]; - sprintf(separator, "|%s|%s|%s|\n", S(W_NAME + 2), S(W_TIME + 2), S(W_FTIME + 2)); - printf("| %-" STR(W_NAME) "s | %-" STR(W_TIME) "s | %-" STR(W_FTIME) "s | \n%s", title, "Time spent(ns)", "Formatted time spent", separator); - #undef S - } } diff --git a/toolbox.hpp b/toolbox.hpp index fc1e444..515abf5 100644 --- a/toolbox.hpp +++ b/toolbox.hpp @@ -1,6 +1,7 @@ #pragma once #include #include +#include #define W_NAME 49 #define W_TIME 17 @@ -19,28 +20,88 @@ namespace asp { void toolbox_unit_test(void) noexcept; std::string thousand_sep(const uint64_t&, const char&) noexcept; std::string thousand_sep(const uint64_t&) noexcept; - void print_separator(const char* const) noexcept; - template - inline constexpr void measure_time_void(const char* step_name, const F& fnc, Args &&...args) noexcept { + /** + * @brief Print a formatted row of titles with of gaps seperated by a separator. + * + * @param gaps List of size gaps + * @param titles List of titles + * @param separator Separator character between each gap + */ + template + constexpr void formatted_row(const std::array& gaps, const std::array& titles, + const char* const separator = "│", const char line_ending = '\n') noexcept { + for(size_t i = 0; i < N; ++i) + printf("%s %*s ", separator, -gaps[i], titles[i]); + printf("%s%c", separator, line_ending); + } + + /** + * @brief Print a formatted line of repeated characters. + * + * @param gaps List of size gaps + * @param right Character on the left + * @param middle Character between each separator + * @param separator Separator character between each gap + * @param left Character on the right + */ + template + constexpr void formatted_line(const std::array& gaps, const char* const left, const char* const middle, + const char* const separator, const char* const right, const char line_ending = '\n') noexcept { + printf("%s", left); + for(size_t i = 0; i < N; ++i){ + for(int32_t j = std::abs(gaps[i]) + 2; j > 0; --j) + printf("%s", separator); + if(i != N - 1) + printf("%s", middle); + } + + printf("%s%c", right, line_ending); + } + + /** + * @brief Print a formatted header with the given titles and sizes. + * + * @param gaps List of size gaps + * @param titles List of titles + */ + template + constexpr void header(const std::array& gaps, const std::array& titles) noexcept { + formatted_line(gaps, "┌", "┬", "─", "┐"); + formatted_row(gaps, titles); + formatted_line(gaps, "├", "┼", "─", "┤"); + } + + /** + * @brief Print a formatted footer with the given sizes. + * + * @param gaps List of size gaps + */ + template + constexpr void footer(const std::array& gaps) noexcept { + formatted_line(gaps, "└", "┴", "─", "┘"); + } + + template + constexpr void measure_time_void(const std::array& gaps, const char* step_name, const F& fnc, Args &&...args) noexcept { #ifndef __DEBUG - printf("| %-" STR(W_NAME) "s | %" STR(W_TIME) "s | %-" STR(W_FTIME) "s |\r", step_name, "In progress", "In progress"); + formatted_row(gaps, { "Testing summary", "In progress", "In progress" }, "│", '\r'); #endif const auto start = time(); fnc(std::forward(args)...); const long long timespent = duration_ns(time() - start); - printf("| %-" STR(W_NAME) "s | %" STR(W_TIME) "s | %-" STR(W_FTIME) "s |\n", step_name, thousand_sep(timespent).c_str(), format_time_ns(timespent).c_str()); + formatted_row(gaps, { step_name, thousand_sep(timespent).c_str(), format_time_ns(timespent).c_str() }); } - template - inline constexpr T measure_time(const char* step_name, const F& fnc, Args &&...args) noexcept { + template + constexpr T measure_time(const std::array& gaps, const char* step_name, const F& fnc, Args &&...args) noexcept { #ifndef __DEBUG - printf("| %-" STR(W_NAME) "s | %" STR(W_TIME) "s | %-" STR(W_FTIME) "s |\r", step_name, "In progress", "In progress"); + formatted_row(gaps, { "Testing summary", "In progress", "In progress" }, "│", '\r'); #endif const auto start = time(); const T res = fnc(std::forward(args)...); const long long timespent = duration_ns(time() - start); - printf("| %-" STR(W_NAME) "s | %" STR(W_TIME) "s | %-" STR(W_FTIME) "s |\n", step_name, thousand_sep(timespent).c_str(), format_time_ns(timespent).c_str()); + formatted_row(gaps, { step_name, thousand_sep(timespent).c_str(), format_time_ns(timespent).c_str() }); return res; } };