Reimplement probe::enc as a true measure of presortedness

The old implementation recognizes that Enx(X) as proposed by Skienna
does not match Mannila's first criterion for what makes a measures of
presortedness, and uses Enc(X) - 1 instead. However, in doing so, it
violates Mannila's fourth criterion.

The new implementation uses M_Enc as proposed by Estivill-Castro in
*Sorting and Measures of Disorder*, which satisfies all of Mannila's
criteria.

Author: Morwenn

docs/Measures-of-presortedness.md

@@ -152,13 +152,30 @@ When enough memory is available `probe::dis` runs in O(n) using an algorithm des
 #include <cpp-sort/probes/enc.h>
 ```
 
-Computes the number of encroaching lists that can be extracted from $X$ minus one (see *Encroaching lists as a measure of presortedness* by S. Skiena).
+Computes an approximation of the number of encroaching lists that can be extracted from $X$ (see *Encroaching lists as a measure of presortedness* by S. Skiena). Encroaching lists are better explained by their construction algorithm: create an empty list $L$ of lists given a sequence $X$ of elements, for each element $E$ of $X$:
+1. If $L$ is empty, create a new list with $E$.
+2. Otherwise, compare $E$ to the head and tail of the rightmost list of $L$.
+  2.1 If $E$ is greater than the head, find the lefmost list that has a head smaller than $E$, and prepend $E$ to that list.
+  2.2 Otherwise, it $E$ is smaller than the tail, find the lefmost list that has a tail greater than $E$, and append $E$ to that list.
+  3.3 Otherwise append a new list to $L$ with the element $E$.
+
+Those lists are called encroaching because the bounds of a given list "encroach" those of all lists on its right.
+
+The number of encroaching lists does not satisfy the formal definition of a measure of presortedness because it returns $1$ for non-empty sorted sequences instead of $0$, which does not respect first Mannila's criterion. Using $Enc(X) - 1$ does not work either because it does not respect Mannila's fourth criterion. To circumvent these issues, `probe::enc` implements an equivalent measure of disorder $M_{Enc}$ proposed by V. Estivill-Castro in *Sorting and Measures of Disorder*, which satisfies all of Mannila's criteria for what makes a measure of presortedness:
+
+$$
+M_{Enc}(X)=
+\begin{cases}
+0 & \text{if } X \text{ is sorted,}\\
+Enc(X_{tail}) & \text{otherwise, where } X_{tail} \text{ is } X \text{ without its leading ascending run.}
+\end{cases}
+$$
 
 | Complexity  | Memory      | Iterators     |
 | ----------- | ----------- | ------------- |
 | n log n     | n           | Forward       |
 
-`max_for_size`: $\frac{|X| + 1}{2} - 1$ when the values already extracted from $X$ constitute stronger bounds than the values yet to be extracted (for example the sequence $\langle 0, 9, 1, 8, 2, 7, 3, 6, 4, 5 \rangle$ will trigger the worst case).
+`max_for_size`: $\frac{|X|}{2}$ when all values extracted from $X$ are within the bounds of already extracted encroaching lists (for example the sequence $\langle 10, 0, 9, 1, 8, 2, 7, 3, 6, 4, 5 \rangle$ triggers the worst case).
 
 ### *Exc*
 

include/cpp-sort/probes/enc.h

@@ -18,6 +18,7 @@
 #include <cpp-sort/utility/as_function.h>
 #include <cpp-sort/utility/branchless_traits.h>
 #include <cpp-sort/utility/functional.h>
+#include "../detail/is_sorted_until.h"
 #include "../detail/iterator_traits.h"
 #include "../detail/lower_bound.h"
 #include "../detail/type_traits.h"
@@ -70,9 +71,11 @@ namespace cppsort::probe
                 auto&& comp = utility::as_function(compare);
                 auto&& proj = utility::as_function(projection);
 
-                if (first == last || std::next(first) == last) {
-                    return 0;
-                }
+                // Ignore the first monotonic run of the collection, technically
+                // implements M_Enc as proposed by V. Estivill-Castro in *Sorting
+                // and Measures of Disorder*
+                first = cppsort::detail::is_sorted_until(first, last, compare, projection);
+                if (first == last) return 0;
 
                 // Heads an tails of encroaching lists
                 std::vector<std::pair<ForwardIterator, ForwardIterator>> lists;
@@ -109,14 +112,14 @@ namespace cppsort::probe
                     ++first;
                 }
 
-                return lists.size() - 1;
+                return lists.size();
             }
 
             template<typename Integer>
             static constexpr auto max_for_size(Integer n)
                 -> Integer
             {
-                return n == 0 ? 0 : (n + 1) / 2 - 1;
+                return n / 2;
             }
         };
     }

tests/probes/enc.cpp

@@ -16,22 +16,34 @@ TEST_CASE( "presortedness measure: enc", "[probe][enc]" )
     SECTION( "simple test" )
     {
         const std::forward_list<int> li = { 4, 6, 5, 2, 9, 1, 3, 8, 0, 7 };
-        CHECK( enc(li) == 2 );
-        CHECK( enc(li.begin(), li.end()) == 2 );
+        CHECK( enc(li) == 3 );
+        CHECK( enc(li.begin(), li.end()) == 3 );
 
         std::vector<internal_compare<int>> tricky(li.begin(), li.end());
-        CHECK( enc(tricky, &internal_compare<int>::compare_to) == 2 );
+        CHECK( enc(tricky, &internal_compare<int>::compare_to) == 3 );
     }
 
     SECTION( "upper bound" )
     {
         // The upper bound should correspond to half the size
         // of the input sequence minus one
 
-        const std::forward_list<int> li = { 10, 0, 9, 1, 8, 2, 7, 3, 6, 4, 5 };
-        auto max_n = enc.max_for_size(cppsort::utility::size(li));
-        CHECK( max_n == 5 );
-        CHECK( enc(li) == max_n );
-        CHECK( enc(li.begin(), li.end()) == max_n );
+        {
+            // Even number of elements
+            const std::forward_list<int> li = { 11, 10, 0, 9, 1, 8, 2, 7, 3, 6, 4, 5 };
+            auto max_n = enc.max_for_size(cppsort::utility::size(li));
+            CHECK( max_n == 6 );
+            CHECK( enc(li) == max_n );
+            CHECK( enc(li.begin(), li.end()) == max_n );
+        }
+
+        {
+            // Odd number of elements
+            const std::forward_list<int> li = { 11, 10, 0, 9, 1, 8, 2, 7, 3, 6, 4 };
+            auto max_n = enc.max_for_size(cppsort::utility::size(li));
+            CHECK( max_n == 5 );
+            CHECK( enc(li) == max_n );
+            CHECK( enc(li.begin(), li.end()) == max_n );
+        }
     }
 }

tests/probes/relations.cpp

@@ -109,10 +109,8 @@ TEST_CASE( "relations between measures of presortedness", "[probe]" )
         return enc(sequence) <= std::min<long long>(rem + 1, size - rem);
     });
 
-    rc::prop("(Enc(X) + 1) ≤ 2 Exc(X)", [](const std::vector<int>& sequence) {
-        auto exc = cppsort::probe::exc(sequence);
-        auto enc = cppsort::probe::enc(sequence);
-        return (enc == 0 && exc == 0) || (enc + 1 <= 2 * exc);
+    rc::prop("Enc(X) ≤ 2 Exc(X)", [](const std::vector<int>& sequence) {
+        return cppsort::probe::enc(sequence) <= 2 * cppsort::probe::exc(sequence);
     });
 
     rc::prop("Conjecture: Enc(X) ≤ Exc(X)", [](const std::vector<int>& sequence) {
@@ -130,8 +128,8 @@ TEST_CASE( "relations between measures of presortedness", "[probe]" )
         return sus(sequence) <= max(sequence);
     });
 
-    rc::prop("Enc(X) ≤ SUS(X)", [](const std::vector<int>& sequence) {
-        return enc(sequence) <= sus(sequence);
+    rc::prop("Enc(X) ≤ SUS(X) + 1", [](const std::vector<int>& sequence) {
+        return enc(sequence) <= sus(sequence) + 1;
     });
 
     // Heapsort - Adapted for Presorted Files