From 6cf07fc33c5a246a651b19144b1d207e314539e0 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Sat, 21 Aug 2021 15:04:40 -0700 Subject: [PATCH 01/17] MemoryBenchmark: Generate baseline before adding 3-argument sorting functions --- examples/MemoryBenchmark/README.md | 60 +++++++++++++-------------- examples/MemoryBenchmark/samd.txt | 30 +++++++------- examples/MemoryBenchmark/teensy32.txt | 30 +++++++------- 3 files changed, 60 insertions(+), 60 deletions(-) diff --git a/examples/MemoryBenchmark/README.md b/examples/MemoryBenchmark/README.md index 5a24b63..75d4b10 100644 --- a/examples/MemoryBenchmark/README.md +++ b/examples/MemoryBenchmark/README.md @@ -117,26 +117,26 @@ ASCII table. +---------------------------------------------------------------------+ | Functionality | flash/ ram | delta | |----------------------------------------+--------------+-------------| -| Baseline | 10664/ 0 | 0/ 0 | +| Baseline | 10520/ 0 | 0/ 0 | |----------------------------------------+--------------+-------------| -| bubbleSort() | 10696/ 0 | 32/ 0 | -| insertionSort() | 10712/ 0 | 48/ 0 | -| selectionSort() | 10740/ 0 | 76/ 0 | +| bubbleSort() | 10568/ 0 | 48/ 0 | +| insertionSort() | 10568/ 0 | 48/ 0 | +| selectionSort() | 10584/ 0 | 64/ 0 | |----------------------------------------+--------------+-------------| -| shellSortClassic() | 10720/ 0 | 56/ 0 | -| shellSortKnuth() | 10736/ 0 | 72/ 0 | -| shellSortTokuda() | 10836/ 0 | 172/ 0 | +| shellSortClassic() | 10584/ 0 | 64/ 0 | +| shellSortKnuth() | 10576/ 0 | 56/ 0 | +| shellSortTokuda() | 10648/ 0 | 128/ 0 | |----------------------------------------+--------------+-------------| -| combSort13() | 10724/ 0 | 60/ 0 | -| combSort13m() | 10740/ 0 | 76/ 0 | -| combSort133() | 10716/ 0 | 52/ 0 | -| combSort133m() | 10740/ 0 | 76/ 0 | +| combSort13() | 10584/ 0 | 64/ 0 | +| combSort13m() | 10600/ 0 | 80/ 0 | +| combSort133() | 10576/ 0 | 56/ 0 | +| combSort133m() | 10592/ 0 | 72/ 0 | |----------------------------------------+--------------+-------------| -| quickSortMiddle() | 10764/ 0 | 100/ 0 | -| quickSortMedian() | 10796/ 0 | 132/ 0 | -| quickSortMedianSwapped() | 10808/ 0 | 144/ 0 | +| quickSortMiddle() | 10616/ 0 | 96/ 0 | +| quickSortMedian() | 10648/ 0 | 128/ 0 | +| quickSortMedianSwapped() | 10664/ 0 | 144/ 0 | |----------------------------------------+--------------+-------------| -| qsort() | 11448/ 0 | 784/ 0 | +| qsort() | 11320/ 0 | 800/ 0 | +---------------------------------------------------------------------+ ``` @@ -259,26 +259,26 @@ usage by objects. +---------------------------------------------------------------------+ | Functionality | flash/ ram | delta | |----------------------------------------+--------------+-------------| -| Baseline | 7788/ 3256 | 0/ 0 | +| Baseline | 7116/ 3256 | 0/ 0 | |----------------------------------------+--------------+-------------| -| bubbleSort() | 7816/ 3256 | 28/ 0 | -| insertionSort() | 7844/ 3256 | 56/ 0 | -| selectionSort() | 7852/ 3256 | 64/ 0 | +| bubbleSort() | 7144/ 3256 | 28/ 0 | +| insertionSort() | 7172/ 3256 | 56/ 0 | +| selectionSort() | 7180/ 3256 | 64/ 0 | |----------------------------------------+--------------+-------------| -| shellSortClassic() | 7868/ 3256 | 80/ 0 | -| shellSortKnuth() | 7880/ 3256 | 92/ 0 | -| shellSortTokuda() | 7976/ 3256 | 188/ 0 | +| shellSortClassic() | 7196/ 3256 | 80/ 0 | +| shellSortKnuth() | 7208/ 3256 | 92/ 0 | +| shellSortTokuda() | 7304/ 3256 | 188/ 0 | |----------------------------------------+--------------+-------------| -| combSort13() | 7864/ 3256 | 76/ 0 | -| combSort13m() | 7876/ 3256 | 88/ 0 | -| combSort133() | 7844/ 3256 | 56/ 0 | -| combSort133m() | 7860/ 3256 | 72/ 0 | +| combSort13() | 7192/ 3256 | 76/ 0 | +| combSort13m() | 7204/ 3256 | 88/ 0 | +| combSort133() | 7172/ 3256 | 56/ 0 | +| combSort133m() | 7188/ 3256 | 72/ 0 | |----------------------------------------+--------------+-------------| -| quickSortMiddle() | 7896/ 3256 | 108/ 0 | -| quickSortMedian() | 7932/ 3256 | 144/ 0 | -| quickSortMedianSwapped() | 7960/ 3256 | 172/ 0 | +| quickSortMiddle() | 7224/ 3256 | 108/ 0 | +| quickSortMedian() | 7260/ 3256 | 144/ 0 | +| quickSortMedianSwapped() | 7288/ 3256 | 172/ 0 | |----------------------------------------+--------------+-------------| -| qsort() | 9248/ 3256 | 1460/ 0 | +| qsort() | 8576/ 3256 | 1460/ 0 | +---------------------------------------------------------------------+ ``` diff --git a/examples/MemoryBenchmark/samd.txt b/examples/MemoryBenchmark/samd.txt index 3677945..277d53a 100644 --- a/examples/MemoryBenchmark/samd.txt +++ b/examples/MemoryBenchmark/samd.txt @@ -1,15 +1,15 @@ -0 10664 262144 -1 10696 262144 -2 10712 262144 -3 10740 262144 -4 10720 262144 -5 10736 262144 -6 10836 262144 -7 10724 262144 -8 10740 262144 -9 10716 262144 -10 10740 262144 -11 10764 262144 -12 10796 262144 -13 10808 262144 -14 11448 262144 +0 10520 262144 +1 10568 262144 +2 10568 262144 +3 10584 262144 +4 10584 262144 +5 10576 262144 +6 10648 262144 +7 10584 262144 +8 10600 262144 +9 10576 262144 +10 10592 262144 +11 10616 262144 +12 10648 262144 +13 10664 262144 +14 11320 262144 diff --git a/examples/MemoryBenchmark/teensy32.txt b/examples/MemoryBenchmark/teensy32.txt index 3141051..54fba26 100644 --- a/examples/MemoryBenchmark/teensy32.txt +++ b/examples/MemoryBenchmark/teensy32.txt @@ -1,15 +1,15 @@ -0 7788 262144 3256 65536 -1 7816 262144 3256 65536 -2 7844 262144 3256 65536 -3 7852 262144 3256 65536 -4 7868 262144 3256 65536 -5 7880 262144 3256 65536 -6 7976 262144 3256 65536 -7 7864 262144 3256 65536 -8 7876 262144 3256 65536 -9 7844 262144 3256 65536 -10 7860 262144 3256 65536 -11 7896 262144 3256 65536 -12 7932 262144 3256 65536 -13 7960 262144 3256 65536 -14 9248 262144 3256 65536 +0 7116 262144 3256 65536 +1 7144 262144 3256 65536 +2 7172 262144 3256 65536 +3 7180 262144 3256 65536 +4 7196 262144 3256 65536 +5 7208 262144 3256 65536 +6 7304 262144 3256 65536 +7 7192 262144 3256 65536 +8 7204 262144 3256 65536 +9 7172 262144 3256 65536 +10 7188 262144 3256 65536 +11 7224 262144 3256 65536 +12 7260 262144 3256 65536 +13 7288 262144 3256 65536 +14 8576 262144 3256 65536 From 8abbd2b08da8b5470220af4c62aefabba8b9a632 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Sat, 21 Aug 2021 14:12:14 -0700 Subject: [PATCH 02/17] src: Add 3-argument versions of all sort functions that accept a comparison predicate (function or lambda expression) --- examples/HelloSort/HelloSort.ino | 45 ++++- src/ace_sorting/bubbleSort.h | 31 +++- src/ace_sorting/combSort.h | 281 ++++++++++++++++++++++++------ src/ace_sorting/insertionSort.h | 42 ++++- src/ace_sorting/quickSort.h | 230 ++++++++++++++++++++---- src/ace_sorting/selectionSort.h | 50 ++++++ src/ace_sorting/shellSort.h | 194 +++++++++++++++++++-- tests/SortingTest/SortingTest.ino | 120 +++++++++++++ 8 files changed, 868 insertions(+), 125 deletions(-) diff --git a/examples/HelloSort/HelloSort.ino b/examples/HelloSort/HelloSort.ino index da54e6e..48faf93 100644 --- a/examples/HelloSort/HelloSort.ino +++ b/examples/HelloSort/HelloSort.ino @@ -1,9 +1,11 @@ /* - * Quick demo of one of the sorting functions: create an array of integers with - * random numbers, and sort the array. Print out the unsorted and sorted arrays. - * Other sorting functions follow the same pattern. The compiler is able to - * infer the type of the data, so you don't normally need to specify the - * template type to the shellSortKnuth() function. + * Quick demo of one of the sorting functions, in this example, + * shellSortKnuth(). All the other sorting algorithms have the exact same + * function signature. First, create an array of integers with random numbers. + * Then sort the array in different ways, including reverse sorting. Print out + * the unsorted and sorted arrays. The compiler is able to infer the type of the + * data, so you don't normally need to specify the template type to the + * shellSortKnuth() function. */ #include @@ -18,6 +20,7 @@ using ace_sorting::shellSortKnuth; const uint16_t ARRAY_SIZE = 50; int array[ARRAY_SIZE]; +// Print given array. void printArray(int* array, uint16_t arraySize) { for (uint16_t i = 0; i < arraySize; i++) { SERIAL_PORT_MONITOR.print(array[i]); @@ -26,12 +29,17 @@ void printArray(int* array, uint16_t arraySize) { SERIAL_PORT_MONITOR.println(); } +// Fill array with random numbers. void fillArray(int* array, uint16_t arraySize) { for (uint16_t i = 0; i < arraySize; i++) { array[i] = random(256); } } +bool lessThan(int a, int b) { + return a < b; +} + //----------------------------------------------------------------------------- void setup() { @@ -49,15 +57,34 @@ void setup() { randomSeed(analogRead(A0)); #endif + SERIAL_PORT_MONITOR.print("Unsorted: "); fillArray(array, ARRAY_SIZE); - SERIAL_PORT_MONITOR.println("Unsorted:"); printArray(array, ARRAY_SIZE); + SERIAL_PORT_MONITOR.println(); - // The compiler automatically generates the correct version of - // shellSortKnuth() based on the type of `array`. + // Use default ascending sort order. + SERIAL_PORT_MONITOR.print("Sorted using implicit ascending: "); shellSortKnuth(array, ARRAY_SIZE); - SERIAL_PORT_MONITOR.println("Sorted:"); printArray(array, ARRAY_SIZE); + SERIAL_PORT_MONITOR.println(); + + // Use function pointer. + SERIAL_PORT_MONITOR.print("Sorted using function pointer: "); + shellSortKnuth(array, ARRAY_SIZE, lessThan); + printArray(array, ARRAY_SIZE); + SERIAL_PORT_MONITOR.println(); + + // Use lambda expression + SERIAL_PORT_MONITOR.print("Sorted using lambda expression: "); + shellSortKnuth(array, ARRAY_SIZE, [](int a, int b) { return a < b; }); + printArray(array, ARRAY_SIZE); + SERIAL_PORT_MONITOR.println(); + + // Reverse sort using lambda expression + SERIAL_PORT_MONITOR.print("Reverse sorted using lambda expression: "); + shellSortKnuth(array, ARRAY_SIZE, [](int a, int b) { return a > b; }); + printArray(array, ARRAY_SIZE); + SERIAL_PORT_MONITOR.println(); #if defined(EPOXY_DUINO) exit(0); diff --git a/src/ace_sorting/bubbleSort.h b/src/ace_sorting/bubbleSort.h index e0e8faf..5caf41a 100644 --- a/src/ace_sorting/bubbleSort.h +++ b/src/ace_sorting/bubbleSort.h @@ -41,13 +41,42 @@ namespace ace_sorting { * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void bubbleSort(T data[], uint16_t n) { bool swapped; do { swapped = false; for (uint16_t i = 1; i < n; i++) { - if (data[i - 1] > data[i]) { + if (data[i] < data[i - 1]) { + swap(data[i - 1], data[i]); + swapped = true; + } + } + } while (swapped); +} +#else +template +void bubbleSort(T data[], uint16_t n) { + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + bubbleSort(data, n, lessThan); +} +#endif + +/** + * Same as the 2-argument bubbleSort() with the addition of a `lessThan` + * lambda expression or function. + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void bubbleSort(T data[], uint16_t n, F&& lessThan) { + bool swapped; + do { + swapped = false; + for (uint16_t i = 1; i < n; i++) { + if (lessThan(data[i], data[i - 1])) { swap(data[i - 1], data[i]); swapped = true; } diff --git a/src/ace_sorting/combSort.h b/src/ace_sorting/combSort.h index ac3c28a..85c883b 100644 --- a/src/ace_sorting/combSort.h +++ b/src/ace_sorting/combSort.h @@ -46,27 +46,67 @@ namespace ace_sorting { * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void combSort13(T data[], uint16_t n) { - bool swapped = true; + bool swapped = true; - uint16_t gap = n; - while (swapped || gap > 1) { - gap = gap * 10 / 13; - if (gap == 0) gap = 1; - swapped = false; + uint16_t gap = n; + while (swapped || gap > 1) { + gap = gap * 10 / 13; + if (gap == 0) gap = 1; + swapped = false; - uint16_t i; + uint16_t i; uint16_t j; - for (i = 0, j = gap; j < n; i++, j++) { - if (data[i] > data[j]) { + for (i = 0, j = gap; j < n; i++, j++) { + if (data[j] < data[i]) { swap(data[i], data[j]); - swapped = true; - } - } - } + swapped = true; + } + } + } +} +#else +template +void combSort13(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + combSort13(data, n, lessThan); +} +#endif + +/** + * Same as the 2-argument combSort13() with the addition of a `lessThan` lambda + * expression or function. + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void combSort13(T data[], uint16_t n, F&& lessThan) { + bool swapped = true; + + uint16_t gap = n; + while (swapped || gap > 1) { + gap = gap * 10 / 13; + if (gap == 0) gap = 1; + swapped = false; + + uint16_t i; + uint16_t j; + for (i = 0, j = gap; j < n; i++, j++) { + if (lessThan(data[j], data[i])) { + swap(data[i], data[j]); + swapped = true; + } + } + } } +//----------------------------------------------------------------------------- + /** * Same as combSort13() with the modification that if the gap is 9 or 10, it is * set to 11, so that the gap sequence becomes (11, 8, 6, 4, 3, 2, 1). For @@ -79,30 +119,74 @@ void combSort13(T data[], uint16_t n) { * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void combSort13m(T data[], uint16_t n) { - bool swapped = true; + bool swapped = true; - uint16_t gap = n; - while (swapped || gap > 1) { - gap = gap * 10 / 13; + uint16_t gap = n; + while (swapped || gap > 1) { + gap = gap * 10 / 13; if (gap == 9 || gap == 10) { gap = 11; } else if (gap == 0) { gap = 1; } - swapped = false; + swapped = false; - uint16_t i; + uint16_t i; uint16_t j; - for (i = 0, j = gap; j < n; i++, j++) { - if (data[i] > data[j]) { + for (i = 0, j = gap; j < n; i++, j++) { + if (data[j] < data[i]) { swap(data[i], data[j]); - swapped = true; - } - } - } + swapped = true; + } + } + } } +#else +template +void combSort13m(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + combSort13m(data, n, lessThan); +} +#endif + +/** + * Same as the 2-argument combSort13m() with the addition of a `lessThan` lambda + * expression or function. + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void combSort13m(T data[], uint16_t n, F&& lessThan) { + bool swapped = true; + + uint16_t gap = n; + while (swapped || gap > 1) { + gap = gap * 10 / 13; + if (gap == 9 || gap == 10) { + gap = 11; + } else if (gap == 0) { + gap = 1; + } + swapped = false; + + uint16_t i; + uint16_t j; + for (i = 0, j = gap; j < n; i++, j++) { + if (lessThan(data[j], data[i])) { + swap(data[i], data[j]); + swapped = true; + } + } + } +} + +//----------------------------------------------------------------------------- /** * Comb sort using a gap factor of 4/3=1.33 (successive gap is multiplied by 3 @@ -111,41 +195,82 @@ void combSort13m(T data[], uint16_t n) { * 21845. * * This gap ratio seemed appealing because the division by 4 will be optimized - * by the compiler into a left shift by 2 bits, so this algorithm does not + * by the compiler into a right shift of 2 bits, so this algorithm does not * perform any integer division. Experimentation on 8-bit processors without - * hardware dvision this algorithm is slightly faster than combSort13() on - * average. + * hardware dvision shows that this algorithm is slightly faster than + * combSort13() on average. * - * On 32-bit or 64-bit processors with hardware division, experimentation shows - * that this algorithm is actually slightly slower on average than combSort13(). - * And it seems to have a slightly higher variance, with some input data causing - * large spikes in runtime compared to the average. + * On 32-bit or 64-bit processors with hardware division, on larger input + * `data`, experimentation shows that this algorithm is actually slightly slower + * on average than combSort13(). And it seems to have a slightly higher + * variance, with some input data causing large spikes in runtime compared to + * the average. * * Average complexity: O(n^2 / 2^p). * See https://en.wikipedia.org/wiki/Comb_sort * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void combSort133(T data[], uint16_t n) { - bool swapped = true; + bool swapped = true; - uint16_t gap = n; - while (swapped || gap > 1) { - gap = gap * 3 / 4; - if (gap == 0) gap = 1; - swapped = false; + uint16_t gap = n; + while (swapped || gap > 1) { + gap = gap * 3 / 4; + if (gap == 0) gap = 1; + swapped = false; - uint16_t i; + uint16_t i; uint16_t j; - for (i = 0, j = gap; j < n; i++, j++) { - if (data[i] > data[j]) { + for (i = 0, j = gap; j < n; i++, j++) { + if (data[j] < data[i]) { swap(data[i], data[j]); - swapped = true; - } - } - } + swapped = true; + } + } + } } +#else +template +void combSort133(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + combSort133(data, n, lessThan); +} +#endif + +/** + * Same as the 2-argument combSort133() with the addition of a `lessThan` lambda + * expression or function. + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void combSort133(T data[], uint16_t n, F&& lessThan) { + bool swapped = true; + + uint16_t gap = n; + while (swapped || gap > 1) { + gap = gap * 3 / 4; + if (gap == 0) gap = 1; + swapped = false; + + uint16_t i; + uint16_t j; + for (i = 0, j = gap; j < n; i++, j++) { + if (lessThan(data[j], data[i])) { + swap(data[i], data[j]); + swapped = true; + } + } + } +} + +//----------------------------------------------------------------------------- /** * Same as combSort133() but modified so that a gap of 9 or 10 becomes gap=11 so @@ -158,29 +283,71 @@ void combSort133(T data[], uint16_t n) { * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) +template +void combSort133m(T data[], uint16_t n) { + bool swapped = true; + + uint16_t gap = n; + while (swapped || gap > 1) { + gap = gap * 3 / 4; + if (gap == 9 || gap == 10) { + gap = 11; + } else if (gap == 0) { + gap = 1; + } + swapped = false; + + uint16_t i; + uint16_t j; + for (i = 0, j = gap; j < n; i++, j++) { + if (data[j] < data[i]) { + swap(data[i], data[j]); + swapped = true; + } + } + } +} +#else template void combSort133m(T data[], uint16_t n) { - bool swapped = true; + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + combSort133m(data, n, lessThan); +} +#endif - uint16_t gap = n; - while (swapped || gap > 1) { - gap = gap * 3 / 4; +/** + * Same as the 2-argument combSort133m() with the addition of a `lessThan` + * lambda expression or function. + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void combSort133m(T data[], uint16_t n, F&& lessThan) { + bool swapped = true; + + uint16_t gap = n; + while (swapped || gap > 1) { + gap = gap * 3 / 4; if (gap == 9 || gap == 10) { gap = 11; } else if (gap == 0) { gap = 1; } - swapped = false; + swapped = false; - uint16_t i; + uint16_t i; uint16_t j; - for (i = 0, j = gap; j < n; i++, j++) { - if (data[i] > data[j]) { + for (i = 0, j = gap; j < n; i++, j++) { + if (lessThan(data[j], data[i])) { swap(data[i], data[j]); - swapped = true; - } - } - } + swapped = true; + } + } + } } } diff --git a/src/ace_sorting/insertionSort.h b/src/ace_sorting/insertionSort.h index 03cd9f7..944be48 100644 --- a/src/ace_sorting/insertionSort.h +++ b/src/ace_sorting/insertionSort.h @@ -26,21 +26,22 @@ SOFTWARE. * @file insertionSort.h * * Insertion sort. + * See https://en.wikipedia.org/wiki/Insertion_sort */ #ifndef ACE_SORTING_INSERTION_SORT_H #define ACE_SORTING_INSERTION_SORT_H -#include "swap.h" - namespace ace_sorting { /** * Insertion sort. * Average complexity: O(n^2) + * See https://en.wikipedia.org/wiki/Insertion_sort * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void insertionSort(T data[], uint16_t n) { for (uint16_t i = 1; i < n; i++) { @@ -60,6 +61,43 @@ void insertionSort(T data[], uint16_t n) { data[j] = temp; } } +#else +template +void insertionSort(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + insertionSort(data, n, lessThan); +} +#endif + +/** + * Same as the 2-argument insertionSort() with the addition of a `lessThan` + * lambda expression or function. + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void insertionSort(T data[], uint16_t n, F&& lessThan) { + for (uint16_t i = 1; i < n; i++) { + T temp = data[i]; + + // Shift one slot to the right. + uint16_t j; + for (j = i; j > 0; j--) { + // The following is equivalent to: (data[j - 1] <= temp) + if (! lessThan(temp, data[j - 1])) break; + data[j] = data[j - 1]; + } + + // This can assign 'temp' back into the original slot if no shifting was + // done. That's ok because T is assumed to be relatively cheap to copy, and + // checking for (i != j) is more expensive than just doing the extra + // assignment. + data[j] = temp; + } +} } diff --git a/src/ace_sorting/quickSort.h b/src/ace_sorting/quickSort.h index 6d30e9b..6993f49 100644 --- a/src/ace_sorting/quickSort.h +++ b/src/ace_sorting/quickSort.h @@ -26,6 +26,7 @@ SOFTWARE. * @file quickSort.h * * Quick sort algorithms. + * See https://en.wikipedia.org/wiki/Quicksort */ #ifndef ACE_SORTING_QUICK_SORT_H @@ -44,29 +45,72 @@ namespace ace_sorting { * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void quickSortMiddle(T data[], uint16_t n) { if (n <= 1) return; - + T pivot = data[n / 2]; T* left = data; T* right = data + n - 1; - + while (left <= right) { - if (*left < pivot) { + if (*left < pivot) { left++; - } else if (*right > pivot) { + } else if (pivot < *right) { right--; - } else { + } else { swap(*left, *right); - left++; - right--; - } + left++; + right--; + } } - quickSortMiddle(data, right - data + 1); - quickSortMiddle(left, data + n - left); + quickSortMiddle(data, right - data + 1); + quickSortMiddle(left, data + n - left); +} +#else +template +void quickSortMiddle(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + quickSortMiddle(data, n, lessThan); } +#endif + +/** + * Same as the 2-argument quickSortMiddle() with the addition of a `lessThan` + * lambda expression or function. + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void quickSortMiddle(T data[], uint16_t n, F&& lessThan) { + if (n <= 1) return; + + T pivot = data[n / 2]; + T* left = data; + T* right = data + n - 1; + + while (left <= right) { + if (lessThan(*left, pivot)) { + left++; + } else if (lessThan(pivot, *right)) { + right--; + } else { + swap(*left, *right); + left++; + right--; + } + } + + quickSortMiddle(data, right - data + 1, lessThan); + quickSortMiddle(left, data + n - left, lessThan); +} + +//----------------------------------------------------------------------------- /** * Quick sort using Sedgewick's recommendation of using the median of low, @@ -77,67 +121,179 @@ void quickSortMiddle(T data[], uint16_t n) { * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void quickSortMedian(T data[], uint16_t n) { if (n <= 1) return; - + // Select the median of data[low], data[mid], and data[high] as the estimate // of the ideal pivot. Don't swap (low, mid) or (mid, high) (compare that // quickSortMedianSwapped()) to save flash memory. They will get swapped in // the partitioning while-loop below. uint16_t mid = n / 2; T pivot = data[mid]; - if (data[0] > data[n - 1]) { + if (data[n - 1] < data[0]) { swap(data[0], data[n - 1]); } - if (data[0] > pivot) { + if (pivot < data[0]) { pivot = data[0]; - } else if (pivot > data[n - 1]) { + } else if (data[n - 1] < pivot) { pivot = data[n - 1]; } T* left = data; T* right = data + n - 1; - + while (left <= right) { - if (*left < pivot) { + if (*left < pivot) { left++; - } else if (*right > pivot) { + } else if (pivot < *right) { right--; - } else { + } else { swap(*left, *right); - left++; - right--; - } + left++; + right--; + } } - quickSortMedian(data, right - data + 1); - quickSortMedian(left, data + n - left); + quickSortMedian(data, right - data + 1); + quickSortMedian(left, data + n - left); +} +#else +template +void quickSortMedian(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + quickSortMedian(data, n, lessThan); } +#endif + +/** + * Same as the 2-argument quickSortMedian() with the addition of a `lessThan` + * lambda expression or function. + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void quickSortMedian(T data[], uint16_t n, F&& lessThan) { + if (n <= 1) return; + + // Select the median of data[low], data[mid], and data[high] as the estimate + // of the ideal pivot. Don't swap (low, mid) or (mid, high) (compare that + // quickSortMedianSwapped()) to save flash memory. They will get swapped in + // the partitioning while-loop below. + uint16_t mid = n / 2; + T pivot = data[mid]; + if (lessThan(data[n - 1], data[0])) { + swap(data[0], data[n - 1]); + } + if (lessThan(pivot, data[0])) { + pivot = data[0]; + } else if (lessThan(data[n - 1], pivot)) { + pivot = data[n - 1]; + } + + T* left = data; + T* right = data + n - 1; + + while (left <= right) { + if (lessThan(*left, pivot)) { + left++; + } else if (lessThan(pivot, *right)) { + right--; + } else { + swap(*left, *right); + left++; + right--; + } + } + + quickSortMedian(data, right - data + 1, lessThan); + quickSortMedian(left, data + n - left, lessThan); +} + +//----------------------------------------------------------------------------- /** * Same as quickSortMedian(), but swap the low and high so that low, mid, and * high elements become sorted. This means that the low and high are already * partitioned, so we can omit those 2 points from the partitioning while-loop. * This code consumes a lot more flash memory due to the additional swap() - * calls. + * calls, but runs slightly faster. * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) +template +void quickSortMedianSwapped(T data[], uint16_t n) { + if (n <= 1) return; + + // Select the median of data[low], data[mid], and data[high] as the estimate + // of the ideal pivot. In the process, the (low, mid, high) become sorted. + uint16_t mid = n / 2; + T pivot = data[mid]; + if (data[n - 1] < data[0]) { + swap(data[0], data[n - 1]); + } + if (pivot < data[0]) { + swap(data[0], data[mid]); + } else if (data[n - 1] < pivot) { + swap(data[mid], data[n - 1]); + } + pivot = data[mid]; + + // We can skip the low and high because they are already sorted. + T* left = data + 1; + T* right = data + n - 2; + + while (left <= right) { + if (*left < pivot) { + left++; + } else if (pivot < *right) { + right--; + } else { + swap(*left, *right); + left++; + right--; + } + } + + quickSortMedianSwapped(data, right - data + 1); + quickSortMedianSwapped(left, data + n - left); +} +#else template void quickSortMedianSwapped(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + quickSortMedianSwapped(data, n, lessThan); +} +#endif + +/** + * Same as the 2-argument quickSortMedianSwapped() with the addition of a + * `lessThan` lambda expression or function. + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void quickSortMedianSwapped(T data[], uint16_t n, F&& lessThan) { if (n <= 1) return; - + // Select the median of data[low], data[mid], and data[high] as the estimate // of the ideal pivot. In the process, the (low, mid, high) become sorted. uint16_t mid = n / 2; T pivot = data[mid]; - if (data[0] > data[n - 1]) { + if (lessThan(data[n - 1], data[0])) { swap(data[0], data[n - 1]); } - if (data[0] > pivot) { + if (lessThan(pivot, data[0])) { swap(data[0], data[mid]); - } else if (pivot > data[n - 1]) { + } else if (lessThan(data[n - 1], pivot)) { swap(data[mid], data[n - 1]); } pivot = data[mid]; @@ -145,21 +301,21 @@ void quickSortMedianSwapped(T data[], uint16_t n) { // We can skip the low and high because they are already sorted. T* left = data + 1; T* right = data + n - 2; - + while (left <= right) { - if (*left < pivot) { + if (lessThan(*left, pivot)) { left++; - } else if (*right > pivot) { + } else if (lessThan(pivot, *right)) { right--; - } else { + } else { swap(*left, *right); - left++; - right--; - } + left++; + right--; + } } - quickSortMedianSwapped(data, right - data + 1); - quickSortMedianSwapped(left, data + n - left); + quickSortMedianSwapped(data, right - data + 1, lessThan); + quickSortMedianSwapped(left, data + n - left, lessThan); } } diff --git a/src/ace_sorting/selectionSort.h b/src/ace_sorting/selectionSort.h index 7d47ce2..0f79113 100644 --- a/src/ace_sorting/selectionSort.h +++ b/src/ace_sorting/selectionSort.h @@ -26,6 +26,7 @@ SOFTWARE. * @file selectionSort.h * * Selection sort. + * See https://en.wikipedia.org/wiki/Selection_sort */ #ifndef ACE_SORTING_SELECTION_SORT_H @@ -38,9 +39,11 @@ namespace ace_sorting { /** * Selection sort. * Average complexity: O(n^2) + * See https://en.wikipedia.org/wiki/Selection_sort * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void selectionSort(T data[], uint16_t n) { for (uint16_t i = 0; i < n; i++) { @@ -71,6 +74,53 @@ void selectionSort(T data[], uint16_t n) { } } } +#else +template +void selectionSort(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + selectionSort(data, n, lessThan); +} +#endif + +/** + * Same as the 2-argument selectionSort() with the addition of a `lessThan` + * lambda expression or function. + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void selectionSort(T data[], uint16_t n, F&& lessThan) { + for (uint16_t i = 0; i < n; i++) { + + // Loop to find the smallest element. + uint16_t iSmallest = i; + T smallest = data[i]; + + // Starting the loop with 'j = i + 1' increases flash usage on AVR by 12 + // bytes. But it does not reduce the execution time signficantly, because + // the (i + 1) will be done anyway by the j++ in the loop. So the only thing + // we save is a single redundant 'smallest < smallest' comparison. + for (uint16_t j = i; j < n; j++) { + if (lessThan(data[j], smallest)) { + iSmallest = j; + smallest = data[j]; + } + } + + // This extra check (i != iSmallest) is not really necessary, because if the + // first element was already the smallest, it would swap the value back into + // itself. However, the one situation where Selection Sort *might* be used + // over Insertion Sort is when the write operation is far more expensive + // than a read operation. So this test preserves that advantage of the + // Selection Sort, by avoiding doing an unnecessary swap. + if (i != iSmallest) { + swap(data[i], data[iSmallest]); + } + } +} } diff --git a/src/ace_sorting/shellSort.h b/src/ace_sorting/shellSort.h index 7ee241c..c9ce68b 100644 --- a/src/ace_sorting/shellSort.h +++ b/src/ace_sorting/shellSort.h @@ -31,8 +31,6 @@ SOFTWARE. #ifndef ACE_SORTING_SHELL_SORT_H #define ACE_SORTING_SHELL_SORT_H -#include "swap.h" - namespace ace_sorting { /** @@ -42,14 +40,15 @@ namespace ace_sorting { * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void shellSortClassic(T data[], uint16_t n) { - uint16_t gap = n; - while (gap > 1) { - gap /= 2; + uint16_t gap = n; + while (gap > 1) { + gap /= 2; // Do insertion sort of each sub-array separated by gap. - for (uint16_t i = gap; i < n; i++) { + for (uint16_t i = gap; i < n; i++) { T temp = data[i]; // Shift one slot to the right. @@ -64,30 +63,77 @@ void shellSortClassic(T data[], uint16_t n) { // to be relatively cheap to copy, and checking for (i != j) is more // expensive than just doing the extra assignment. data[j] = temp; - } - } + } + } +} +#else +template +void shellSortClassic(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + shellSortClassic(data, n, lessThan); +} +#endif + +/** + * Shell sort with gap size reduced by factor of 2 each iteration. + * Average complexity: Between O(n^1.3) to O(n^1.5) + * See https://en.wikipedia.org/wiki/Shellsort + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void shellSortClassic(T data[], uint16_t n, F&& lessThan) { + uint16_t gap = n; + while (gap > 1) { + gap /= 2; + + // Do insertion sort of each sub-array separated by gap. + for (uint16_t i = gap; i < n; i++) { + T temp = data[i]; + + // Shift one slot to the right. + uint16_t j; + for (j = i; j >= gap; j -= gap) { + // The following is equivalent to: (data[j - gap] <= temp) + if (! lessThan(temp, data[j - gap])) break; + data[j] = data[j - gap]; + } + + // Just like insertionSort(), this can assign 'temp' back into the + // original slot if no shifting was done. That's ok because T is assumed + // to be relatively cheap to copy, and checking for (i != j) is more + // expensive than just doing the extra assignment. + data[j] = temp; + } + } } +//----------------------------------------------------------------------------- + /** * Shell sort using gap size from Knuth. * Average complexity: Between O(n^1.3) to O(n^1.5) * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void shellSortKnuth(T data[], uint16_t n) { // Calculate the largest gap using Knuth's formula. If n is a compile-time // constant and relatively "small" (observed to be true at least up to 100), // the compiler will precalculate the loop below and replace it with a // compile-time constant. - uint16_t gap = 1; + uint16_t gap = 1; while (gap < n / 3) { gap = gap * 3 + 1; } - while (gap > 0) { + while (gap > 0) { // Do insertion sort of each sub-array separated by gap. - for (uint16_t i = gap; i < n; i++) { + for (uint16_t i = gap; i < n; i++) { T temp = data[i]; // Shift one slot to the right. @@ -102,12 +148,61 @@ void shellSortKnuth(T data[], uint16_t n) { // to be relatively cheap to copy, and checking for (i != j) is more // expensive than just doing the extra assignment. data[j] = temp; - } + } + + gap = (gap - 1) / 3; + } +} +#else +template +void shellSortKnuth(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + shellSortKnuth(data, n, lessThan); +} +#endif + +/** + * Shell sort using gap size from Knuth. + * Average complexity: Between O(n^1.3) to O(n^1.5) + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void shellSortKnuth(T data[], uint16_t n, F&& lessThan) { + uint16_t gap = 1; + while (gap < n / 3) { + gap = gap * 3 + 1; + } + + while (gap > 0) { + // Do insertion sort of each sub-array separated by gap. + for (uint16_t i = gap; i < n; i++) { + T temp = data[i]; + + // Shift one slot to the right. + uint16_t j; + for (j = i; j >= gap; j -= gap) { + // The following is equivalent to: (data[j - gap] <= temp) + if (! lessThan(temp, data[j - gap])) break; + data[j] = data[j - gap]; + } + + // Just like insertionSort(), this can assign 'temp' back into the + // original slot if no shifting was done. That's ok because T is assumed + // to be relatively cheap to copy, and checking for (i != j) is more + // expensive than just doing the extra assignment. + data[j] = temp; + } gap = (gap - 1) / 3; - } + } } +//----------------------------------------------------------------------------- + /** * Shell sort using gap sizes empirically determined by Tokuda. See * https://en.wikipedia.org/wiki/Shellsort and https://oeis.org/A108870. @@ -115,6 +210,7 @@ void shellSortKnuth(T data[], uint16_t n) { * * @tparam T type of data to sort */ +#if defined(ACE_SORTING_DIRECT) template void shellSortTokuda(T data[], const uint16_t n) { @@ -122,20 +218,20 @@ void shellSortTokuda(T data[], const uint16_t n) // https://en.wikipedia.org/wiki/Shellsort // https://oeis.org/A108870 static const uint16_t sGaps[] = { - 1, 4, 9, 20, 46, 103, 233, 525, 1182, 2660, 5985, 13467, 30301, + 1, 4, 9, 20, 46, 103, 233, 525, 1182, 2660, 5985, 13467, 30301, }; const uint16_t nGaps = sizeof(sGaps) / sizeof(uint16_t); // Find the starting gap. - uint16_t iGap; + uint16_t iGap; for (iGap = 0; sGaps[iGap] < n && iGap < nGaps; iGap++) {} if (iGap != 0) iGap--; - while (true) { + while (true) { uint16_t gap = sGaps[iGap]; // Do insertion sort of each sub-array separated by gap. - for (uint16_t i = gap; i < n; i++) { + for (uint16_t i = gap; i < n; i++) { T temp = data[i]; // Shift one slot to the right. @@ -150,11 +246,71 @@ void shellSortTokuda(T data[], const uint16_t n) // to be relatively cheap to copy, and checking for (i != j) is more // expensive than just doing the extra assignment. data[j] = temp; - } + } + + if (iGap == 0) break; + iGap--; + } +} +#else +template +void shellSortTokuda(T data[], uint16_t n) { + // This lambda expression does not perform any captures, so the compiler will + // optimize and inline the less-than expression. + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + shellSortTokuda(data, n, lessThan); +} +#endif + +/** + * Shell sort using gap sizes empirically determined by Tokuda. See + * https://en.wikipedia.org/wiki/Shellsort and https://oeis.org/A108870. + * Average complexity: Between O(n^1.3) to O(n^1.5) + * + * @tparam T type of data to sort + * @tparam F type of lambda expression or function that returns true if a < b + */ +template +void shellSortTokuda(T data[], const uint16_t n, F&& lessThan) +{ + // Experimentally observed ideal gaps. + // https://en.wikipedia.org/wiki/Shellsort + // https://oeis.org/A108870 + static const uint16_t sGaps[] = { + 1, 4, 9, 20, 46, 103, 233, 525, 1182, 2660, 5985, 13467, 30301, + }; + const uint16_t nGaps = sizeof(sGaps) / sizeof(uint16_t); + + // Find the starting gap. + uint16_t iGap; + for (iGap = 0; sGaps[iGap] < n && iGap < nGaps; iGap++) {} + if (iGap != 0) iGap--; + + while (true) { + uint16_t gap = sGaps[iGap]; + + // Do insertion sort of each sub-array separated by gap. + for (uint16_t i = gap; i < n; i++) { + T temp = data[i]; + + // Shift one slot to the right. + uint16_t j; + for (j = i; j >= gap; j -= gap) { + // The following is equivalent to: (data[j - gap] <= temp) + if (! lessThan(temp, data[j - gap])) break; + data[j] = data[j - gap]; + } + + // Just like insertionSort(), this can assign 'temp' back into the + // original slot if no shifting was done. That's ok because T is assumed + // to be relatively cheap to copy, and checking for (i != j) is more + // expensive than just doing the extra assignment. + data[j] = temp; + } if (iGap == 0) break; iGap--; - } + } } } diff --git a/tests/SortingTest/SortingTest.ino b/tests/SortingTest/SortingTest.ino index 0102125..d0ae04f 100644 --- a/tests/SortingTest/SortingTest.ino +++ b/tests/SortingTest/SortingTest.ino @@ -8,6 +8,7 @@ using aunit::TestRunner; using aunit::TestOnce; using ace_common::isSorted; +using ace_common::isReverseSorted; using ace_sorting::bubbleSort; using ace_sorting::insertionSort; using ace_sorting::selectionSort; @@ -97,6 +98,8 @@ class SortingTest : public TestOnce { } }; +//---------------------------------------------------------------------------- + testF(SortingTest, bubbleSort) { assertSort(bubbleSort); } @@ -149,6 +152,123 @@ testF(SortingTest, quickSortMedianSwapped) { assertSort(quickSortMedianSwapped); } +//---------------------------------------------------------------------------- + +/* +// It does not seem possible to create a pointer to the 3-argument version +// of the generic xxxSort() function because of the template F&& argument +// which has no human-readable name because the lambda expression is generated +// by the compiler. So the following attempt does not work. +// +typedef bool (*Compare)(const uint16_t& a, const uint16_t& b); +typedef void (*GenericSortFunction)( + uint16_t data[], uint16_t n, Compare lessThan); +*/ + +// Define lambda expression that reverses the sort order. A normal function will +// also work. The nice thing about using a lambda expression is that it can be +// embedded directly in the calling function and be able to capture variables in +// the local scope, though that feature is not used here. +auto&& greaterThan = [](const uint16_t& a, const uint16_t& b) { + return a > b; +}; + +class ReverseSortingTest : public TestOnce { + protected: + const uint16_t kDataSize = 300; + + void setup() override { + TestOnce::setup(); + mData = new uint16_t[kDataSize]; + fillArray(mData, kDataSize); + } + + void teardown() override { + delete[] mData; + TestOnce::teardown(); + } + + uint16_t* mData; +}; + +testF(ReverseSortingTest, bubbleSort) { + assertFalse(isSorted(mData, kDataSize)); + bubbleSort(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, insertionSort) { + assertFalse(isSorted(mData, kDataSize)); + insertionSort(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, selectionSort) { + assertFalse(isSorted(mData, kDataSize)); + selectionSort(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, shellSortClassic) { + assertFalse(isSorted(mData, kDataSize)); + shellSortClassic(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, shellSortKnuth) { + assertFalse(isSorted(mData, kDataSize)); + shellSortKnuth(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, shellSortTokuda) { + assertFalse(isSorted(mData, kDataSize)); + shellSortTokuda(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, combSort13) { + assertFalse(isSorted(mData, kDataSize)); + combSort13(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, combSort13m) { + assertFalse(isSorted(mData, kDataSize)); + combSort13m(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, combSort133) { + assertFalse(isSorted(mData, kDataSize)); + combSort133(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, combSort133m) { + assertFalse(isSorted(mData, kDataSize)); + combSort133m(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, quickSortMiddle) { + assertFalse(isSorted(mData, kDataSize)); + quickSortMiddle(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, quickSortMedian) { + assertFalse(isSorted(mData, kDataSize)); + quickSortMedian(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + +testF(ReverseSortingTest, quickSortMedianSwapped) { + assertFalse(isSorted(mData, kDataSize)); + quickSortMedianSwapped(mData, kDataSize, greaterThan); + assertTrue(isReverseSorted(mData, kDataSize)); +} + //---------------------------------------------------------------------------- // setup() and loop() //---------------------------------------------------------------------------- From 9bf289f2fdcfae91a454d6ce7399620dbeaedbef Mon Sep 17 00:00:00 2001 From: Brian Park Date: Sat, 21 Aug 2021 14:53:12 -0700 Subject: [PATCH 03/17] src: Add ability to select between direct and indirect versions of the 2-argument sortXxx() algorithms --- src/ace_sorting/bubbleSort.h | 10 +++++++++- src/ace_sorting/combSort.h | 16 ++++++++++++---- src/ace_sorting/insertionSort.h | 10 +++++++++- src/ace_sorting/quickSort.h | 23 ++++++++++++++++++----- src/ace_sorting/selectionSort.h | 10 +++++++++- src/ace_sorting/shellSort.h | 15 ++++++++++++--- 6 files changed, 69 insertions(+), 15 deletions(-) diff --git a/src/ace_sorting/bubbleSort.h b/src/ace_sorting/bubbleSort.h index 5caf41a..5af6225 100644 --- a/src/ace_sorting/bubbleSort.h +++ b/src/ace_sorting/bubbleSort.h @@ -33,6 +33,14 @@ SOFTWARE. #include "swap.h" +// If set to 1, use the direct inlined implementation of the 2-argument +// bubbleSort(). Otherwise, use the 3-argument bubbleSort() to implement +// 2-argument bubbleSort(). For bubbleSort, the compiler will optimize both +// versions to be identical. +#if ! defined(ACE_SORTING_DIRECT_BUBBLE_SORT) + #define ACE_SORTING_DIRECT_BUBBLE_SORT 0 +#endif + namespace ace_sorting { /** @@ -41,7 +49,7 @@ namespace ace_sorting { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_BUBBLE_SORT template void bubbleSort(T data[], uint16_t n) { bool swapped; diff --git a/src/ace_sorting/combSort.h b/src/ace_sorting/combSort.h index 85c883b..56237b8 100644 --- a/src/ace_sorting/combSort.h +++ b/src/ace_sorting/combSort.h @@ -33,6 +33,14 @@ SOFTWARE. #include "swap.h" +// If set to 1, use the direct inlined implementation of the 2-argument +// combSortXxx(). Otherwise, use the 3-argument combSortXxx() to implement +// 2-argument combSortXxx(). For combSortXxx(), the compiler will optimize both +// versions to be identical. +#if ! defined(ACE_SORTING_DIRECT_COMB_SORT) + #define ACE_SORTING_DIRECT_COMB_SORT 0 +#endif + namespace ace_sorting { /** @@ -46,7 +54,7 @@ namespace ace_sorting { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_COMB_SORT template void combSort13(T data[], uint16_t n) { bool swapped = true; @@ -119,7 +127,7 @@ void combSort13(T data[], uint16_t n, F&& lessThan) { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_COMB_SORT template void combSort13m(T data[], uint16_t n) { bool swapped = true; @@ -211,7 +219,7 @@ void combSort13m(T data[], uint16_t n, F&& lessThan) { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_COMB_SORT template void combSort133(T data[], uint16_t n) { bool swapped = true; @@ -283,7 +291,7 @@ void combSort133(T data[], uint16_t n, F&& lessThan) { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_COMB_SORT template void combSort133m(T data[], uint16_t n) { bool swapped = true; diff --git a/src/ace_sorting/insertionSort.h b/src/ace_sorting/insertionSort.h index 944be48..659dcea 100644 --- a/src/ace_sorting/insertionSort.h +++ b/src/ace_sorting/insertionSort.h @@ -32,6 +32,14 @@ SOFTWARE. #ifndef ACE_SORTING_INSERTION_SORT_H #define ACE_SORTING_INSERTION_SORT_H +// If set to 1, use the direct inlined implementation of the 2-argument +// insertionSort(). Otherwise, use the 3-argument insertionSort() to implement +// 2-argument insertionSort(). For insertionSort(), the compiler will optimize +// both versions to be identical. +#if ! defined(ACE_SORTING_DIRECT_INSERTION_SORT) + #define ACE_SORTING_DIRECT_INSERTION_SORT 0 +#endif + namespace ace_sorting { /** @@ -41,7 +49,7 @@ namespace ace_sorting { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_INSERTION_SORT template void insertionSort(T data[], uint16_t n) { for (uint16_t i = 1; i < n; i++) { diff --git a/src/ace_sorting/quickSort.h b/src/ace_sorting/quickSort.h index 6993f49..78006e5 100644 --- a/src/ace_sorting/quickSort.h +++ b/src/ace_sorting/quickSort.h @@ -34,6 +34,16 @@ SOFTWARE. #include "swap.h" +// If set to 1, use the direct inlined implementation of the 2-argument +// quickSortXxx(). Otherwise, use the 3-argument quickSortXxx() to implement +// 2-argument quickSortXxx(). Unlike other sorting algorithms, the compiler +// cannot seem to optimize away the extra level of indirection, probably due to +// the recursive calls. We save 40 bytes of flash (out of 200-300 bytes) if we +// use the direct inlined version for the 2-argument variant. Set this to 1. +#if ! defined(ACE_SORTING_DIRECT_QUICK_SORT) + #define ACE_SORTING_DIRECT_QUICK_SORT 1 +#endif + namespace ace_sorting { /** @@ -45,7 +55,7 @@ namespace ace_sorting { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_QUICK_SORT template void quickSortMiddle(T data[], uint16_t n) { if (n <= 1) return; @@ -72,8 +82,11 @@ void quickSortMiddle(T data[], uint16_t n) { #else template void quickSortMiddle(T data[], uint16_t n) { - // This lambda expression does not perform any captures, so the compiler will - // optimize and inline the less-than expression. + // This lambda expression does not perform any captures, so the compiler ought + // to be able to optimize and inline the less-than expression. However, the + // optimization does not seem to work, probably because of the recursive call + // into itself. So we set ACE_SORTING_DIRECT_QUICK_SORT=1 to use the direct + // inlined version. auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; quickSortMiddle(data, n, lessThan); } @@ -121,7 +134,7 @@ void quickSortMiddle(T data[], uint16_t n, F&& lessThan) { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_QUICK_SORT template void quickSortMedian(T data[], uint16_t n) { if (n <= 1) return; @@ -225,7 +238,7 @@ void quickSortMedian(T data[], uint16_t n, F&& lessThan) { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_QUICK_SORT template void quickSortMedianSwapped(T data[], uint16_t n) { if (n <= 1) return; diff --git a/src/ace_sorting/selectionSort.h b/src/ace_sorting/selectionSort.h index 0f79113..c283736 100644 --- a/src/ace_sorting/selectionSort.h +++ b/src/ace_sorting/selectionSort.h @@ -36,6 +36,14 @@ SOFTWARE. namespace ace_sorting { +// If set to 1, use the direct inlined implementation of the 2-argument +// selectionSort(). Otherwise, use the 3-argument selectionSort() to implement +// 2-argument selectionSort(). For selectionSort(), the compiler will optimize +// both versions to be identical. +#if ! defined(ACE_SORTING_DIRECT_SELECTION_SORT) + #define ACE_SORTING_DIRECT_SELECTION_SORT 0 +#endif + /** * Selection sort. * Average complexity: O(n^2) @@ -43,7 +51,7 @@ namespace ace_sorting { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_SELECTION_SORT template void selectionSort(T data[], uint16_t n) { for (uint16_t i = 0; i < n; i++) { diff --git a/src/ace_sorting/shellSort.h b/src/ace_sorting/shellSort.h index c9ce68b..c976219 100644 --- a/src/ace_sorting/shellSort.h +++ b/src/ace_sorting/shellSort.h @@ -26,11 +26,20 @@ SOFTWARE. * @file shellSort.h * * Shell sort with different gap algorithms. + * See https://en.wikipedia.org/wiki/Shellsort */ #ifndef ACE_SORTING_SHELL_SORT_H #define ACE_SORTING_SHELL_SORT_H +// If set to 1, use the direct inlined implementation of the 2-argument +// shellSortXxx(). Otherwise, use the 3-argument shellSortXxx() to implement +// 2-argument shellSortXxx(). For shellSortXxx(), the compiler will optimize +// both versions to be identical. +#if ! defined(ACE_SORTING_DIRECT_SHELL_SORT) + #define ACE_SORTING_DIRECT_SHELL_SORT 0 +#endif + namespace ace_sorting { /** @@ -40,7 +49,7 @@ namespace ace_sorting { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_SHELL_SORT template void shellSortClassic(T data[], uint16_t n) { uint16_t gap = n; @@ -119,7 +128,7 @@ void shellSortClassic(T data[], uint16_t n, F&& lessThan) { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_SHELL_SORT template void shellSortKnuth(T data[], uint16_t n) { // Calculate the largest gap using Knuth's formula. If n is a compile-time @@ -210,7 +219,7 @@ void shellSortKnuth(T data[], uint16_t n, F&& lessThan) { * * @tparam T type of data to sort */ -#if defined(ACE_SORTING_DIRECT) +#if ACE_SORTING_DIRECT_SHELL_SORT template void shellSortTokuda(T data[], const uint16_t n) { From 696a6c5dbe0f51ab12a02a1ae3e6ca8237e647f4 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Sun, 22 Aug 2021 15:00:51 -0700 Subject: [PATCH 04/17] MemoryBenchmark: Regenerate with 2-argument versions routing into the 3-argument versions with a default lessThan lambda expression --- examples/MemoryBenchmark/README.md | 23 ++++++++++++++------- examples/MemoryBenchmark/esp8266.txt | 2 +- examples/MemoryBenchmark/generate_readme.py | 7 +++++++ examples/MemoryBenchmark/micro.txt | 2 +- examples/MemoryBenchmark/nano.txt | 2 +- examples/MemoryBenchmark/samd.txt | 4 ++-- examples/MemoryBenchmark/stm32.txt | 2 +- examples/MemoryBenchmark/teensy32.txt | 4 ++-- 8 files changed, 30 insertions(+), 16 deletions(-) diff --git a/examples/MemoryBenchmark/README.md b/examples/MemoryBenchmark/README.md index 75d4b10..8248437 100644 --- a/examples/MemoryBenchmark/README.md +++ b/examples/MemoryBenchmark/README.md @@ -39,6 +39,13 @@ ASCII table. indicates that the `qsort()` function is already compiled into the ESP32 runtime library. +**v0.2+** + +* Add 3-argument version of sorting functions to pass in a comparison predicate, + and route the 2-argument version into the 3-argument version. +* Usually no difference in flash size, as the compiler seems to be able to + inline the lambda expression. In fact, some actually got a few bytes smaller. + ## Arduino Nano * 16MHz ATmega328P @@ -66,7 +73,7 @@ ASCII table. |----------------------------------------+--------------+-------------| | quickSortMiddle() | 1244/ 214 | 178/ 0 | | quickSortMedian() | 1296/ 214 | 230/ 0 | -| quickSortMedianSwapped() | 1344/ 214 | 278/ 0 | +| quickSortMedianSwapped() | 1342/ 214 | 276/ 0 | |----------------------------------------+--------------+-------------| | qsort() | 2150/ 214 | 1084/ 0 | +---------------------------------------------------------------------+ @@ -100,7 +107,7 @@ ASCII table. |----------------------------------------+--------------+-------------| | quickSortMiddle() | 4238/ 354 | 178/ 0 | | quickSortMedian() | 4290/ 354 | 230/ 0 | -| quickSortMedianSwapped() | 4338/ 354 | 278/ 0 | +| quickSortMedianSwapped() | 4336/ 354 | 276/ 0 | |----------------------------------------+--------------+-------------| | qsort() | 5144/ 354 | 1084/ 0 | +---------------------------------------------------------------------+ @@ -119,13 +126,13 @@ ASCII table. |----------------------------------------+--------------+-------------| | Baseline | 10520/ 0 | 0/ 0 | |----------------------------------------+--------------+-------------| -| bubbleSort() | 10568/ 0 | 48/ 0 | +| bubbleSort() | 10560/ 0 | 40/ 0 | | insertionSort() | 10568/ 0 | 48/ 0 | | selectionSort() | 10584/ 0 | 64/ 0 | |----------------------------------------+--------------+-------------| | shellSortClassic() | 10584/ 0 | 64/ 0 | | shellSortKnuth() | 10576/ 0 | 56/ 0 | -| shellSortTokuda() | 10648/ 0 | 128/ 0 | +| shellSortTokuda() | 10640/ 0 | 120/ 0 | |----------------------------------------+--------------+-------------| | combSort13() | 10584/ 0 | 64/ 0 | | combSort13m() | 10600/ 0 | 80/ 0 | @@ -161,7 +168,7 @@ ASCII table. |----------------------------------------+--------------+-------------| | shellSortClassic() | 26884/ 3844 | 64/ 0 | | shellSortKnuth() | 26900/ 3844 | 80/ 0 | -| shellSortTokuda() | 26956/ 3844 | 136/ 0 | +| shellSortTokuda() | 26944/ 3844 | 124/ 0 | |----------------------------------------+--------------+-------------| | combSort13() | 26896/ 3844 | 76/ 0 | | combSort13m() | 26904/ 3844 | 84/ 0 | @@ -195,7 +202,7 @@ ASCII table. |----------------------------------------+--------------+-------------| | shellSortClassic() | 257180/26976 | 80/ 0 | | shellSortKnuth() | 257212/26976 | 112/ 0 | -| shellSortTokuda() | 257256/27004 | 156/ 28 | +| shellSortTokuda() | 257240/27004 | 140/ 28 | |----------------------------------------+--------------+-------------| | combSort13() | 257196/26976 | 96/ 0 | | combSort13m() | 257212/26976 | 112/ 0 | @@ -261,13 +268,13 @@ usage by objects. |----------------------------------------+--------------+-------------| | Baseline | 7116/ 3256 | 0/ 0 | |----------------------------------------+--------------+-------------| -| bubbleSort() | 7144/ 3256 | 28/ 0 | +| bubbleSort() | 7148/ 3256 | 32/ 0 | | insertionSort() | 7172/ 3256 | 56/ 0 | | selectionSort() | 7180/ 3256 | 64/ 0 | |----------------------------------------+--------------+-------------| | shellSortClassic() | 7196/ 3256 | 80/ 0 | | shellSortKnuth() | 7208/ 3256 | 92/ 0 | -| shellSortTokuda() | 7304/ 3256 | 188/ 0 | +| shellSortTokuda() | 7284/ 3256 | 168/ 0 | |----------------------------------------+--------------+-------------| | combSort13() | 7192/ 3256 | 76/ 0 | | combSort13m() | 7204/ 3256 | 88/ 0 | diff --git a/examples/MemoryBenchmark/esp8266.txt b/examples/MemoryBenchmark/esp8266.txt index 20aad2b..cd0e9c2 100644 --- a/examples/MemoryBenchmark/esp8266.txt +++ b/examples/MemoryBenchmark/esp8266.txt @@ -4,7 +4,7 @@ 3 257180 1044464 26976 81920 4 257180 1044464 26976 81920 5 257212 1044464 26976 81920 -6 257256 1044464 27004 81920 +6 257240 1044464 27004 81920 7 257196 1044464 26976 81920 8 257212 1044464 26976 81920 9 257180 1044464 26976 81920 diff --git a/examples/MemoryBenchmark/generate_readme.py b/examples/MemoryBenchmark/generate_readme.py index 59ee7a1..043c483 100755 --- a/examples/MemoryBenchmark/generate_readme.py +++ b/examples/MemoryBenchmark/generate_readme.py @@ -63,6 +63,13 @@ indicates that the `qsort()` function is already compiled into the ESP32 runtime library. +**v0.2+** + +* Add 3-argument version of sorting functions to pass in a comparison predicate, + and route the 2-argument version into the 3-argument version. +* Usually no difference in flash size, as the compiler seems to be able to + inline the lambda expression. In fact, some actually got a few bytes smaller. + ## Arduino Nano * 16MHz ATmega328P diff --git a/examples/MemoryBenchmark/micro.txt b/examples/MemoryBenchmark/micro.txt index ee3ebeb..2babadb 100644 --- a/examples/MemoryBenchmark/micro.txt +++ b/examples/MemoryBenchmark/micro.txt @@ -11,5 +11,5 @@ 10 4188 28672 354 2560 11 4238 28672 354 2560 12 4290 28672 354 2560 -13 4338 28672 354 2560 +13 4336 28672 354 2560 14 5144 28672 354 2560 diff --git a/examples/MemoryBenchmark/nano.txt b/examples/MemoryBenchmark/nano.txt index 4c6cc25..0c60fb2 100644 --- a/examples/MemoryBenchmark/nano.txt +++ b/examples/MemoryBenchmark/nano.txt @@ -11,5 +11,5 @@ 10 1194 30720 214 2048 11 1244 30720 214 2048 12 1296 30720 214 2048 -13 1344 30720 214 2048 +13 1342 30720 214 2048 14 2150 30720 214 2048 diff --git a/examples/MemoryBenchmark/samd.txt b/examples/MemoryBenchmark/samd.txt index 277d53a..a8c7d0e 100644 --- a/examples/MemoryBenchmark/samd.txt +++ b/examples/MemoryBenchmark/samd.txt @@ -1,10 +1,10 @@ 0 10520 262144 -1 10568 262144 +1 10560 262144 2 10568 262144 3 10584 262144 4 10584 262144 5 10576 262144 -6 10648 262144 +6 10640 262144 7 10584 262144 8 10600 262144 9 10576 262144 diff --git a/examples/MemoryBenchmark/stm32.txt b/examples/MemoryBenchmark/stm32.txt index a564471..47f9d2d 100644 --- a/examples/MemoryBenchmark/stm32.txt +++ b/examples/MemoryBenchmark/stm32.txt @@ -4,7 +4,7 @@ 3 26900 131072 3844 20480 4 26884 131072 3844 20480 5 26900 131072 3844 20480 -6 26956 131072 3844 20480 +6 26944 131072 3844 20480 7 26896 131072 3844 20480 8 26904 131072 3844 20480 9 26888 131072 3844 20480 diff --git a/examples/MemoryBenchmark/teensy32.txt b/examples/MemoryBenchmark/teensy32.txt index 54fba26..7938e67 100644 --- a/examples/MemoryBenchmark/teensy32.txt +++ b/examples/MemoryBenchmark/teensy32.txt @@ -1,10 +1,10 @@ 0 7116 262144 3256 65536 -1 7144 262144 3256 65536 +1 7148 262144 3256 65536 2 7172 262144 3256 65536 3 7180 262144 3256 65536 4 7196 262144 3256 65536 5 7208 262144 3256 65536 -6 7304 262144 3256 65536 +6 7284 262144 3256 65536 7 7192 262144 3256 65536 8 7204 262144 3256 65536 9 7172 262144 3256 65536 From da3b1de545c9f4cd446d1c1d62ba43dd9e033d12 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Sun, 22 Aug 2021 16:20:54 -0700 Subject: [PATCH 05/17] examples/HelloSort: Add expected output --- examples/HelloSort/HelloSort.ino | 28 ++++++++++++++++++++++------ examples/HelloSort/Makefile | 1 - 2 files changed, 22 insertions(+), 7 deletions(-) diff --git a/examples/HelloSort/HelloSort.ino b/examples/HelloSort/HelloSort.ino index 48faf93..0590d21 100644 --- a/examples/HelloSort/HelloSort.ino +++ b/examples/HelloSort/HelloSort.ino @@ -1,11 +1,26 @@ /* * Quick demo of one of the sorting functions, in this example, * shellSortKnuth(). All the other sorting algorithms have the exact same - * function signature. First, create an array of integers with random numbers. - * Then sort the array in different ways, including reverse sorting. Print out - * the unsorted and sorted arrays. The compiler is able to infer the type of the - * data, so you don't normally need to specify the template type to the - * shellSortKnuth() function. + * function signature. The compiler is able to infer the type of the data, so + * you don't normally need to specify the template type to the shellSortKnuth() + * function. + * + * Expected output: + * + * Unsorted: 234 19 95 219 255 132 27 194 83 96 245 161 228 205 193 215 101 216 + * 120 95 + * + * Sorted using implicit ascending: 19 27 83 95 95 96 101 120 132 161 193 194 + * 205 215 216 219 228 234 245 255 + * + * Sorted using function pointer: 19 27 83 95 95 96 101 120 132 161 193 194 205 + * 215 216 219 228 234 245 255 + * + * Sorted using lambda expression: 19 27 83 95 95 96 101 120 132 161 193 194 205 + * 215 216 219 228 234 245 255 + * + * Reverse sorted using lambda expression: 255 245 234 228 219 216 215 205 194 + * 193 161 132 120 101 96 95 95 83 27 19 */ #include @@ -13,11 +28,12 @@ using ace_sorting::shellSortKnuth; +// ESP32 does not define SERIAL_PORT_MONITOR #if !defined(SERIAL_PORT_MONITOR) #define SERIAL_PORT_MONITOR Serial #endif -const uint16_t ARRAY_SIZE = 50; +const uint16_t ARRAY_SIZE = 20; int array[ARRAY_SIZE]; // Print given array. diff --git a/examples/HelloSort/Makefile b/examples/HelloSort/Makefile index 79db6d2..10ae8dd 100644 --- a/examples/HelloSort/Makefile +++ b/examples/HelloSort/Makefile @@ -3,5 +3,4 @@ APP_NAME := HelloSort ARDUINO_LIBS := AceSorting -MORE_CLEAN := more_clean include ../../../EpoxyDuino/EpoxyDuino.mk From 8d0a971fa4b9c9569cc33cc1b8781fa68803a4b4 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Sun, 22 Aug 2021 16:21:22 -0700 Subject: [PATCH 06/17] examples/CompoundSortingDemo: Add example of sorting with compound keys --- .../CompoundSortingDemo.ino | 161 ++++++++++++++++++ examples/CompoundSortingDemo/Makefile | 6 + 2 files changed, 167 insertions(+) create mode 100644 examples/CompoundSortingDemo/CompoundSortingDemo.ino create mode 100644 examples/CompoundSortingDemo/Makefile diff --git a/examples/CompoundSortingDemo/CompoundSortingDemo.ino b/examples/CompoundSortingDemo/CompoundSortingDemo.ino new file mode 100644 index 0000000..d7f4423 --- /dev/null +++ b/examples/CompoundSortingDemo/CompoundSortingDemo.ino @@ -0,0 +1,161 @@ +/* + * Demo of a more complex sorting using a compound key and a lambda expression. + * This version uses shellSortKnuth(), but all the other sorting algorithms have + * the exact same function signature. + * + * Expected output: + * + * Unsorted + * -------- + * Michael 3 + * Soren 1 + * Arun 5 + * Meilin 6 + * Emilia 3 + * Dimitri 2 + * Dembe 8 + * Nasir 10 + * Hiromi 9 + * Petra 6 + * + * Sorted by name + * -------------- + * Arun 5 + * Dembe 8 + * Dimitri 2 + * Emilia 3 + * Hiromi 9 + * Meilin 6 + * Michael 3 + * Nasir 10 + * Petra 6 + * Soren 1 + * + * Sorted by (score, name) + * ----------------------- + * Soren 1 + * Dimitri 2 + * Emilia 3 + * Michael 3 + * Arun 5 + * Meilin 6 + * Petra 6 + * Dembe 8 + * Hiromi 9 + * Nasir 10 + */ + +#include // strcmp() +#include +#include + +using ace_sorting::shellSortKnuth; + +// ESP32 does not define SERIAL_PORT_MONITOR +#if ! defined(SERIAL_PORT_MONITOR) + #define SERIAL_PORT_MONITOR Serial +#endif + +// Record of a person's name and score. +struct Record { + const char* name; + int score; +}; + +// List of names and their scores. This table is const so cannot be modified. +// The names and this table could be stored in PROGMEM, but that would +// significantly clutter up the code with type conversions which makes this +// example harder to understand. +const uint16_t ARRAY_SIZE = 10; +const Record RECORDS[ARRAY_SIZE] = { + { "Michael", 3 }, + { "Soren", 1 }, + { "Arun", 5 }, + { "Meilin", 6 }, + { "Emilia", 3 }, + { "Dimitri", 2 }, + { "Dembe", 8 }, + { "Nasir", 10 }, + { "Hiromi", 9 }, + { "Petra", 6 }, +}; + +// Print the records given an array of pointers to Record. +void printRecords(const Record* const records[], uint16_t arraySize) { + for (uint16_t i = 0; i < arraySize; i++) { + const Record* record = records[i]; + SERIAL_PORT_MONITOR.print(record->name); + SERIAL_PORT_MONITOR.print(' '); + SERIAL_PORT_MONITOR.print(record->score); + SERIAL_PORT_MONITOR.println(); + } +} + +// Fill the recordPtrs[] array with the pointers to RECORDS[]. The original +// RECORDS[] is immutable, so we need a helper array to perform the sorting. +void fillRecordPointers(const Record* recordPtrs[], uint16_t arraySize) { + for (uint16_t i = 0; i < arraySize; i++) { + recordPtrs[i] = &RECORDS[i]; + } +} + +// Predicate that returns true if Record 'a' is less than Record 'b' by first +// looking at the 'score', then using 'name' to break the tie on score. +bool sortByScoreThenName(const Record* a, const Record* b) { + if (a->score < b->score) { + return true; + } else if (a->score > b->score) { + return false; + } else { + return strcmp(a->name, b->name) < 0; + } +} + +//----------------------------------------------------------------------------- + +void setup() { +#if ! defined(EPOXY_DUINO) + delay(1000); +#endif + + SERIAL_PORT_MONITOR.begin(115200); + while (!SERIAL_PORT_MONITOR); // Leonardo/Micro + + const Record* recordPtrs[ARRAY_SIZE]; + fillRecordPointers(recordPtrs, ARRAY_SIZE); + + // Print original ordering. + SERIAL_PORT_MONITOR.println(F("Unsorted")); + SERIAL_PORT_MONITOR.println(F("--------")); + printRecords(recordPtrs, ARRAY_SIZE); + SERIAL_PORT_MONITOR.println(); + + // Sort by name. Use an inline lambda expression because the predicate is + // very short. + SERIAL_PORT_MONITOR.println(F("Sorted by name")); + SERIAL_PORT_MONITOR.println(F("--------------")); + shellSortKnuth( + recordPtrs, + ARRAY_SIZE, + [](const Record* a, const Record* b) { + return strcmp(a->name, b->name) < 0; + } + ); + printRecords(recordPtrs, ARRAY_SIZE); + SERIAL_PORT_MONITOR.println(); + + // Sort by score then name. Use a helper function for readability because the + // predicate is more complex, but an inlined lambda expression would work + // perfectly fine. + SERIAL_PORT_MONITOR.println(F("Sorted by (score, name)")); + SERIAL_PORT_MONITOR.println(F("-----------------------")); + shellSortKnuth(recordPtrs, ARRAY_SIZE, sortByScoreThenName); + printRecords(recordPtrs, ARRAY_SIZE); + SERIAL_PORT_MONITOR.println(); + +#if defined(EPOXY_DUINO) + exit(0); +#endif +} + +void loop() {} diff --git a/examples/CompoundSortingDemo/Makefile b/examples/CompoundSortingDemo/Makefile new file mode 100644 index 0000000..96f0560 --- /dev/null +++ b/examples/CompoundSortingDemo/Makefile @@ -0,0 +1,6 @@ +# See https://github.com/bxparks/EpoxyDuino for documentation about using +# EpoxyDuino to compile and run AUnit tests natively on Linux or MacOS. + +APP_NAME := CompoundSortingDemo +ARDUINO_LIBS := AceSorting +include ../../../EpoxyDuino/EpoxyDuino.mk From daf956f7b5f6c43b4ae025484a57af9e02837aa7 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Sun, 22 Aug 2021 17:31:47 -0700 Subject: [PATCH 07/17] AutoBenchmark: Regenerate with 2-argument versions routing into the 3-argument versions with a default lessThan lambda expression --- examples/AutoBenchmark/README.md | 199 +++++++++++----------- examples/AutoBenchmark/esp32.txt | 158 ++++++++--------- examples/AutoBenchmark/esp8266.txt | 130 +++++++------- examples/AutoBenchmark/generate_readme.py | 5 + examples/AutoBenchmark/micro.txt | 112 ++++++------ examples/AutoBenchmark/nano.txt | 112 ++++++------ examples/AutoBenchmark/samd.txt | 160 ++++++++--------- examples/AutoBenchmark/stm32.txt | 162 +++++++++--------- examples/AutoBenchmark/teensy32.txt | 148 ++++++++-------- 9 files changed, 598 insertions(+), 588 deletions(-) diff --git a/examples/AutoBenchmark/README.md b/examples/AutoBenchmark/README.md index dfc2896..c72b26f 100644 --- a/examples/AutoBenchmark/README.md +++ b/examples/AutoBenchmark/README.md @@ -54,6 +54,11 @@ $ make README.md * The C-library `qsort()` is far slower than the C++ version because it uses a callback to a comparison function through a function pointer. +**v0.2+** + +* No performance change after rerouting 2-argument sorting functions into + the 3-argument versions using a default lambda expression. + ## Results The following results show the runtime of each sorting function in milliseconds, @@ -71,24 +76,24 @@ when sorting different array sizes. | \ N | 10 | 30 | 100 | 300 | 1000 | 3000 | | Function \ | | | | | | | |---------------------+-------+-------+--------+---------+---------+---------| -| bubbleSort() | 0.107 | 1.077 | 12.735 | 116.675 | | | -| insertionSort() | 0.045 | 0.263 | 2.557 | 22.252 | | | -| selectionSort() | 0.088 | 0.560 | 5.600 | 48.892 | | | +| bubbleSort() | 0.099 | 1.044 | 12.305 | 118.589 | | | +| insertionSort() | 0.049 | 0.251 | 2.463 | 21.288 | | | +| selectionSort() | 0.087 | 0.553 | 5.365 | 46.275 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| shellSortClassic() | 0.074 | 0.310 | 1.706 | 6.865 | | | -| shellSortKnuth() | 0.101 | 0.330 | 1.450 | 5.665 | | | -| shellSortTokuda() | 0.075 | 0.327 | 1.614 | 6.540 | | | +| shellSortClassic() | 0.074 | 0.306 | 1.711 | 6.868 | | | +| shellSortKnuth() | 0.100 | 0.325 | 1.431 | 5.683 | | | +| shellSortTokuda() | 0.075 | 0.336 | 1.616 | 6.555 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| combSort13() | 0.160 | 0.534 | 2.214 | 8.167 | | | -| combSort13m() | 0.165 | 0.550 | 2.219 | 8.181 | | | -| combSort133() | 0.086 | 0.396 | 1.944 | 7.702 | | | -| combSort133m() | 0.086 | 0.416 | 1.978 | 7.740 | | | +| combSort13() | 0.167 | 0.534 | 2.215 | 8.260 | | | +| combSort13m() | 0.164 | 0.557 | 2.233 | 8.176 | | | +| combSort133() | 0.084 | 0.400 | 1.968 | 7.730 | | | +| combSort133m() | 0.087 | 0.419 | 1.979 | 7.805 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| quickSortMiddle() | 0.096 | 0.368 | 1.568 | 5.651 | | | -| quickSortMedian() | 0.117 | 0.431 | 1.717 | 5.905 | | | -| quickSortMdnSwppd() | 0.094 | 0.341 | 1.417 | 4.909 | | | +| quickSortMiddle() | 0.097 | 0.373 | 1.582 | 5.536 | | | +| quickSortMedian() | 0.117 | 0.423 | 1.717 | 5.905 | | | +| quickSortMdnSwppd() | 0.092 | 0.338 | 1.396 | 4.895 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| qsort() | 0.204 | 0.855 | 3.629 | 13.021 | | | +| qsort() | 0.208 | 0.827 | 3.642 | 13.068 | | | +---------------------+-------+-------+--------+---------+---------+---------+ ``` @@ -105,24 +110,24 @@ when sorting different array sizes. | \ N | 10 | 30 | 100 | 300 | 1000 | 3000 | | Function \ | | | | | | | |---------------------+-------+-------+--------+---------+---------+---------| -| bubbleSort() | 0.115 | 1.083 | 12.773 | 121.179 | | | -| insertionSort() | 0.041 | 0.291 | 2.527 | 21.032 | | | -| selectionSort() | 0.081 | 0.561 | 5.632 | 49.153 | | | +| bubbleSort() | 0.091 | 1.136 | 12.908 | 120.933 | | | +| insertionSort() | 0.048 | 0.271 | 2.652 | 22.188 | | | +| selectionSort() | 0.084 | 0.556 | 5.391 | 46.513 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| shellSortClassic() | 0.074 | 0.310 | 1.712 | 6.912 | | | -| shellSortKnuth() | 0.101 | 0.339 | 1.445 | 5.601 | | | -| shellSortTokuda() | 0.076 | 0.337 | 1.634 | 6.588 | | | +| shellSortClassic() | 0.075 | 0.314 | 1.730 | 6.950 | | | +| shellSortKnuth() | 0.100 | 0.330 | 1.455 | 5.634 | | | +| shellSortTokuda() | 0.075 | 0.337 | 1.645 | 6.555 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| combSort13() | 0.165 | 0.537 | 2.209 | 8.215 | | | -| combSort13m() | 0.164 | 0.557 | 2.219 | 8.134 | | | -| combSort133() | 0.086 | 0.389 | 1.996 | 7.767 | | | -| combSort133m() | 0.091 | 0.423 | 1.997 | 7.729 | | | +| combSort13() | 0.162 | 0.538 | 2.234 | 8.211 | | | +| combSort13m() | 0.164 | 0.559 | 2.266 | 8.232 | | | +| combSort133() | 0.088 | 0.390 | 1.996 | 7.672 | | | +| combSort133m() | 0.087 | 0.424 | 1.993 | 7.763 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| quickSortMiddle() | 0.099 | 0.375 | 1.619 | 5.711 | | | -| quickSortMedian() | 0.119 | 0.427 | 1.748 | 5.976 | | | -| quickSortMdnSwppd() | 0.094 | 0.341 | 1.401 | 4.974 | | | +| quickSortMiddle() | 0.098 | 0.372 | 1.617 | 5.667 | | | +| quickSortMedian() | 0.116 | 0.432 | 1.720 | 5.956 | | | +| quickSortMdnSwppd() | 0.090 | 0.345 | 1.391 | 4.914 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| qsort() | 0.200 | 0.839 | 3.661 | 12.974 | | | +| qsort() | 0.202 | 0.900 | 3.674 | 13.046 | | | +---------------------+-------+-------+--------+---------+---------+---------+ ``` @@ -138,24 +143,24 @@ when sorting different array sizes. | \ N | 10 | 30 | 100 | 300 | 1000 | 3000 | | Function \ | | | | | | | |---------------------+-------+-------+--------+---------+---------+---------| -| bubbleSort() | 0.039 | 0.357 | 3.984 | 36.967 | 429.557 | | -| insertionSort() | 0.014 | 0.095 | 0.880 | 8.132 | 87.197 | | -| selectionSort() | 0.023 | 0.159 | 1.620 | 14.279 | 157.547 | | +| bubbleSort() | 0.031 | 0.282 | 3.405 | 32.272 | 363.409 | | +| insertionSort() | 0.016 | 0.088 | 0.941 | 8.144 | 89.678 | | +| selectionSort() | 0.024 | 0.162 | 1.629 | 14.306 | 157.639 | | |---------------------+-------+-------+--------+---------+---------+---------| -| shellSortClassic() | 0.016 | 0.064 | 0.349 | 1.405 | 5.861 | 22.452 | -| shellSortKnuth() | 0.019 | 0.067 | 0.289 | 1.153 | 5.111 | 19.448 | -| shellSortTokuda() | 0.020 | 0.081 | 0.390 | 1.556 | 6.673 | 24.187 | +| shellSortClassic() | 0.016 | 0.064 | 0.349 | 1.408 | 5.912 | 22.251 | +| shellSortKnuth() | 0.019 | 0.065 | 0.298 | 1.154 | 5.074 | 19.321 | +| shellSortTokuda() | 0.019 | 0.081 | 0.390 | 1.568 | 6.690 | 24.190 | |---------------------+-------+-------+--------+---------+---------+---------| -| combSort13() | 0.035 | 0.118 | 0.496 | 1.859 | 8.180 | 29.661 | -| combSort13m() | 0.035 | 0.124 | 0.512 | 1.882 | 7.892 | 28.483 | -| combSort133() | 0.020 | 0.090 | 0.454 | 1.764 | 7.897 | 26.989 | -| combSort133m() | 0.021 | 0.097 | 0.454 | 1.752 | 7.623 | 27.649 | +| combSort13() | 0.035 | 0.121 | 0.532 | 1.934 | 8.697 | 31.638 | +| combSort13m() | 0.036 | 0.128 | 0.534 | 1.931 | 8.274 | 29.531 | +| combSort133() | 0.021 | 0.090 | 0.452 | 1.825 | 8.259 | 28.640 | +| combSort133m() | 0.021 | 0.100 | 0.470 | 1.822 | 7.949 | 28.592 | |---------------------+-------+-------+--------+---------+---------+---------| -| quickSortMiddle() | 0.021 | 0.073 | 0.315 | 1.077 | 4.211 | 14.031 | -| quickSortMedian() | 0.026 | 0.088 | 0.344 | 1.161 | 4.343 | 14.455 | -| quickSortMdnSwppd() | 0.020 | 0.070 | 0.285 | 1.001 | 3.783 | 12.630 | +| quickSortMiddle() | 0.022 | 0.077 | 0.312 | 1.097 | 4.246 | 14.192 | +| quickSortMedian() | 0.026 | 0.088 | 0.338 | 1.158 | 4.387 | 14.495 | +| quickSortMdnSwppd() | 0.020 | 0.069 | 0.281 | 0.980 | 3.720 | 12.486 | |---------------------+-------+-------+--------+---------+---------+---------| -| qsort() | 0.054 | 0.213 | 0.886 | 3.215 | 12.678 | 42.791 | +| qsort() | 0.052 | 0.204 | 0.873 | 3.088 | 12.102 | 41.217 | +---------------------+-------+-------+--------+---------+---------+---------+ ``` @@ -171,24 +176,24 @@ when sorting different array sizes. | \ N | 10 | 30 | 100 | 300 | 1000 | 3000 | | Function \ | | | | | | | |---------------------+-------+-------+--------+---------+---------+---------| -| bubbleSort() | 0.018 | 0.161 | 2.105 | 19.955 | 225.639 | | -| insertionSort() | 0.010 | 0.054 | 0.495 | 4.486 | 48.616 | | -| selectionSort() | 0.017 | 0.116 | 1.167 | 10.197 | 112.180 | | +| bubbleSort() | 0.022 | 0.169 | 2.156 | 20.662 | 230.118 | | +| insertionSort() | 0.009 | 0.054 | 0.488 | 4.278 | 45.077 | | +| selectionSort() | 0.016 | 0.102 | 1.023 | 8.931 | 98.184 | | |---------------------+-------+-------+--------+---------+---------+---------| -| shellSortClassic() | 0.014 | 0.058 | 0.324 | 1.284 | 5.427 | 20.852 | -| shellSortKnuth() | 0.014 | 0.059 | 0.305 | 1.236 | 5.604 | 21.566 | -| shellSortTokuda() | 0.011 | 0.047 | 0.226 | 0.901 | 3.904 | 14.199 | +| shellSortClassic() | 0.014 | 0.057 | 0.305 | 1.243 | 5.157 | 19.747 | +| shellSortKnuth() | 0.013 | 0.057 | 0.276 | 1.131 | 5.058 | 19.403 | +| shellSortTokuda() | 0.012 | 0.048 | 0.226 | 0.905 | 3.888 | 14.123 | |---------------------+-------+-------+--------+---------+---------+---------| -| combSort13() | 0.019 | 0.087 | 0.442 | 1.770 | 7.895 | 28.862 | -| combSort13m() | 0.018 | 0.087 | 0.430 | 1.697 | 7.380 | 26.657 | -| combSort133() | 0.018 | 0.085 | 0.417 | 1.649 | 7.630 | 26.148 | -| combSort133m() | 0.019 | 0.089 | 0.419 | 1.619 | 7.151 | 25.380 | +| combSort13() | 0.017 | 0.080 | 0.396 | 1.601 | 7.173 | 26.248 | +| combSort13m() | 0.018 | 0.084 | 0.416 | 1.585 | 6.998 | 25.575 | +| combSort133() | 0.016 | 0.073 | 0.378 | 1.481 | 6.775 | 22.826 | +| combSort133m() | 0.017 | 0.080 | 0.382 | 1.496 | 6.436 | 23.289 | |---------------------+-------+-------+--------+---------+---------+---------| -| quickSortMiddle() | 0.019 | 0.067 | 0.278 | 0.990 | 3.835 | 13.145 | -| quickSortMedian() | 0.020 | 0.076 | 0.311 | 1.101 | 4.212 | 14.381 | -| quickSortMdnSwppd() | 0.015 | 0.056 | 0.228 | 0.836 | 3.285 | 11.265 | +| quickSortMiddle() | 0.017 | 0.064 | 0.260 | 0.941 | 3.559 | 12.330 | +| quickSortMedian() | 0.020 | 0.070 | 0.280 | 0.994 | 3.769 | 12.632 | +| quickSortMdnSwppd() | 0.015 | 0.056 | 0.236 | 0.855 | 3.318 | 11.345 | |---------------------+-------+-------+--------+---------+---------+---------| -| qsort() | 0.034 | 0.149 | 0.615 | 2.221 | 8.921 | 30.627 | +| qsort() | 0.033 | 0.132 | 0.609 | 2.251 | 8.882 | 30.578 | +---------------------+-------+-------+--------+---------+---------+---------+ ``` @@ -204,24 +209,24 @@ when sorting different array sizes. | \ N | 10 | 30 | 100 | 300 | 1000 | 3000 | | Function \ | | | | | | | |---------------------+-------+-------+--------+---------+---------+---------| -| bubbleSort() | 0.021 | 0.192 | 2.231 | 20.143 | 225.651 | | -| insertionSort() | 0.009 | 0.037 | 0.362 | 3.220 | 34.646 | | -| selectionSort() | 0.017 | 0.085 | 0.892 | 7.930 | 87.723 | | +| bubbleSort() | 0.022 | 0.181 | 2.116 | 19.118 | 213.942 | | +| insertionSort() | 0.011 | 0.037 | 0.361 | 3.222 | 34.652 | | +| selectionSort() | 0.017 | 0.092 | 0.961 | 8.500 | 93.980 | | |---------------------+-------+-------+--------+---------+---------+---------| -| shellSortClassic() | 0.011 | 0.039 | 0.215 | 0.878 | 3.609 | 13.789 | -| shellSortKnuth() | 0.010 | 0.036 | 0.172 | 0.690 | 3.022 | 11.304 | -| shellSortTokuda() | 0.009 | 0.039 | 0.183 | 0.735 | 3.140 | 11.366 | +| shellSortClassic() | 0.010 | 0.039 | 0.215 | 0.878 | 3.610 | 13.789 | +| shellSortKnuth() | 0.010 | 0.036 | 0.172 | 0.690 | 3.021 | 11.306 | +| shellSortTokuda() | 0.009 | 0.040 | 0.188 | 0.756 | 3.227 | 11.678 | |---------------------+-------+-------+--------+---------+---------+---------| -| combSort13() | 0.013 | 0.048 | 0.219 | 0.846 | 3.711 | 13.689 | -| combSort13m() | 0.014 | 0.051 | 0.222 | 0.840 | 3.622 | 13.104 | +| combSort13() | 0.013 | 0.048 | 0.219 | 0.846 | 3.712 | 13.695 | +| combSort13m() | 0.013 | 0.051 | 0.223 | 0.840 | 3.625 | 13.102 | | combSort133() | 0.010 | 0.040 | 0.208 | 0.796 | 3.571 | 12.430 | -| combSort133m() | 0.010 | 0.044 | 0.206 | 0.793 | 3.465 | 12.387 | +| combSort133m() | 0.010 | 0.045 | 0.206 | 0.793 | 3.466 | 12.387 | |---------------------+-------+-------+--------+---------+---------+---------| -| quickSortMiddle() | 0.013 | 0.045 | 0.185 | 0.651 | 2.519 | 8.307 | -| quickSortMedian() | 0.016 | 0.052 | 0.200 | 0.677 | 2.551 | 8.403 | -| quickSortMdnSwppd() | 0.012 | 0.039 | 0.159 | 0.558 | 2.122 | 7.109 | +| quickSortMiddle() | 0.013 | 0.045 | 0.185 | 0.650 | 2.518 | 8.303 | +| quickSortMedian() | 0.016 | 0.052 | 0.203 | 0.684 | 2.574 | 8.470 | +| quickSortMdnSwppd() | 0.012 | 0.039 | 0.160 | 0.560 | 2.128 | 7.129 | |---------------------+-------+-------+--------+---------+---------+---------| -| qsort() | 0.028 | 0.092 | 0.416 | 1.516 | 6.010 | 20.789 | +| qsort() | 0.027 | 0.092 | 0.417 | 1.515 | 6.009 | 20.782 | +---------------------+-------+-------+--------+---------+---------+---------+ ``` @@ -237,24 +242,24 @@ when sorting different array sizes. | \ N | 10 | 30 | 100 | 300 | 1000 | 3000 | | Function \ | | | | | | | |---------------------+-------+-------+--------+---------+---------+---------| -| bubbleSort() | 0.006 | 0.049 | 0.622 | 5.704 | 63.678 | | -| insertionSort() | 0.004 | 0.017 | 0.157 | 1.295 | 15.081 | | -| selectionSort() | 0.005 | 0.032 | 0.341 | 3.035 | 33.618 | | +| bubbleSort() | 0.006 | 0.057 | 0.626 | 5.670 | 64.461 | | +| insertionSort() | 0.004 | 0.017 | 0.156 | 1.285 | 14.827 | | +| selectionSort() | 0.006 | 0.030 | 0.304 | 2.671 | 29.458 | | |---------------------+-------+-------+--------+---------+---------+---------| -| shellSortClassic() | 0.004 | 0.014 | 0.077 | 0.302 | 1.283 | 4.861 | -| shellSortKnuth() | 0.004 | 0.013 | 0.062 | 0.247 | 1.110 | 4.155 | -| shellSortTokuda() | 0.004 | 0.014 | 0.065 | 0.263 | 1.115 | 4.034 | +| shellSortClassic() | 0.004 | 0.014 | 0.076 | 0.304 | 1.277 | 4.899 | +| shellSortKnuth() | 0.004 | 0.013 | 0.062 | 0.245 | 1.102 | 4.205 | +| shellSortTokuda() | 0.004 | 0.014 | 0.064 | 0.261 | 1.114 | 4.029 | |---------------------+-------+-------+--------+---------+---------+---------| -| combSort13() | 0.005 | 0.019 | 0.095 | 0.377 | 1.688 | 6.257 | -| combSort13m() | 0.005 | 0.020 | 0.097 | 0.373 | 1.641 | 5.996 | -| combSort133() | 0.005 | 0.019 | 0.091 | 0.365 | 1.644 | 5.650 | -| combSort133m() | 0.005 | 0.021 | 0.096 | 0.368 | 1.599 | 5.661 | +| combSort13() | 0.005 | 0.019 | 0.095 | 0.376 | 1.704 | 6.222 | +| combSort13m() | 0.006 | 0.020 | 0.098 | 0.381 | 1.640 | 5.996 | +| combSort133() | 0.005 | 0.019 | 0.093 | 0.368 | 1.649 | 5.668 | +| combSort133m() | 0.005 | 0.021 | 0.095 | 0.360 | 1.588 | 5.684 | |---------------------+-------+-------+--------+---------+---------+---------| -| quickSortMiddle() | 0.005 | 0.018 | 0.070 | 0.249 | 0.975 | 3.346 | -| quickSortMedian() | 0.006 | 0.018 | 0.072 | 0.255 | 0.967 | 3.249 | -| quickSortMdnSwppd() | 0.004 | 0.014 | 0.059 | 0.211 | 0.826 | 2.803 | +| quickSortMiddle() | 0.005 | 0.017 | 0.071 | 0.252 | 0.987 | 3.427 | +| quickSortMedian() | 0.006 | 0.018 | 0.073 | 0.255 | 0.969 | 3.263 | +| quickSortMdnSwppd() | 0.004 | 0.014 | 0.059 | 0.209 | 0.815 | 2.804 | |---------------------+-------+-------+--------+---------+---------+---------| -| qsort() | 0.008 | 0.032 | 0.143 | 0.524 | 2.099 | 7.221 | +| qsort() | 0.008 | 0.033 | 0.144 | 0.522 | 2.131 | 7.245 | +---------------------+-------+-------+--------+---------+---------+---------+ ``` @@ -271,24 +276,24 @@ when sorting different array sizes. | \ N | 10 | 30 | 100 | 300 | 1000 | 3000 | | Function \ | | | | | | | |---------------------+-------+-------+--------+---------+---------+---------| -| bubbleSort() | 0.009 | 0.079 | 0.824 | 8.469 | 98.471 | | -| insertionSort() | 0.006 | 0.041 | 0.394 | 3.390 | 36.820 | | -| selectionSort() | 0.008 | 0.057 | 0.590 | 5.215 | 57.558 | | +| bubbleSort() | 0.009 | 0.083 | 0.945 | 9.217 | 102.362 | | +| insertionSort() | 0.005 | 0.040 | 0.399 | 3.290 | 36.427 | | +| selectionSort() | 0.009 | 0.065 | 0.653 | 5.715 | 62.889 | | |---------------------+-------+-------+--------+---------+---------+---------| -| shellSortClassic() | 0.007 | 0.029 | 0.162 | 0.648 | 2.712 | 10.394 | -| shellSortKnuth() | 0.006 | 0.027 | 0.133 | 0.531 | 2.339 | 8.903 | -| shellSortTokuda() | 0.007 | 0.028 | 0.136 | 0.539 | 2.314 | 8.366 | +| shellSortClassic() | 0.007 | 0.029 | 0.159 | 0.648 | 2.694 | 10.372 | +| shellSortKnuth() | 0.006 | 0.027 | 0.131 | 0.526 | 2.345 | 8.972 | +| shellSortTokuda() | 0.007 | 0.028 | 0.135 | 0.539 | 2.312 | 8.365 | |---------------------+-------+-------+--------+---------+---------+---------| -| combSort13() | 0.008 | 0.036 | 0.182 | 0.722 | 3.233 | 11.887 | -| combSort13m() | 0.008 | 0.038 | 0.186 | 0.725 | 3.139 | 11.431 | -| combSort133() | 0.008 | 0.035 | 0.174 | 0.698 | 3.101 | 10.902 | -| combSort133m() | 0.008 | 0.038 | 0.180 | 0.710 | 3.030 | 10.801 | +| combSort13() | 0.008 | 0.037 | 0.182 | 0.720 | 3.234 | 11.948 | +| combSort13m() | 0.008 | 0.038 | 0.182 | 0.721 | 3.146 | 11.470 | +| combSort133() | 0.008 | 0.035 | 0.175 | 0.693 | 3.142 | 10.841 | +| combSort133m() | 0.008 | 0.038 | 0.179 | 0.700 | 3.037 | 10.841 | |---------------------+-------+-------+--------+---------+---------+---------| -| quickSortMiddle() | 0.007 | 0.026 | 0.109 | 0.388 | 1.520 | 5.278 | -| quickSortMedian() | 0.009 | 0.030 | 0.122 | 0.423 | 1.590 | 5.387 | -| quickSortMdnSwppd() | 0.007 | 0.025 | 0.100 | 0.365 | 1.412 | 4.752 | +| quickSortMiddle() | 0.007 | 0.026 | 0.108 | 0.399 | 1.543 | 5.324 | +| quickSortMedian() | 0.009 | 0.030 | 0.122 | 0.414 | 1.598 | 5.353 | +| quickSortMdnSwppd() | 0.007 | 0.025 | 0.103 | 0.357 | 1.403 | 4.750 | |---------------------+-------+-------+--------+---------+---------+---------| -| qsort() | 0.017 | 0.073 | 0.315 | 1.156 | 4.576 | 15.732 | +| qsort() | 0.017 | 0.071 | 0.317 | 1.154 | 4.579 | 15.830 | +---------------------+-------+-------+--------+---------+---------+---------+ ``` diff --git a/examples/AutoBenchmark/esp32.txt b/examples/AutoBenchmark/esp32.txt index 07495aa..49da306 100644 --- a/examples/AutoBenchmark/esp32.txt +++ b/examples/AutoBenchmark/esp32.txt @@ -1,83 +1,83 @@ BENCHMARKS -bubbleSort() 10 0.004 0.006 0.008 3 -bubbleSort() 30 0.039 0.049 0.057 3 -bubbleSort() 100 0.592 0.622 0.640 3 -bubbleSort() 300 5.452 5.704 5.860 3 -bubbleSort() 1000 62.985 63.678 64.192 3 -insertionSort() 10 0.002 0.004 0.006 3 -insertionSort() 30 0.015 0.017 0.018 3 -insertionSort() 100 0.143 0.157 0.173 3 -insertionSort() 300 1.263 1.295 1.343 3 -insertionSort() 1000 14.992 15.081 15.257 3 -selectionSort() 10 0.004 0.005 0.007 3 -selectionSort() 30 0.032 0.032 0.033 3 -selectionSort() 100 0.338 0.341 0.346 3 -selectionSort() 300 3.035 3.035 3.035 3 -selectionSort() 1000 33.613 33.618 33.620 3 -shellSortClassic() 10 0.003 0.004 0.006 20 -shellSortClassic() 30 0.013 0.014 0.016 20 -shellSortClassic() 100 0.071 0.077 0.087 20 -shellSortClassic() 300 0.294 0.302 0.318 20 -shellSortClassic() 1000 1.250 1.283 1.347 20 -shellSortClassic() 3000 4.675 4.861 5.049 20 -shellSortKnuth() 10 0.003 0.004 0.008 20 -shellSortKnuth() 30 0.011 0.013 0.015 20 -shellSortKnuth() 100 0.058 0.062 0.070 20 -shellSortKnuth() 300 0.236 0.247 0.259 20 -shellSortKnuth() 1000 1.067 1.110 1.203 20 -shellSortKnuth() 3000 3.935 4.155 4.279 20 -shellSortTokuda() 10 0.003 0.004 0.008 20 -shellSortTokuda() 30 0.013 0.014 0.023 20 -shellSortTokuda() 100 0.062 0.065 0.075 20 -shellSortTokuda() 300 0.255 0.263 0.274 20 -shellSortTokuda() 1000 1.100 1.115 1.144 20 -shellSortTokuda() 3000 4.003 4.034 4.061 20 -combSort13() 10 0.004 0.005 0.008 20 -combSort13() 30 0.018 0.019 0.021 20 -combSort13() 100 0.092 0.095 0.100 20 -combSort13() 300 0.358 0.377 0.410 20 -combSort13() 1000 1.571 1.688 1.789 20 -combSort13() 3000 5.826 6.257 6.734 20 -combSort13m() 10 0.003 0.005 0.008 20 -combSort13m() 30 0.020 0.020 0.022 20 -combSort13m() 100 0.092 0.097 0.107 20 -combSort13m() 300 0.358 0.373 0.389 20 -combSort13m() 1000 1.565 1.641 1.714 20 -combSort13m() 3000 5.827 5.996 6.053 20 -combSort133() 10 0.004 0.005 0.008 20 +bubbleSort() 10 0.004 0.006 0.009 3 +bubbleSort() 30 0.052 0.057 0.060 3 +bubbleSort() 100 0.605 0.626 0.666 3 +bubbleSort() 300 5.372 5.670 5.840 3 +bubbleSort() 1000 62.177 64.461 65.873 3 +insertionSort() 10 0.003 0.004 0.007 3 +insertionSort() 30 0.014 0.017 0.022 3 +insertionSort() 100 0.145 0.156 0.166 3 +insertionSort() 300 1.277 1.285 1.290 3 +insertionSort() 1000 14.567 14.827 15.048 3 +selectionSort() 10 0.004 0.006 0.008 3 +selectionSort() 30 0.029 0.030 0.030 3 +selectionSort() 100 0.301 0.304 0.309 3 +selectionSort() 300 2.671 2.671 2.672 3 +selectionSort() 1000 29.455 29.458 29.463 3 +shellSortClassic() 10 0.003 0.004 0.007 20 +shellSortClassic() 30 0.013 0.014 0.015 20 +shellSortClassic() 100 0.069 0.076 0.082 20 +shellSortClassic() 300 0.295 0.304 0.323 20 +shellSortClassic() 1000 1.243 1.277 1.339 20 +shellSortClassic() 3000 4.709 4.899 5.132 20 +shellSortKnuth() 10 0.003 0.004 0.007 20 +shellSortKnuth() 30 0.012 0.013 0.016 20 +shellSortKnuth() 100 0.059 0.062 0.066 20 +shellSortKnuth() 300 0.235 0.245 0.255 20 +shellSortKnuth() 1000 1.065 1.102 1.179 20 +shellSortKnuth() 3000 3.994 4.205 4.379 20 +shellSortTokuda() 10 0.003 0.004 0.010 20 +shellSortTokuda() 30 0.013 0.014 0.015 20 +shellSortTokuda() 100 0.061 0.064 0.072 20 +shellSortTokuda() 300 0.250 0.261 0.268 20 +shellSortTokuda() 1000 1.097 1.114 1.136 20 +shellSortTokuda() 3000 3.985 4.029 4.075 20 +combSort13() 10 0.004 0.005 0.007 20 +combSort13() 30 0.018 0.019 0.022 20 +combSort13() 100 0.092 0.095 0.107 20 +combSort13() 300 0.358 0.376 0.403 20 +combSort13() 1000 1.564 1.704 1.864 20 +combSort13() 3000 5.819 6.222 6.509 20 +combSort13m() 10 0.004 0.006 0.013 20 +combSort13m() 30 0.020 0.020 0.023 20 +combSort13m() 100 0.092 0.098 0.107 20 +combSort13m() 300 0.358 0.381 0.411 20 +combSort13m() 1000 1.572 1.640 1.722 20 +combSort13m() 3000 5.827 5.996 6.277 20 +combSort133() 10 0.004 0.005 0.007 20 combSort133() 30 0.018 0.019 0.021 20 -combSort133() 100 0.085 0.091 0.108 20 -combSort133() 300 0.341 0.365 0.409 20 -combSort133() 1000 1.519 1.644 1.812 20 -combSort133() 3000 5.442 5.650 6.125 20 -combSort133m() 10 0.004 0.005 0.007 20 +combSort133() 100 0.085 0.093 0.123 20 +combSort133() 300 0.342 0.368 0.394 20 +combSort133() 1000 1.513 1.649 1.819 20 +combSort133() 3000 5.442 5.668 5.899 20 +combSort133m() 10 0.004 0.005 0.008 20 combSort133m() 30 0.020 0.021 0.028 20 -combSort133m() 100 0.092 0.096 0.108 20 -combSort133m() 300 0.341 0.368 0.394 20 -combSort133m() 1000 1.587 1.599 1.670 20 -combSort133m() 3000 5.442 5.661 6.350 20 -quickSortMiddle() 10 0.004 0.005 0.008 20 -quickSortMiddle() 30 0.014 0.018 0.027 20 -quickSortMiddle() 100 0.062 0.070 0.083 20 -quickSortMiddle() 300 0.218 0.249 0.296 20 -quickSortMiddle() 1000 0.886 0.975 1.064 20 -quickSortMiddle() 3000 3.149 3.346 3.712 20 -quickSortMedian() 10 0.005 0.006 0.010 20 -quickSortMedian() 30 0.016 0.018 0.020 20 -quickSortMedian() 100 0.068 0.072 0.083 20 -quickSortMedian() 300 0.235 0.255 0.271 20 -quickSortMedian() 1000 0.920 0.967 1.054 20 -quickSortMedian() 3000 3.106 3.249 3.393 20 -quickSortMedianSwapped() 10 0.003 0.004 0.011 20 -quickSortMedianSwapped() 30 0.013 0.014 0.016 20 -quickSortMedianSwapped() 100 0.056 0.059 0.068 20 -quickSortMedianSwapped() 300 0.200 0.211 0.224 20 -quickSortMedianSwapped() 1000 0.794 0.826 0.898 20 -quickSortMedianSwapped() 3000 2.694 2.803 2.989 20 -qsort() 10 0.006 0.008 0.017 20 -qsort() 30 0.029 0.032 0.042 20 -qsort() 100 0.132 0.143 0.160 20 -qsort() 300 0.509 0.524 0.551 20 -qsort() 1000 2.043 2.099 2.169 20 -qsort() 3000 7.136 7.221 7.391 20 +combSort133m() 100 0.092 0.095 0.108 20 +combSort133m() 300 0.341 0.360 0.372 20 +combSort133m() 1000 1.512 1.588 1.595 20 +combSort133m() 3000 5.442 5.684 6.582 20 +quickSortMiddle() 10 0.004 0.005 0.011 20 +quickSortMiddle() 30 0.015 0.017 0.019 20 +quickSortMiddle() 100 0.064 0.071 0.077 20 +quickSortMiddle() 300 0.227 0.252 0.287 20 +quickSortMiddle() 1000 0.915 0.987 1.165 20 +quickSortMiddle() 3000 3.140 3.427 3.707 20 +quickSortMedian() 10 0.004 0.006 0.010 20 +quickSortMedian() 30 0.016 0.018 0.026 20 +quickSortMedian() 100 0.068 0.073 0.080 20 +quickSortMedian() 300 0.237 0.255 0.275 20 +quickSortMedian() 1000 0.930 0.969 1.027 20 +quickSortMedian() 3000 3.144 3.263 3.479 20 +quickSortMedianSwapped() 10 0.004 0.004 0.009 20 +quickSortMedianSwapped() 30 0.012 0.014 0.016 20 +quickSortMedianSwapped() 100 0.054 0.059 0.075 20 +quickSortMedianSwapped() 300 0.198 0.209 0.231 20 +quickSortMedianSwapped() 1000 0.789 0.815 0.857 20 +quickSortMedianSwapped() 3000 2.682 2.804 2.930 20 +qsort() 10 0.006 0.008 0.014 20 +qsort() 30 0.029 0.033 0.044 20 +qsort() 100 0.135 0.144 0.171 20 +qsort() 300 0.507 0.522 0.557 20 +qsort() 1000 2.071 2.131 2.223 20 +qsort() 3000 7.140 7.245 7.592 20 END diff --git a/examples/AutoBenchmark/esp8266.txt b/examples/AutoBenchmark/esp8266.txt index 3e28d90..016e1be 100644 --- a/examples/AutoBenchmark/esp8266.txt +++ b/examples/AutoBenchmark/esp8266.txt @@ -1,83 +1,83 @@ BENCHMARKS -bubbleSort() 10 0.014 0.021 0.031 3 -bubbleSort() 30 0.184 0.192 0.199 3 -bubbleSort() 100 2.177 2.231 2.318 3 -bubbleSort() 300 18.915 20.143 21.185 3 -bubbleSort() 1000 222.008 225.651 230.578 3 -insertionSort() 10 0.006 0.009 0.013 3 -insertionSort() 30 0.036 0.037 0.039 3 -insertionSort() 100 0.338 0.362 0.383 3 -insertionSort() 300 3.106 3.220 3.331 3 -insertionSort() 1000 34.432 34.646 35.043 3 -selectionSort() 10 0.011 0.017 0.028 3 -selectionSort() 30 0.084 0.085 0.085 3 -selectionSort() 100 0.891 0.892 0.892 3 -selectionSort() 300 7.924 7.930 7.939 3 -selectionSort() 1000 87.681 87.723 87.751 3 -shellSortClassic() 10 0.009 0.011 0.024 20 +bubbleSort() 10 0.013 0.022 0.034 3 +bubbleSort() 30 0.175 0.181 0.188 3 +bubbleSort() 100 2.065 2.116 2.198 3 +bubbleSort() 300 17.936 19.118 20.139 3 +bubbleSort() 1000 210.481 213.942 218.615 3 +insertionSort() 10 0.006 0.011 0.020 3 +insertionSort() 30 0.036 0.037 0.038 3 +insertionSort() 100 0.335 0.361 0.383 3 +insertionSort() 300 3.109 3.222 3.335 3 +insertionSort() 1000 34.450 34.652 35.054 3 +selectionSort() 10 0.013 0.017 0.024 3 +selectionSort() 30 0.092 0.092 0.092 3 +selectionSort() 100 0.959 0.961 0.963 3 +selectionSort() 300 8.498 8.500 8.502 3 +selectionSort() 1000 93.959 93.980 93.993 3 +shellSortClassic() 10 0.009 0.010 0.025 20 shellSortClassic() 30 0.037 0.039 0.041 20 shellSortClassic() 100 0.205 0.215 0.226 20 -shellSortClassic() 300 0.848 0.878 0.907 20 -shellSortClassic() 1000 3.506 3.609 3.755 20 -shellSortClassic() 3000 13.416 13.789 14.644 20 -shellSortKnuth() 10 0.008 0.010 0.029 20 +shellSortClassic() 300 0.847 0.878 0.907 20 +shellSortClassic() 1000 3.505 3.610 3.769 20 +shellSortClassic() 3000 13.417 13.789 14.640 20 +shellSortKnuth() 10 0.008 0.010 0.028 20 shellSortKnuth() 30 0.033 0.036 0.041 20 -shellSortKnuth() 100 0.159 0.172 0.186 20 -shellSortKnuth() 300 0.664 0.690 0.722 20 -shellSortKnuth() 1000 2.882 3.022 3.250 20 -shellSortKnuth() 3000 10.877 11.304 12.011 20 +shellSortKnuth() 100 0.159 0.172 0.185 20 +shellSortKnuth() 300 0.664 0.690 0.719 20 +shellSortKnuth() 1000 2.882 3.021 3.250 20 +shellSortKnuth() 3000 10.914 11.306 12.014 20 shellSortTokuda() 10 0.008 0.009 0.020 20 -shellSortTokuda() 30 0.036 0.039 0.042 20 -shellSortTokuda() 100 0.177 0.183 0.188 20 -shellSortTokuda() 300 0.724 0.735 0.745 20 -shellSortTokuda() 1000 3.088 3.140 3.211 20 -shellSortTokuda() 3000 11.265 11.366 11.473 20 +shellSortTokuda() 30 0.037 0.040 0.042 20 +shellSortTokuda() 100 0.181 0.188 0.194 20 +shellSortTokuda() 300 0.745 0.756 0.766 20 +shellSortTokuda() 1000 3.177 3.227 3.275 20 +shellSortTokuda() 3000 11.566 11.678 11.781 20 combSort13() 10 0.012 0.013 0.024 20 combSort13() 30 0.045 0.048 0.051 20 combSort13() 100 0.196 0.219 0.247 20 combSort13() 300 0.803 0.846 0.951 20 -combSort13() 1000 3.611 3.711 4.106 20 -combSort13() 3000 12.774 13.689 14.229 20 -combSort13m() 10 0.011 0.014 0.028 20 +combSort13() 1000 3.611 3.712 4.103 20 +combSort13() 3000 12.762 13.695 14.261 20 +combSort13m() 10 0.011 0.013 0.028 20 combSort13m() 30 0.050 0.051 0.056 20 -combSort13m() 100 0.213 0.222 0.247 20 -combSort13m() 300 0.804 0.840 0.904 20 -combSort13m() 1000 3.611 3.622 3.775 20 -combSort13m() 3000 12.754 13.104 13.735 20 -combSort133() 10 0.008 0.010 0.017 20 +combSort13m() 100 0.213 0.223 0.247 20 +combSort13m() 300 0.804 0.840 0.903 20 +combSort13m() 1000 3.611 3.625 3.783 20 +combSort13m() 3000 12.754 13.102 13.747 20 +combSort133() 10 0.008 0.010 0.020 20 combSort133() 30 0.039 0.040 0.040 20 -combSort133() 100 0.188 0.208 0.270 20 +combSort133() 100 0.188 0.208 0.271 20 combSort133() 300 0.751 0.796 0.997 20 -combSort133() 1000 3.315 3.571 3.804 20 -combSort133() 3000 11.911 12.430 12.895 20 -combSort133m() 10 0.009 0.010 0.017 20 -combSort133m() 30 0.043 0.044 0.049 20 -combSort133m() 100 0.204 0.206 0.221 20 +combSort133() 1000 3.315 3.571 3.825 20 +combSort133() 3000 11.915 12.430 12.923 20 +combSort133m() 10 0.009 0.010 0.021 20 +combSort133m() 30 0.043 0.045 0.058 20 +combSort133m() 100 0.204 0.206 0.220 20 combSort133m() 300 0.753 0.793 0.804 20 -combSort133m() 1000 3.317 3.465 3.497 20 -combSort133m() 3000 11.916 12.387 13.395 20 +combSort133m() 1000 3.316 3.466 3.505 20 +combSort133m() 3000 11.914 12.387 13.381 20 quickSortMiddle() 10 0.011 0.013 0.027 20 -quickSortMiddle() 30 0.039 0.045 0.052 20 -quickSortMiddle() 100 0.162 0.185 0.213 20 -quickSortMiddle() 300 0.602 0.651 0.755 20 -quickSortMiddle() 1000 2.359 2.519 2.770 20 -quickSortMiddle() 3000 7.920 8.307 8.785 20 +quickSortMiddle() 30 0.039 0.045 0.053 20 +quickSortMiddle() 100 0.161 0.185 0.213 20 +quickSortMiddle() 300 0.602 0.650 0.755 20 +quickSortMiddle() 1000 2.359 2.518 2.762 20 +quickSortMiddle() 3000 7.905 8.303 8.786 20 quickSortMedian() 10 0.013 0.016 0.035 20 quickSortMedian() 30 0.046 0.052 0.055 20 -quickSortMedian() 100 0.186 0.200 0.216 20 -quickSortMedian() 300 0.640 0.677 0.715 20 -quickSortMedian() 1000 2.461 2.551 2.642 20 -quickSortMedian() 3000 8.200 8.403 8.587 20 -quickSortMedianSwapped() 10 0.009 0.012 0.035 20 -quickSortMedianSwapped() 30 0.034 0.039 0.045 20 -quickSortMedianSwapped() 100 0.150 0.159 0.186 20 -quickSortMedianSwapped() 300 0.530 0.558 0.597 20 -quickSortMedianSwapped() 1000 2.029 2.122 2.304 20 -quickSortMedianSwapped() 3000 6.933 7.109 7.609 20 -qsort() 10 0.017 0.028 0.150 20 +quickSortMedian() 100 0.189 0.203 0.219 20 +quickSortMedian() 300 0.646 0.684 0.721 20 +quickSortMedian() 1000 2.484 2.574 2.665 20 +quickSortMedian() 3000 8.280 8.470 8.656 20 +quickSortMedianSwapped() 10 0.009 0.012 0.031 20 +quickSortMedianSwapped() 30 0.035 0.039 0.045 20 +quickSortMedianSwapped() 100 0.150 0.160 0.176 20 +quickSortMedianSwapped() 300 0.532 0.560 0.600 20 +quickSortMedianSwapped() 1000 2.035 2.128 2.313 20 +quickSortMedianSwapped() 3000 6.956 7.129 7.623 20 +qsort() 10 0.017 0.027 0.143 20 qsort() 30 0.085 0.092 0.105 20 -qsort() 100 0.399 0.416 0.450 20 -qsort() 300 1.480 1.516 1.694 20 -qsort() 1000 5.884 6.010 6.152 20 -qsort() 3000 20.491 20.789 21.354 20 +qsort() 100 0.399 0.417 0.472 20 +qsort() 300 1.480 1.515 1.694 20 +qsort() 1000 5.899 6.009 6.148 20 +qsort() 3000 20.499 20.782 21.323 20 END diff --git a/examples/AutoBenchmark/generate_readme.py b/examples/AutoBenchmark/generate_readme.py index 7967a22..16ee0af 100755 --- a/examples/AutoBenchmark/generate_readme.py +++ b/examples/AutoBenchmark/generate_readme.py @@ -79,6 +79,11 @@ * The C-library `qsort()` is far slower than the C++ version because it uses a callback to a comparison function through a function pointer. +**v0.2+** + +* No performance change after rerouting 2-argument sorting functions into + the 3-argument versions using a default lambda expression. + ## Results The following results show the runtime of each sorting function in milliseconds, diff --git a/examples/AutoBenchmark/micro.txt b/examples/AutoBenchmark/micro.txt index 5b18b42..7334f61 100644 --- a/examples/AutoBenchmark/micro.txt +++ b/examples/AutoBenchmark/micro.txt @@ -1,58 +1,58 @@ BENCHMARKS -bubbleSort() 10 0.096 0.115 0.140 3 -bubbleSort() 30 1.004 1.083 1.128 3 -bubbleSort() 100 12.076 12.773 13.428 3 -bubbleSort() 300 118.872 121.179 123.004 3 -insertionSort() 10 0.040 0.041 0.044 3 -insertionSort() 30 0.276 0.291 0.312 3 -insertionSort() 100 2.396 2.527 2.616 3 -insertionSort() 300 20.624 21.032 21.504 3 -selectionSort() 10 0.076 0.081 0.084 3 -selectionSort() 30 0.552 0.561 0.568 3 -selectionSort() 100 5.628 5.632 5.636 3 -selectionSort() 300 49.144 49.153 49.160 3 -shellSortClassic() 10 0.064 0.074 0.084 25 -shellSortClassic() 30 0.288 0.310 0.328 25 -shellSortClassic() 100 1.612 1.712 1.864 25 -shellSortClassic() 300 6.724 6.912 7.196 25 -shellSortKnuth() 10 0.092 0.101 0.116 25 -shellSortKnuth() 30 0.312 0.339 0.396 25 -shellSortKnuth() 100 1.368 1.445 1.568 25 -shellSortKnuth() 300 5.364 5.601 5.872 25 -shellSortTokuda() 10 0.064 0.076 0.088 25 -shellSortTokuda() 30 0.308 0.337 0.368 25 -shellSortTokuda() 100 1.556 1.634 1.688 25 -shellSortTokuda() 300 6.448 6.588 6.820 25 -combSort13() 10 0.156 0.165 0.192 25 -combSort13() 30 0.496 0.537 0.576 25 -combSort13() 100 1.988 2.209 2.648 25 -combSort13() 300 7.836 8.215 8.808 25 -combSort13m() 10 0.136 0.164 0.204 25 -combSort13m() 30 0.540 0.557 0.624 25 -combSort13m() 100 2.128 2.219 2.364 25 -combSort13m() 300 7.864 8.134 8.376 25 -combSort133() 10 0.080 0.086 0.104 25 -combSort133() 30 0.376 0.389 0.432 25 -combSort133() 100 1.824 1.996 2.404 25 -combSort133() 300 7.332 7.767 8.240 25 -combSort133m() 10 0.080 0.091 0.112 25 -combSort133m() 30 0.408 0.423 0.464 25 -combSort133m() 100 1.952 1.997 2.144 25 -combSort133m() 300 7.312 7.729 8.268 25 -quickSortMiddle() 10 0.084 0.099 0.116 25 -quickSortMiddle() 30 0.340 0.375 0.444 25 -quickSortMiddle() 100 1.444 1.619 1.924 25 -quickSortMiddle() 300 5.196 5.711 6.424 25 -quickSortMedian() 10 0.100 0.119 0.136 25 -quickSortMedian() 30 0.396 0.427 0.480 25 -quickSortMedian() 100 1.632 1.748 1.944 25 -quickSortMedian() 300 5.764 5.976 6.464 25 -quickSortMedianSwapped() 10 0.076 0.094 0.116 25 -quickSortMedianSwapped() 30 0.312 0.341 0.376 25 -quickSortMedianSwapped() 100 1.304 1.401 1.476 25 -quickSortMedianSwapped() 300 4.728 4.974 5.368 25 -qsort() 10 0.160 0.200 0.244 25 -qsort() 30 0.756 0.839 0.984 25 -qsort() 100 3.472 3.661 3.852 25 -qsort() 300 12.516 12.974 13.364 25 +bubbleSort() 10 0.056 0.091 0.140 3 +bubbleSort() 30 1.108 1.136 1.172 3 +bubbleSort() 100 12.496 12.908 13.684 3 +bubbleSort() 300 117.940 120.933 124.088 3 +insertionSort() 10 0.036 0.048 0.056 3 +insertionSort() 30 0.260 0.271 0.284 3 +insertionSort() 100 2.492 2.652 2.744 3 +insertionSort() 300 21.436 22.188 23.432 3 +selectionSort() 10 0.084 0.084 0.084 3 +selectionSort() 30 0.552 0.556 0.560 3 +selectionSort() 100 5.388 5.391 5.392 3 +selectionSort() 300 46.508 46.513 46.524 3 +shellSortClassic() 10 0.068 0.075 0.084 25 +shellSortClassic() 30 0.288 0.314 0.344 25 +shellSortClassic() 100 1.584 1.730 1.820 25 +shellSortClassic() 300 6.676 6.950 7.300 25 +shellSortKnuth() 10 0.092 0.100 0.112 25 +shellSortKnuth() 30 0.304 0.330 0.384 25 +shellSortKnuth() 100 1.376 1.455 1.540 25 +shellSortKnuth() 300 5.388 5.634 5.988 25 +shellSortTokuda() 10 0.068 0.075 0.084 25 +shellSortTokuda() 30 0.312 0.337 0.380 25 +shellSortTokuda() 100 1.572 1.645 1.728 25 +shellSortTokuda() 300 6.364 6.555 6.692 25 +combSort13() 10 0.152 0.162 0.188 25 +combSort13() 30 0.492 0.538 0.632 25 +combSort13() 100 2.124 2.234 2.500 25 +combSort13() 300 7.844 8.211 8.756 25 +combSort13m() 10 0.132 0.164 0.192 25 +combSort13m() 30 0.544 0.559 0.616 25 +combSort13m() 100 2.132 2.266 2.504 25 +combSort13m() 300 7.876 8.232 8.812 25 +combSort133() 10 0.080 0.088 0.108 25 +combSort133() 30 0.372 0.390 0.448 25 +combSort133() 100 1.820 1.996 2.724 25 +combSort133() 300 7.332 7.672 7.888 25 +combSort133m() 10 0.080 0.087 0.100 25 +combSort133m() 30 0.412 0.424 0.464 25 +combSort133m() 100 1.944 1.993 2.136 25 +combSort133m() 300 7.328 7.763 8.296 25 +quickSortMiddle() 10 0.080 0.098 0.112 25 +quickSortMiddle() 30 0.332 0.372 0.428 25 +quickSortMiddle() 100 1.456 1.617 1.908 25 +quickSortMiddle() 300 5.216 5.667 6.756 25 +quickSortMedian() 10 0.088 0.116 0.132 25 +quickSortMedian() 30 0.396 0.432 0.480 25 +quickSortMedian() 100 1.632 1.720 1.868 25 +quickSortMedian() 300 5.708 5.956 6.304 25 +quickSortMedianSwapped() 10 0.076 0.090 0.104 25 +quickSortMedianSwapped() 30 0.316 0.345 0.376 25 +quickSortMedianSwapped() 100 1.264 1.391 1.572 25 +quickSortMedianSwapped() 300 4.708 4.914 5.120 25 +qsort() 10 0.164 0.202 0.272 25 +qsort() 30 0.772 0.900 1.728 25 +qsort() 100 3.496 3.674 3.968 25 +qsort() 300 12.676 13.046 13.680 25 END diff --git a/examples/AutoBenchmark/nano.txt b/examples/AutoBenchmark/nano.txt index c3a2e5c..bde69ec 100644 --- a/examples/AutoBenchmark/nano.txt +++ b/examples/AutoBenchmark/nano.txt @@ -1,58 +1,58 @@ BENCHMARKS -bubbleSort() 10 0.084 0.107 0.132 3 -bubbleSort() 30 0.976 1.077 1.192 3 -bubbleSort() 100 11.836 12.735 13.648 3 -bubbleSort() 300 116.268 116.675 117.240 3 -insertionSort() 10 0.040 0.045 0.056 3 -insertionSort() 30 0.252 0.263 0.276 3 -insertionSort() 100 2.532 2.557 2.572 3 -insertionSort() 300 22.036 22.252 22.396 3 -selectionSort() 10 0.084 0.088 0.096 3 -selectionSort() 30 0.556 0.560 0.564 3 -selectionSort() 100 5.596 5.600 5.604 3 -selectionSort() 300 48.888 48.892 48.896 3 -shellSortClassic() 10 0.068 0.074 0.080 25 -shellSortClassic() 30 0.292 0.310 0.332 25 -shellSortClassic() 100 1.588 1.706 1.824 25 -shellSortClassic() 300 6.640 6.865 7.056 25 -shellSortKnuth() 10 0.092 0.101 0.112 25 -shellSortKnuth() 30 0.300 0.330 0.380 25 -shellSortKnuth() 100 1.340 1.450 1.652 25 -shellSortKnuth() 300 5.444 5.665 6.232 25 -shellSortTokuda() 10 0.068 0.075 0.084 25 -shellSortTokuda() 30 0.312 0.327 0.348 25 -shellSortTokuda() 100 1.556 1.614 1.700 25 -shellSortTokuda() 300 6.424 6.540 6.688 25 -combSort13() 10 0.128 0.160 0.204 25 -combSort13() 30 0.492 0.534 0.576 25 -combSort13() 100 2.120 2.214 2.640 25 -combSort13() 300 7.816 8.167 8.336 25 -combSort13m() 10 0.156 0.165 0.196 25 -combSort13m() 30 0.532 0.550 0.564 25 -combSort13m() 100 2.104 2.219 2.348 25 -combSort13m() 300 7.820 8.181 8.720 25 -combSort133() 10 0.080 0.086 0.108 25 -combSort133() 30 0.380 0.396 0.520 25 -combSort133() 100 1.808 1.944 2.288 25 -combSort133() 300 7.292 7.702 8.232 25 -combSort133m() 10 0.068 0.086 0.100 25 -combSort133m() 30 0.404 0.416 0.428 25 -combSort133m() 100 1.940 1.978 2.120 25 -combSort133m() 300 7.328 7.740 8.228 25 -quickSortMiddle() 10 0.076 0.096 0.112 25 -quickSortMiddle() 30 0.332 0.368 0.428 25 -quickSortMiddle() 100 1.436 1.568 1.808 25 -quickSortMiddle() 300 5.220 5.651 6.248 25 -quickSortMedian() 10 0.100 0.117 0.136 25 -quickSortMedian() 30 0.396 0.431 0.488 25 -quickSortMedian() 100 1.620 1.717 1.864 25 -quickSortMedian() 300 5.652 5.905 6.168 25 -quickSortMedianSwapped() 10 0.080 0.094 0.116 25 -quickSortMedianSwapped() 30 0.312 0.341 0.380 25 -quickSortMedianSwapped() 100 1.296 1.417 1.536 25 -quickSortMedianSwapped() 300 4.672 4.909 5.256 25 -qsort() 10 0.160 0.204 0.232 25 -qsort() 30 0.784 0.855 0.928 25 -qsort() 100 3.424 3.629 3.852 25 -qsort() 300 12.600 13.021 13.828 25 +bubbleSort() 10 0.064 0.099 0.124 3 +bubbleSort() 30 0.696 1.044 1.248 3 +bubbleSort() 100 11.920 12.305 12.540 3 +bubbleSort() 300 116.980 118.589 121.404 3 +insertionSort() 10 0.044 0.049 0.052 3 +insertionSort() 30 0.248 0.251 0.256 3 +insertionSort() 100 2.300 2.463 2.556 3 +insertionSort() 300 20.540 21.288 22.056 3 +selectionSort() 10 0.084 0.087 0.088 3 +selectionSort() 30 0.552 0.553 0.556 3 +selectionSort() 100 5.360 5.365 5.372 3 +selectionSort() 300 46.272 46.275 46.276 3 +shellSortClassic() 10 0.064 0.074 0.084 25 +shellSortClassic() 30 0.276 0.306 0.328 25 +shellSortClassic() 100 1.620 1.711 1.800 25 +shellSortClassic() 300 6.732 6.868 7.164 25 +shellSortKnuth() 10 0.092 0.100 0.112 25 +shellSortKnuth() 30 0.304 0.325 0.356 25 +shellSortKnuth() 100 1.328 1.431 1.536 25 +shellSortKnuth() 300 5.360 5.683 6.208 25 +shellSortTokuda() 10 0.064 0.075 0.092 25 +shellSortTokuda() 30 0.312 0.336 0.356 25 +shellSortTokuda() 100 1.536 1.616 1.700 25 +shellSortTokuda() 300 6.384 6.555 6.740 25 +combSort13() 10 0.152 0.167 0.196 25 +combSort13() 30 0.492 0.534 0.620 25 +combSort13() 100 2.116 2.215 2.488 25 +combSort13() 300 7.840 8.260 8.756 25 +combSort13m() 10 0.156 0.164 0.192 25 +combSort13m() 30 0.540 0.557 0.616 25 +combSort13m() 100 2.108 2.233 2.524 25 +combSort13m() 300 7.792 8.176 8.756 25 +combSort133() 10 0.076 0.084 0.100 25 +combSort133() 30 0.372 0.400 0.524 25 +combSort133() 100 1.816 1.968 2.272 25 +combSort133() 300 7.304 7.730 8.604 25 +combSort133m() 10 0.080 0.087 0.108 25 +combSort133m() 30 0.408 0.419 0.432 25 +combSort133m() 100 1.936 1.979 2.108 25 +combSort133m() 300 7.280 7.805 8.648 25 +quickSortMiddle() 10 0.084 0.097 0.120 25 +quickSortMiddle() 30 0.336 0.373 0.428 25 +quickSortMiddle() 100 1.480 1.582 1.712 25 +quickSortMiddle() 300 5.016 5.536 6.248 25 +quickSortMedian() 10 0.092 0.117 0.136 25 +quickSortMedian() 30 0.384 0.423 0.468 25 +quickSortMedian() 100 1.632 1.717 1.824 25 +quickSortMedian() 300 5.684 5.905 6.184 25 +quickSortMedianSwapped() 10 0.072 0.092 0.104 25 +quickSortMedianSwapped() 30 0.308 0.338 0.364 25 +quickSortMedianSwapped() 100 1.312 1.396 1.568 25 +quickSortMedianSwapped() 300 4.616 4.895 5.544 25 +qsort() 10 0.152 0.208 0.300 25 +qsort() 30 0.756 0.827 0.952 25 +qsort() 100 3.424 3.642 3.844 25 +qsort() 300 12.584 13.068 13.504 25 END diff --git a/examples/AutoBenchmark/samd.txt b/examples/AutoBenchmark/samd.txt index 5af15f7..4a7b997 100644 --- a/examples/AutoBenchmark/samd.txt +++ b/examples/AutoBenchmark/samd.txt @@ -1,83 +1,83 @@ BENCHMARKS -bubbleSort() 10 0.036 0.039 0.044 3 -bubbleSort() 30 0.315 0.357 0.387 3 -bubbleSort() 100 3.964 3.984 4.011 3 -bubbleSort() 300 35.300 36.967 38.476 3 -bubbleSort() 1000 425.463 429.557 431.644 3 -insertionSort() 10 0.012 0.014 0.016 3 -insertionSort() 30 0.087 0.095 0.108 3 -insertionSort() 100 0.834 0.880 0.948 3 -insertionSort() 300 7.820 8.132 8.320 3 -insertionSort() 1000 86.152 87.197 88.020 3 -selectionSort() 10 0.023 0.023 0.023 3 -selectionSort() 30 0.157 0.159 0.161 3 -selectionSort() 100 1.619 1.620 1.621 3 -selectionSort() 300 14.278 14.279 14.281 3 -selectionSort() 1000 157.534 157.547 157.568 3 -shellSortClassic() 10 0.014 0.016 0.018 20 -shellSortClassic() 30 0.058 0.064 0.071 20 -shellSortClassic() 100 0.334 0.349 0.380 20 -shellSortClassic() 300 1.363 1.405 1.460 20 -shellSortClassic() 1000 5.677 5.861 6.097 20 -shellSortClassic() 3000 21.989 22.452 23.069 20 -shellSortKnuth() 10 0.017 0.019 0.021 20 -shellSortKnuth() 30 0.062 0.067 0.074 20 -shellSortKnuth() 100 0.277 0.289 0.310 20 -shellSortKnuth() 300 1.102 1.153 1.206 20 -shellSortKnuth() 1000 4.867 5.111 5.437 20 -shellSortKnuth() 3000 18.550 19.448 20.784 20 -shellSortTokuda() 10 0.017 0.020 0.021 20 -shellSortTokuda() 30 0.076 0.081 0.085 20 -shellSortTokuda() 100 0.371 0.390 0.409 20 -shellSortTokuda() 300 1.514 1.556 1.596 20 -shellSortTokuda() 1000 6.580 6.673 6.773 20 -shellSortTokuda() 3000 23.952 24.187 24.643 20 -combSort13() 10 0.033 0.035 0.039 20 -combSort13() 30 0.109 0.118 0.124 20 -combSort13() 100 0.450 0.496 0.553 20 -combSort13() 300 1.777 1.859 1.987 20 -combSort13() 1000 7.915 8.180 8.935 20 -combSort13() 3000 28.934 29.661 31.978 20 -combSort13m() 10 0.034 0.035 0.041 20 -combSort13m() 30 0.121 0.124 0.137 20 -combSort13m() 100 0.481 0.512 0.560 20 -combSort13m() 300 1.784 1.882 1.991 20 -combSort13m() 1000 7.561 7.892 8.251 20 -combSort13m() 3000 27.894 28.483 28.964 20 -combSort133() 10 0.019 0.020 0.023 20 -combSort133() 30 0.086 0.090 0.102 20 -combSort133() 100 0.409 0.454 0.590 20 -combSort133() 300 1.652 1.764 1.868 20 -combSort133() 1000 7.282 7.897 8.620 20 -combSort133() 3000 26.165 26.989 28.205 20 +bubbleSort() 10 0.027 0.031 0.035 3 +bubbleSort() 30 0.216 0.282 0.331 3 +bubbleSort() 100 3.366 3.405 3.468 3 +bubbleSort() 300 31.077 32.272 33.701 3 +bubbleSort() 1000 355.351 363.409 370.085 3 +insertionSort() 10 0.013 0.016 0.019 3 +insertionSort() 30 0.078 0.088 0.093 3 +insertionSort() 100 0.868 0.941 0.989 3 +insertionSort() 300 7.541 8.144 8.547 3 +insertionSort() 1000 87.778 89.678 91.223 3 +selectionSort() 10 0.023 0.024 0.024 3 +selectionSort() 30 0.160 0.162 0.163 3 +selectionSort() 100 1.627 1.629 1.630 3 +selectionSort() 300 14.304 14.306 14.310 3 +selectionSort() 1000 157.626 157.639 157.659 3 +shellSortClassic() 10 0.015 0.016 0.018 20 +shellSortClassic() 30 0.060 0.064 0.068 20 +shellSortClassic() 100 0.325 0.349 0.377 20 +shellSortClassic() 300 1.369 1.408 1.480 20 +shellSortClassic() 1000 5.636 5.912 6.118 20 +shellSortClassic() 3000 21.351 22.251 22.906 20 +shellSortKnuth() 10 0.018 0.019 0.020 20 +shellSortKnuth() 30 0.060 0.065 0.079 20 +shellSortKnuth() 100 0.272 0.298 0.320 20 +shellSortKnuth() 300 1.099 1.154 1.236 20 +shellSortKnuth() 1000 4.889 5.074 5.429 20 +shellSortKnuth() 3000 18.413 19.321 20.476 20 +shellSortTokuda() 10 0.017 0.019 0.021 20 +shellSortTokuda() 30 0.075 0.081 0.087 20 +shellSortTokuda() 100 0.371 0.390 0.412 20 +shellSortTokuda() 300 1.528 1.568 1.618 20 +shellSortTokuda() 1000 6.609 6.690 6.771 20 +shellSortTokuda() 3000 23.886 24.190 24.533 20 +combSort13() 10 0.029 0.035 0.039 20 +combSort13() 30 0.113 0.121 0.137 20 +combSort13() 100 0.497 0.532 0.617 20 +combSort13() 300 1.850 1.934 1.973 20 +combSort13() 1000 8.271 8.697 10.070 20 +combSort13() 3000 30.277 31.638 34.597 20 +combSort13m() 10 0.034 0.036 0.042 20 +combSort13m() 30 0.124 0.128 0.138 20 +combSort13m() 100 0.500 0.534 0.655 20 +combSort13m() 300 1.852 1.931 2.077 20 +combSort13m() 1000 7.921 8.274 8.616 20 +combSort13m() 3000 29.195 29.531 30.300 20 +combSort133() 10 0.019 0.021 0.024 20 +combSort133() 30 0.089 0.090 0.093 20 +combSort133() 100 0.427 0.452 0.508 20 +combSort133() 300 1.724 1.825 1.942 20 +combSort133() 1000 7.613 8.259 9.418 20 +combSort133() 3000 27.321 28.640 32.716 20 combSort133m() 10 0.021 0.021 0.023 20 -combSort133m() 30 0.096 0.097 0.101 20 -combSort133m() 100 0.446 0.454 0.487 20 -combSort133m() 300 1.653 1.752 1.870 20 -combSort133m() 1000 7.293 7.623 7.971 20 -combSort133m() 3000 26.179 27.649 32.205 20 -quickSortMiddle() 10 0.017 0.021 0.027 20 -quickSortMiddle() 30 0.062 0.073 0.089 20 -quickSortMiddle() 100 0.283 0.315 0.383 20 -quickSortMiddle() 300 1.005 1.077 1.182 20 -quickSortMiddle() 1000 3.864 4.211 4.759 20 -quickSortMiddle() 3000 13.376 14.031 14.748 20 -quickSortMedian() 10 0.022 0.026 0.031 20 -quickSortMedian() 30 0.077 0.088 0.100 20 -quickSortMedian() 100 0.328 0.344 0.369 20 -quickSortMedian() 300 1.106 1.161 1.227 20 -quickSortMedian() 1000 4.233 4.343 4.525 20 -quickSortMedian() 3000 14.120 14.455 15.235 20 -quickSortMedianSwapped() 10 0.017 0.020 0.023 20 -quickSortMedianSwapped() 30 0.064 0.070 0.077 20 -quickSortMedianSwapped() 100 0.264 0.285 0.315 20 -quickSortMedianSwapped() 300 0.939 1.001 1.065 20 -quickSortMedianSwapped() 1000 3.631 3.783 4.090 20 -quickSortMedianSwapped() 3000 12.076 12.630 13.381 20 -qsort() 10 0.041 0.054 0.068 20 -qsort() 30 0.189 0.213 0.249 20 -qsort() 100 0.827 0.886 0.921 20 -qsort() 300 3.118 3.215 3.375 20 -qsort() 1000 12.392 12.678 12.994 20 -qsort() 3000 42.268 42.791 43.244 20 +combSort133m() 30 0.098 0.100 0.103 20 +combSort133m() 100 0.464 0.470 0.507 20 +combSort133m() 300 1.718 1.822 1.949 20 +combSort133m() 1000 7.605 7.949 7.982 20 +combSort133m() 3000 27.355 28.592 31.646 20 +quickSortMiddle() 10 0.017 0.022 0.028 20 +quickSortMiddle() 30 0.065 0.077 0.090 20 +quickSortMiddle() 100 0.288 0.312 0.363 20 +quickSortMiddle() 300 0.998 1.097 1.210 20 +quickSortMiddle() 1000 3.962 4.246 4.576 20 +quickSortMiddle() 3000 13.572 14.192 15.172 20 +quickSortMedian() 10 0.022 0.026 0.028 20 +quickSortMedian() 30 0.080 0.088 0.094 20 +quickSortMedian() 100 0.323 0.338 0.347 20 +quickSortMedian() 300 1.114 1.158 1.197 20 +quickSortMedian() 1000 4.246 4.387 4.612 20 +quickSortMedian() 3000 14.131 14.495 15.369 20 +quickSortMedianSwapped() 10 0.017 0.020 0.024 20 +quickSortMedianSwapped() 30 0.063 0.069 0.077 20 +quickSortMedianSwapped() 100 0.263 0.281 0.299 20 +quickSortMedianSwapped() 300 0.931 0.980 1.031 20 +quickSortMedianSwapped() 1000 3.583 3.720 3.916 20 +quickSortMedianSwapped() 3000 12.021 12.486 13.078 20 +qsort() 10 0.040 0.052 0.061 20 +qsort() 30 0.183 0.204 0.231 20 +qsort() 100 0.825 0.873 0.928 20 +qsort() 300 3.017 3.088 3.205 20 +qsort() 1000 11.895 12.102 12.361 20 +qsort() 3000 40.749 41.217 42.525 20 END diff --git a/examples/AutoBenchmark/stm32.txt b/examples/AutoBenchmark/stm32.txt index a3c6365..c744f63 100644 --- a/examples/AutoBenchmark/stm32.txt +++ b/examples/AutoBenchmark/stm32.txt @@ -1,83 +1,83 @@ BENCHMARKS -bubbleSort() 10 0.013 0.018 0.025 3 -bubbleSort() 30 0.128 0.161 0.214 3 -bubbleSort() 100 2.064 2.105 2.186 3 -bubbleSort() 300 19.574 19.955 20.358 3 -bubbleSort() 1000 222.869 225.639 229.515 3 -insertionSort() 10 0.008 0.010 0.011 3 -insertionSort() 30 0.051 0.054 0.057 3 -insertionSort() 100 0.466 0.495 0.544 3 -insertionSort() 300 4.402 4.486 4.636 3 -insertionSort() 1000 47.204 48.616 49.785 3 -selectionSort() 10 0.017 0.017 0.017 3 -selectionSort() 30 0.115 0.116 0.116 3 -selectionSort() 100 1.165 1.167 1.169 3 -selectionSort() 300 10.196 10.197 10.200 3 -selectionSort() 1000 112.178 112.180 112.183 3 -shellSortClassic() 10 0.013 0.014 0.015 20 -shellSortClassic() 30 0.055 0.058 0.064 20 -shellSortClassic() 100 0.297 0.324 0.362 20 -shellSortClassic() 300 1.229 1.284 1.337 20 -shellSortClassic() 1000 5.292 5.427 5.557 20 -shellSortClassic() 3000 20.049 20.852 21.631 20 -shellSortKnuth() 10 0.012 0.014 0.019 20 -shellSortKnuth() 30 0.054 0.059 0.068 20 -shellSortKnuth() 100 0.287 0.305 0.331 20 -shellSortKnuth() 300 1.168 1.236 1.322 20 -shellSortKnuth() 1000 5.335 5.604 6.061 20 -shellSortKnuth() 3000 20.874 21.566 22.651 20 -shellSortTokuda() 10 0.010 0.011 0.012 20 -shellSortTokuda() 30 0.042 0.047 0.051 20 -shellSortTokuda() 100 0.217 0.226 0.235 20 -shellSortTokuda() 300 0.874 0.901 0.927 20 -shellSortTokuda() 1000 3.816 3.904 3.968 20 -shellSortTokuda() 3000 14.045 14.199 14.364 20 -combSort13() 10 0.018 0.019 0.022 20 -combSort13() 30 0.081 0.087 0.104 20 -combSort13() 100 0.428 0.442 0.498 20 -combSort13() 300 1.674 1.770 1.886 20 -combSort13() 1000 7.301 7.895 8.699 20 -combSort13() 3000 28.178 28.862 30.275 20 -combSort13m() 10 0.017 0.018 0.025 20 -combSort13m() 30 0.087 0.087 0.092 20 -combSort13m() 100 0.409 0.430 0.448 20 -combSort13m() 300 1.611 1.697 1.814 20 -combSort13m() 1000 7.009 7.380 7.683 20 -combSort13m() 3000 26.049 26.657 28.064 20 -combSort133() 10 0.017 0.018 0.022 20 -combSort133() 30 0.082 0.085 0.107 20 -combSort133() 100 0.394 0.417 0.468 20 -combSort133() 300 1.585 1.649 1.693 20 -combSort133() 1000 7.000 7.630 8.396 20 -combSort133() 3000 25.152 26.148 28.293 20 -combSort133m() 10 0.014 0.019 0.021 20 -combSort133m() 30 0.087 0.089 0.098 20 -combSort133m() 100 0.413 0.419 0.448 20 -combSort133m() 300 1.535 1.619 1.643 20 -combSort133m() 1000 6.783 7.151 7.787 20 -combSort133m() 3000 24.373 25.380 27.393 20 -quickSortMiddle() 10 0.016 0.019 0.033 20 -quickSortMiddle() 30 0.059 0.067 0.079 20 -quickSortMiddle() 100 0.259 0.278 0.301 20 -quickSortMiddle() 300 0.926 0.990 1.096 20 -quickSortMiddle() 1000 3.620 3.835 4.171 20 -quickSortMiddle() 3000 12.483 13.145 13.883 20 -quickSortMedian() 10 0.018 0.020 0.026 20 -quickSortMedian() 30 0.071 0.076 0.079 20 -quickSortMedian() 100 0.289 0.311 0.345 20 -quickSortMedian() 300 1.054 1.101 1.167 20 -quickSortMedian() 1000 4.050 4.212 4.573 20 -quickSortMedian() 3000 13.888 14.381 15.341 20 -quickSortMedianSwapped() 10 0.012 0.015 0.018 20 -quickSortMedianSwapped() 30 0.051 0.056 0.061 20 -quickSortMedianSwapped() 100 0.217 0.228 0.243 20 -quickSortMedianSwapped() 300 0.788 0.836 0.909 20 -quickSortMedianSwapped() 1000 3.162 3.285 3.619 20 -quickSortMedianSwapped() 3000 10.776 11.265 12.538 20 -qsort() 10 0.025 0.034 0.047 20 -qsort() 30 0.123 0.149 0.317 20 -qsort() 100 0.566 0.615 0.836 20 -qsort() 300 2.173 2.221 2.313 20 -qsort() 1000 8.652 8.921 9.368 20 -qsort() 3000 30.092 30.627 31.322 20 +bubbleSort() 10 0.018 0.022 0.027 3 +bubbleSort() 30 0.152 0.169 0.193 3 +bubbleSort() 100 1.927 2.156 2.353 3 +bubbleSort() 300 19.949 20.662 21.305 3 +bubbleSort() 1000 228.374 230.118 232.415 3 +insertionSort() 10 0.008 0.009 0.009 3 +insertionSort() 30 0.052 0.054 0.057 3 +insertionSort() 100 0.469 0.488 0.522 3 +insertionSort() 300 4.091 4.278 4.452 3 +insertionSort() 1000 43.610 45.077 46.415 3 +selectionSort() 10 0.015 0.016 0.016 3 +selectionSort() 30 0.102 0.102 0.103 3 +selectionSort() 100 1.023 1.023 1.024 3 +selectionSort() 300 8.928 8.931 8.932 3 +selectionSort() 1000 98.184 98.184 98.184 3 +shellSortClassic() 10 0.013 0.014 0.027 20 +shellSortClassic() 30 0.054 0.057 0.062 20 +shellSortClassic() 100 0.294 0.305 0.329 20 +shellSortClassic() 300 1.207 1.243 1.282 20 +shellSortClassic() 1000 5.022 5.157 5.329 20 +shellSortClassic() 3000 19.189 19.747 20.193 20 +shellSortKnuth() 10 0.012 0.013 0.024 20 +shellSortKnuth() 30 0.050 0.057 0.069 20 +shellSortKnuth() 100 0.248 0.276 0.293 20 +shellSortKnuth() 300 1.075 1.131 1.219 20 +shellSortKnuth() 1000 4.758 5.058 5.285 20 +shellSortKnuth() 3000 18.788 19.403 20.601 20 +shellSortTokuda() 10 0.009 0.012 0.019 20 +shellSortTokuda() 30 0.044 0.048 0.054 20 +shellSortTokuda() 100 0.213 0.226 0.240 20 +shellSortTokuda() 300 0.887 0.905 0.937 20 +shellSortTokuda() 1000 3.845 3.888 3.933 20 +shellSortTokuda() 3000 13.971 14.123 14.372 20 +combSort13() 10 0.016 0.017 0.025 20 +combSort13() 30 0.074 0.080 0.094 20 +combSort13() 100 0.389 0.396 0.458 20 +combSort13() 300 1.526 1.601 1.723 20 +combSort13() 1000 6.661 7.173 7.623 20 +combSort13() 3000 24.752 26.248 27.647 20 +combSort13m() 10 0.016 0.018 0.025 20 +combSort13m() 30 0.083 0.084 0.092 20 +combSort13m() 100 0.389 0.416 0.523 20 +combSort13m() 300 1.529 1.585 1.630 20 +combSort13m() 1000 6.658 6.998 7.306 20 +combSort13m() 3000 24.757 25.575 26.686 20 +combSort133() 10 0.013 0.016 0.024 20 +combSort133() 30 0.072 0.073 0.077 20 +combSort133() 100 0.346 0.378 0.474 20 +combSort133() 300 1.395 1.481 1.674 20 +combSort133() 1000 6.161 6.775 8.620 20 +combSort133() 3000 22.134 22.826 23.977 20 +combSort133m() 10 0.016 0.017 0.025 20 +combSort133m() 30 0.079 0.080 0.081 20 +combSort133m() 100 0.376 0.382 0.410 20 +combSort133m() 300 1.399 1.496 1.583 20 +combSort133m() 1000 6.159 6.436 6.470 20 +combSort133m() 3000 22.137 23.289 27.667 20 +quickSortMiddle() 10 0.013 0.017 0.026 20 +quickSortMiddle() 30 0.053 0.064 0.072 20 +quickSortMiddle() 100 0.225 0.260 0.288 20 +quickSortMiddle() 300 0.868 0.941 1.011 20 +quickSortMiddle() 1000 3.303 3.559 3.920 20 +quickSortMiddle() 3000 11.224 12.330 13.212 20 +quickSortMedian() 10 0.016 0.020 0.032 20 +quickSortMedian() 30 0.064 0.070 0.077 20 +quickSortMedian() 100 0.266 0.280 0.296 20 +quickSortMedian() 300 0.928 0.994 1.069 20 +quickSortMedian() 1000 3.654 3.769 3.937 20 +quickSortMedian() 3000 12.272 12.632 13.990 20 +quickSortMedianSwapped() 10 0.013 0.015 0.024 20 +quickSortMedianSwapped() 30 0.049 0.056 0.063 20 +quickSortMedianSwapped() 100 0.219 0.236 0.254 20 +quickSortMedianSwapped() 300 0.803 0.855 0.970 20 +quickSortMedianSwapped() 1000 3.203 3.318 3.567 20 +quickSortMedianSwapped() 3000 10.810 11.345 12.163 20 +qsort() 10 0.026 0.033 0.040 20 +qsort() 30 0.119 0.132 0.145 20 +qsort() 100 0.579 0.609 0.643 20 +qsort() 300 2.187 2.251 2.448 20 +qsort() 1000 8.719 8.882 9.120 20 +qsort() 3000 30.058 30.578 31.259 20 END diff --git a/examples/AutoBenchmark/teensy32.txt b/examples/AutoBenchmark/teensy32.txt index ece77a7..a0af23c 100644 --- a/examples/AutoBenchmark/teensy32.txt +++ b/examples/AutoBenchmark/teensy32.txt @@ -1,83 +1,83 @@ BENCHMARKS bubbleSort() 10 0.008 0.009 0.010 3 -bubbleSort() 30 0.073 0.079 0.082 3 -bubbleSort() 100 0.743 0.824 0.940 3 -bubbleSort() 300 8.002 8.469 8.977 3 -bubbleSort() 1000 94.984 98.471 101.370 3 -insertionSort() 10 0.006 0.006 0.007 3 -insertionSort() 30 0.036 0.041 0.049 3 -insertionSort() 100 0.385 0.394 0.402 3 -insertionSort() 300 3.300 3.390 3.485 3 -insertionSort() 1000 36.376 36.820 37.584 3 -selectionSort() 10 0.008 0.008 0.008 3 -selectionSort() 30 0.057 0.057 0.058 3 -selectionSort() 100 0.589 0.590 0.590 3 -selectionSort() 300 5.212 5.215 5.218 3 -selectionSort() 1000 57.556 57.558 57.560 3 +bubbleSort() 30 0.074 0.083 0.091 3 +bubbleSort() 100 0.870 0.945 1.020 3 +bubbleSort() 300 9.099 9.217 9.399 3 +bubbleSort() 1000 98.266 102.362 104.583 3 +insertionSort() 10 0.005 0.005 0.006 3 +insertionSort() 30 0.038 0.040 0.043 3 +insertionSort() 100 0.385 0.399 0.409 3 +insertionSort() 300 3.220 3.290 3.365 3 +insertionSort() 1000 35.585 36.427 37.111 3 +selectionSort() 10 0.009 0.009 0.010 3 +selectionSort() 30 0.064 0.065 0.065 3 +selectionSort() 100 0.652 0.653 0.654 3 +selectionSort() 300 5.714 5.715 5.718 3 +selectionSort() 1000 62.887 62.889 62.892 3 shellSortClassic() 10 0.006 0.007 0.009 20 shellSortClassic() 30 0.027 0.029 0.031 20 -shellSortClassic() 100 0.150 0.162 0.173 20 -shellSortClassic() 300 0.630 0.648 0.671 20 -shellSortClassic() 1000 2.651 2.712 2.809 20 -shellSortClassic() 3000 9.971 10.394 10.906 20 -shellSortKnuth() 10 0.005 0.006 0.008 20 -shellSortKnuth() 30 0.025 0.027 0.032 20 -shellSortKnuth() 100 0.123 0.133 0.141 20 -shellSortKnuth() 300 0.511 0.531 0.552 20 -shellSortKnuth() 1000 2.244 2.339 2.490 20 -shellSortKnuth() 3000 8.658 8.903 9.199 20 +shellSortClassic() 100 0.150 0.159 0.171 20 +shellSortClassic() 300 0.628 0.648 0.661 20 +shellSortClassic() 1000 2.631 2.694 2.862 20 +shellSortClassic() 3000 10.140 10.372 10.594 20 +shellSortKnuth() 10 0.005 0.006 0.007 20 +shellSortKnuth() 30 0.023 0.027 0.031 20 +shellSortKnuth() 100 0.125 0.131 0.140 20 +shellSortKnuth() 300 0.511 0.526 0.556 20 +shellSortKnuth() 1000 2.274 2.345 2.463 20 +shellSortKnuth() 3000 8.421 8.972 9.684 20 shellSortTokuda() 10 0.006 0.007 0.008 20 -shellSortTokuda() 30 0.026 0.028 0.030 20 -shellSortTokuda() 100 0.130 0.136 0.142 20 -shellSortTokuda() 300 0.529 0.539 0.547 20 -shellSortTokuda() 1000 2.256 2.314 2.364 20 -shellSortTokuda() 3000 8.287 8.366 8.440 20 -combSort13() 10 0.007 0.008 0.010 20 -combSort13() 30 0.033 0.036 0.039 20 -combSort13() 100 0.175 0.182 0.212 20 -combSort13() 300 0.688 0.722 0.770 20 -combSort13() 1000 3.134 3.233 3.414 20 -combSort13() 3000 11.533 11.887 12.768 20 +shellSortTokuda() 30 0.027 0.028 0.030 20 +shellSortTokuda() 100 0.131 0.135 0.140 20 +shellSortTokuda() 300 0.526 0.539 0.549 20 +shellSortTokuda() 1000 2.280 2.312 2.342 20 +shellSortTokuda() 3000 8.292 8.365 8.436 20 +combSort13() 10 0.007 0.008 0.009 20 +combSort13() 30 0.033 0.037 0.046 20 +combSort13() 100 0.175 0.182 0.208 20 +combSort13() 300 0.687 0.720 0.733 20 +combSort13() 1000 3.134 3.234 3.550 20 +combSort13() 3000 11.535 11.948 12.772 20 combSort13m() 10 0.008 0.008 0.010 20 -combSort13m() 30 0.037 0.038 0.040 20 -combSort13m() 100 0.176 0.186 0.220 20 -combSort13m() 300 0.689 0.725 0.770 20 -combSort13m() 1000 3.128 3.139 3.272 20 -combSort13m() 3000 11.124 11.431 11.545 20 +combSort13m() 30 0.037 0.038 0.038 20 +combSort13m() 100 0.175 0.182 0.194 20 +combSort13m() 300 0.687 0.721 0.773 20 +combSort13m() 1000 2.997 3.146 3.272 20 +combSort13m() 3000 11.118 11.470 11.939 20 combSort133() 10 0.007 0.008 0.009 20 -combSort133() 30 0.034 0.035 0.035 20 -combSort133() 100 0.163 0.174 0.207 20 -combSort133() 300 0.660 0.698 0.745 20 -combSort133() 1000 2.904 3.101 3.319 20 -combSort133() 3000 10.451 10.902 12.078 20 +combSort133() 30 0.034 0.035 0.037 20 +combSort133() 100 0.163 0.175 0.220 20 +combSort133() 300 0.658 0.693 0.708 20 +combSort133() 1000 3.039 3.142 3.327 20 +combSort133() 3000 10.451 10.841 12.484 20 combSort133m() 10 0.007 0.008 0.010 20 -combSort133m() 30 0.037 0.038 0.042 20 -combSort133m() 100 0.176 0.180 0.191 20 -combSort133m() 300 0.699 0.710 0.746 20 -combSort133m() 1000 2.908 3.030 3.050 20 -combSort133m() 3000 10.448 10.801 11.276 20 -quickSortMiddle() 10 0.006 0.007 0.009 20 -quickSortMiddle() 30 0.023 0.026 0.028 20 -quickSortMiddle() 100 0.095 0.109 0.140 20 -quickSortMiddle() 300 0.353 0.388 0.423 20 -quickSortMiddle() 1000 1.424 1.520 1.806 20 -quickSortMiddle() 3000 4.957 5.278 5.846 20 -quickSortMedian() 10 0.007 0.009 0.010 20 -quickSortMedian() 30 0.028 0.030 0.032 20 -quickSortMedian() 100 0.114 0.122 0.134 20 -quickSortMedian() 300 0.399 0.423 0.456 20 -quickSortMedian() 1000 1.520 1.590 1.663 20 -quickSortMedian() 3000 5.180 5.387 5.604 20 -quickSortMedianSwapped() 10 0.006 0.007 0.009 20 -quickSortMedianSwapped() 30 0.022 0.025 0.028 20 -quickSortMedianSwapped() 100 0.094 0.100 0.108 20 -quickSortMedianSwapped() 300 0.345 0.365 0.381 20 -quickSortMedianSwapped() 1000 1.341 1.412 1.662 20 -quickSortMedianSwapped() 3000 4.559 4.752 5.080 20 -qsort() 10 0.013 0.017 0.022 20 -qsort() 30 0.067 0.073 0.101 20 -qsort() 100 0.301 0.315 0.335 20 -qsort() 300 1.135 1.156 1.197 20 -qsort() 1000 4.474 4.576 4.722 20 -qsort() 3000 15.456 15.732 16.127 20 +combSort133m() 30 0.037 0.038 0.040 20 +combSort133m() 100 0.176 0.179 0.193 20 +combSort133m() 300 0.659 0.700 0.744 20 +combSort133m() 1000 2.911 3.037 3.052 20 +combSort133m() 3000 10.443 10.841 12.494 20 +quickSortMiddle() 10 0.005 0.007 0.009 20 +quickSortMiddle() 30 0.023 0.026 0.030 20 +quickSortMiddle() 100 0.095 0.108 0.119 20 +quickSortMiddle() 300 0.360 0.399 0.453 20 +quickSortMiddle() 1000 1.405 1.543 1.738 20 +quickSortMiddle() 3000 5.032 5.324 6.742 20 +quickSortMedian() 10 0.007 0.009 0.009 20 +quickSortMedian() 30 0.027 0.030 0.032 20 +quickSortMedian() 100 0.116 0.122 0.132 20 +quickSortMedian() 300 0.394 0.414 0.440 20 +quickSortMedian() 1000 1.542 1.598 1.672 20 +quickSortMedian() 3000 5.201 5.353 5.734 20 +quickSortMedianSwapped() 10 0.005 0.007 0.009 20 +quickSortMedianSwapped() 30 0.022 0.025 0.029 20 +quickSortMedianSwapped() 100 0.093 0.103 0.113 20 +quickSortMedianSwapped() 300 0.337 0.357 0.378 20 +quickSortMedianSwapped() 1000 1.348 1.403 1.454 20 +quickSortMedianSwapped() 3000 4.563 4.750 4.938 20 +qsort() 10 0.014 0.017 0.022 20 +qsort() 30 0.062 0.071 0.077 20 +qsort() 100 0.308 0.317 0.336 20 +qsort() 300 1.118 1.154 1.183 20 +qsort() 1000 4.483 4.579 4.710 20 +qsort() 3000 15.545 15.830 16.163 20 END From 01b8542e50c09be2c07afdd09a1bf059c941b92b Mon Sep 17 00:00:00 2001 From: Brian Park Date: Mon, 23 Aug 2021 08:30:34 -0700 Subject: [PATCH 08/17] README.md: Update MemoryBenchmark and AutoBenchmark samples --- README.md | 58 +++++++++++++++++++++++++++---------------------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/README.md b/README.md index b42ab58..762b30c 100644 --- a/README.md +++ b/README.md @@ -417,7 +417,7 @@ The full details of flash and static memory consumptions are given in |----------------------------------------+--------------+-------------| | quickSortMiddle() | 1244/ 214 | 178/ 0 | | quickSortMedian() | 1296/ 214 | 230/ 0 | -| quickSortMedianSwapped() | 1344/ 214 | 278/ 0 | +| quickSortMedianSwapped() | 1344/ 214 | 276/ 0 | |----------------------------------------+--------------+-------------| | qsort() | 2150/ 214 | 1084/ 0 | +---------------------------------------------------------------------+ @@ -437,7 +437,7 @@ The full details of flash and static memory consumptions are given in |----------------------------------------+--------------+-------------| | shellSortClassic() | 257180/26976 | 80/ 0 | | shellSortKnuth() | 257212/26976 | 112/ 0 | -| shellSortTokuda() | 257256/27004 | 156/ 28 | +| shellSortTokuda() | 257256/27004 | 140/ 28 | |----------------------------------------+--------------+-------------| | combSort13() | 257196/26976 | 96/ 0 | | combSort13m() | 257212/26976 | 112/ 0 | @@ -466,24 +466,24 @@ Here are 2 samples. | \ N | 10 | 30 | 100 | 300 | 1000 | 3000 | | Function \ | | | | | | | |---------------------+-------+-------+--------+---------+---------+---------| -| bubbleSort() | 0.107 | 1.077 | 12.735 | 116.675 | | | -| insertionSort() | 0.045 | 0.263 | 2.557 | 22.252 | | | -| selectionSort() | 0.088 | 0.560 | 5.600 | 48.892 | | | +| bubbleSort() | 0.099 | 1.044 | 12.305 | 118.589 | | | +| insertionSort() | 0.049 | 0.251 | 2.463 | 21.288 | | | +| selectionSort() | 0.087 | 0.553 | 5.365 | 46.275 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| shellSortClassic() | 0.074 | 0.310 | 1.706 | 6.865 | | | -| shellSortKnuth() | 0.101 | 0.330 | 1.450 | 5.665 | | | -| shellSortTokuda() | 0.075 | 0.327 | 1.614 | 6.540 | | | +| shellSortClassic() | 0.074 | 0.306 | 1.711 | 6.868 | | | +| shellSortKnuth() | 0.100 | 0.325 | 1.431 | 5.683 | | | +| shellSortTokuda() | 0.075 | 0.336 | 1.616 | 6.555 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| combSort13() | 0.160 | 0.534 | 2.214 | 8.167 | | | -| combSort13m() | 0.165 | 0.550 | 2.219 | 8.181 | | | -| combSort133() | 0.086 | 0.396 | 1.944 | 7.702 | | | -| combSort133m() | 0.086 | 0.416 | 1.978 | 7.740 | | | +| combSort13() | 0.167 | 0.534 | 2.215 | 8.260 | | | +| combSort13m() | 0.164 | 0.557 | 2.233 | 8.176 | | | +| combSort133() | 0.084 | 0.400 | 1.968 | 7.730 | | | +| combSort133m() | 0.087 | 0.419 | 1.979 | 7.805 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| quickSortMiddle() | 0.096 | 0.368 | 1.568 | 5.651 | | | -| quickSortMedian() | 0.117 | 0.431 | 1.717 | 5.905 | | | -| quickSortMdnSwppd() | 0.094 | 0.341 | 1.417 | 4.909 | | | +| quickSortMiddle() | 0.097 | 0.373 | 1.582 | 5.536 | | | +| quickSortMedian() | 0.117 | 0.423 | 1.717 | 5.905 | | | +| quickSortMdnSwppd() | 0.092 | 0.338 | 1.396 | 4.895 | | | |---------------------+-------+-------+--------+---------+---------+---------| -| qsort() | 0.204 | 0.855 | 3.629 | 13.021 | | | +| qsort() | 0.208 | 0.827 | 3.642 | 13.068 | | | +---------------------+-------+-------+--------+---------+---------+---------+ ``` @@ -494,24 +494,24 @@ Here are 2 samples. | \ N | 10 | 30 | 100 | 300 | 1000 | 3000 | | Function \ | | | | | | | |---------------------+-------+-------+--------+---------+---------+---------| -| bubbleSort() | 0.021 | 0.192 | 2.231 | 20.143 | 225.651 | | -| insertionSort() | 0.009 | 0.037 | 0.362 | 3.220 | 34.646 | | -| selectionSort() | 0.017 | 0.085 | 0.892 | 7.930 | 87.723 | | +| bubbleSort() | 0.022 | 0.181 | 2.116 | 19.118 | 213.942 | | +| insertionSort() | 0.011 | 0.037 | 0.361 | 3.222 | 34.652 | | +| selectionSort() | 0.017 | 0.092 | 0.961 | 8.500 | 93.980 | | |---------------------+-------+-------+--------+---------+---------+---------| -| shellSortClassic() | 0.011 | 0.039 | 0.215 | 0.878 | 3.609 | 13.789 | -| shellSortKnuth() | 0.010 | 0.036 | 0.172 | 0.690 | 3.022 | 11.304 | -| shellSortTokuda() | 0.009 | 0.039 | 0.183 | 0.735 | 3.140 | 11.366 | +| shellSortClassic() | 0.010 | 0.039 | 0.215 | 0.878 | 3.610 | 13.789 | +| shellSortKnuth() | 0.010 | 0.036 | 0.172 | 0.690 | 3.021 | 11.306 | +| shellSortTokuda() | 0.009 | 0.040 | 0.188 | 0.756 | 3.227 | 11.678 | |---------------------+-------+-------+--------+---------+---------+---------| -| combSort13() | 0.013 | 0.048 | 0.219 | 0.846 | 3.711 | 13.689 | -| combSort13m() | 0.014 | 0.051 | 0.222 | 0.840 | 3.622 | 13.104 | +| combSort13() | 0.013 | 0.048 | 0.219 | 0.846 | 3.712 | 13.695 | +| combSort13m() | 0.013 | 0.051 | 0.223 | 0.840 | 3.625 | 13.102 | | combSort133() | 0.010 | 0.040 | 0.208 | 0.796 | 3.571 | 12.430 | -| combSort133m() | 0.010 | 0.044 | 0.206 | 0.793 | 3.465 | 12.387 | +| combSort133m() | 0.010 | 0.045 | 0.206 | 0.793 | 3.466 | 12.387 | |---------------------+-------+-------+--------+---------+---------+---------| -| quickSortMiddle() | 0.013 | 0.045 | 0.185 | 0.651 | 2.519 | 8.307 | -| quickSortMedian() | 0.016 | 0.052 | 0.200 | 0.677 | 2.551 | 8.403 | -| quickSortMdnSwppd() | 0.012 | 0.039 | 0.159 | 0.558 | 2.122 | 7.109 | +| quickSortMiddle() | 0.013 | 0.045 | 0.185 | 0.650 | 2.518 | 8.303 | +| quickSortMedian() | 0.016 | 0.052 | 0.203 | 0.684 | 2.574 | 8.470 | +| quickSortMdnSwppd() | 0.012 | 0.039 | 0.160 | 0.560 | 2.128 | 7.129 | |---------------------+-------+-------+--------+---------+---------+---------| -| qsort() | 0.028 | 0.092 | 0.416 | 1.516 | 6.010 | 20.789 | +| qsort() | 0.027 | 0.092 | 0.417 | 1.515 | 6.009 | 20.782 | +---------------------+-------+-------+--------+---------+---------+---------+ ``` From d52da98ac04b2625f9db9cabade1aa17bfd3aab8 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Mon, 23 Aug 2021 08:27:25 -0700 Subject: [PATCH 09/17] README.md: Add documentation of 3-argument sorting functions that accept a lambda expression or function pointer --- CHANGELOG.md | 15 ++++ README.md | 246 +++++++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 244 insertions(+), 17 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 931601c..f15b1aa 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,21 @@ # Changelog * Unreleased + * Add 3-argument versions of each sorting function which accepts a lambda + expression or function pointer that evalutes the general "less-than" + comparison between 2 elements in the array. + * Can be used to implement any sorting criteria, e.g. reverse sort, or + sorting using compound keys. + * Reimplement 2-argument versions of each sorting function to simply + call the 3-argument versions using a default "less-than" function + to give simple ascending order. + * The `quickSortXxx()` algorithms do not optimize well, probably due + to the recursive function call, so the 2-argument version is + duplicated from the 3-argument version. + * Add `examples/CompoundSortingDemo` to illustrate the 3-argument + sorting functions to sort by (name, score) pair. + * No changes observed to flash memory consumption or CPU execution + times. * v0.2 (2021-08-06) * Add Selection Sort, mostly for completeness. It's another `O(N^2)` sort but is slower than Insertion Sort, and is not a stable sort. diff --git a/README.md b/README.md index 762b30c..e1af621 100644 --- a/README.md +++ b/README.md @@ -45,9 +45,6 @@ Supports the following algorithms: **Version**: 0.2 (2021-08-06) -**Status**: Simple versions are working and stable. Versions accepting custom -comparators coming soon. - **Changelog**: [CHANGELOG.md](CHANGELOG.md) ## Table of Contents @@ -67,6 +64,10 @@ comparators coming soon. * [Comb Sort](#CombSort) * [Quick Sort](#QuickSort) * [C Library Qsort](#CLibraryQsort) +* [Advanced Usage](#AdvancedUsage) + * [Function Pointer](#FunctionPointer) + * [Lambda Expression](#LambdaExpression) + * [Compiler Optimizations](#CompilerOptimizations) * [Resource Consumption](#ResourceConsumption) * [Flash And Static Memory](#FlashAndStaticMemory) * [CPU Cycles](#CpuCycles) @@ -180,6 +181,8 @@ Some of the examples may depend on: * [examples/HelloSort](examples/HelloSort) * A demo of one of the sorting functions. +* [examples/CompoundSortingDemo](examples/CompoundSortingDemo) + * Sorting by `name`, then break any ties by sorting by `score`. * Benchmarks * [examples/MemoryBenchmark](examples/MemoryBenchmark) * Determine flash and static RAM consumption of various algorithms. @@ -213,8 +216,12 @@ using ace_sorting::shellSortKnuth; See https://en.wikipedia.org/wiki/Bubble_sort. ```C++ +namespace ace_sorting { + template void bubbleSort(T data[], uint16_t n); + +} ``` * Flash consumption: 44 bytes on AVR @@ -229,8 +236,12 @@ void bubbleSort(T data[], uint16_t n); See https://en.wikipedia.org/wiki/Insertion_sort. ```C++ +namespace ace_sorting { + template void insertionSort(T data[], uint16_t n); + +} ``` * Flash consumption, 60 bytes on AVR @@ -246,8 +257,12 @@ void insertionSort(T data[], uint16_t n); See https://en.wikipedia.org/wiki/Selection_sort. ```C++ +namespace ace_sorting { + template void selectionSort(T data[], uint16_t n); + +} ``` * Flash consumption, 100 bytes on AVR @@ -267,6 +282,8 @@ See https://en.wikipedia.org/wiki/Shellsort. Three versions are provided in this library: ```C++ +namespace ace_sorting { + template void shellSortClassic(T data[], uint16_t n); @@ -275,6 +292,8 @@ void shellSortKnuth(T data[], uint16_t n); template void shellSortTokuda(T data[], uint16_t n); + +} ``` * Flash consumption: 100-180 bytes of flash on AVR @@ -293,6 +312,8 @@ and https://rosettacode.org/wiki/Sorting_algorithms/Comb_sort. Four versions are provided in this library: ```C++ +namespace ace_sorting { + template void combSort13(T data[], uint16_t n); @@ -304,12 +325,19 @@ void combSort133(T data[], uint16_t n); template void combSort133m(T data[], uint16_t n); + +} ``` * Flash consumption: 106-172 bytes on AVR * Additional ram consumption: none * Runtime complexity: `O(N^k)` where k seems similar to Shell Sort * Stable sort: No +* Upper limits: + * `combSort13()` and `combSort13m()`: `n = 6553` on 8-bit AVR processors + due to integer overflow. + * `combSort133()` and `combSort133m()`: `n = 21845` on 8-bit AVR processors + due to integer overflow. * **Recommendation**: * Use `combSort133()` on 8-bit processors. * Use `combSort13m()` on 32-bit processors. @@ -319,23 +347,25 @@ The `combSort13()` and `combSort13m()` functions use a gap factor of `10/13 = or 10. That apparently make the algorithm faster for reasons that I have not been able to find on the internet. -The `combSort133()` and `combSort133m()` use a gap factor of `4/3 = 1.33`. The -`4/3` ratio allows the compiler to replace an integer division with a left bit -shift, so that code is smaller and faster on 8-bit processors without hardware -integer division. The `combSort133m()` function modifies the gap sequence when -the gap is 9 or 10. +The `combSort133()` and `combSort133m()` functions use a gap factor of `4/3 = +1.33`. The `4/3` ratio allows the compiler to replace an integer division with a +left bit shift, so that code is smaller and faster on 8-bit processors without +hardware integer division. The `combSort133m()` function modifies the gap +sequence when the gap is 9 or 10. -Overall, [examples/AutoBenchmark](examples/AutoBenchmark) shows that Comb Sort -is consistently slower than Shell Sort so it is difficult to recommend it over -Shell Sort. +In terms of performance, [examples/AutoBenchmark](examples/AutoBenchmark) shows +that Comb Sort is consistently slower than Shell Sort so it is difficult to +recommend it over Shell Sort. ### Quick Sort -https://en.wikipedia.org/wiki/Quicksort. Three versions are provided in this +See https://en.wikipedia.org/wiki/Quicksort. Three versions are provided in this library: ```C++ +namespace ace_sorting { + template void quickSortMiddle(T data[], uint16_t n); @@ -344,8 +374,20 @@ void quickSortMedian(T data[], uint16_t n); template void quickSortMedianSwapped(T data[], uint16_t n); + +} ``` +* `quickSortMiddle()` + * The pivot is the middle element in each partition, regardless of its + value. +* `quickSortMedian()` + * The pivot is the median element among the 3 elements on the left, middle, + and right slots of each partition. +* `quickSortMedianSwapped()` + * The pivot is the median element among the 3 elements on the left, middle, + and right slots of each partition. + * The 3 elements are swapped so that they are sorted. * Flash consumption: 178-278 bytes on AVR * Additional ram consumption: `O(log(N))` bytes on stack due to recursion * Runtime complexity: `O(N log(N))` @@ -379,11 +421,173 @@ It has the following characteristics: * Stable sort: No * **Not recommended** due to excessive flash consumption and slowness. -According to benchmarks, `qsort()` is 2-3X slower than the C++ `quickSortXxx()`, -and consumes 4-5X more flash memory. The `qsort()` function is probably more -sophisticated in the handling of edge cases, but it suffers from being a general -function that uses pointer to a comparator call-back function. That makes it -2-3X slower than the C++ template functions in this library. Not recommended. +According to benchmarks, `qsort()` is 2-3X slower than the C++ `quickSortXxx()` +functions provided by this library, and consumes 4-5X more flash memory. The +`qsort()` function is probably more sophisticated in the handling of edge cases, +but it suffers from being a general function that uses a call-back function. The +overhead of that function call makes it 2-3X slower than the C++ template +functions in this library where the comparison function call is usually inlined +by the compiler. For these reasons, it is difficult to recommend the C-library +`qsort()` function. + + +## Advanced Usage + +Each sorting algorithm comes in another variant that takes 3 arguments instead +of 2 arguments. For completeness, here are the signatures of the 3-argument +variants: + +```C++ +namespace ace_sorting { + +template +void bubbleSort(T data[], uint16_t n, F&& lessThan); + +template +void insertionSort(T data[], uint16_t n, F&& lessThan); + +template +void selectionSort(T data[], uint16_t n, F&& lessThan); + +template +void shellSortClassic(T data[], uint16_t n, F&& lessThan); + +template +void shellSortKnuth(T data[], uint16_t n, F&& lessThan); + +template +void shellSortTokuda(T data[], uint16_t n, F&& lessThan); + +template +void combSort13(T data[], uint16_t n, F&& lessThan); + +template +void combSort13m(T data[], uint16_t n, F&& lessThan); + +template +void combSort133(T data[], uint16_t n, F&& lessThan); + +template +void combSort133m(T data[], uint16_t n, F&& lessThan); + +template +void quickSortMiddle(T data[], uint16_t n, F&& lessThan); + +template +void quickSortMedian(T data[], uint16_t n, F&& lessThan); + +template +void quickSortMedianSwapped(T data[], uint16_t n, F&& lessThan); + +} +``` + +The 3rd argument `lessThan` is a user-defined function pointer or a lambda +expression that implements the "less than" comparison operator between 2 +elements in the `data[]` array. (The `F&&` is a C++11 syntax that means "rvalue +reference to a templatized type of `F`".) In the context of this library, the +`lessThan` parameter can be thought of as a function-like thing that accepts 2 +elements of type `T` and returns a `bool`. Two types of this `lessThan` +parameter is explained below. + + +### Function Pointer + +If `lessThan` is a function pointer, then its signature should look something +like one of these: + +```C++ +bool lessThan(const T& a, const T& b); + +bool lessThan(T a, T b); +``` + +The [examples/CompoundSortingDemo](examples/CompoundSortingDemo) example shows +what this looks like to sort an array of pointers to `Record` entries by +`score`, then by `name`, to break any ties: + +```C++ +struct Record { + const char* name; + int score; +}; + +bool sortByScoreThenName(const Record* a, const Record* b) { + if (a->score < b->score) { + return true; + } else if (a->score > b->score) { + return false; + } else { + return strcmp(a->name, b->name) < 0; + } +} + +const uint16_t ARRAY_SIZE = 10; +const Record RECORDS[ARRAY_SIZE] = { + ... +}; + +const Record* recordPtrs[ARRAY_SIZE]; + +void doSorting() { + shellSortKnuth(recordPtrs, ARRAY_SIZE, sortByScoreThenName); + ... +} +``` + + +### Lambda Expression + +Through the magic of C++ templates, the `lessThan` parameter can also be a +lambda expression. When the comparison operator is simple and short, this +feature can save us the hassle of creating a separate function that is used only +once. + +The [examples/HelloSort](examples/HelloSort) example shows how to sort an array +of integers in reverse order using an inlined lambda expression that reverses +the comparison operator: + +```C++ +const uint16_t ARRAY_SIZE = 20; +int array[ARRAY_SIZE]; + +void doSorting() { + shellSortKnuth(array, ARRAY_SIZE, [](int a, int b) { return a > b; }); + ... +} +``` + + +### Compiler Optimizations + +All 2-argument variants of the sorting functions (except for the Quick Sort +functions `quickSortXxx()`, see below) are implemented by simply calling the +3-argument sorting functions using a default lambda expression using the `<` +operator like this: + +```C++ +template +void shellSortKnuth(T data[], uint16_t n) { + auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; }; + shellSortKnuth(data, n, lessThan); +} +``` + +The benchmarks in [examples/MemoryBenchmark](examples/MemoryBenchmark) show that +the compiler is able to completely optimize away the overhead of the inlined +lambda expression and produce code that is equivalent to inserting the `<` +binary operator directly into the code that implements the 3-argument variant. +No additional flash memory is consumed. + +The only exception to this compiler optimization occurs with the Quick Sort +algorithms. The compiler seems unable to optimize away the extra layer of +indirection, probably due to the recursive function calls in the Quick Sort +algorithms. Therefore, the 2-argument variants of `quickSortXxx()` algorithms +are duplicated from the 3-argument variants with the simple `<` operator +hardcoded, so that the simple case of ascending sorting consumes as little flash +memory as possible. (In the source code, the `ACE_SORTING_DIRECT_QUICK_SORT` +macro is set to `1` by default to achieve this, in contrast to all other sorting +functions where the equivalent macro is set to `0`.) ## Resource Consumption @@ -586,6 +790,14 @@ them. processors, and 8 bytes on 64-bit processors. However, I did not want to worry about edge case behavior of some of these algorithms for extremely large values of `n`. +* The behavior of the sorting algorithms with a `data` size of exactly `n = + 65535` has not been validated. + * Some algorithms may be buggy in this edge case due to integer overflows. + * The actual maximum value of `n` may actually be `65534` for + some algorithms. +* Some of the Comb Sort algorithms have even lower limits of `n` due to integer + overflows. + * See remarks above and in the source code. * No hybrid sorting algorithms. * Different sorting algorithms are more efficient at different ranges of `N`. So hybrid algorithms will use different sorting algorithms at From b7c33cb0f58517ded80ccb7533dcf7d7b69324d3 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Mon, 23 Aug 2021 08:52:23 -0700 Subject: [PATCH 10/17] library.properties: Expand short description with list of sorting algorithms --- library.properties | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library.properties b/library.properties index 9d185a2..0f49b01 100644 --- a/library.properties +++ b/library.properties @@ -2,8 +2,8 @@ name=AceSorting version=0.2.0 author=Brian T. Park maintainer=Brian T. Park -sentence=Various sorting algorithms for Arduino. -paragraph=Bubble Sort, Insertion Sort, Selection Sort, Shell Sort, Comb Sort, Quick Sort. +sentence=Various sorting algorithms for Arduino, including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions). +paragraph=Provides 2 variants of each algorithm: a simple variant which sorts in ascending order using the implicit less-than operator, and a three-argument variant that accepts a function pointer or lambda expression to sort using a user-defined sorting function. category=Data Processing url=https://github.com/bxparks/AceSorting architectures=* From 82f4736c076eba2031348c30b3470ad1b98cd4d4 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Mon, 23 Aug 2021 09:17:39 -0700 Subject: [PATCH 11/17] examples/HelloSorting: Renamed from HelloSort to prevent confusion that HelloSort is a type of sorting algorithm --- CHANGELOG.md | 2 +- README.md | 41 ++++++++++--------- .../HelloSorting.ino} | 0 examples/{HelloSort => HelloSorting}/Makefile | 2 +- 4 files changed, 24 insertions(+), 21 deletions(-) rename examples/{HelloSort/HelloSort.ino => HelloSorting/HelloSorting.ino} (100%) rename examples/{HelloSort => HelloSorting}/Makefile (89%) diff --git a/CHANGELOG.md b/CHANGELOG.md index f15b1aa..d0cd49a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,7 +19,7 @@ * v0.2 (2021-08-06) * Add Selection Sort, mostly for completeness. It's another `O(N^2)` sort but is slower than Insertion Sort, and is not a stable sort. - * Add [examples/HelloSort](examples/HelloSort). + * Add [examples/HelloSorting](examples/HelloSorting). * Add **tl;dr** section in README.md to summarize my recommendations. * v0.1 (2021-08-04) * Add `combSort133()` which uses a gap factor of 4/3, which eliminates diff --git a/README.md b/README.md index e1af621..cad6ef5 100644 --- a/README.md +++ b/README.md @@ -31,17 +31,20 @@ Supports the following algorithms: **tl;dr** -* In most cases, use `shellSortKnuth()`, costing only 142 bytes on an AVR and - 80-112 bytes on 32-bit processors. It is faster than any `O(N^2)` algorithm - while consuming only 34-82 extra bytes of flash over `insertionSort()`. -* If `N > ~100`, and you need faster sorting, and you have sufficient memory for - recursive functions, use `quickSortMiddle()` on 8-bit AVR processors, and - `quickSortMedianSwapped()` on 32-bit processors. -* Use `insertionSort()` if you need a stable sort. +* In most cases, use `shellSortKnuth()`. + * It costs only 142 bytes on an AVR and 80-112 bytes on 32-bit processors. + * It is faster than any `O(N^2)` algorithm while consuming only 34-82 extra + bytes of flash over `insertionSort()`. +* If `N > ~100`, *and* you have sufficient static memory for recursive + functions, *and* `shellSortKnuth()` is not fast enough, use + `quickSortMiddle()` on 8-bit AVR processors, and `quickSortMedianSwapped()` on + 32-bit processors. * Use `combSort133()` or `shellSortClassic()` to get the smallest sorting function faster than `O(N^2)`. -* Don't use the C library `qsort()`. It is 2-3X slower than the `quickSortXxx()` - functions in this library, and consumes 4-5X more in flash bytes. +* Use `insertionSort()` if you need a stable sort. +* Don't use the C library `qsort()`. + * It is 2-3X slower than the `quickSortXxx()` functions in this library, and + consumes 4-5X more in flash bytes. **Version**: 0.2 (2021-08-06) @@ -49,7 +52,7 @@ Supports the following algorithms: ## Table of Contents -* [Hello Sort](#HelloSort) +* [Hello Sorting](#HelloSorting) * [Installation](#Installation) * [Source Code](#SourceCode) * [Dependencies](#Dependencies) @@ -81,11 +84,11 @@ Supports the following algorithms: * [Feedback and Support](#FeedbackAndSupport) * [Authors](#Authors) - -## Hello Sort + +## Hello Sorting -This is a simplified version of the [examples/HelloSort](examples/HelloSort) -demo: +This is a simplified version of the +[examples/HelloSorting](examples/HelloSorting) demo: ```C++ #include @@ -93,7 +96,7 @@ demo: using ace_sorting::shellSortKnuth; -const uint16_t ARRAY_SIZE = 50; +const uint16_t ARRAY_SIZE = 20; int array[ARRAY_SIZE]; void printArray(int* array, uint16_t arraySize) { @@ -179,7 +182,7 @@ Some of the examples may depend on: ### Examples -* [examples/HelloSort](examples/HelloSort) +* [examples/HelloSorting](examples/HelloSorting) * A demo of one of the sorting functions. * [examples/CompoundSortingDemo](examples/CompoundSortingDemo) * Sorting by `name`, then break any ties by sorting by `score`. @@ -543,9 +546,9 @@ lambda expression. When the comparison operator is simple and short, this feature can save us the hassle of creating a separate function that is used only once. -The [examples/HelloSort](examples/HelloSort) example shows how to sort an array -of integers in reverse order using an inlined lambda expression that reverses -the comparison operator: +The [examples/HelloSorting](examples/HelloSorting) example shows how to sort an +array of integers in reverse order using an inlined lambda expression that +reverses the comparison operator: ```C++ const uint16_t ARRAY_SIZE = 20; diff --git a/examples/HelloSort/HelloSort.ino b/examples/HelloSorting/HelloSorting.ino similarity index 100% rename from examples/HelloSort/HelloSort.ino rename to examples/HelloSorting/HelloSorting.ino diff --git a/examples/HelloSort/Makefile b/examples/HelloSorting/Makefile similarity index 89% rename from examples/HelloSort/Makefile rename to examples/HelloSorting/Makefile index 10ae8dd..410bf65 100644 --- a/examples/HelloSort/Makefile +++ b/examples/HelloSorting/Makefile @@ -1,6 +1,6 @@ # See https://github.com/bxparks/EpoxyDuino for documentation about using # EpoxyDuino to compile and run AUnit tests natively on Linux or MacOS. -APP_NAME := HelloSort +APP_NAME := HelloSorting ARDUINO_LIBS := AceSorting include ../../../EpoxyDuino/EpoxyDuino.mk From 9861358577abc1b5a08e9287f229aa28574a6c19 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Mon, 23 Aug 2021 09:30:56 -0700 Subject: [PATCH 12/17] README.md: Add note that sort() in Arduino_AVRSTL library is a bubble sort --- README.md | 37 +++++++++++++++++++------------------ 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/README.md b/README.md index cad6ef5..d5f4816 100644 --- a/README.md +++ b/README.md @@ -783,19 +783,21 @@ them. * If you need bigger, copy the sorting algorithm that you want and change the `uint16_t n` to a `uint32_t n`. * Using a fixed `uint16_t` means that the edge case behavior of these - algorithms are consistency across all platforms. + algorithms are consistent across all platforms. * Certain implementation choices and optimizations can be made if we know - that `n` cannot exceed a bounded value. For example, the - `shellSortTokuda()` function can use a pre-generated sequence of gaps - which is a reasonable size because it only needs to go up to 65535. + that `n` cannot exceed a bounded value. + * For example, the `shellSortTokuda()` function can use a pre-generated + sequence of gaps which is a reasonable size because it only needs to + go up to 65535. * The alternative was to use the `size_t` type whose size is different on different platforms: 2 bytes on 8-bit processors, 4 bytes on 32-bit - processors, and 8 bytes on 64-bit processors. However, I did not want to - worry about edge case behavior of some of these algorithms for extremely - large values of `n`. + processors, and 8 bytes on 64-bit processors. + * However, I did not want to worry about edge case behavior of some of + these algorithms for extremely large values of `n`. * The behavior of the sorting algorithms with a `data` size of exactly `n = 65535` has not been validated. - * Some algorithms may be buggy in this edge case due to integer overflows. + * Some algorithms may be buggy because this edge case may trigger + an integer overflow. * The actual maximum value of `n` may actually be `65534` for some algorithms. * Some of the Comb Sort algorithms have even lower limits of `n` due to integer @@ -835,14 +837,13 @@ handful, but I found them unsuitable for me. `quickSortMiddle()` provided by this library. * No unit tests provided. * https://github.com/arduino-libraries/Arduino_AVRSTL - * Provides a template `sort()` function. - * Often STL library functions are too general, therefore, too bloated for - many resource constrained environments. I suspect that the STL `sort()` - function falls into this category. + * Provides a template `sort()` function, which delegates to `stable_sort()`. + * But this implementation is a bubble sort which is `O(N^2)` and + is not even stable. + * In fairness, there is a "FIXME" note in the code which + implies that a better algorithm ought to be provided. * The library is configured to target only the `avr` and `megaavr` - platforms. Does it work on other processors? I don't know, and I don't - want to spend the time to figure that out, because working with the STL - code is too painful. + platforms. * No unit tests provided. Here are some of the reasons that I created my own library: @@ -856,10 +857,10 @@ Here are some of the reasons that I created my own library: algorithms. I wanted to know these numbers precisely so that I could make informed trade off decisions. * I did not want to deal with the complexity of the C++ STL library. It is just - too painful in an embedded environment. + too painful in small embedded programming projects. * Lastly, I wanted to implement my own sorting routines to make sure that I had - a complete understanding of each algorithm. I had forgotten so much since my - undergraduate years. + a complete understanding of each algorithm. I had forgotten so much since + learning many of these in my undergraduate years. ## License From d47d1c700263bab248d8d10585eb6dc0d1850774 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Mon, 23 Aug 2021 09:34:47 -0700 Subject: [PATCH 13/17] README.md: Update Tool Chain versions to ArduinoCLI 0.15.2 and Teensyduino 1.54 --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index d5f4816..5474030 100644 --- a/README.md +++ b/README.md @@ -757,7 +757,7 @@ The following boards are **not** supported: ### Tool Chain * [Arduino IDE 1.8.13](https://www.arduino.cc/en/Main/Software) -* [Arduino CLI 0.14.0](https://arduino.github.io/arduino-cli) +* [Arduino CLI 0.15.2](https://arduino.github.io/arduino-cli) * [SpenceKonde ATTinyCore 1.5.2](https://github.com/SpenceKonde/ATTinyCore) * [Arduino AVR Boards 1.8.3](https://github.com/arduino/ArduinoCore-avr) * [Arduino SAMD Boards 1.8.9](https://github.com/arduino/ArduinoCore-samd) @@ -766,7 +766,7 @@ The following boards are **not** supported: * [STM32duino 2.0.0](https://github.com/stm32duino/Arduino_Core_STM32) * [ESP8266 Arduino 2.7.4](https://github.com/esp8266/Arduino) * [ESP32 Arduino 1.0.6](https://github.com/espressif/arduino-esp32) -* [Teensyduino 1.53](https://www.pjrc.com/teensy/td_download.html) +* [Teensyduino 1.54](https://www.pjrc.com/teensy/td_download.html) ### Operating System From 13f8c17cafeec517797e6ce294adeb539bf6c436 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Mon, 23 Aug 2021 10:37:57 -0700 Subject: [PATCH 14/17] Bump version to v0.3 --- CHANGELOG.md | 1 + README.md | 51 ++++++++++++++----- docs/doxygen.cfg | 4 +- examples/AutoBenchmark/README.md | 4 +- examples/AutoBenchmark/generate_readme.py | 4 +- examples/MemoryBenchmark/README.md | 6 +-- examples/MemoryBenchmark/generate_readme.py | 6 +-- examples/WorstCaseBenchmark/README.md | 2 +- .../WorstCaseBenchmark/generate_readme.py | 2 +- library.properties | 2 +- src/AceSorting.h | 4 +- 11 files changed, 55 insertions(+), 31 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d0cd49a..03412fa 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,7 @@ # Changelog * Unreleased +* v0.3 (2021-08-23) * Add 3-argument versions of each sorting function which accepts a lambda expression or function pointer that evalutes the general "less-than" comparison between 2 elements in the array. diff --git a/README.md b/README.md index 5474030..fa23189 100644 --- a/README.md +++ b/README.md @@ -46,7 +46,7 @@ Supports the following algorithms: * It is 2-3X slower than the `quickSortXxx()` functions in this library, and consumes 4-5X more in flash bytes. -**Version**: 0.2 (2021-08-06) +**Version**: 0.3 (2021-08-23) **Changelog**: [CHANGELOG.md](CHANGELOG.md) @@ -138,17 +138,16 @@ void loop() {} ## Installation -The latest stable release will eventually be available in the Arduino IDE -Library Manager. Search for "AceSorting". Click install. (It is not there -yet.) +The latest stable release is available in the Arduino IDE Library Manager. +Search for "AceSorting". Click install. The development version can be installed by cloning the [GitHub repository](https://github.com/bxparks/AceSorting), checking out the -`develop` branch, then manually copying over the contents to the `./libraries` -directory used by the Arduino IDE. (The result is a directory named -`./libraries/AceSorting`.) +`develop` branch, then manually copying over to or creating a symlink from the +`./libraries` directory used by the Arduino IDE. (The result is a directory +or link named `./libraries/AceSorting`.) -The `master` branch contains the stable release. +The `master` branch contains the stable releases. ### Source Code @@ -183,9 +182,10 @@ Some of the examples may depend on: ### Examples * [examples/HelloSorting](examples/HelloSorting) - * A demo of one of the sorting functions. + * A simple demo of one of the sorting functions. * [examples/CompoundSortingDemo](examples/CompoundSortingDemo) - * Sorting by `name`, then break any ties by sorting by `score`. + * A more complex example of sorting by a compound key, first by + `score`, then breaking any ties by `name`. * Benchmarks * [examples/MemoryBenchmark](examples/MemoryBenchmark) * Determine flash and static RAM consumption of various algorithms. @@ -193,7 +193,7 @@ Some of the examples may depend on: * Determine CPU runtime of various algorithms. * [examples/WorstCaseBenchmark](examples/WorstCaseBenchmark) * Determine CPU runtime of worst case input data (e.g. sorted, reverse - sorted). + sorted). ## Usage @@ -205,7 +205,8 @@ Only a single header file `AceSorting.h` is required to use this library. To prevent name clashes with other libraries that the calling code may use, all classes are defined in the `ace_sorting` namespace. To use the code without prepending the `ace_sorting::` prefix, use the `using` directive to select the -specific algorithm: +specific algorithm. For example, to use the `shellSortKnut()` function, use +something like this: ```C++ #include @@ -231,6 +232,9 @@ void bubbleSort(T data[], uint16_t n); * Additional ram consumption: none * Runtime complexity: `O(N^2)` * Stable sort: Yes +* Performance Notes: + * If `data[]` is already sorted, this is `O(N)`. + * Worst performance `O(N^2)` when data is reverse sorted. * **Not recommended** @@ -251,6 +255,9 @@ void insertionSort(T data[], uint16_t n); * Additional ram consumption: none * Runtime complexity: `O(N^2)` but 5-6X faster than `bubbleSort()` * Stable sort: Yes +* Performance Notes: + * If `data[]` is already sorted, this algorithm is `O(N)`. + * Worst performance `O(N^2)` when data is reverse sorted. * **Recommendation**: Use for N smaller than about 100 and only if you need a stable sort @@ -272,6 +279,9 @@ void selectionSort(T data[], uint16_t n); * Additional ram consumption: none * Runtime complexity: `O(N^2)` but 2X slower than `insertionSort()` * Stable sort: No +* Performance Notes: + * Little change in performance when data is already sorted or reverse + sorted. * **Not recommended**: * Larger and slower than `insertionSort()` but is not a stable sort. * The only thing it has going for it is that it has the least number of @@ -303,6 +313,10 @@ void shellSortTokuda(T data[], uint16_t n); * Additional ram consumption: none * Runtime complexity: `O(N^k)` where `k=1.3 to 1.5` * Stable sort: No +* Performance Notes: + * As fast as Quick Sort for `N < ~100`. + * Little change in performance when data is already sorted or reverse + sorted. * **Recomendation**: Use `shellSortKnuth()`, which seems consistently faster than `shellSortClassic()`, just as fast as `shellSortTokuda()` but is simpler and takes less flash memory than `shellSortTokuda()`. @@ -336,12 +350,17 @@ void combSort133m(T data[], uint16_t n); * Additional ram consumption: none * Runtime complexity: `O(N^k)` where k seems similar to Shell Sort * Stable sort: No +* Performance Notes: + * Slightly slower than Shell Sort over similar data sets. + * Little change in performance when data is already sorted or reverse + sorted. * Upper limits: * `combSort13()` and `combSort13m()`: `n = 6553` on 8-bit AVR processors due to integer overflow. * `combSort133()` and `combSort133m()`: `n = 21845` on 8-bit AVR processors due to integer overflow. * **Recommendation**: + * Prefer Shell Sort over Comb Sort in most situations. * Use `combSort133()` on 8-bit processors. * Use `combSort13m()` on 32-bit processors. @@ -395,6 +414,10 @@ void quickSortMedianSwapped(T data[], uint16_t n); * Additional ram consumption: `O(log(N))` bytes on stack due to recursion * Runtime complexity: `O(N log(N))` * Stable sort: No +* Performance Notes: + * Fastest algorithm for large (`N > ~100`) data sets. + * Little change in performance when data is already sorted or reverse + sorted. * **Recommendation** * Avoid on 8-bit processors with limited ram due to extra stack usage by recursion. @@ -838,8 +861,8 @@ handful, but I found them unsuitable for me. * No unit tests provided. * https://github.com/arduino-libraries/Arduino_AVRSTL * Provides a template `sort()` function, which delegates to `stable_sort()`. - * But this implementation is a bubble sort which is `O(N^2)` and - is not even stable. + * But this implementation is a bubble sort which is `O(N^2)` and in practice + much slower than `insertionSort(). * In fairness, there is a "FIXME" note in the code which implies that a better algorithm ought to be provided. * The library is configured to target only the `avr` and `megaavr` diff --git a/docs/doxygen.cfg b/docs/doxygen.cfg index fa4b787..a1aaef4 100644 --- a/docs/doxygen.cfg +++ b/docs/doxygen.cfg @@ -38,13 +38,13 @@ PROJECT_NAME = "AceSorting" # could be handy for archiving the generated documentation or if some version # control system is used. -PROJECT_NUMBER = 0.2 +PROJECT_NUMBER = 0.3 # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a # quick idea about the purpose of the project. Keep the description short. -PROJECT_BRIEF = "Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)" +PROJECT_BRIEF = "Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)" # With the PROJECT_LOGO tag one can specify a logo or an icon that is included # in the documentation. The maximum height of the logo should not exceed 55 diff --git a/examples/AutoBenchmark/README.md b/examples/AutoBenchmark/README.md index c72b26f..02bd87b 100644 --- a/examples/AutoBenchmark/README.md +++ b/examples/AutoBenchmark/README.md @@ -2,7 +2,7 @@ Determine the speed of various AceSorting functions, for various array sizes. -**Version**: AceSorting v0.2 +**Version**: AceSorting v0.3 **DO NOT EDIT**: This file was auto-generated using `make README.md`. @@ -54,7 +54,7 @@ $ make README.md * The C-library `qsort()` is far slower than the C++ version because it uses a callback to a comparison function through a function pointer. -**v0.2+** +**v0.3** * No performance change after rerouting 2-argument sorting functions into the 3-argument versions using a default lambda expression. diff --git a/examples/AutoBenchmark/generate_readme.py b/examples/AutoBenchmark/generate_readme.py index 16ee0af..5ba16d4 100755 --- a/examples/AutoBenchmark/generate_readme.py +++ b/examples/AutoBenchmark/generate_readme.py @@ -27,7 +27,7 @@ Determine the speed of various AceSorting functions, for various array sizes. -**Version**: AceSorting v0.2 +**Version**: AceSorting v0.3 **DO NOT EDIT**: This file was auto-generated using `make README.md`. @@ -79,7 +79,7 @@ * The C-library `qsort()` is far slower than the C++ version because it uses a callback to a comparison function through a function pointer. -**v0.2+** +**v0.3** * No performance change after rerouting 2-argument sorting functions into the 3-argument versions using a default lambda expression. diff --git a/examples/MemoryBenchmark/README.md b/examples/MemoryBenchmark/README.md index 8248437..53c89f9 100644 --- a/examples/MemoryBenchmark/README.md +++ b/examples/MemoryBenchmark/README.md @@ -5,7 +5,7 @@ memory and static RAM sizes were recorded. The `FEATURE_BASELINE` selection is the baseline, and its memory usage numbers are subtracted from the subsequent `FEATURE_*` memory usage. -**Version**: AceSorting v0.2 +**Version**: AceSorting v0.3 **DO NOT EDIT**: This file was auto-generated using `make README.md`. @@ -31,7 +31,7 @@ ASCII table. ## Library Size Changes -**v0.1.0** +**v0.1** * Initial version. * The memory usage for C-library `qsort()` is suspiciously low on the ESP32, @@ -39,7 +39,7 @@ ASCII table. indicates that the `qsort()` function is already compiled into the ESP32 runtime library. -**v0.2+** +**v0.3** * Add 3-argument version of sorting functions to pass in a comparison predicate, and route the 2-argument version into the 3-argument version. diff --git a/examples/MemoryBenchmark/generate_readme.py b/examples/MemoryBenchmark/generate_readme.py index 043c483..d369a19 100755 --- a/examples/MemoryBenchmark/generate_readme.py +++ b/examples/MemoryBenchmark/generate_readme.py @@ -29,7 +29,7 @@ the baseline, and its memory usage numbers are subtracted from the subsequent `FEATURE_*` memory usage. -**Version**: AceSorting v0.2 +**Version**: AceSorting v0.3 **DO NOT EDIT**: This file was auto-generated using `make README.md`. @@ -55,7 +55,7 @@ ## Library Size Changes -**v0.1.0** +**v0.1** * Initial version. * The memory usage for C-library `qsort()` is suspiciously low on the ESP32, @@ -63,7 +63,7 @@ indicates that the `qsort()` function is already compiled into the ESP32 runtime library. -**v0.2+** +**v0.3** * Add 3-argument version of sorting functions to pass in a comparison predicate, and route the 2-argument version into the 3-argument version. diff --git a/examples/WorstCaseBenchmark/README.md b/examples/WorstCaseBenchmark/README.md index e5a1461..5e3af6b 100644 --- a/examples/WorstCaseBenchmark/README.md +++ b/examples/WorstCaseBenchmark/README.md @@ -7,7 +7,7 @@ could trigger worst case runtime. Three types of arrays are tested: * already sorted array * reverse sorted array -**Version**: AceSorting v0.2 +**Version**: AceSorting v0.3 **DO NOT EDIT**: This file was auto-generated using `make README.md`. diff --git a/examples/WorstCaseBenchmark/generate_readme.py b/examples/WorstCaseBenchmark/generate_readme.py index 6f99678..1e53a6b 100755 --- a/examples/WorstCaseBenchmark/generate_readme.py +++ b/examples/WorstCaseBenchmark/generate_readme.py @@ -32,7 +32,7 @@ * already sorted array * reverse sorted array -**Version**: AceSorting v0.2 +**Version**: AceSorting v0.3 **DO NOT EDIT**: This file was auto-generated using `make README.md`. diff --git a/library.properties b/library.properties index 0f49b01..e5b9fab 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=AceSorting -version=0.2.0 +version=0.3.0 author=Brian T. Park maintainer=Brian T. Park sentence=Various sorting algorithms for Arduino, including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions). diff --git a/src/AceSorting.h b/src/AceSorting.h index 522fd1a..4f64fe4 100644 --- a/src/AceSorting.h +++ b/src/AceSorting.h @@ -43,8 +43,8 @@ SOFTWARE. #endif // Version format: xxyyzz == "xx.yy.zz" -#define ACE_SORTING_VERSION 200 -#define ACE_SORTING_VERSION_STRING "0.2.0" +#define ACE_SORTING_VERSION 300 +#define ACE_SORTING_VERSION_STRING "0.3.0" #include "ace_sorting/swap.h" #include "ace_sorting/bubbleSort.h" From bf4b994b546ccf2bff83a6bb03fa9487af6a736c Mon Sep 17 00:00:00 2001 From: Brian Park Date: Mon, 23 Aug 2021 10:46:43 -0700 Subject: [PATCH 15/17] src/*.h: Convert comments for ACE_SORTING_DIRECT_{xxx} into doxygen docstrings to silence warnings --- src/ace_sorting/bubbleSort.h | 10 ++++++---- src/ace_sorting/combSort.h | 10 ++++++---- src/ace_sorting/insertionSort.h | 10 ++++++---- src/ace_sorting/quickSort.h | 16 ++++++++++------ src/ace_sorting/selectionSort.h | 10 ++++++---- src/ace_sorting/shellSort.h | 10 ++++++---- 6 files changed, 40 insertions(+), 26 deletions(-) diff --git a/src/ace_sorting/bubbleSort.h b/src/ace_sorting/bubbleSort.h index 5af6225..616b6ca 100644 --- a/src/ace_sorting/bubbleSort.h +++ b/src/ace_sorting/bubbleSort.h @@ -33,11 +33,13 @@ SOFTWARE. #include "swap.h" -// If set to 1, use the direct inlined implementation of the 2-argument -// bubbleSort(). Otherwise, use the 3-argument bubbleSort() to implement -// 2-argument bubbleSort(). For bubbleSort, the compiler will optimize both -// versions to be identical. #if ! defined(ACE_SORTING_DIRECT_BUBBLE_SORT) + /** + * If set to 1, use the direct inlined implementation of the 2-argument + * bubbleSort(). Otherwise, use the 3-argument bubbleSort() to implement + * 2-argument bubbleSort(). For bubbleSort, the compiler will optimize both + * versions to be identical. + */ #define ACE_SORTING_DIRECT_BUBBLE_SORT 0 #endif diff --git a/src/ace_sorting/combSort.h b/src/ace_sorting/combSort.h index 56237b8..e3da961 100644 --- a/src/ace_sorting/combSort.h +++ b/src/ace_sorting/combSort.h @@ -33,11 +33,13 @@ SOFTWARE. #include "swap.h" -// If set to 1, use the direct inlined implementation of the 2-argument -// combSortXxx(). Otherwise, use the 3-argument combSortXxx() to implement -// 2-argument combSortXxx(). For combSortXxx(), the compiler will optimize both -// versions to be identical. #if ! defined(ACE_SORTING_DIRECT_COMB_SORT) + /** + * If set to 1, use the direct inlined implementation of the 2-argument + * combSortXxx(). Otherwise, use the 3-argument combSortXxx() to implement + * 2-argument combSortXxx(). For combSortXxx(), the compiler will optimize + * both versions to be identical. + */ #define ACE_SORTING_DIRECT_COMB_SORT 0 #endif diff --git a/src/ace_sorting/insertionSort.h b/src/ace_sorting/insertionSort.h index 659dcea..7117b71 100644 --- a/src/ace_sorting/insertionSort.h +++ b/src/ace_sorting/insertionSort.h @@ -32,11 +32,13 @@ SOFTWARE. #ifndef ACE_SORTING_INSERTION_SORT_H #define ACE_SORTING_INSERTION_SORT_H -// If set to 1, use the direct inlined implementation of the 2-argument -// insertionSort(). Otherwise, use the 3-argument insertionSort() to implement -// 2-argument insertionSort(). For insertionSort(), the compiler will optimize -// both versions to be identical. #if ! defined(ACE_SORTING_DIRECT_INSERTION_SORT) + /** + * If set to 1, use the direct inlined implementation of the 2-argument + * insertionSort(). Otherwise, use the 3-argument insertionSort() to implement + * 2-argument insertionSort(). For insertionSort(), the compiler will optimize + * both versions to be identical. + */ #define ACE_SORTING_DIRECT_INSERTION_SORT 0 #endif diff --git a/src/ace_sorting/quickSort.h b/src/ace_sorting/quickSort.h index 78006e5..7ffa9b4 100644 --- a/src/ace_sorting/quickSort.h +++ b/src/ace_sorting/quickSort.h @@ -34,13 +34,17 @@ SOFTWARE. #include "swap.h" -// If set to 1, use the direct inlined implementation of the 2-argument -// quickSortXxx(). Otherwise, use the 3-argument quickSortXxx() to implement -// 2-argument quickSortXxx(). Unlike other sorting algorithms, the compiler -// cannot seem to optimize away the extra level of indirection, probably due to -// the recursive calls. We save 40 bytes of flash (out of 200-300 bytes) if we -// use the direct inlined version for the 2-argument variant. Set this to 1. #if ! defined(ACE_SORTING_DIRECT_QUICK_SORT) + /** + * If set to 1, use the direct inlined implementation of the 2-argument + * quickSortXxx(). Otherwise, use the 3-argument quickSortXxx() to implement + * 2-argument quickSortXxx(). + * + * Unlike other sorting algorithms, the compiler cannot seem to optimize away + * the extra level of indirection, probably due to the recursive calls. We + * save 40 bytes of flash (out of 200-300 bytes) by setting this to 1 so that + * the 2-argument variant is manually inlined. + */ #define ACE_SORTING_DIRECT_QUICK_SORT 1 #endif diff --git a/src/ace_sorting/selectionSort.h b/src/ace_sorting/selectionSort.h index c283736..c09eadf 100644 --- a/src/ace_sorting/selectionSort.h +++ b/src/ace_sorting/selectionSort.h @@ -36,11 +36,13 @@ SOFTWARE. namespace ace_sorting { -// If set to 1, use the direct inlined implementation of the 2-argument -// selectionSort(). Otherwise, use the 3-argument selectionSort() to implement -// 2-argument selectionSort(). For selectionSort(), the compiler will optimize -// both versions to be identical. #if ! defined(ACE_SORTING_DIRECT_SELECTION_SORT) + /** + * If set to 1, use the direct inlined implementation of the 2-argument + * selectionSort(). Otherwise, use the 3-argument selectionSort() to implement + * 2-argument selectionSort(). For selectionSort(), the compiler will optimize + * both versions to be identical. + */ #define ACE_SORTING_DIRECT_SELECTION_SORT 0 #endif diff --git a/src/ace_sorting/shellSort.h b/src/ace_sorting/shellSort.h index c976219..cc8bf5f 100644 --- a/src/ace_sorting/shellSort.h +++ b/src/ace_sorting/shellSort.h @@ -32,11 +32,13 @@ SOFTWARE. #ifndef ACE_SORTING_SHELL_SORT_H #define ACE_SORTING_SHELL_SORT_H -// If set to 1, use the direct inlined implementation of the 2-argument -// shellSortXxx(). Otherwise, use the 3-argument shellSortXxx() to implement -// 2-argument shellSortXxx(). For shellSortXxx(), the compiler will optimize -// both versions to be identical. #if ! defined(ACE_SORTING_DIRECT_SHELL_SORT) + /** + * If set to 1, use the direct inlined implementation of the 2-argument + * shellSortXxx(). Otherwise, use the 3-argument shellSortXxx() to implement + * 2-argument shellSortXxx(). For shellSortXxx(), the compiler will optimize + * both versions to be identical. + */ #define ACE_SORTING_DIRECT_SHELL_SORT 0 #endif From f7447d4cc4ad6281699ae42eaaf3985b728e595b Mon Sep 17 00:00:00 2001 From: Brian Park Date: Mon, 23 Aug 2021 10:47:00 -0700 Subject: [PATCH 16/17] docs: Regenerate doxygen --- docs/html/AceSorting_8h_source.html | 8 +- docs/html/bubbleSort_8h.html | 88 ++++- docs/html/bubbleSort_8h_source.html | 69 +++- docs/html/combSort_8h.html | 267 ++++++++++++- docs/html/combSort_8h_source.html | 341 +++++++++++----- docs/html/dir_000000_000001.html | 4 +- .../dir_54c88fbaa58defb9f1b2842cb9ef0a89.html | 4 +- .../dir_68267d1309a1af8e8297ef4c3efbcdba.html | 4 +- docs/html/files.html | 4 +- docs/html/globals.html | 94 +++++ docs/html/globals_defs.html | 94 +++++ docs/html/graph_legend.html | 4 +- docs/html/index.html | 4 +- docs/html/insertionSort_8h.html | 104 ++++- docs/html/insertionSort_8h__incl.map | 4 - docs/html/insertionSort_8h__incl.md5 | 1 - docs/html/insertionSort_8h__incl.png | Bin 5022 -> 0 bytes docs/html/insertionSort_8h_source.html | 101 +++-- docs/html/menudata.js | 5 +- docs/html/quickSort_8h.html | 207 +++++++++- docs/html/quickSort_8h_source.html | 360 ++++++++++++----- docs/html/search/all_0.js | 8 +- docs/html/search/all_1.js | 4 +- docs/html/search/all_2.js | 10 +- docs/html/search/all_3.js | 4 +- docs/html/search/all_4.js | 8 +- docs/html/search/all_5.js | 16 +- docs/html/search/defines_0.html | 30 ++ docs/html/search/defines_0.js | 9 + docs/html/search/files_0.js | 2 +- docs/html/search/files_1.js | 2 +- docs/html/search/files_2.js | 2 +- docs/html/search/files_3.js | 2 +- docs/html/search/files_4.js | 6 +- docs/html/search/functions_0.js | 2 +- docs/html/search/functions_1.js | 8 +- docs/html/search/functions_2.js | 2 +- docs/html/search/functions_3.js | 6 +- docs/html/search/functions_4.js | 10 +- docs/html/search/pages_0.js | 2 +- docs/html/search/searchdata.js | 9 +- docs/html/selectionSort_8h.html | 92 ++++- docs/html/selectionSort_8h_source.html | 134 ++++--- docs/html/shellSort_8h.html | 227 +++++++++-- docs/html/shellSort_8h__incl.map | 4 - docs/html/shellSort_8h__incl.md5 | 1 - docs/html/shellSort_8h__incl.png | Bin 4934 -> 0 bytes docs/html/shellSort_8h_source.html | 373 ++++++++++++------ docs/html/swap_8h.html | 14 +- docs/html/swap_8h__dep__incl.map | 10 +- docs/html/swap_8h__dep__incl.md5 | 2 +- docs/html/swap_8h__dep__incl.png | Bin 41777 -> 30006 bytes docs/html/swap_8h_source.html | 4 +- 53 files changed, 2166 insertions(+), 604 deletions(-) create mode 100644 docs/html/globals.html create mode 100644 docs/html/globals_defs.html delete mode 100644 docs/html/insertionSort_8h__incl.map delete mode 100644 docs/html/insertionSort_8h__incl.md5 delete mode 100644 docs/html/insertionSort_8h__incl.png create mode 100644 docs/html/search/defines_0.html create mode 100644 docs/html/search/defines_0.js delete mode 100644 docs/html/shellSort_8h__incl.map delete mode 100644 docs/html/shellSort_8h__incl.md5 delete mode 100644 docs/html/shellSort_8h__incl.png diff --git a/docs/html/AceSorting_8h_source.html b/docs/html/AceSorting_8h_source.html index 8f8b7f4..07d70c8 100644 --- a/docs/html/AceSorting_8h_source.html +++ b/docs/html/AceSorting_8h_source.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -105,8 +105,8 @@
43 #endif
44 
45 // Version format: xxyyzz == "xx.yy.zz"
-
46 #define ACE_SORTING_VERSION 200
-
47 #define ACE_SORTING_VERSION_STRING "0.2.0"
+
46 #define ACE_SORTING_VERSION 300
+
47 #define ACE_SORTING_VERSION_STRING "0.3.0"
48 
49 #include "ace_sorting/swap.h"
50 #include "ace_sorting/bubbleSort.h"
diff --git a/docs/html/bubbleSort_8h.html b/docs/html/bubbleSort_8h.html index c7db59b..0c60971 100644 --- a/docs/html/bubbleSort_8h.html +++ b/docs/html/bubbleSort_8h.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -68,6 +68,7 @@
+Macros | Functions
bubbleSort.h File Reference
@@ -95,20 +96,50 @@

Go to the source code of this file.

+ + + + +

+Macros

#define ACE_SORTING_DIRECT_BUBBLE_SORT   0
 If set to 1, use the direct inlined implementation of the 2-argument bubbleSort(). More...
 
+ + + +

Functions

template<typename T >
void ace_sorting::bubbleSort (T data[], uint16_t n)
 Bubble sort. More...
 
template<typename T , typename F >
void ace_sorting::bubbleSort (T data[], uint16_t n, F &&lessThan)
 Same as the 2-argument bubbleSort() with the addition of a lessThan lambda expression or function. More...
 

Detailed Description

Bubble sort.

Definition in file bubbleSort.h.

-

Function Documentation

+

Macro Definition Documentation

+ +

◆ ACE_SORTING_DIRECT_BUBBLE_SORT

+ +
+
+ + + + +
#define ACE_SORTING_DIRECT_BUBBLE_SORT   0
+
+ +

If set to 1, use the direct inlined implementation of the 2-argument bubbleSort().

+

Otherwise, use the 3-argument bubbleSort() to implement 2-argument bubbleSort(). For bubbleSort, the compiler will optimize both versions to be identical.

+ +

Definition at line 43 of file bubbleSort.h.

+ +
+
+

Function Documentation

-

◆ bubbleSort()

+

◆ bubbleSort() [1/2]

@@ -144,7 +175,54 @@

Definition at line 45 of file bubbleSort.h.

+

Definition at line 70 of file bubbleSort.h.

+ +

+
+ +

◆ bubbleSort() [2/2]

+ +
+
+
+template<typename T , typename F >
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::bubbleSort (T data[],
uint16_t n,
F && lessThan 
)
+
+ +

Same as the 2-argument bubbleSort() with the addition of a lessThan lambda expression or function.

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 84 of file bubbleSort.h.

diff --git a/docs/html/bubbleSort_8h_source.html b/docs/html/bubbleSort_8h_source.html index 7bb4d5f..cc1f828 100644 --- a/docs/html/bubbleSort_8h_source.html +++ b/docs/html/bubbleSort_8h_source.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -100,29 +100,56 @@
33 
34 #include "swap.h"
35 
-
36 namespace ace_sorting {
+
36 #if ! defined(ACE_SORTING_DIRECT_BUBBLE_SORT)
37 
-
44 template <typename T>
-
45 void bubbleSort(T data[], uint16_t n) {
-
46  bool swapped;
-
47  do {
-
48  swapped = false;
-
49  for (uint16_t i = 1; i < n; i++) {
-
50  if (data[i - 1] > data[i]) {
-
51  swap(data[i - 1], data[i]);
-
52  swapped = true;
-
53  }
-
54  }
-
55  } while (swapped);
-
56 }
-
57 
-
58 }
-
59 
-
60 #endif
+
43  #define ACE_SORTING_DIRECT_BUBBLE_SORT 0
+
44 #endif
+
45 
+
46 namespace ace_sorting {
+
47 
+
54 #if ACE_SORTING_DIRECT_BUBBLE_SORT
+
55 template <typename T>
+
56 void bubbleSort(T data[], uint16_t n) {
+
57  bool swapped;
+
58  do {
+
59  swapped = false;
+
60  for (uint16_t i = 1; i < n; i++) {
+
61  if (data[i] < data[i - 1]) {
+
62  swap(data[i - 1], data[i]);
+
63  swapped = true;
+
64  }
+
65  }
+
66  } while (swapped);
+
67 }
+
68 #else
+
69 template <typename T>
+
70 void bubbleSort(T data[], uint16_t n) {
+
71  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
72  bubbleSort(data, n, lessThan);
+
73 }
+
74 #endif
+
75 
+
83 template <typename T, typename F>
+
84 void bubbleSort(T data[], uint16_t n, F&& lessThan) {
+
85  bool swapped;
+
86  do {
+
87  swapped = false;
+
88  for (uint16_t i = 1; i < n; i++) {
+
89  if (lessThan(data[i], data[i - 1])) {
+
90  swap(data[i - 1], data[i]);
+
91  swapped = true;
+
92  }
+
93  }
+
94  } while (swapped);
+
95 }
+
96 
+
97 }
+
98 
+
99 #endif
ace_sorting::swap
void swap(T &a, T &b)
Swap the parameters.
Definition: swap.h:41
-
ace_sorting::bubbleSort
void bubbleSort(T data[], uint16_t n)
Bubble sort.
Definition: bubbleSort.h:45
+
ace_sorting::bubbleSort
void bubbleSort(T data[], uint16_t n)
Bubble sort.
Definition: bubbleSort.h:70
Generated by   diff --git a/docs/html/combSort_8h.html b/docs/html/combSort_8h.html index ddde37a..f276a1d 100644 --- a/docs/html/combSort_8h.html +++ b/docs/html/combSort_8h.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -68,6 +68,7 @@
+Macros | Functions
combSort.h File Reference
@@ -95,32 +96,74 @@

Go to the source code of this file.

+ + + + +

+Macros

#define ACE_SORTING_DIRECT_COMB_SORT   0
 If set to 1, use the direct inlined implementation of the 2-argument combSortXxx(). More...
 
+ + + + - + + + + + + + + + - + + + + +

Functions

template<typename T >
void ace_sorting::combSort13 (T data[], uint16_t n)
 Comb sort using a gap factor of 1.3 (successive gap is multiplied by 10 / 13). More...
 
template<typename T , typename F >
void ace_sorting::combSort13 (T data[], uint16_t n, F &&lessThan)
 Same as the 2-argument combSort13() with the addition of a lessThan lambda expression or function. More...
 
template<typename T >
void ace_sorting::combSort13m (T data[], uint16_t n)
 Same as combSort13() with the modification that if the gap is 9 or 10, it is set to 11, so that the gap sequence becomes (11, 8, 6, 4, 3, 2, 1). More...
 Same as combSort13() with the modification that if the gap is 9 or 10, it is set to 11, so that the gap sequence becomes (11, 8, 6, 4, 3, 2, 1). More...
 
template<typename T , typename F >
void ace_sorting::combSort13m (T data[], uint16_t n, F &&lessThan)
 Same as the 2-argument combSort13m() with the addition of a lessThan lambda expression or function. More...
 
template<typename T >
void ace_sorting::combSort133 (T data[], uint16_t n)
 Comb sort using a gap factor of 4/3=1.33 (successive gap is multiplied by 3 / 4). More...
 
template<typename T , typename F >
void ace_sorting::combSort133 (T data[], uint16_t n, F &&lessThan)
 Same as the 2-argument combSort133() with the addition of a lessThan lambda expression or function. More...
 
template<typename T >
void ace_sorting::combSort133m (T data[], uint16_t n)
 Same as combSort133() but modified so that a gap of 9 or 10 becomes gap=11 so that the final sequence becomes (11, 8, 6, 4, 3, 2, 1). More...
 Same as combSort133() but modified so that a gap of 9 or 10 becomes gap=11 so that the final sequence becomes (11, 8, 6, 4, 3, 2, 1). More...
 
template<typename T , typename F >
void ace_sorting::combSort133m (T data[], uint16_t n, F &&lessThan)
 Same as the 2-argument combSort133m() with the addition of a lessThan lambda expression or function. More...
 

Detailed Description

Comb sort.

Definition in file combSort.h.

-

Function Documentation

+

Macro Definition Documentation

+ +

◆ ACE_SORTING_DIRECT_COMB_SORT

+ +
+
+ + + + +
#define ACE_SORTING_DIRECT_COMB_SORT   0
+
+ +

If set to 1, use the direct inlined implementation of the 2-argument combSortXxx().

+

Otherwise, use the 3-argument combSortXxx() to implement 2-argument combSortXxx(). For combSortXxx(), the compiler will optimize both versions to be identical.

+ +

Definition at line 43 of file combSort.h.

+ +
+
+

Function Documentation

-

◆ combSort13()

+

◆ combSort13() [1/2]

@@ -157,12 +200,59 @@

Definition at line 50 of file combSort.h.

+

Definition at line 82 of file combSort.h.

+ +

+
+ +

◆ combSort13() [2/2]

+ +
+
+
+template<typename T , typename F >
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::combSort13 (T data[],
uint16_t n,
F && lessThan 
)
+
+ +

Same as the 2-argument combSort13() with the addition of a lessThan lambda expression or function.

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 98 of file combSort.h.

-

◆ combSort133()

+

◆ combSort133() [1/2]

@@ -191,8 +281,8 @@

combSort13() on average.

-

On 32-bit or 64-bit processors with hardware division, experimentation shows that this algorithm is actually slightly slower on average than combSort13(). And it seems to have a slightly higher variance, with some input data causing large spikes in runtime compared to the average.

+

This gap ratio seemed appealing because the division by 4 will be optimized by the compiler into a right shift of 2 bits, so this algorithm does not perform any integer division. Experimentation on 8-bit processors without hardware dvision shows that this algorithm is slightly faster than combSort13() on average.

+

On 32-bit or 64-bit processors with hardware division, on larger input data, experimentation shows that this algorithm is actually slightly slower on average than combSort13(). And it seems to have a slightly higher variance, with some input data causing large spikes in runtime compared to the average.

Average complexity: O(n^2 / 2^p). See https://en.wikipedia.org/wiki/Comb_sort

Template Parameters
@@ -201,12 +291,59 @@

Definition at line 130 of file combSort.h.

+

Definition at line 247 of file combSort.h.

+ + + + +

◆ combSort133() [2/2]

+ +
+
+
+template<typename T , typename F >
+

+ + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::combSort133 (T data[],
uint16_t n,
F && lessThan 
)
+

+ +

Same as the 2-argument combSort133() with the addition of a lessThan lambda expression or function.

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 263 of file combSort.h.

-

◆ combSort133m()

+

◆ combSort133m() [1/2]

@@ -233,8 +370,8 @@

-

Same as combSort133() but modified so that a gap of 9 or 10 becomes gap=11 so that the final sequence becomes (11, 8, 6, 4, 3, 2, 1).

-

Experimentation shows that this is often slightly slower than than combSort133(), probably due to the extra if/then/else statements in the loop.

+

Same as combSort133() but modified so that a gap of 9 or 10 becomes gap=11 so that the final sequence becomes (11, 8, 6, 4, 3, 2, 1).

+

Experimentation shows that this is often slightly slower than than combSort133(), probably due to the extra if/then/else statements in the loop.

Average complexity: O(n^2 / 2^p). See https://en.wikipedia.org/wiki/Comb_sort

Template Parameters
@@ -243,12 +380,59 @@

Definition at line 162 of file combSort.h.

+

Definition at line 323 of file combSort.h.

+ + + + +

◆ combSort133m() [2/2]

+ +
+
+
+template<typename T , typename F >
+

+ + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::combSort133m (T data[],
uint16_t n,
F && lessThan 
)
+

+ +

Same as the 2-argument combSort133m() with the addition of a lessThan lambda expression or function.

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 339 of file combSort.h.

-

◆ combSort13m()

+

◆ combSort13m() [1/2]

@@ -275,7 +459,7 @@

-

Same as combSort13() with the modification that if the gap is 9 or 10, it is set to 11, so that the gap sequence becomes (11, 8, 6, 4, 3, 2, 1).

+

Same as combSort13() with the modification that if the gap is 9 or 10, it is set to 11, so that the gap sequence becomes (11, 8, 6, 4, 3, 2, 1).

For reasons that I don't understand, this makes the algorithm faster and more resistence to outliers.

Average complexity: O(n^2 / 2^p). See https://en.wikipedia.org/wiki/Comb_sort and https://rosettacode.org/wiki/Sorting_algorithms/Comb_sort.

Template Parameters
@@ -285,7 +469,54 @@

Definition at line 83 of file combSort.h.

+

Definition at line 159 of file combSort.h.

+ +

+
+ +

◆ combSort13m() [2/2]

+ +
+
+
+template<typename T , typename F >
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::combSort13m (T data[],
uint16_t n,
F && lessThan 
)
+
+ +

Same as the 2-argument combSort13m() with the addition of a lessThan lambda expression or function.

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 175 of file combSort.h.

diff --git a/docs/html/combSort_8h_source.html b/docs/html/combSort_8h_source.html index b3f9820..c8cfca4 100644 --- a/docs/html/combSort_8h_source.html +++ b/docs/html/combSort_8h_source.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -100,110 +100,253 @@
33 
34 #include "swap.h"
35 
-
36 namespace ace_sorting {
+
36 #if ! defined(ACE_SORTING_DIRECT_COMB_SORT)
37 
-
49 template <typename T>
-
50 void combSort13(T data[], uint16_t n) {
-
51  bool swapped = true;
-
52 
-
53  uint16_t gap = n;
-
54  while (swapped || gap > 1) {
-
55  gap = gap * 10 / 13;
-
56  if (gap == 0) gap = 1;
-
57  swapped = false;
-
58 
-
59  uint16_t i;
-
60  uint16_t j;
-
61  for (i = 0, j = gap; j < n; i++, j++) {
-
62  if (data[i] > data[j]) {
-
63  swap(data[i], data[j]);
-
64  swapped = true;
-
65  }
-
66  }
-
67  }
-
68 }
+
43  #define ACE_SORTING_DIRECT_COMB_SORT 0
+
44 #endif
+
45 
+
46 namespace ace_sorting {
+
47 
+
59 #if ACE_SORTING_DIRECT_COMB_SORT
+
60 template <typename T>
+
61 void combSort13(T data[], uint16_t n) {
+
62  bool swapped = true;
+
63 
+
64  uint16_t gap = n;
+
65  while (swapped || gap > 1) {
+
66  gap = gap * 10 / 13;
+
67  if (gap == 0) gap = 1;
+
68  swapped = false;
69 
-
82 template <typename T>
-
83 void combSort13m(T data[], uint16_t n) {
-
84  bool swapped = true;
-
85 
-
86  uint16_t gap = n;
-
87  while (swapped || gap > 1) {
-
88  gap = gap * 10 / 13;
-
89  if (gap == 9 || gap == 10) {
-
90  gap = 11;
-
91  } else if (gap == 0) {
-
92  gap = 1;
-
93  }
-
94  swapped = false;
-
95 
-
96  uint16_t i;
-
97  uint16_t j;
-
98  for (i = 0, j = gap; j < n; i++, j++) {
-
99  if (data[i] > data[j]) {
-
100  swap(data[i], data[j]);
-
101  swapped = true;
-
102  }
-
103  }
-
104  }
-
105 }
+
70  uint16_t i;
+
71  uint16_t j;
+
72  for (i = 0, j = gap; j < n; i++, j++) {
+
73  if (data[j] < data[i]) {
+
74  swap(data[i], data[j]);
+
75  swapped = true;
+
76  }
+
77  }
+
78  }
+
79 }
+
80 #else
+
81 template <typename T>
+
82 void combSort13(T data[], uint16_t n) {
+
83  // This lambda expression does not perform any captures, so the compiler will
+
84  // optimize and inline the less-than expression.
+
85  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
86  combSort13(data, n, lessThan);
+
87 }
+
88 #endif
+
89 
+
97 template <typename T, typename F>
+
98 void combSort13(T data[], uint16_t n, F&& lessThan) {
+
99  bool swapped = true;
+
100 
+
101  uint16_t gap = n;
+
102  while (swapped || gap > 1) {
+
103  gap = gap * 10 / 13;
+
104  if (gap == 0) gap = 1;
+
105  swapped = false;
106 
-
129 template <typename T>
-
130 void combSort133(T data[], uint16_t n) {
-
131  bool swapped = true;
-
132 
-
133  uint16_t gap = n;
-
134  while (swapped || gap > 1) {
-
135  gap = gap * 3 / 4;
-
136  if (gap == 0) gap = 1;
-
137  swapped = false;
-
138 
-
139  uint16_t i;
-
140  uint16_t j;
-
141  for (i = 0, j = gap; j < n; i++, j++) {
-
142  if (data[i] > data[j]) {
-
143  swap(data[i], data[j]);
-
144  swapped = true;
-
145  }
-
146  }
-
147  }
-
148 }
-
149 
-
161 template <typename T>
-
162 void combSort133m(T data[], uint16_t n) {
-
163  bool swapped = true;
-
164 
-
165  uint16_t gap = n;
-
166  while (swapped || gap > 1) {
-
167  gap = gap * 3 / 4;
-
168  if (gap == 9 || gap == 10) {
-
169  gap = 11;
-
170  } else if (gap == 0) {
-
171  gap = 1;
-
172  }
-
173  swapped = false;
-
174 
-
175  uint16_t i;
-
176  uint16_t j;
-
177  for (i = 0, j = gap; j < n; i++, j++) {
-
178  if (data[i] > data[j]) {
-
179  swap(data[i], data[j]);
-
180  swapped = true;
-
181  }
-
182  }
-
183  }
-
184 }
-
185 
-
186 }
+
107  uint16_t i;
+
108  uint16_t j;
+
109  for (i = 0, j = gap; j < n; i++, j++) {
+
110  if (lessThan(data[j], data[i])) {
+
111  swap(data[i], data[j]);
+
112  swapped = true;
+
113  }
+
114  }
+
115  }
+
116 }
+
117 
+
118 //-----------------------------------------------------------------------------
+
119 
+
132 #if ACE_SORTING_DIRECT_COMB_SORT
+
133 template <typename T>
+
134 void combSort13m(T data[], uint16_t n) {
+
135  bool swapped = true;
+
136 
+
137  uint16_t gap = n;
+
138  while (swapped || gap > 1) {
+
139  gap = gap * 10 / 13;
+
140  if (gap == 9 || gap == 10) {
+
141  gap = 11;
+
142  } else if (gap == 0) {
+
143  gap = 1;
+
144  }
+
145  swapped = false;
+
146 
+
147  uint16_t i;
+
148  uint16_t j;
+
149  for (i = 0, j = gap; j < n; i++, j++) {
+
150  if (data[j] < data[i]) {
+
151  swap(data[i], data[j]);
+
152  swapped = true;
+
153  }
+
154  }
+
155  }
+
156 }
+
157 #else
+
158 template <typename T>
+
159 void combSort13m(T data[], uint16_t n) {
+
160  // This lambda expression does not perform any captures, so the compiler will
+
161  // optimize and inline the less-than expression.
+
162  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
163  combSort13m(data, n, lessThan);
+
164 }
+
165 #endif
+
166 
+
174 template <typename T, typename F>
+
175 void combSort13m(T data[], uint16_t n, F&& lessThan) {
+
176  bool swapped = true;
+
177 
+
178  uint16_t gap = n;
+
179  while (swapped || gap > 1) {
+
180  gap = gap * 10 / 13;
+
181  if (gap == 9 || gap == 10) {
+
182  gap = 11;
+
183  } else if (gap == 0) {
+
184  gap = 1;
+
185  }
+
186  swapped = false;
187 
-
188 #endif
+
188  uint16_t i;
+
189  uint16_t j;
+
190  for (i = 0, j = gap; j < n; i++, j++) {
+
191  if (lessThan(data[j], data[i])) {
+
192  swap(data[i], data[j]);
+
193  swapped = true;
+
194  }
+
195  }
+
196  }
+
197 }
+
198 
+
199 //-----------------------------------------------------------------------------
+
200 
+
224 #if ACE_SORTING_DIRECT_COMB_SORT
+
225 template <typename T>
+
226 void combSort133(T data[], uint16_t n) {
+
227  bool swapped = true;
+
228 
+
229  uint16_t gap = n;
+
230  while (swapped || gap > 1) {
+
231  gap = gap * 3 / 4;
+
232  if (gap == 0) gap = 1;
+
233  swapped = false;
+
234 
+
235  uint16_t i;
+
236  uint16_t j;
+
237  for (i = 0, j = gap; j < n; i++, j++) {
+
238  if (data[j] < data[i]) {
+
239  swap(data[i], data[j]);
+
240  swapped = true;
+
241  }
+
242  }
+
243  }
+
244 }
+
245 #else
+
246 template <typename T>
+
247 void combSort133(T data[], uint16_t n) {
+
248  // This lambda expression does not perform any captures, so the compiler will
+
249  // optimize and inline the less-than expression.
+
250  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
251  combSort133(data, n, lessThan);
+
252 }
+
253 #endif
+
254 
+
262 template <typename T, typename F>
+
263 void combSort133(T data[], uint16_t n, F&& lessThan) {
+
264  bool swapped = true;
+
265 
+
266  uint16_t gap = n;
+
267  while (swapped || gap > 1) {
+
268  gap = gap * 3 / 4;
+
269  if (gap == 0) gap = 1;
+
270  swapped = false;
+
271 
+
272  uint16_t i;
+
273  uint16_t j;
+
274  for (i = 0, j = gap; j < n; i++, j++) {
+
275  if (lessThan(data[j], data[i])) {
+
276  swap(data[i], data[j]);
+
277  swapped = true;
+
278  }
+
279  }
+
280  }
+
281 }
+
282 
+
283 //-----------------------------------------------------------------------------
+
284 
+
296 #if ACE_SORTING_DIRECT_COMB_SORT
+
297 template <typename T>
+
298 void combSort133m(T data[], uint16_t n) {
+
299  bool swapped = true;
+
300 
+
301  uint16_t gap = n;
+
302  while (swapped || gap > 1) {
+
303  gap = gap * 3 / 4;
+
304  if (gap == 9 || gap == 10) {
+
305  gap = 11;
+
306  } else if (gap == 0) {
+
307  gap = 1;
+
308  }
+
309  swapped = false;
+
310 
+
311  uint16_t i;
+
312  uint16_t j;
+
313  for (i = 0, j = gap; j < n; i++, j++) {
+
314  if (data[j] < data[i]) {
+
315  swap(data[i], data[j]);
+
316  swapped = true;
+
317  }
+
318  }
+
319  }
+
320 }
+
321 #else
+
322 template <typename T>
+
323 void combSort133m(T data[], uint16_t n) {
+
324  // This lambda expression does not perform any captures, so the compiler will
+
325  // optimize and inline the less-than expression.
+
326  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
327  combSort133m(data, n, lessThan);
+
328 }
+
329 #endif
+
330 
+
338 template <typename T, typename F>
+
339 void combSort133m(T data[], uint16_t n, F&& lessThan) {
+
340  bool swapped = true;
+
341 
+
342  uint16_t gap = n;
+
343  while (swapped || gap > 1) {
+
344  gap = gap * 3 / 4;
+
345  if (gap == 9 || gap == 10) {
+
346  gap = 11;
+
347  } else if (gap == 0) {
+
348  gap = 1;
+
349  }
+
350  swapped = false;
+
351 
+
352  uint16_t i;
+
353  uint16_t j;
+
354  for (i = 0, j = gap; j < n; i++, j++) {
+
355  if (lessThan(data[j], data[i])) {
+
356  swap(data[i], data[j]);
+
357  swapped = true;
+
358  }
+
359  }
+
360  }
+
361 }
+
362 
+
363 }
+
364 
+
365 #endif
ace_sorting::swap
void swap(T &a, T &b)
Swap the parameters.
Definition: swap.h:41
-
ace_sorting::combSort133
void combSort133(T data[], uint16_t n)
Comb sort using a gap factor of 4/3=1.33 (successive gap is multiplied by 3 / 4).
Definition: combSort.h:130
-
ace_sorting::combSort13
void combSort13(T data[], uint16_t n)
Comb sort using a gap factor of 1.3 (successive gap is multiplied by 10 / 13).
Definition: combSort.h:50
-
ace_sorting::combSort133m
void combSort133m(T data[], uint16_t n)
Same as combSort133() but modified so that a gap of 9 or 10 becomes gap=11 so that the final sequence...
Definition: combSort.h:162
-
ace_sorting::combSort13m
void combSort13m(T data[], uint16_t n)
Same as combSort13() with the modification that if the gap is 9 or 10, it is set to 11,...
Definition: combSort.h:83
+
ace_sorting::combSort133
void combSort133(T data[], uint16_t n)
Comb sort using a gap factor of 4/3=1.33 (successive gap is multiplied by 3 / 4).
Definition: combSort.h:247
+
ace_sorting::combSort13
void combSort13(T data[], uint16_t n)
Comb sort using a gap factor of 1.3 (successive gap is multiplied by 10 / 13).
Definition: combSort.h:82
+
ace_sorting::combSort133m
void combSort133m(T data[], uint16_t n)
Same as combSort133() but modified so that a gap of 9 or 10 becomes gap=11 so that the final sequence...
Definition: combSort.h:323
+
ace_sorting::combSort13m
void combSort13m(T data[], uint16_t n)
Same as combSort13() with the modification that if the gap is 9 or 10, it is set to 11,...
Definition: combSort.h:159
Generated by   diff --git a/docs/html/dir_000000_000001.html b/docs/html/dir_000000_000001.html index c9f71da..6c81c55 100644 --- a/docs/html/dir_000000_000001.html +++ b/docs/html/dir_000000_000001.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
diff --git a/docs/html/dir_54c88fbaa58defb9f1b2842cb9ef0a89.html b/docs/html/dir_54c88fbaa58defb9f1b2842cb9ef0a89.html index f7b3589..8bac622 100644 --- a/docs/html/dir_54c88fbaa58defb9f1b2842cb9ef0a89.html +++ b/docs/html/dir_54c88fbaa58defb9f1b2842cb9ef0a89.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
diff --git a/docs/html/dir_68267d1309a1af8e8297ef4c3efbcdba.html b/docs/html/dir_68267d1309a1af8e8297ef4c3efbcdba.html index 06ec96e..5b24517 100644 --- a/docs/html/dir_68267d1309a1af8e8297ef4c3efbcdba.html +++ b/docs/html/dir_68267d1309a1af8e8297ef4c3efbcdba.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
diff --git a/docs/html/files.html b/docs/html/files.html index f3b09a5..187e803 100644 --- a/docs/html/files.html +++ b/docs/html/files.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
diff --git a/docs/html/globals.html b/docs/html/globals.html new file mode 100644 index 0000000..ecf5c21 --- /dev/null +++ b/docs/html/globals.html @@ -0,0 +1,94 @@ + + + + + + + +AceSorting: File Members + + + + + + + + + +
+
+ + + + + + +
+
AceSorting +  0.3 +
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
Here is a list of all documented file members with links to the documentation:
 +
+ +
+Generated by   +doxygen + 1.8.17 +
+ + diff --git a/docs/html/globals_defs.html b/docs/html/globals_defs.html new file mode 100644 index 0000000..9ff9f63 --- /dev/null +++ b/docs/html/globals_defs.html @@ -0,0 +1,94 @@ + + + + + + + +AceSorting: File Members + + + + + + + + + +
+
+ + + + + + +
+
AceSorting +  0.3 +
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+  +
+ +
+Generated by   +doxygen + 1.8.17 +
+ + diff --git a/docs/html/graph_legend.html b/docs/html/graph_legend.html index 6379758..59bb6bd 100644 --- a/docs/html/graph_legend.html +++ b/docs/html/graph_legend.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
diff --git a/docs/html/index.html b/docs/html/index.html index 1b13de0..f195bae 100644 --- a/docs/html/index.html +++ b/docs/html/index.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
diff --git a/docs/html/insertionSort_8h.html b/docs/html/insertionSort_8h.html index 143d769..1062ac4 100644 --- a/docs/html/insertionSort_8h.html +++ b/docs/html/insertionSort_8h.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -68,22 +68,13 @@
+Macros | Functions
insertionSort.h File Reference
-
#include "swap.h"
-
-Include dependency graph for insertionSort.h:
-
-
- - - - -
-
+
This graph shows which files directly or indirectly include this file:
@@ -95,20 +86,50 @@

Go to the source code of this file.

+ + + + +

+Macros

#define ACE_SORTING_DIRECT_INSERTION_SORT   0
 If set to 1, use the direct inlined implementation of the 2-argument insertionSort(). More...
 
+ + + +

Functions

template<typename T >
void ace_sorting::insertionSort (T data[], uint16_t n)
 Insertion sort. More...
 
template<typename T , typename F >
void ace_sorting::insertionSort (T data[], uint16_t n, F &&lessThan)
 Same as the 2-argument insertionSort() with the addition of a lessThan lambda expression or function. More...
 

Detailed Description

-

Insertion sort.

+

Insertion sort. See https://en.wikipedia.org/wiki/Insertion_sort

Definition in file insertionSort.h.

-

Function Documentation

+

Macro Definition Documentation

+ +

◆ ACE_SORTING_DIRECT_INSERTION_SORT

+ +
+
+ + + + +
#define ACE_SORTING_DIRECT_INSERTION_SORT   0
+
+ +

If set to 1, use the direct inlined implementation of the 2-argument insertionSort().

+

Otherwise, use the 3-argument insertionSort() to implement 2-argument insertionSort(). For insertionSort(), the compiler will optimize both versions to be identical.

+ +

Definition at line 42 of file insertionSort.h.

+ +
+
+

Function Documentation

-

◆ insertionSort()

+

◆ insertionSort() [1/2]

@@ -136,15 +157,62 @@

Insertion sort.

-

Average complexity: O(n^2)

+

Average complexity: O(n^2) See https://en.wikipedia.org/wiki/Insertion_sort

+
Template Parameters
+ + +
Ttype of data to sort
+
+
+ +

Definition at line 76 of file insertionSort.h.

+ +

+
+ +

◆ insertionSort() [2/2]

+ +
+
+
+template<typename T , typename F >
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::insertionSort (T data[],
uint16_t n,
F && lessThan 
)
+
+ +

Same as the 2-argument insertionSort() with the addition of a lessThan lambda expression or function.

Template Parameters
+
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
-

Definition at line 45 of file insertionSort.h.

+

Definition at line 92 of file insertionSort.h.

diff --git a/docs/html/insertionSort_8h__incl.map b/docs/html/insertionSort_8h__incl.map deleted file mode 100644 index 50dadf0..0000000 --- a/docs/html/insertionSort_8h__incl.map +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/docs/html/insertionSort_8h__incl.md5 b/docs/html/insertionSort_8h__incl.md5 deleted file mode 100644 index 15de687..0000000 --- a/docs/html/insertionSort_8h__incl.md5 +++ /dev/null @@ -1 +0,0 @@ -443518eba040113e3c67f3c458406390 \ No newline at end of file diff --git a/docs/html/insertionSort_8h__incl.png b/docs/html/insertionSort_8h__incl.png deleted file mode 100644 index 2109e8c6cc9b7db41529f9451c56c8c97fccaf86..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5022 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
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -95,39 +95,72 @@
22 SOFTWARE.
23 */
24 
-
31 #ifndef ACE_SORTING_INSERTION_SORT_H
-
32 #define ACE_SORTING_INSERTION_SORT_H
-
33 
-
34 #include "swap.h"
-
35 
-
36 namespace ace_sorting {
-
37 
-
44 template <typename T>
-
45 void insertionSort(T data[], uint16_t n) {
-
46  for (uint16_t i = 1; i < n; i++) {
-
47  T temp = data[i];
-
48 
-
49  // Shift one slot to the right.
-
50  uint16_t j;
-
51  for (j = i; j > 0; j--) {
-
52  if (data[j - 1] <= temp) break;
-
53  data[j] = data[j - 1];
-
54  }
-
55 
-
56  // This can assign 'temp' back into the original slot if no shifting was
-
57  // done. That's ok because T is assumed to be relatively cheap to copy, and
-
58  // checking for (i != j) is more expensive than just doing the extra
-
59  // assignment.
-
60  data[j] = temp;
-
61  }
-
62 }
-
63 
-
64 }
-
65 
-
66 #endif
+
32 #ifndef ACE_SORTING_INSERTION_SORT_H
+
33 #define ACE_SORTING_INSERTION_SORT_H
+
34 
+
35 #if ! defined(ACE_SORTING_DIRECT_INSERTION_SORT)
+
36 
+
42  #define ACE_SORTING_DIRECT_INSERTION_SORT 0
+
43 #endif
+
44 
+
45 namespace ace_sorting {
+
46 
+
54 #if ACE_SORTING_DIRECT_INSERTION_SORT
+
55 template <typename T>
+
56 void insertionSort(T data[], uint16_t n) {
+
57  for (uint16_t i = 1; i < n; i++) {
+
58  T temp = data[i];
+
59 
+
60  // Shift one slot to the right.
+
61  uint16_t j;
+
62  for (j = i; j > 0; j--) {
+
63  if (data[j - 1] <= temp) break;
+
64  data[j] = data[j - 1];
+
65  }
+
66 
+
67  // This can assign 'temp' back into the original slot if no shifting was
+
68  // done. That's ok because T is assumed to be relatively cheap to copy, and
+
69  // checking for (i != j) is more expensive than just doing the extra
+
70  // assignment.
+
71  data[j] = temp;
+
72  }
+
73 }
+
74 #else
+
75 template <typename T>
+
76 void insertionSort(T data[], uint16_t n) {
+
77  // This lambda expression does not perform any captures, so the compiler will
+
78  // optimize and inline the less-than expression.
+
79  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
80  insertionSort(data, n, lessThan);
+
81 }
+
82 #endif
+
83 
+
91 template <typename T, typename F>
+
92 void insertionSort(T data[], uint16_t n, F&& lessThan) {
+
93  for (uint16_t i = 1; i < n; i++) {
+
94  T temp = data[i];
+
95 
+
96  // Shift one slot to the right.
+
97  uint16_t j;
+
98  for (j = i; j > 0; j--) {
+
99  // The following is equivalent to: (data[j - 1] <= temp)
+
100  if (! lessThan(temp, data[j - 1])) break;
+
101  data[j] = data[j - 1];
+
102  }
+
103 
+
104  // This can assign 'temp' back into the original slot if no shifting was
+
105  // done. That's ok because T is assumed to be relatively cheap to copy, and
+
106  // checking for (i != j) is more expensive than just doing the extra
+
107  // assignment.
+
108  data[j] = temp;
+
109  }
+
110 }
+
111 
+
112 }
+
113 
+
114 #endif
- -
ace_sorting::insertionSort
void insertionSort(T data[], uint16_t n)
Insertion sort.
Definition: insertionSort.h:45
+
ace_sorting::insertionSort
void insertionSort(T data[], uint16_t n)
Insertion sort.
Definition: insertionSort.h:76
Generated by   diff --git a/docs/html/menudata.js b/docs/html/menudata.js index e1341b0..a357e02 100644 --- a/docs/html/menudata.js +++ b/docs/html/menudata.js @@ -23,4 +23,7 @@ for the JavaScript code in this file var menudata={children:[ {text:"Main Page",url:"index.html"}, {text:"Files",url:"files.html",children:[ -{text:"File List",url:"files.html"}]}]} +{text:"File List",url:"files.html"}, +{text:"File Members",url:"globals.html",children:[ +{text:"All",url:"globals.html"}, +{text:"Macros",url:"globals_defs.html"}]}]}]} diff --git a/docs/html/quickSort_8h.html b/docs/html/quickSort_8h.html index e3fd37c..f210efe 100644 --- a/docs/html/quickSort_8h.html +++ b/docs/html/quickSort_8h.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -68,6 +68,7 @@
+Macros | Functions
quickSort.h File Reference
@@ -95,28 +96,67 @@

Go to the source code of this file.

+ + + + +

+Macros

#define ACE_SORTING_DIRECT_QUICK_SORT   1
 If set to 1, use the direct inlined implementation of the 2-argument quickSortXxx(). More...
 
+ + + + + + + + - + + + + +

Functions

template<typename T >
void ace_sorting::quickSortMiddle (T data[], uint16_t n)
 Quick sort using Hoare's original partition where the pivot is the middle of the array. More...
 
template<typename T , typename F >
void ace_sorting::quickSortMiddle (T data[], uint16_t n, F &&lessThan)
 Same as the 2-argument quickSortMiddle() with the addition of a lessThan lambda expression or function. More...
 
template<typename T >
void ace_sorting::quickSortMedian (T data[], uint16_t n)
 Quick sort using Sedgewick's recommendation of using the median of low, middle and high. More...
 
template<typename T , typename F >
void ace_sorting::quickSortMedian (T data[], uint16_t n, F &&lessThan)
 Same as the 2-argument quickSortMedian() with the addition of a lessThan lambda expression or function. More...
 
template<typename T >
void ace_sorting::quickSortMedianSwapped (T data[], uint16_t n)
 Same as quickSortMedian(), but swap the low and high so that low, mid, and high elements become sorted. More...
 Same as quickSortMedian(), but swap the low and high so that low, mid, and high elements become sorted. More...
 
template<typename T , typename F >
void ace_sorting::quickSortMedianSwapped (T data[], uint16_t n, F &&lessThan)
 Same as the 2-argument quickSortMedianSwapped() with the addition of a lessThan lambda expression or function. More...
 

Detailed Description

-

Quick sort algorithms.

+

Quick sort algorithms. See https://en.wikipedia.org/wiki/Quicksort

Definition in file quickSort.h.

-

Function Documentation

+

Macro Definition Documentation

+ +

◆ ACE_SORTING_DIRECT_QUICK_SORT

+ +
+
+ + + + +
#define ACE_SORTING_DIRECT_QUICK_SORT   1
+
+ +

If set to 1, use the direct inlined implementation of the 2-argument quickSortXxx().

+

Otherwise, use the 3-argument quickSortXxx() to implement 2-argument quickSortXxx().

+

Unlike other sorting algorithms, the compiler cannot seem to optimize away the extra level of indirection, probably due to the recursive calls. We save 40 bytes of flash (out of 200-300 bytes) by setting this to 1 so that the 2-argument variant is manually inlined.

+ +

Definition at line 48 of file quickSort.h.

+ +
+
+

Function Documentation

-

◆ quickSortMedian()

+

◆ quickSortMedian() [1/2]

@@ -153,12 +193,59 @@

Definition at line 81 of file quickSort.h.

+

Definition at line 143 of file quickSort.h.

+ +

+
+ +

◆ quickSortMedian() [2/2]

+ +
+
+
+template<typename T , typename F >
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::quickSortMedian (T data[],
uint16_t n,
F && lessThan 
)
+
+ +

Same as the 2-argument quickSortMedian() with the addition of a lessThan lambda expression or function.

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 197 of file quickSort.h.

-

◆ quickSortMedianSwapped()

+

◆ quickSortMedianSwapped() [1/2]

@@ -185,8 +272,8 @@

-

Same as quickSortMedian(), but swap the low and high so that low, mid, and high elements become sorted.

-

This means that the low and high are already partitioned, so we can omit those 2 points from the partitioning while-loop. This code consumes a lot more flash memory due to the additional swap() calls.

+

Same as quickSortMedian(), but swap the low and high so that low, mid, and high elements become sorted.

+

This means that the low and high are already partitioned, so we can omit those 2 points from the partitioning while-loop. This code consumes a lot more flash memory due to the additional swap() calls, but runs slightly faster.

Template Parameters
@@ -194,12 +281,59 @@

Definition at line 128 of file quickSort.h.

+

Definition at line 247 of file quickSort.h.

+ + + + +

◆ quickSortMedianSwapped() [2/2]

+ +
+
+
+template<typename T , typename F >
+

Ttype of data to sort
+ + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::quickSortMedianSwapped (T data[],
uint16_t n,
F && lessThan 
)
+

+ +

Same as the 2-argument quickSortMedianSwapped() with the addition of a lessThan lambda expression or function.

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 301 of file quickSort.h.

-

◆ quickSortMiddle()

+

◆ quickSortMiddle() [1/2]

@@ -236,7 +370,54 @@

Definition at line 48 of file quickSort.h.

+

Definition at line 64 of file quickSort.h.

+ +

+
+ +

◆ quickSortMiddle() [2/2]

+ +
+
+
+template<typename T , typename F >
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::quickSortMiddle (T data[],
uint16_t n,
F && lessThan 
)
+
+ +

Same as the 2-argument quickSortMiddle() with the addition of a lessThan lambda expression or function.

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 107 of file quickSort.h.

diff --git a/docs/html/quickSort_8h_source.html b/docs/html/quickSort_8h_source.html index e546ba5..c1cc669 100644 --- a/docs/html/quickSort_8h_source.html +++ b/docs/html/quickSort_8h_source.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -95,122 +95,264 @@
22 SOFTWARE.
23 */
24 
-
31 #ifndef ACE_SORTING_QUICK_SORT_H
-
32 #define ACE_SORTING_QUICK_SORT_H
-
33 
-
34 #include "swap.h"
-
35 
-
36 namespace ace_sorting {
-
37 
-
47 template <typename T>
-
48 void quickSortMiddle(T data[], uint16_t n) {
-
49  if (n <= 1) return;
-
50 
-
51  T pivot = data[n / 2];
-
52  T* left = data;
-
53  T* right = data + n - 1;
-
54 
-
55  while (left <= right) {
-
56  if (*left < pivot) {
-
57  left++;
-
58  } else if (*right > pivot) {
-
59  right--;
-
60  } else {
-
61  swap(*left, *right);
-
62  left++;
-
63  right--;
-
64  }
-
65  }
+
32 #ifndef ACE_SORTING_QUICK_SORT_H
+
33 #define ACE_SORTING_QUICK_SORT_H
+
34 
+
35 #include "swap.h"
+
36 
+
37 #if ! defined(ACE_SORTING_DIRECT_QUICK_SORT)
+
38 
+
48  #define ACE_SORTING_DIRECT_QUICK_SORT 1
+
49 #endif
+
50 
+
51 namespace ace_sorting {
+
52 
+
62 #if ACE_SORTING_DIRECT_QUICK_SORT
+
63 template <typename T>
+
64 void quickSortMiddle(T data[], uint16_t n) {
+
65  if (n <= 1) return;
66 
-
67  quickSortMiddle(data, right - data + 1);
-
68  quickSortMiddle(left, data + n - left);
-
69 }
+
67  T pivot = data[n / 2];
+
68  T* left = data;
+
69  T* right = data + n - 1;
70 
-
80 template <typename T>
-
81 void quickSortMedian(T data[], uint16_t n) {
-
82  if (n <= 1) return;
-
83 
-
84  // Select the median of data[low], data[mid], and data[high] as the estimate
-
85  // of the ideal pivot. Don't swap (low, mid) or (mid, high) (compare that
-
86  // quickSortMedianSwapped()) to save flash memory. They will get swapped in
-
87  // the partitioning while-loop below.
-
88  uint16_t mid = n / 2;
-
89  T pivot = data[mid];
-
90  if (data[0] > data[n - 1]) {
-
91  swap(data[0], data[n - 1]);
-
92  }
-
93  if (data[0] > pivot) {
-
94  pivot = data[0];
-
95  } else if (pivot > data[n - 1]) {
-
96  pivot = data[n - 1];
-
97  }
+
71  while (left <= right) {
+
72  if (*left < pivot) {
+
73  left++;
+
74  } else if (pivot < *right) {
+
75  right--;
+
76  } else {
+
77  swap(*left, *right);
+
78  left++;
+
79  right--;
+
80  }
+
81  }
+
82 
+
83  quickSortMiddle(data, right - data + 1);
+
84  quickSortMiddle(left, data + n - left);
+
85 }
+
86 #else
+
87 template <typename T>
+
88 void quickSortMiddle(T data[], uint16_t n) {
+
89  // This lambda expression does not perform any captures, so the compiler ought
+
90  // to be able to optimize and inline the less-than expression. However, the
+
91  // optimization does not seem to work, probably because of the recursive call
+
92  // into itself. So we set ACE_SORTING_DIRECT_QUICK_SORT=1 to use the direct
+
93  // inlined version.
+
94  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
95  quickSortMiddle(data, n, lessThan);
+
96 }
+
97 #endif
98 
-
99  T* left = data;
-
100  T* right = data + n - 1;
-
101 
-
102  while (left <= right) {
-
103  if (*left < pivot) {
-
104  left++;
-
105  } else if (*right > pivot) {
-
106  right--;
-
107  } else {
-
108  swap(*left, *right);
-
109  left++;
-
110  right--;
-
111  }
-
112  }
+
106 template <typename T, typename F>
+
107 void quickSortMiddle(T data[], uint16_t n, F&& lessThan) {
+
108  if (n <= 1) return;
+
109 
+
110  T pivot = data[n / 2];
+
111  T* left = data;
+
112  T* right = data + n - 1;
113 
-
114  quickSortMedian(data, right - data + 1);
-
115  quickSortMedian(left, data + n - left);
-
116 }
-
117 
-
127 template <typename T>
-
128 void quickSortMedianSwapped(T data[], uint16_t n) {
-
129  if (n <= 1) return;
-
130 
-
131  // Select the median of data[low], data[mid], and data[high] as the estimate
-
132  // of the ideal pivot. In the process, the (low, mid, high) become sorted.
-
133  uint16_t mid = n / 2;
-
134  T pivot = data[mid];
-
135  if (data[0] > data[n - 1]) {
-
136  swap(data[0], data[n - 1]);
-
137  }
-
138  if (data[0] > pivot) {
-
139  swap(data[0], data[mid]);
-
140  } else if (pivot > data[n - 1]) {
-
141  swap(data[mid], data[n - 1]);
-
142  }
-
143  pivot = data[mid];
-
144 
-
145  // We can skip the low and high because they are already sorted.
-
146  T* left = data + 1;
-
147  T* right = data + n - 2;
-
148 
-
149  while (left <= right) {
-
150  if (*left < pivot) {
-
151  left++;
-
152  } else if (*right > pivot) {
-
153  right--;
-
154  } else {
-
155  swap(*left, *right);
-
156  left++;
-
157  right--;
-
158  }
+
114  while (left <= right) {
+
115  if (lessThan(*left, pivot)) {
+
116  left++;
+
117  } else if (lessThan(pivot, *right)) {
+
118  right--;
+
119  } else {
+
120  swap(*left, *right);
+
121  left++;
+
122  right--;
+
123  }
+
124  }
+
125 
+
126  quickSortMiddle(data, right - data + 1, lessThan);
+
127  quickSortMiddle(left, data + n - left, lessThan);
+
128 }
+
129 
+
130 //-----------------------------------------------------------------------------
+
131 
+
141 #if ACE_SORTING_DIRECT_QUICK_SORT
+
142 template <typename T>
+
143 void quickSortMedian(T data[], uint16_t n) {
+
144  if (n <= 1) return;
+
145 
+
146  // Select the median of data[low], data[mid], and data[high] as the estimate
+
147  // of the ideal pivot. Don't swap (low, mid) or (mid, high) (compare that
+
148  // quickSortMedianSwapped()) to save flash memory. They will get swapped in
+
149  // the partitioning while-loop below.
+
150  uint16_t mid = n / 2;
+
151  T pivot = data[mid];
+
152  if (data[n - 1] < data[0]) {
+
153  swap(data[0], data[n - 1]);
+
154  }
+
155  if (pivot < data[0]) {
+
156  pivot = data[0];
+
157  } else if (data[n - 1] < pivot) {
+
158  pivot = data[n - 1];
159  }
160 
-
161  quickSortMedianSwapped(data, right - data + 1);
-
162  quickSortMedianSwapped(left, data + n - left);
-
163 }
-
164 
-
165 }
-
166 
-
167 #endif
+
161  T* left = data;
+
162  T* right = data + n - 1;
+
163 
+
164  while (left <= right) {
+
165  if (*left < pivot) {
+
166  left++;
+
167  } else if (pivot < *right) {
+
168  right--;
+
169  } else {
+
170  swap(*left, *right);
+
171  left++;
+
172  right--;
+
173  }
+
174  }
+
175 
+
176  quickSortMedian(data, right - data + 1);
+
177  quickSortMedian(left, data + n - left);
+
178 }
+
179 #else
+
180 template <typename T>
+
181 void quickSortMedian(T data[], uint16_t n) {
+
182  // This lambda expression does not perform any captures, so the compiler will
+
183  // optimize and inline the less-than expression.
+
184  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
185  quickSortMedian(data, n, lessThan);
+
186 }
+
187 #endif
+
188 
+
196 template <typename T, typename F>
+
197 void quickSortMedian(T data[], uint16_t n, F&& lessThan) {
+
198  if (n <= 1) return;
+
199 
+
200  // Select the median of data[low], data[mid], and data[high] as the estimate
+
201  // of the ideal pivot. Don't swap (low, mid) or (mid, high) (compare that
+
202  // quickSortMedianSwapped()) to save flash memory. They will get swapped in
+
203  // the partitioning while-loop below.
+
204  uint16_t mid = n / 2;
+
205  T pivot = data[mid];
+
206  if (lessThan(data[n - 1], data[0])) {
+
207  swap(data[0], data[n - 1]);
+
208  }
+
209  if (lessThan(pivot, data[0])) {
+
210  pivot = data[0];
+
211  } else if (lessThan(data[n - 1], pivot)) {
+
212  pivot = data[n - 1];
+
213  }
+
214 
+
215  T* left = data;
+
216  T* right = data + n - 1;
+
217 
+
218  while (left <= right) {
+
219  if (lessThan(*left, pivot)) {
+
220  left++;
+
221  } else if (lessThan(pivot, *right)) {
+
222  right--;
+
223  } else {
+
224  swap(*left, *right);
+
225  left++;
+
226  right--;
+
227  }
+
228  }
+
229 
+
230  quickSortMedian(data, right - data + 1, lessThan);
+
231  quickSortMedian(left, data + n - left, lessThan);
+
232 }
+
233 
+
234 //-----------------------------------------------------------------------------
+
235 
+
245 #if ACE_SORTING_DIRECT_QUICK_SORT
+
246 template <typename T>
+
247 void quickSortMedianSwapped(T data[], uint16_t n) {
+
248  if (n <= 1) return;
+
249 
+
250  // Select the median of data[low], data[mid], and data[high] as the estimate
+
251  // of the ideal pivot. In the process, the (low, mid, high) become sorted.
+
252  uint16_t mid = n / 2;
+
253  T pivot = data[mid];
+
254  if (data[n - 1] < data[0]) {
+
255  swap(data[0], data[n - 1]);
+
256  }
+
257  if (pivot < data[0]) {
+
258  swap(data[0], data[mid]);
+
259  } else if (data[n - 1] < pivot) {
+
260  swap(data[mid], data[n - 1]);
+
261  }
+
262  pivot = data[mid];
+
263 
+
264  // We can skip the low and high because they are already sorted.
+
265  T* left = data + 1;
+
266  T* right = data + n - 2;
+
267 
+
268  while (left <= right) {
+
269  if (*left < pivot) {
+
270  left++;
+
271  } else if (pivot < *right) {
+
272  right--;
+
273  } else {
+
274  swap(*left, *right);
+
275  left++;
+
276  right--;
+
277  }
+
278  }
+
279 
+
280  quickSortMedianSwapped(data, right - data + 1);
+
281  quickSortMedianSwapped(left, data + n - left);
+
282 }
+
283 #else
+
284 template <typename T>
+
285 void quickSortMedianSwapped(T data[], uint16_t n) {
+
286  // This lambda expression does not perform any captures, so the compiler will
+
287  // optimize and inline the less-than expression.
+
288  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
289  quickSortMedianSwapped(data, n, lessThan);
+
290 }
+
291 #endif
+
292 
+
300 template <typename T, typename F>
+
301 void quickSortMedianSwapped(T data[], uint16_t n, F&& lessThan) {
+
302  if (n <= 1) return;
+
303 
+
304  // Select the median of data[low], data[mid], and data[high] as the estimate
+
305  // of the ideal pivot. In the process, the (low, mid, high) become sorted.
+
306  uint16_t mid = n / 2;
+
307  T pivot = data[mid];
+
308  if (lessThan(data[n - 1], data[0])) {
+
309  swap(data[0], data[n - 1]);
+
310  }
+
311  if (lessThan(pivot, data[0])) {
+
312  swap(data[0], data[mid]);
+
313  } else if (lessThan(data[n - 1], pivot)) {
+
314  swap(data[mid], data[n - 1]);
+
315  }
+
316  pivot = data[mid];
+
317 
+
318  // We can skip the low and high because they are already sorted.
+
319  T* left = data + 1;
+
320  T* right = data + n - 2;
+
321 
+
322  while (left <= right) {
+
323  if (lessThan(*left, pivot)) {
+
324  left++;
+
325  } else if (lessThan(pivot, *right)) {
+
326  right--;
+
327  } else {
+
328  swap(*left, *right);
+
329  left++;
+
330  right--;
+
331  }
+
332  }
+
333 
+
334  quickSortMedianSwapped(data, right - data + 1, lessThan);
+
335  quickSortMedianSwapped(left, data + n - left, lessThan);
+
336 }
+
337 
+
338 }
+
339 
+
340 #endif
-
ace_sorting::quickSortMedianSwapped
void quickSortMedianSwapped(T data[], uint16_t n)
Same as quickSortMedian(), but swap the low and high so that low, mid, and high elements become sorte...
Definition: quickSort.h:128
+
ace_sorting::quickSortMedianSwapped
void quickSortMedianSwapped(T data[], uint16_t n)
Same as quickSortMedian(), but swap the low and high so that low, mid, and high elements become sorte...
Definition: quickSort.h:247
ace_sorting::swap
void swap(T &a, T &b)
Swap the parameters.
Definition: swap.h:41
-
ace_sorting::quickSortMiddle
void quickSortMiddle(T data[], uint16_t n)
Quick sort using Hoare's original partition where the pivot is the middle of the array.
Definition: quickSort.h:48
-
ace_sorting::quickSortMedian
void quickSortMedian(T data[], uint16_t n)
Quick sort using Sedgewick's recommendation of using the median of low, middle and high.
Definition: quickSort.h:81
+
ace_sorting::quickSortMiddle
void quickSortMiddle(T data[], uint16_t n)
Quick sort using Hoare's original partition where the pivot is the middle of the array.
Definition: quickSort.h:64
+
ace_sorting::quickSortMedian
void quickSortMedian(T data[], uint16_t n)
Quick sort using Sedgewick's recommendation of using the median of low, middle and high.
Definition: quickSort.h:143
Generated by   diff --git a/docs/html/search/all_0.js b/docs/html/search/all_0.js index cf28436..a96b59f 100644 --- a/docs/html/search/all_0.js +++ b/docs/html/search/all_0.js @@ -1,4 +1,10 @@ var searchData= [ - ['acesorting_20library_0',['AceSorting Library',['../index.html',1,'']]] + ['ace_5fsorting_5fdirect_5fbubble_5fsort_0',['ACE_SORTING_DIRECT_BUBBLE_SORT',['../bubbleSort_8h.html#a0736ba440330c5708367115dc73b0389',1,'bubbleSort.h']]], + ['ace_5fsorting_5fdirect_5fcomb_5fsort_1',['ACE_SORTING_DIRECT_COMB_SORT',['../combSort_8h.html#a1422101fefaf413a2c4e90e3eb8ff383',1,'combSort.h']]], + ['ace_5fsorting_5fdirect_5finsertion_5fsort_2',['ACE_SORTING_DIRECT_INSERTION_SORT',['../insertionSort_8h.html#a8b8979afb17e881cecedf53c2ffa879f',1,'insertionSort.h']]], + ['ace_5fsorting_5fdirect_5fquick_5fsort_3',['ACE_SORTING_DIRECT_QUICK_SORT',['../quickSort_8h.html#a34d4758b814849a2f2deed5609a4fee6',1,'quickSort.h']]], + ['ace_5fsorting_5fdirect_5fselection_5fsort_4',['ACE_SORTING_DIRECT_SELECTION_SORT',['../selectionSort_8h.html#a27e7c440fe0c592ff733de09c36a525b',1,'selectionSort.h']]], + ['ace_5fsorting_5fdirect_5fshell_5fsort_5',['ACE_SORTING_DIRECT_SHELL_SORT',['../shellSort_8h.html#ad9776023d66c43bcd73ca3a075582a25',1,'shellSort.h']]], + ['acesorting_20library_6',['AceSorting Library',['../index.html',1,'']]] ]; diff --git a/docs/html/search/all_1.js b/docs/html/search/all_1.js index 6f19549..2e1928c 100644 --- a/docs/html/search/all_1.js +++ b/docs/html/search/all_1.js @@ -1,5 +1,5 @@ var searchData= [ - ['bubblesort_1',['bubbleSort',['../bubbleSort_8h.html#a09f50f1f164d939d14f5ac3ac48eabaa',1,'ace_sorting']]], - ['bubblesort_2eh_2',['bubbleSort.h',['../bubbleSort_8h.html',1,'']]] + ['bubblesort_7',['bubbleSort',['../bubbleSort_8h.html#a09f50f1f164d939d14f5ac3ac48eabaa',1,'ace_sorting::bubbleSort(T data[], uint16_t n)'],['../bubbleSort_8h.html#ad9fcb9a9cd3305a2b5b8057a06e2d64e',1,'ace_sorting::bubbleSort(T data[], uint16_t n, F &&lessThan)']]], + ['bubblesort_2eh_8',['bubbleSort.h',['../bubbleSort_8h.html',1,'']]] ]; diff --git a/docs/html/search/all_2.js b/docs/html/search/all_2.js index 2d04ebe..30e6976 100644 --- a/docs/html/search/all_2.js +++ b/docs/html/search/all_2.js @@ -1,8 +1,8 @@ var searchData= [ - ['combsort_2eh_3',['combSort.h',['../combSort_8h.html',1,'']]], - ['combsort13_4',['combSort13',['../combSort_8h.html#aa80bb895dd5f95eb13e09b404e4661c9',1,'ace_sorting']]], - ['combsort133_5',['combSort133',['../combSort_8h.html#a7b128ab4c802690dc782da161357aab0',1,'ace_sorting']]], - ['combsort133m_6',['combSort133m',['../combSort_8h.html#a0148155acfcb2e3152df431035ab3da8',1,'ace_sorting']]], - ['combsort13m_7',['combSort13m',['../combSort_8h.html#ac0e984a1bfc3f295ab4d9220da0fdc7f',1,'ace_sorting']]] + ['combsort_2eh_9',['combSort.h',['../combSort_8h.html',1,'']]], + ['combsort13_10',['combSort13',['../combSort_8h.html#aa80bb895dd5f95eb13e09b404e4661c9',1,'ace_sorting::combSort13(T data[], uint16_t n)'],['../combSort_8h.html#a05d86362a42cf0fc782c08135ee0d0f6',1,'ace_sorting::combSort13(T data[], uint16_t n, F &&lessThan)']]], + ['combsort133_11',['combSort133',['../combSort_8h.html#a7b128ab4c802690dc782da161357aab0',1,'ace_sorting::combSort133(T data[], uint16_t n)'],['../combSort_8h.html#a3056e3e2ebf49fcb580822d8a02f0ecf',1,'ace_sorting::combSort133(T data[], uint16_t n, F &&lessThan)']]], + ['combsort133m_12',['combSort133m',['../combSort_8h.html#a0148155acfcb2e3152df431035ab3da8',1,'ace_sorting::combSort133m(T data[], uint16_t n)'],['../combSort_8h.html#a6cc90f96182e8fa488aadcb198ed79c9',1,'ace_sorting::combSort133m(T data[], uint16_t n, F &&lessThan)']]], + ['combsort13m_13',['combSort13m',['../combSort_8h.html#ac0e984a1bfc3f295ab4d9220da0fdc7f',1,'ace_sorting::combSort13m(T data[], uint16_t n)'],['../combSort_8h.html#a43d0f574d6ada7592850acd2a86d2672',1,'ace_sorting::combSort13m(T data[], uint16_t n, F &&lessThan)']]] ]; diff --git a/docs/html/search/all_3.js b/docs/html/search/all_3.js index 8452ae6..40727c6 100644 --- a/docs/html/search/all_3.js +++ b/docs/html/search/all_3.js @@ -1,5 +1,5 @@ var searchData= [ - ['insertionsort_8',['insertionSort',['../insertionSort_8h.html#aac763b62e542f9b96b393fc633af0a3b',1,'ace_sorting']]], - ['insertionsort_2eh_9',['insertionSort.h',['../insertionSort_8h.html',1,'']]] + ['insertionsort_14',['insertionSort',['../insertionSort_8h.html#aac763b62e542f9b96b393fc633af0a3b',1,'ace_sorting::insertionSort(T data[], uint16_t n)'],['../insertionSort_8h.html#a0b8e2cd45c85523728e9611abfca83c9',1,'ace_sorting::insertionSort(T data[], uint16_t n, F &&lessThan)']]], + ['insertionsort_2eh_15',['insertionSort.h',['../insertionSort_8h.html',1,'']]] ]; diff --git a/docs/html/search/all_4.js b/docs/html/search/all_4.js index 2d7d747..cd9dcaf 100644 --- a/docs/html/search/all_4.js +++ b/docs/html/search/all_4.js @@ -1,7 +1,7 @@ var searchData= [ - ['quicksort_2eh_10',['quickSort.h',['../quickSort_8h.html',1,'']]], - ['quicksortmedian_11',['quickSortMedian',['../quickSort_8h.html#a8822a1e77ec6e6a1f4b1ecd19f5c4887',1,'ace_sorting']]], - ['quicksortmedianswapped_12',['quickSortMedianSwapped',['../quickSort_8h.html#a84bf2af64a70082a735f1ce9353984b4',1,'ace_sorting']]], - ['quicksortmiddle_13',['quickSortMiddle',['../quickSort_8h.html#a341b8d661849f81b882ed6c1dc195e1c',1,'ace_sorting']]] + ['quicksort_2eh_16',['quickSort.h',['../quickSort_8h.html',1,'']]], + ['quicksortmedian_17',['quickSortMedian',['../quickSort_8h.html#a8822a1e77ec6e6a1f4b1ecd19f5c4887',1,'ace_sorting::quickSortMedian(T data[], uint16_t n)'],['../quickSort_8h.html#a03af968ac0babb7dcc1ee0a9409d3cd3',1,'ace_sorting::quickSortMedian(T data[], uint16_t n, F &&lessThan)']]], + ['quicksortmedianswapped_18',['quickSortMedianSwapped',['../quickSort_8h.html#a84bf2af64a70082a735f1ce9353984b4',1,'ace_sorting::quickSortMedianSwapped(T data[], uint16_t n)'],['../quickSort_8h.html#ae10d9e1e79c3860fc1a04cc95d49515b',1,'ace_sorting::quickSortMedianSwapped(T data[], uint16_t n, F &&lessThan)']]], + ['quicksortmiddle_19',['quickSortMiddle',['../quickSort_8h.html#a341b8d661849f81b882ed6c1dc195e1c',1,'ace_sorting::quickSortMiddle(T data[], uint16_t n)'],['../quickSort_8h.html#aecb976f27be600c8797a458df7491cda',1,'ace_sorting::quickSortMiddle(T data[], uint16_t n, F &&lessThan)']]] ]; diff --git a/docs/html/search/all_5.js b/docs/html/search/all_5.js index 96770c1..1c20a79 100644 --- a/docs/html/search/all_5.js +++ b/docs/html/search/all_5.js @@ -1,11 +1,11 @@ var searchData= [ - ['selectionsort_14',['selectionSort',['../selectionSort_8h.html#a68fc184ad9a55e35542cb1c78065bbd7',1,'ace_sorting']]], - ['selectionsort_2eh_15',['selectionSort.h',['../selectionSort_8h.html',1,'']]], - ['shellsort_2eh_16',['shellSort.h',['../shellSort_8h.html',1,'']]], - ['shellsortclassic_17',['shellSortClassic',['../shellSort_8h.html#aa17d405fc10023a2dae35c6800f72992',1,'ace_sorting']]], - ['shellsortknuth_18',['shellSortKnuth',['../shellSort_8h.html#aa3ffa9009047d108d89f27a97f250731',1,'ace_sorting']]], - ['shellsorttokuda_19',['shellSortTokuda',['../shellSort_8h.html#aecfe06e8598182f86aaaa192ae643f7c',1,'ace_sorting']]], - ['swap_20',['swap',['../swap_8h.html#a14e0c07fb427a4bc51b26fa03ae19eb0',1,'ace_sorting']]], - ['swap_2eh_21',['swap.h',['../swap_8h.html',1,'']]] + ['selectionsort_20',['selectionSort',['../selectionSort_8h.html#a68fc184ad9a55e35542cb1c78065bbd7',1,'ace_sorting::selectionSort(T data[], uint16_t n)'],['../selectionSort_8h.html#aab52ed55316601d2c18252e541f516eb',1,'ace_sorting::selectionSort(T data[], uint16_t n, F &&lessThan)']]], + ['selectionsort_2eh_21',['selectionSort.h',['../selectionSort_8h.html',1,'']]], + ['shellsort_2eh_22',['shellSort.h',['../shellSort_8h.html',1,'']]], + ['shellsortclassic_23',['shellSortClassic',['../shellSort_8h.html#aa17d405fc10023a2dae35c6800f72992',1,'ace_sorting::shellSortClassic(T data[], uint16_t n)'],['../shellSort_8h.html#ac95cc3d68f249a973e1a9d3519b7fd49',1,'ace_sorting::shellSortClassic(T data[], uint16_t n, F &&lessThan)']]], + ['shellsortknuth_24',['shellSortKnuth',['../shellSort_8h.html#aa3ffa9009047d108d89f27a97f250731',1,'ace_sorting::shellSortKnuth(T data[], uint16_t n)'],['../shellSort_8h.html#af78075091d5961c4001d658d49835bfd',1,'ace_sorting::shellSortKnuth(T data[], uint16_t n, F &&lessThan)']]], + ['shellsorttokuda_25',['shellSortTokuda',['../shellSort_8h.html#a00e01bc0bdc73d9e59164095fda8664e',1,'ace_sorting::shellSortTokuda(T data[], uint16_t n)'],['../shellSort_8h.html#a2563aa1b90e1a15d2da68980775bc90a',1,'ace_sorting::shellSortTokuda(T data[], const uint16_t n, F &&lessThan)']]], + ['swap_26',['swap',['../swap_8h.html#a14e0c07fb427a4bc51b26fa03ae19eb0',1,'ace_sorting']]], + ['swap_2eh_27',['swap.h',['../swap_8h.html',1,'']]] ]; diff --git a/docs/html/search/defines_0.html b/docs/html/search/defines_0.html new file mode 100644 index 0000000..2deb369 --- /dev/null +++ b/docs/html/search/defines_0.html @@ -0,0 +1,30 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/docs/html/search/defines_0.js b/docs/html/search/defines_0.js new file mode 100644 index 0000000..77ee527 --- /dev/null +++ b/docs/html/search/defines_0.js @@ -0,0 +1,9 @@ +var searchData= +[ + ['ace_5fsorting_5fdirect_5fbubble_5fsort_49',['ACE_SORTING_DIRECT_BUBBLE_SORT',['../bubbleSort_8h.html#a0736ba440330c5708367115dc73b0389',1,'bubbleSort.h']]], + ['ace_5fsorting_5fdirect_5fcomb_5fsort_50',['ACE_SORTING_DIRECT_COMB_SORT',['../combSort_8h.html#a1422101fefaf413a2c4e90e3eb8ff383',1,'combSort.h']]], + ['ace_5fsorting_5fdirect_5finsertion_5fsort_51',['ACE_SORTING_DIRECT_INSERTION_SORT',['../insertionSort_8h.html#a8b8979afb17e881cecedf53c2ffa879f',1,'insertionSort.h']]], + ['ace_5fsorting_5fdirect_5fquick_5fsort_52',['ACE_SORTING_DIRECT_QUICK_SORT',['../quickSort_8h.html#a34d4758b814849a2f2deed5609a4fee6',1,'quickSort.h']]], + ['ace_5fsorting_5fdirect_5fselection_5fsort_53',['ACE_SORTING_DIRECT_SELECTION_SORT',['../selectionSort_8h.html#a27e7c440fe0c592ff733de09c36a525b',1,'selectionSort.h']]], + ['ace_5fsorting_5fdirect_5fshell_5fsort_54',['ACE_SORTING_DIRECT_SHELL_SORT',['../shellSort_8h.html#ad9776023d66c43bcd73ca3a075582a25',1,'shellSort.h']]] +]; diff --git a/docs/html/search/files_0.js b/docs/html/search/files_0.js index 1d8dc05..93ca8f6 100644 --- a/docs/html/search/files_0.js +++ b/docs/html/search/files_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['bubblesort_2eh_22',['bubbleSort.h',['../bubbleSort_8h.html',1,'']]] + ['bubblesort_2eh_28',['bubbleSort.h',['../bubbleSort_8h.html',1,'']]] ]; diff --git a/docs/html/search/files_1.js b/docs/html/search/files_1.js index 7103e3f..9949400 100644 --- a/docs/html/search/files_1.js +++ b/docs/html/search/files_1.js @@ -1,4 +1,4 @@ var searchData= [ - ['combsort_2eh_23',['combSort.h',['../combSort_8h.html',1,'']]] + ['combsort_2eh_29',['combSort.h',['../combSort_8h.html',1,'']]] ]; diff --git a/docs/html/search/files_2.js b/docs/html/search/files_2.js index 07b6c0b..87fb191 100644 --- a/docs/html/search/files_2.js +++ b/docs/html/search/files_2.js @@ -1,4 +1,4 @@ var searchData= [ - ['insertionsort_2eh_24',['insertionSort.h',['../insertionSort_8h.html',1,'']]] + ['insertionsort_2eh_30',['insertionSort.h',['../insertionSort_8h.html',1,'']]] ]; diff --git a/docs/html/search/files_3.js b/docs/html/search/files_3.js index 8a4f8e6..3ad2791 100644 --- a/docs/html/search/files_3.js +++ b/docs/html/search/files_3.js @@ -1,4 +1,4 @@ var searchData= [ - ['quicksort_2eh_25',['quickSort.h',['../quickSort_8h.html',1,'']]] + ['quicksort_2eh_31',['quickSort.h',['../quickSort_8h.html',1,'']]] ]; diff --git a/docs/html/search/files_4.js b/docs/html/search/files_4.js index ad7962c..79575ec 100644 --- a/docs/html/search/files_4.js +++ b/docs/html/search/files_4.js @@ -1,6 +1,6 @@ var searchData= [ - ['selectionsort_2eh_26',['selectionSort.h',['../selectionSort_8h.html',1,'']]], - ['shellsort_2eh_27',['shellSort.h',['../shellSort_8h.html',1,'']]], - ['swap_2eh_28',['swap.h',['../swap_8h.html',1,'']]] + ['selectionsort_2eh_32',['selectionSort.h',['../selectionSort_8h.html',1,'']]], + ['shellsort_2eh_33',['shellSort.h',['../shellSort_8h.html',1,'']]], + ['swap_2eh_34',['swap.h',['../swap_8h.html',1,'']]] ]; diff --git a/docs/html/search/functions_0.js b/docs/html/search/functions_0.js index b20cffc..a383f21 100644 --- a/docs/html/search/functions_0.js +++ b/docs/html/search/functions_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['bubblesort_29',['bubbleSort',['../bubbleSort_8h.html#a09f50f1f164d939d14f5ac3ac48eabaa',1,'ace_sorting']]] + ['bubblesort_35',['bubbleSort',['../bubbleSort_8h.html#a09f50f1f164d939d14f5ac3ac48eabaa',1,'ace_sorting::bubbleSort(T data[], uint16_t n)'],['../bubbleSort_8h.html#ad9fcb9a9cd3305a2b5b8057a06e2d64e',1,'ace_sorting::bubbleSort(T data[], uint16_t n, F &&lessThan)']]] ]; diff --git a/docs/html/search/functions_1.js b/docs/html/search/functions_1.js index 82dd28c..c8401a6 100644 --- a/docs/html/search/functions_1.js +++ b/docs/html/search/functions_1.js @@ -1,7 +1,7 @@ var searchData= [ - ['combsort13_30',['combSort13',['../combSort_8h.html#aa80bb895dd5f95eb13e09b404e4661c9',1,'ace_sorting']]], - ['combsort133_31',['combSort133',['../combSort_8h.html#a7b128ab4c802690dc782da161357aab0',1,'ace_sorting']]], - ['combsort133m_32',['combSort133m',['../combSort_8h.html#a0148155acfcb2e3152df431035ab3da8',1,'ace_sorting']]], - ['combsort13m_33',['combSort13m',['../combSort_8h.html#ac0e984a1bfc3f295ab4d9220da0fdc7f',1,'ace_sorting']]] + ['combsort13_36',['combSort13',['../combSort_8h.html#aa80bb895dd5f95eb13e09b404e4661c9',1,'ace_sorting::combSort13(T data[], uint16_t n)'],['../combSort_8h.html#a05d86362a42cf0fc782c08135ee0d0f6',1,'ace_sorting::combSort13(T data[], uint16_t n, F &&lessThan)']]], + ['combsort133_37',['combSort133',['../combSort_8h.html#a7b128ab4c802690dc782da161357aab0',1,'ace_sorting::combSort133(T data[], uint16_t n)'],['../combSort_8h.html#a3056e3e2ebf49fcb580822d8a02f0ecf',1,'ace_sorting::combSort133(T data[], uint16_t n, F &&lessThan)']]], + ['combsort133m_38',['combSort133m',['../combSort_8h.html#a0148155acfcb2e3152df431035ab3da8',1,'ace_sorting::combSort133m(T data[], uint16_t n)'],['../combSort_8h.html#a6cc90f96182e8fa488aadcb198ed79c9',1,'ace_sorting::combSort133m(T data[], uint16_t n, F &&lessThan)']]], + ['combsort13m_39',['combSort13m',['../combSort_8h.html#ac0e984a1bfc3f295ab4d9220da0fdc7f',1,'ace_sorting::combSort13m(T data[], uint16_t n)'],['../combSort_8h.html#a43d0f574d6ada7592850acd2a86d2672',1,'ace_sorting::combSort13m(T data[], uint16_t n, F &&lessThan)']]] ]; diff --git a/docs/html/search/functions_2.js b/docs/html/search/functions_2.js index f1f0896..2bf995e 100644 --- a/docs/html/search/functions_2.js +++ b/docs/html/search/functions_2.js @@ -1,4 +1,4 @@ var searchData= [ - ['insertionsort_34',['insertionSort',['../insertionSort_8h.html#aac763b62e542f9b96b393fc633af0a3b',1,'ace_sorting']]] + ['insertionsort_40',['insertionSort',['../insertionSort_8h.html#aac763b62e542f9b96b393fc633af0a3b',1,'ace_sorting::insertionSort(T data[], uint16_t n)'],['../insertionSort_8h.html#a0b8e2cd45c85523728e9611abfca83c9',1,'ace_sorting::insertionSort(T data[], uint16_t n, F &&lessThan)']]] ]; diff --git a/docs/html/search/functions_3.js b/docs/html/search/functions_3.js index 72c6f12..65d65c3 100644 --- a/docs/html/search/functions_3.js +++ b/docs/html/search/functions_3.js @@ -1,6 +1,6 @@ var searchData= [ - ['quicksortmedian_35',['quickSortMedian',['../quickSort_8h.html#a8822a1e77ec6e6a1f4b1ecd19f5c4887',1,'ace_sorting']]], - ['quicksortmedianswapped_36',['quickSortMedianSwapped',['../quickSort_8h.html#a84bf2af64a70082a735f1ce9353984b4',1,'ace_sorting']]], - ['quicksortmiddle_37',['quickSortMiddle',['../quickSort_8h.html#a341b8d661849f81b882ed6c1dc195e1c',1,'ace_sorting']]] + ['quicksortmedian_41',['quickSortMedian',['../quickSort_8h.html#a8822a1e77ec6e6a1f4b1ecd19f5c4887',1,'ace_sorting::quickSortMedian(T data[], uint16_t n)'],['../quickSort_8h.html#a03af968ac0babb7dcc1ee0a9409d3cd3',1,'ace_sorting::quickSortMedian(T data[], uint16_t n, F &&lessThan)']]], + ['quicksortmedianswapped_42',['quickSortMedianSwapped',['../quickSort_8h.html#a84bf2af64a70082a735f1ce9353984b4',1,'ace_sorting::quickSortMedianSwapped(T data[], uint16_t n)'],['../quickSort_8h.html#ae10d9e1e79c3860fc1a04cc95d49515b',1,'ace_sorting::quickSortMedianSwapped(T data[], uint16_t n, F &&lessThan)']]], + ['quicksortmiddle_43',['quickSortMiddle',['../quickSort_8h.html#a341b8d661849f81b882ed6c1dc195e1c',1,'ace_sorting::quickSortMiddle(T data[], uint16_t n)'],['../quickSort_8h.html#aecb976f27be600c8797a458df7491cda',1,'ace_sorting::quickSortMiddle(T data[], uint16_t n, F &&lessThan)']]] ]; diff --git a/docs/html/search/functions_4.js b/docs/html/search/functions_4.js index 9c6377e..6875a9a 100644 --- a/docs/html/search/functions_4.js +++ b/docs/html/search/functions_4.js @@ -1,8 +1,8 @@ var searchData= [ - ['selectionsort_38',['selectionSort',['../selectionSort_8h.html#a68fc184ad9a55e35542cb1c78065bbd7',1,'ace_sorting']]], - ['shellsortclassic_39',['shellSortClassic',['../shellSort_8h.html#aa17d405fc10023a2dae35c6800f72992',1,'ace_sorting']]], - ['shellsortknuth_40',['shellSortKnuth',['../shellSort_8h.html#aa3ffa9009047d108d89f27a97f250731',1,'ace_sorting']]], - ['shellsorttokuda_41',['shellSortTokuda',['../shellSort_8h.html#aecfe06e8598182f86aaaa192ae643f7c',1,'ace_sorting']]], - ['swap_42',['swap',['../swap_8h.html#a14e0c07fb427a4bc51b26fa03ae19eb0',1,'ace_sorting']]] + ['selectionsort_44',['selectionSort',['../selectionSort_8h.html#a68fc184ad9a55e35542cb1c78065bbd7',1,'ace_sorting::selectionSort(T data[], uint16_t n)'],['../selectionSort_8h.html#aab52ed55316601d2c18252e541f516eb',1,'ace_sorting::selectionSort(T data[], uint16_t n, F &&lessThan)']]], + ['shellsortclassic_45',['shellSortClassic',['../shellSort_8h.html#aa17d405fc10023a2dae35c6800f72992',1,'ace_sorting::shellSortClassic(T data[], uint16_t n)'],['../shellSort_8h.html#ac95cc3d68f249a973e1a9d3519b7fd49',1,'ace_sorting::shellSortClassic(T data[], uint16_t n, F &&lessThan)']]], + ['shellsortknuth_46',['shellSortKnuth',['../shellSort_8h.html#aa3ffa9009047d108d89f27a97f250731',1,'ace_sorting::shellSortKnuth(T data[], uint16_t n)'],['../shellSort_8h.html#af78075091d5961c4001d658d49835bfd',1,'ace_sorting::shellSortKnuth(T data[], uint16_t n, F &&lessThan)']]], + ['shellsorttokuda_47',['shellSortTokuda',['../shellSort_8h.html#a00e01bc0bdc73d9e59164095fda8664e',1,'ace_sorting::shellSortTokuda(T data[], uint16_t n)'],['../shellSort_8h.html#a2563aa1b90e1a15d2da68980775bc90a',1,'ace_sorting::shellSortTokuda(T data[], const uint16_t n, F &&lessThan)']]], + ['swap_48',['swap',['../swap_8h.html#a14e0c07fb427a4bc51b26fa03ae19eb0',1,'ace_sorting']]] ]; diff --git a/docs/html/search/pages_0.js b/docs/html/search/pages_0.js index 9cd677f..db83381 100644 --- a/docs/html/search/pages_0.js +++ b/docs/html/search/pages_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['acesorting_20library_43',['AceSorting Library',['../index.html',1,'']]] + ['acesorting_20library_55',['AceSorting Library',['../index.html',1,'']]] ]; diff --git a/docs/html/search/searchdata.js b/docs/html/search/searchdata.js index d94e070..01caf81 100644 --- a/docs/html/search/searchdata.js +++ b/docs/html/search/searchdata.js @@ -3,7 +3,8 @@ var indexSectionsWithContent = 0: "abciqs", 1: "bciqs", 2: "bciqs", - 3: "a" + 3: "a", + 4: "a" }; var indexSectionNames = @@ -11,7 +12,8 @@ var indexSectionNames = 0: "all", 1: "files", 2: "functions", - 3: "pages" + 3: "defines", + 4: "pages" }; var indexSectionLabels = @@ -19,6 +21,7 @@ var indexSectionLabels = 0: "All", 1: "Files", 2: "Functions", - 3: "Pages" + 3: "Macros", + 4: "Pages" }; diff --git a/docs/html/selectionSort_8h.html b/docs/html/selectionSort_8h.html index 3d211df..598c043 100644 --- a/docs/html/selectionSort_8h.html +++ b/docs/html/selectionSort_8h.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -68,6 +68,7 @@
+Macros | Functions
selectionSort.h File Reference
@@ -95,20 +96,50 @@

Go to the source code of this file.

+ + + + +

+Macros

#define ACE_SORTING_DIRECT_SELECTION_SORT   0
 If set to 1, use the direct inlined implementation of the 2-argument selectionSort(). More...
 
+ + + +

Functions

template<typename T >
void ace_sorting::selectionSort (T data[], uint16_t n)
 Selection sort. More...
 
template<typename T , typename F >
void ace_sorting::selectionSort (T data[], uint16_t n, F &&lessThan)
 Same as the 2-argument selectionSort() with the addition of a lessThan lambda expression or function. More...
 

Detailed Description

-

Selection sort.

+

Selection sort. See https://en.wikipedia.org/wiki/Selection_sort

Definition in file selectionSort.h.

-

Function Documentation

+

Macro Definition Documentation

+ +

◆ ACE_SORTING_DIRECT_SELECTION_SORT

+ +
+
+ + + + +
#define ACE_SORTING_DIRECT_SELECTION_SORT   0
+
+ +

If set to 1, use the direct inlined implementation of the 2-argument selectionSort().

+

Otherwise, use the 3-argument selectionSort() to implement 2-argument selectionSort(). For selectionSort(), the compiler will optimize both versions to be identical.

+ +

Definition at line 46 of file selectionSort.h.

+ +
+
+

Function Documentation

-

◆ selectionSort()

+

◆ selectionSort() [1/2]

@@ -136,15 +167,62 @@

Selection sort.

-

Average complexity: O(n^2)

+

Average complexity: O(n^2) See https://en.wikipedia.org/wiki/Selection_sort

+
Template Parameters
+ + +
Ttype of data to sort
+
+
+ +

Definition at line 89 of file selectionSort.h.

+ +

+
+ +

◆ selectionSort() [2/2]

+ +
+
+
+template<typename T , typename F >
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::selectionSort (T data[],
uint16_t n,
F && lessThan 
)
+
+ +

Same as the 2-argument selectionSort() with the addition of a lessThan lambda expression or function.

Template Parameters
+
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
-

Definition at line 45 of file selectionSort.h.

+

Definition at line 105 of file selectionSort.h.

diff --git a/docs/html/selectionSort_8h_source.html b/docs/html/selectionSort_8h_source.html index dd86b94..33fa5dc 100644 --- a/docs/html/selectionSort_8h_source.html +++ b/docs/html/selectionSort_8h_source.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -95,51 +95,97 @@
22 SOFTWARE.
23 */
24 
-
31 #ifndef ACE_SORTING_SELECTION_SORT_H
-
32 #define ACE_SORTING_SELECTION_SORT_H
-
33 
-
34 #include "swap.h"
-
35 
-
36 namespace ace_sorting {
-
37 
-
44 template <typename T>
-
45 void selectionSort(T data[], uint16_t n) {
-
46  for (uint16_t i = 0; i < n; i++) {
-
47 
-
48  // Loop to find the smallest element.
-
49  uint16_t iSmallest = i;
-
50  T smallest = data[i];
-
51 
-
52  // Starting the loop with 'j = i + 1' increases flash usage on AVR by 12
-
53  // bytes. But it does not reduce the execution time signficantly, because
-
54  // the (i + 1) will be done anyway by the j++ in the loop. So the only thing
-
55  // we save is a single redundant 'smallest < smallest' comparison.
-
56  for (uint16_t j = i; j < n; j++) {
-
57  if (data[j] < smallest) {
-
58  iSmallest = j;
-
59  smallest = data[j];
-
60  }
-
61  }
-
62 
-
63  // This extra check (i != iSmallest) is not really necessary, because if the
-
64  // first element was already the smallest, it would swap the value back into
-
65  // itself. However, the one situation where Selection Sort *might* be used
-
66  // over Insertion Sort is when the write operation is far more expensive
-
67  // than a read operation. So this test preserves that advantage of the
-
68  // Selection Sort, by avoiding doing an unnecessary swap.
-
69  if (i != iSmallest) {
-
70  swap(data[i], data[iSmallest]);
-
71  }
-
72  }
-
73 }
-
74 
-
75 }
-
76 
-
77 #endif
+
32 #ifndef ACE_SORTING_SELECTION_SORT_H
+
33 #define ACE_SORTING_SELECTION_SORT_H
+
34 
+
35 #include "swap.h"
+
36 
+
37 namespace ace_sorting {
+
38 
+
39 #if ! defined(ACE_SORTING_DIRECT_SELECTION_SORT)
+
40 
+
46  #define ACE_SORTING_DIRECT_SELECTION_SORT 0
+
47 #endif
+
48 
+
56 #if ACE_SORTING_DIRECT_SELECTION_SORT
+
57 template <typename T>
+
58 void selectionSort(T data[], uint16_t n) {
+
59  for (uint16_t i = 0; i < n; i++) {
+
60 
+
61  // Loop to find the smallest element.
+
62  uint16_t iSmallest = i;
+
63  T smallest = data[i];
+
64 
+
65  // Starting the loop with 'j = i + 1' increases flash usage on AVR by 12
+
66  // bytes. But it does not reduce the execution time signficantly, because
+
67  // the (i + 1) will be done anyway by the j++ in the loop. So the only thing
+
68  // we save is a single redundant 'smallest < smallest' comparison.
+
69  for (uint16_t j = i; j < n; j++) {
+
70  if (data[j] < smallest) {
+
71  iSmallest = j;
+
72  smallest = data[j];
+
73  }
+
74  }
+
75 
+
76  // This extra check (i != iSmallest) is not really necessary, because if the
+
77  // first element was already the smallest, it would swap the value back into
+
78  // itself. However, the one situation where Selection Sort *might* be used
+
79  // over Insertion Sort is when the write operation is far more expensive
+
80  // than a read operation. So this test preserves that advantage of the
+
81  // Selection Sort, by avoiding doing an unnecessary swap.
+
82  if (i != iSmallest) {
+
83  swap(data[i], data[iSmallest]);
+
84  }
+
85  }
+
86 }
+
87 #else
+
88 template <typename T>
+
89 void selectionSort(T data[], uint16_t n) {
+
90  // This lambda expression does not perform any captures, so the compiler will
+
91  // optimize and inline the less-than expression.
+
92  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
93  selectionSort(data, n, lessThan);
+
94 }
+
95 #endif
+
96 
+
104 template <typename T, typename F>
+
105 void selectionSort(T data[], uint16_t n, F&& lessThan) {
+
106  for (uint16_t i = 0; i < n; i++) {
+
107 
+
108  // Loop to find the smallest element.
+
109  uint16_t iSmallest = i;
+
110  T smallest = data[i];
+
111 
+
112  // Starting the loop with 'j = i + 1' increases flash usage on AVR by 12
+
113  // bytes. But it does not reduce the execution time signficantly, because
+
114  // the (i + 1) will be done anyway by the j++ in the loop. So the only thing
+
115  // we save is a single redundant 'smallest < smallest' comparison.
+
116  for (uint16_t j = i; j < n; j++) {
+
117  if (lessThan(data[j], smallest)) {
+
118  iSmallest = j;
+
119  smallest = data[j];
+
120  }
+
121  }
+
122 
+
123  // This extra check (i != iSmallest) is not really necessary, because if the
+
124  // first element was already the smallest, it would swap the value back into
+
125  // itself. However, the one situation where Selection Sort *might* be used
+
126  // over Insertion Sort is when the write operation is far more expensive
+
127  // than a read operation. So this test preserves that advantage of the
+
128  // Selection Sort, by avoiding doing an unnecessary swap.
+
129  if (i != iSmallest) {
+
130  swap(data[i], data[iSmallest]);
+
131  }
+
132  }
+
133 }
+
134 
+
135 }
+
136 
+
137 #endif
ace_sorting::swap
void swap(T &a, T &b)
Swap the parameters.
Definition: swap.h:41
-
ace_sorting::selectionSort
void selectionSort(T data[], uint16_t n)
Selection sort.
Definition: selectionSort.h:45
+
ace_sorting::selectionSort
void selectionSort(T data[], uint16_t n)
Selection sort.
Definition: selectionSort.h:89
Generated by   diff --git a/docs/html/shellSort_8h.html b/docs/html/shellSort_8h.html index a7fd0d2..1be0fe4 100644 --- a/docs/html/shellSort_8h.html +++ b/docs/html/shellSort_8h.html @@ -22,9 +22,9 @@
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
@@ -68,22 +68,13 @@
+Macros | Functions
shellSort.h File Reference
-
#include "swap.h"
-
-Include dependency graph for shellSort.h:
-
-
- - - - -
-
+
This graph shows which files directly or indirectly include this file:
@@ -95,28 +86,66 @@

Go to the source code of this file.

+ + + + +

+Macros

#define ACE_SORTING_DIRECT_SHELL_SORT   0
 If set to 1, use the direct inlined implementation of the 2-argument shellSortXxx(). More...
 
+ + + + - - - - + + + + + + + + + + + +

Functions

template<typename T >
void ace_sorting::shellSortClassic (T data[], uint16_t n)
 Shell sort with gap size reduced by factor of 2 each iteration. More...
 
template<typename T , typename F >
void ace_sorting::shellSortClassic (T data[], uint16_t n, F &&lessThan)
 Shell sort with gap size reduced by factor of 2 each iteration. More...
 
template<typename T >
void ace_sorting::shellSortKnuth (T data[], uint16_t n)
 Shell sort using gap size from Knuth. More...
 
template<typename T >
void ace_sorting::shellSortTokuda (T data[], const uint16_t n)
 Shell sort using gap sizes empirically determined by Tokuda. More...
 
template<typename T , typename F >
void ace_sorting::shellSortKnuth (T data[], uint16_t n, F &&lessThan)
 Shell sort using gap size from Knuth. More...
 
template<typename T >
void ace_sorting::shellSortTokuda (T data[], uint16_t n)
 Shell sort using gap sizes empirically determined by Tokuda. More...
 
template<typename T , typename F >
void ace_sorting::shellSortTokuda (T data[], const uint16_t n, F &&lessThan)
 Shell sort using gap sizes empirically determined by Tokuda. More...
 

Detailed Description

-

Shell sort with different gap algorithms.

+

Shell sort with different gap algorithms. See https://en.wikipedia.org/wiki/Shellsort

Definition in file shellSort.h.

-

Function Documentation

+

Macro Definition Documentation

+ +

◆ ACE_SORTING_DIRECT_SHELL_SORT

+ +
+
+ + + + +
#define ACE_SORTING_DIRECT_SHELL_SORT   0
+
+ +

If set to 1, use the direct inlined implementation of the 2-argument shellSortXxx().

+

Otherwise, use the 3-argument shellSortXxx() to implement 2-argument shellSortXxx(). For shellSortXxx(), the compiler will optimize both versions to be identical.

+ +

Definition at line 42 of file shellSort.h.

+ +
+
+

Function Documentation

-

◆ shellSortClassic()

+

◆ shellSortClassic() [1/2]

@@ -152,12 +181,60 @@

Definition at line 46 of file shellSort.h.

+

Definition at line 82 of file shellSort.h.

+ +

+
+ +

◆ shellSortClassic() [2/2]

+ +
+
+
+template<typename T , typename F >
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::shellSortClassic (T data[],
uint16_t n,
F && lessThan 
)
+
+ +

Shell sort with gap size reduced by factor of 2 each iteration.

+

Average complexity: Between O(n^1.3) to O(n^1.5) See https://en.wikipedia.org/wiki/Shellsort

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 99 of file shellSort.h.

-

◆ shellSortKnuth()

+

◆ shellSortKnuth() [1/2]

@@ -193,17 +270,65 @@

Definition at line 78 of file shellSort.h.

+

Definition at line 169 of file shellSort.h.

- -

◆ shellSortTokuda()

+ +

◆ shellSortKnuth() [2/2]

-template<typename T >
+template<typename T , typename F >
+ + + + + + + + + + + + + + + + + + + + + + + + +
void ace_sorting::shellSortKnuth (T data[],
uint16_t n,
F && lessThan 
)
+
+ +

Shell sort using gap size from Knuth.

+

Average complexity: Between O(n^1.3) to O(n^1.5)

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 185 of file shellSort.h.

+ +
+
+ +

◆ shellSortTokuda() [1/2]

+ +
+
+
+template<typename T , typename F >
@@ -215,6 +340,54 @@

+ + + + + + + + + + + + + +
void ace_sorting::shellSortTokuda const uint16_t n,
F && lessThan 
)
+
+ +

Shell sort using gap sizes empirically determined by Tokuda.

+

See https://en.wikipedia.org/wiki/Shellsort and https://oeis.org/A108870. Average complexity: Between O(n^1.3) to O(n^1.5)

+
Template Parameters
+ + + +
Ttype of data to sort
Ftype of lambda expression or function that returns true if a < b
+
+
+ +

Definition at line 285 of file shellSort.h.

+ +
+
+ +

◆ shellSortTokuda() [2/2]

+ +
+
+
+template<typename T >
+ + + + + + + + + + + @@ -234,7 +407,7 @@

Definition at line 119 of file shellSort.h.

+

Definition at line 268 of file shellSort.h.

diff --git a/docs/html/shellSort_8h__incl.map b/docs/html/shellSort_8h__incl.map deleted file mode 100644 index 6f384a8..0000000 --- a/docs/html/shellSort_8h__incl.map +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/docs/html/shellSort_8h__incl.md5 b/docs/html/shellSort_8h__incl.md5 deleted file mode 100644 index 6889b99..0000000 --- a/docs/html/shellSort_8h__incl.md5 +++ /dev/null @@ -1 +0,0 @@ -695d5e9a86caa836968904c5fd170e71 \ No newline at end of file diff --git a/docs/html/shellSort_8h__incl.png b/docs/html/shellSort_8h__incl.png deleted file mode 100644 index b0207e1564ba0873f4b18ca354ccea5bce1b72e9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4934 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 diff --git a/docs/html/shellSort_8h_source.html b/docs/html/shellSort_8h_source.html index 6e09611..c6cd793 100644 --- a/docs/html/shellSort_8h_source.html +++ b/docs/html/shellSort_8h_source.html @@ -22,9 +22,9 @@

@@ -95,123 +95,260 @@
22 SOFTWARE.
23 */
24 
-
31 #ifndef ACE_SORTING_SHELL_SORT_H
-
32 #define ACE_SORTING_SHELL_SORT_H
-
33 
-
34 #include "swap.h"
-
35 
-
36 namespace ace_sorting {
-
37 
-
45 template <typename T>
-
46 void shellSortClassic(T data[], uint16_t n) {
-
47  uint16_t gap = n;
-
48  while (gap > 1) {
-
49  gap /= 2;
-
50 
-
51  // Do insertion sort of each sub-array separated by gap.
-
52  for (uint16_t i = gap; i < n; i++) {
-
53  T temp = data[i];
-
54 
-
55  // Shift one slot to the right.
-
56  uint16_t j;
-
57  for (j = i; j >= gap; j -= gap) {
-
58  if (data[j - gap] <= temp) break;
-
59  data[j] = data[j - gap];
-
60  }
-
61 
-
62  // Just like insertionSort(), this can assign 'temp' back into the
-
63  // original slot if no shifting was done. That's ok because T is assumed
-
64  // to be relatively cheap to copy, and checking for (i != j) is more
-
65  // expensive than just doing the extra assignment.
-
66  data[j] = temp;
-
67  }
-
68  }
-
69 }
-
70 
-
77 template <typename T>
-
78 void shellSortKnuth(T data[], uint16_t n) {
-
79  // Calculate the largest gap using Knuth's formula. If n is a compile-time
-
80  // constant and relatively "small" (observed to be true at least up to 100),
-
81  // the compiler will precalculate the loop below and replace it with a
-
82  // compile-time constant.
-
83  uint16_t gap = 1;
-
84  while (gap < n / 3) {
-
85  gap = gap * 3 + 1;
-
86  }
-
87 
-
88  while (gap > 0) {
-
89  // Do insertion sort of each sub-array separated by gap.
-
90  for (uint16_t i = gap; i < n; i++) {
-
91  T temp = data[i];
-
92 
-
93  // Shift one slot to the right.
-
94  uint16_t j;
-
95  for (j = i; j >= gap; j -= gap) {
-
96  if (data[j - gap] <= temp) break;
-
97  data[j] = data[j - gap];
-
98  }
-
99 
-
100  // Just like insertionSort(), this can assign 'temp' back into the
-
101  // original slot if no shifting was done. That's ok because T is assumed
-
102  // to be relatively cheap to copy, and checking for (i != j) is more
-
103  // expensive than just doing the extra assignment.
-
104  data[j] = temp;
-
105  }
-
106 
-
107  gap = (gap - 1) / 3;
-
108  }
-
109 }
-
110 
-
118 template<typename T>
-
119 void shellSortTokuda(T data[], const uint16_t n)
-
120 {
-
121  // Experimentally observed ideal gaps.
-
122  // https://en.wikipedia.org/wiki/Shellsort
-
123  // https://oeis.org/A108870
-
124  static const uint16_t sGaps[] = {
-
125  1, 4, 9, 20, 46, 103, 233, 525, 1182, 2660, 5985, 13467, 30301,
-
126  };
-
127  const uint16_t nGaps = sizeof(sGaps) / sizeof(uint16_t);
-
128 
-
129  // Find the starting gap.
-
130  uint16_t iGap;
-
131  for (iGap = 0; sGaps[iGap] < n && iGap < nGaps; iGap++) {}
-
132  if (iGap != 0) iGap--;
-
133 
-
134  while (true) {
-
135  uint16_t gap = sGaps[iGap];
-
136 
-
137  // Do insertion sort of each sub-array separated by gap.
-
138  for (uint16_t i = gap; i < n; i++) {
-
139  T temp = data[i];
-
140 
-
141  // Shift one slot to the right.
-
142  uint16_t j;
-
143  for (j = i; j >= gap; j -= gap) {
-
144  if (data[j - gap] <= temp) break;
-
145  data[j] = data[j - gap];
-
146  }
-
147 
-
148  // Just like insertionSort(), this can assign 'temp' back into the
-
149  // original slot if no shifting was done. That's ok because T is assumed
-
150  // to be relatively cheap to copy, and checking for (i != j) is more
-
151  // expensive than just doing the extra assignment.
-
152  data[j] = temp;
-
153  }
-
154 
-
155  if (iGap == 0) break;
-
156  iGap--;
-
157  }
-
158 }
-
159 
-
160 }
-
161 
-
162 #endif
+
32 #ifndef ACE_SORTING_SHELL_SORT_H
+
33 #define ACE_SORTING_SHELL_SORT_H
+
34 
+
35 #if ! defined(ACE_SORTING_DIRECT_SHELL_SORT)
+
36 
+
42  #define ACE_SORTING_DIRECT_SHELL_SORT 0
+
43 #endif
+
44 
+
45 namespace ace_sorting {
+
46 
+
54 #if ACE_SORTING_DIRECT_SHELL_SORT
+
55 template <typename T>
+
56 void shellSortClassic(T data[], uint16_t n) {
+
57  uint16_t gap = n;
+
58  while (gap > 1) {
+
59  gap /= 2;
+
60 
+
61  // Do insertion sort of each sub-array separated by gap.
+
62  for (uint16_t i = gap; i < n; i++) {
+
63  T temp = data[i];
+
64 
+
65  // Shift one slot to the right.
+
66  uint16_t j;
+
67  for (j = i; j >= gap; j -= gap) {
+
68  if (data[j - gap] <= temp) break;
+
69  data[j] = data[j - gap];
+
70  }
+
71 
+
72  // Just like insertionSort(), this can assign 'temp' back into the
+
73  // original slot if no shifting was done. That's ok because T is assumed
+
74  // to be relatively cheap to copy, and checking for (i != j) is more
+
75  // expensive than just doing the extra assignment.
+
76  data[j] = temp;
+
77  }
+
78  }
+
79 }
+
80 #else
+
81 template <typename T>
+
82 void shellSortClassic(T data[], uint16_t n) {
+
83  // This lambda expression does not perform any captures, so the compiler will
+
84  // optimize and inline the less-than expression.
+
85  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
86  shellSortClassic(data, n, lessThan);
+
87 }
+
88 #endif
+
89 
+
98 template <typename T, typename F>
+
99 void shellSortClassic(T data[], uint16_t n, F&& lessThan) {
+
100  uint16_t gap = n;
+
101  while (gap > 1) {
+
102  gap /= 2;
+
103 
+
104  // Do insertion sort of each sub-array separated by gap.
+
105  for (uint16_t i = gap; i < n; i++) {
+
106  T temp = data[i];
+
107 
+
108  // Shift one slot to the right.
+
109  uint16_t j;
+
110  for (j = i; j >= gap; j -= gap) {
+
111  // The following is equivalent to: (data[j - gap] <= temp)
+
112  if (! lessThan(temp, data[j - gap])) break;
+
113  data[j] = data[j - gap];
+
114  }
+
115 
+
116  // Just like insertionSort(), this can assign 'temp' back into the
+
117  // original slot if no shifting was done. That's ok because T is assumed
+
118  // to be relatively cheap to copy, and checking for (i != j) is more
+
119  // expensive than just doing the extra assignment.
+
120  data[j] = temp;
+
121  }
+
122  }
+
123 }
+
124 
+
125 //-----------------------------------------------------------------------------
+
126 
+
133 #if ACE_SORTING_DIRECT_SHELL_SORT
+
134 template <typename T>
+
135 void shellSortKnuth(T data[], uint16_t n) {
+
136  // Calculate the largest gap using Knuth's formula. If n is a compile-time
+
137  // constant and relatively "small" (observed to be true at least up to 100),
+
138  // the compiler will precalculate the loop below and replace it with a
+
139  // compile-time constant.
+
140  uint16_t gap = 1;
+
141  while (gap < n / 3) {
+
142  gap = gap * 3 + 1;
+
143  }
+
144 
+
145  while (gap > 0) {
+
146  // Do insertion sort of each sub-array separated by gap.
+
147  for (uint16_t i = gap; i < n; i++) {
+
148  T temp = data[i];
+
149 
+
150  // Shift one slot to the right.
+
151  uint16_t j;
+
152  for (j = i; j >= gap; j -= gap) {
+
153  if (data[j - gap] <= temp) break;
+
154  data[j] = data[j - gap];
+
155  }
+
156 
+
157  // Just like insertionSort(), this can assign 'temp' back into the
+
158  // original slot if no shifting was done. That's ok because T is assumed
+
159  // to be relatively cheap to copy, and checking for (i != j) is more
+
160  // expensive than just doing the extra assignment.
+
161  data[j] = temp;
+
162  }
+
163 
+
164  gap = (gap - 1) / 3;
+
165  }
+
166 }
+
167 #else
+
168 template <typename T>
+
169 void shellSortKnuth(T data[], uint16_t n) {
+
170  // This lambda expression does not perform any captures, so the compiler will
+
171  // optimize and inline the less-than expression.
+
172  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
173  shellSortKnuth(data, n, lessThan);
+
174 }
+
175 #endif
+
176 
+
184 template <typename T, typename F>
+
185 void shellSortKnuth(T data[], uint16_t n, F&& lessThan) {
+
186  uint16_t gap = 1;
+
187  while (gap < n / 3) {
+
188  gap = gap * 3 + 1;
+
189  }
+
190 
+
191  while (gap > 0) {
+
192  // Do insertion sort of each sub-array separated by gap.
+
193  for (uint16_t i = gap; i < n; i++) {
+
194  T temp = data[i];
+
195 
+
196  // Shift one slot to the right.
+
197  uint16_t j;
+
198  for (j = i; j >= gap; j -= gap) {
+
199  // The following is equivalent to: (data[j - gap] <= temp)
+
200  if (! lessThan(temp, data[j - gap])) break;
+
201  data[j] = data[j - gap];
+
202  }
+
203 
+
204  // Just like insertionSort(), this can assign 'temp' back into the
+
205  // original slot if no shifting was done. That's ok because T is assumed
+
206  // to be relatively cheap to copy, and checking for (i != j) is more
+
207  // expensive than just doing the extra assignment.
+
208  data[j] = temp;
+
209  }
+
210 
+
211  gap = (gap - 1) / 3;
+
212  }
+
213 }
+
214 
+
215 //-----------------------------------------------------------------------------
+
216 
+
224 #if ACE_SORTING_DIRECT_SHELL_SORT
+
225 template<typename T>
+
226 void shellSortTokuda(T data[], const uint16_t n)
+
227 {
+
228  // Experimentally observed ideal gaps.
+
229  // https://en.wikipedia.org/wiki/Shellsort
+
230  // https://oeis.org/A108870
+
231  static const uint16_t sGaps[] = {
+
232  1, 4, 9, 20, 46, 103, 233, 525, 1182, 2660, 5985, 13467, 30301,
+
233  };
+
234  const uint16_t nGaps = sizeof(sGaps) / sizeof(uint16_t);
+
235 
+
236  // Find the starting gap.
+
237  uint16_t iGap;
+
238  for (iGap = 0; sGaps[iGap] < n && iGap < nGaps; iGap++) {}
+
239  if (iGap != 0) iGap--;
+
240 
+
241  while (true) {
+
242  uint16_t gap = sGaps[iGap];
+
243 
+
244  // Do insertion sort of each sub-array separated by gap.
+
245  for (uint16_t i = gap; i < n; i++) {
+
246  T temp = data[i];
+
247 
+
248  // Shift one slot to the right.
+
249  uint16_t j;
+
250  for (j = i; j >= gap; j -= gap) {
+
251  if (data[j - gap] <= temp) break;
+
252  data[j] = data[j - gap];
+
253  }
+
254 
+
255  // Just like insertionSort(), this can assign 'temp' back into the
+
256  // original slot if no shifting was done. That's ok because T is assumed
+
257  // to be relatively cheap to copy, and checking for (i != j) is more
+
258  // expensive than just doing the extra assignment.
+
259  data[j] = temp;
+
260  }
+
261 
+
262  if (iGap == 0) break;
+
263  iGap--;
+
264  }
+
265 }
+
266 #else
+
267 template <typename T>
+
268 void shellSortTokuda(T data[], uint16_t n) {
+
269  // This lambda expression does not perform any captures, so the compiler will
+
270  // optimize and inline the less-than expression.
+
271  auto&& lessThan = [](const T& a, const T& b) -> bool { return a < b; };
+
272  shellSortTokuda(data, n, lessThan);
+
273 }
+
274 #endif
+
275 
+
284 template<typename T, typename F>
+
285 void shellSortTokuda(T data[], const uint16_t n, F&& lessThan)
+
286 {
+
287  // Experimentally observed ideal gaps.
+
288  // https://en.wikipedia.org/wiki/Shellsort
+
289  // https://oeis.org/A108870
+
290  static const uint16_t sGaps[] = {
+
291  1, 4, 9, 20, 46, 103, 233, 525, 1182, 2660, 5985, 13467, 30301,
+
292  };
+
293  const uint16_t nGaps = sizeof(sGaps) / sizeof(uint16_t);
+
294 
+
295  // Find the starting gap.
+
296  uint16_t iGap;
+
297  for (iGap = 0; sGaps[iGap] < n && iGap < nGaps; iGap++) {}
+
298  if (iGap != 0) iGap--;
+
299 
+
300  while (true) {
+
301  uint16_t gap = sGaps[iGap];
+
302 
+
303  // Do insertion sort of each sub-array separated by gap.
+
304  for (uint16_t i = gap; i < n; i++) {
+
305  T temp = data[i];
+
306 
+
307  // Shift one slot to the right.
+
308  uint16_t j;
+
309  for (j = i; j >= gap; j -= gap) {
+
310  // The following is equivalent to: (data[j - gap] <= temp)
+
311  if (! lessThan(temp, data[j - gap])) break;
+
312  data[j] = data[j - gap];
+
313  }
+
314 
+
315  // Just like insertionSort(), this can assign 'temp' back into the
+
316  // original slot if no shifting was done. That's ok because T is assumed
+
317  // to be relatively cheap to copy, and checking for (i != j) is more
+
318  // expensive than just doing the extra assignment.
+
319  data[j] = temp;
+
320  }
+
321 
+
322  if (iGap == 0) break;
+
323  iGap--;
+
324  }
+
325 }
+
326 
+
327 }
+
328 
+
329 #endif
- -
ace_sorting::shellSortTokuda
void shellSortTokuda(T data[], const uint16_t n)
Shell sort using gap sizes empirically determined by Tokuda.
Definition: shellSort.h:119
-
ace_sorting::shellSortKnuth
void shellSortKnuth(T data[], uint16_t n)
Shell sort using gap size from Knuth.
Definition: shellSort.h:78
-
ace_sorting::shellSortClassic
void shellSortClassic(T data[], uint16_t n)
Shell sort with gap size reduced by factor of 2 each iteration.
Definition: shellSort.h:46
+
ace_sorting::shellSortTokuda
void shellSortTokuda(T data[], uint16_t n)
Shell sort using gap sizes empirically determined by Tokuda.
Definition: shellSort.h:268
+
ace_sorting::shellSortKnuth
void shellSortKnuth(T data[], uint16_t n)
Shell sort using gap size from Knuth.
Definition: shellSort.h:169
+
ace_sorting::shellSortClassic
void shellSortClassic(T data[], uint16_t n)
Shell sort with gap size reduced by factor of 2 each iteration.
Definition: shellSort.h:82
Generated by   diff --git a/docs/html/swap_8h.html b/docs/html/swap_8h.html index 3085f18..025392c 100644 --- a/docs/html/swap_8h.html +++ b/docs/html/swap_8h.html @@ -22,9 +22,9 @@
@@ -78,14 +78,12 @@
- + - + - - - - + +
diff --git a/docs/html/swap_8h__dep__incl.map b/docs/html/swap_8h__dep__incl.map index 025390f..568c42e 100644 --- a/docs/html/swap_8h__dep__incl.map +++ b/docs/html/swap_8h__dep__incl.map @@ -1,10 +1,8 @@ - + - + - - - - + + diff --git a/docs/html/swap_8h__dep__incl.md5 b/docs/html/swap_8h__dep__incl.md5 index 0e00d30..eec7090 100644 --- a/docs/html/swap_8h__dep__incl.md5 +++ b/docs/html/swap_8h__dep__incl.md5 @@ -1 +1 @@ -3888eb838ba3b2d7bf296a0a49a9eacd \ No newline at end of file +79c4f3ae55457e586056752bee8d62a9 \ No newline at end of file diff --git a/docs/html/swap_8h__dep__incl.png b/docs/html/swap_8h__dep__incl.png index 2f720a2bc493906dc333564ee3071eae083ecccf..acc568cc4796a3de694ac3bf88bbd8d082575561 100644 GIT binary patch literal 30006 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 {Yv=wRy4HrrNX(1x zd`BCCQlQ8|+s{SV0W{^nZhTemg_@R;;gNY57#!RPy9$UVPqef;LG?PgruO%FPHzAG zIKPrV#>BK0oAi^iy+8p`_KRPw;UnYYy93IK)~f?|=c{LCUVMm%IBrw)@Jdak2PWh% zNG4FyIchyB;1M zSX2TZffvf6U3pdPpKvi(t?)90iF2q~pKN=c9)DB#Dnk5K~{j4YS3PJ4<5D`HLkh)j% z%^}h947n<%nLWQ?l0Ci|Q2^tIqbL4z0+rf3J8yv%fYnDFDrB75`T2{yb;sC(4(rCY zo50;^1UHkNm-lKYSG}>N#THft;GuT_fOB@VO)275uDw3~R9RUa_@F#IJV1cj27F;@ z!1VKKAD^o%I@J(nNCS}&b`v`Q(|UjY^a9ufkUADac&BbMGWtPe_+^rBer_%+Cubf2 z3UPeaUf?1joD!tc1ywr$RgC~<2BaZ)5B)2Y8R_W=A`cjsvNAF^;Wpl(Ar%zE?zjK| zfg%z3WL4D0c-i!Rj2)5UKReGYcP+B^b( zbh}GPIoB>FE|-X_npQ_3r9$vS&3H;kXsF%c7(w})u!Q4BFX+MV13vH>4o3m7Yt-30 zJAsA_3Jzw*#ZeLI+4e6R8ZhumBr7P8(%;#@V6)j0sZ`8W>4h;QyTTm7UWjK2fDtZK ziRTXf{{Gtn0*(lU)qQ=b6vE9a;)0e~)z&7xes7?&$r9JMu^&{IVW~!=fdQDE5xf7* z`G%Jk7G4MR6WIgFQi01rSqMKYnJ}UFd5OyO`&SO*9Grfc>)KkNUazNsR! zH~CdLKAV)nSsiZV1R;k=uZtW7&V!(rl<^|q&`k~?h>DGWt*$2Ihwj?74~aNXn9Jc2 zg)UpCLZK)Wiz`PZgEKQ~P>Zm~eK}l*%#%XkC(%zv*PnxMDgky7wBygks9uypxQ-|` zJGecL2AC_E94wZ|+G1gA+dzHnu3OHR$z*ih(&8co>*SF<0Vrwy#u-VYne8&~ z(A`6LO$RrVR0??ts0#NshTes!>H*CJg#r0OA(ogFyilhCR>yz~3&C*5;h0VEI*2Pp zs6vz4W-#3PJ5lyWv!&zGWf`$gdOYRwt*QA3Hk*xme|8=Va1oh39uJ-?gfJM4#>PfW zWUg^^Z0zy=k&(8cdw%IUSCiZAzKC0s`H535m#^2byaS}BY`K^5i3!wFT(5010`epQ zt_ex)DX?}MRVoyTMyzffa+Q~tpR1{P$Fp%CH9;>RuHyCYF;Ix7*=sn|kN(n`A{AXE z5+M%P!6TG~nV_VhZtzSa0|Y6YD3RE(t`F?PJ7S*NZn0P*6HBZ2=4!KZbFo$Hc>qSC zp=dPP%d+%T7KQRy$3fnKqqs)!_IbS@DPeDrfN3Z+haj#to`<+c0BHp#{k79c$0weP z#zIY?x!OBAfG7AA2-u#RF9JIt`ANY_t|6AiWKyHIPWTH*h3@Wd%MWt^dL46`H84Uj zEYl$Qub){O92n48>C@dOG0Xq_<+N!hjn;=>38YCq_K&}t zbk)#43wRlBHeL}`!V+=T)t#NOps3zh89#Jmb8Q;-Gv{)Rk@V$CvFZ(H=6|FTZyPNq zbUnjJ(7(gF1rBE=zwPI%Cjoq_sHixM)fmp!BC*(dX={4@Y7MBuNsWuCa{*O*bH44j z*%}NdCR4KYj8Y(@gAi9W@XI>E-8ZNDvx%E&5%|7Du@R5cBWeR#Yn9OeE(89ST~J_x zKqQP0`0EAN_g=TuLfx_8+D5+iW&ssPl`IC{RImilpoC$B7=*m#2|Ny(oqP{vyok&{ zvX2COUN36=y$^BKrL!VegfIV?SDZ-x;A<_D?etjhE%AQz@V#M@{1EMKnKufP{?IaX z0$-QDBR^EP1Ds~i)uY? From 2bbc62bd7296be06c53ee2caac7e5b09e542a7a9 Mon Sep 17 00:00:00 2001 From: Brian Park Date: Mon, 23 Aug 2021 10:59:50 -0700 Subject: [PATCH 17/17] README.md: Fix typo 'left bit shift' -> 'right bit shift' --- README.md | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index fa23189..bc0f547 100644 --- a/README.md +++ b/README.md @@ -369,11 +369,14 @@ The `combSort13()` and `combSort13m()` functions use a gap factor of `10/13 = or 10. That apparently make the algorithm faster for reasons that I have not been able to find on the internet. -The `combSort133()` and `combSort133m()` functions use a gap factor of `4/3 = -1.33`. The `4/3` ratio allows the compiler to replace an integer division with a -left bit shift, so that code is smaller and faster on 8-bit processors without -hardware integer division. The `combSort133m()` function modifies the gap -sequence when the gap is 9 or 10. +The `combSort133()` function uses a gap factor of `4/3 = 1.33` instead of +`10/13`. The `4/3` ratio means that the gap size is multiplied by `3/4` on each +iteration, which allows the compiler to replace the integer division by `4` with +a right bit shift operation, so that code is smaller and faster on 8-bit +processors without hardware integer division. + +The `combSort133m()` function essentially the same as `combSort133()` but +modifies the gap sequence when the gap is 9 or 10. In terms of performance, [examples/AutoBenchmark](examples/AutoBenchmark) shows that Comb Sort is consistently slower than Shell Sort so it is difficult to
void ace_sorting::shellSortTokuda (T data[],
uint16_t  n 
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)
AceSorting -  0.2 +  0.3
-
Sorting algorithms for Arduino (Bubble Sort, Insertion Sort, Shell Sort, Comb Sort, Quick Sort)
+
Sorting algorithms for Arduino including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions)