Bug fix + improvements to probe::exc

When a cycle started and ended with elements comparing equal, probe::exc
returned an incorrect result, which this commit fixes.

Additionally, this commit fixes the Exc(X) + 1 <= Ham(X) relation when X
is already sorted, and improves the space complexity of probe::exc by
getting rid of the 'sorted' vector in a similar way that what was
recently done for indirect_adapter.

Author: Morwenn

include/cpp-sort/probes/exc.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2022 Morwenn
+ * Copyright (c) 2016-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #ifndef CPPSORT_PROBES_EXC_H_
@@ -11,7 +11,6 @@
 #include <functional>
 #include <iterator>
 #include <utility>
-#include <vector>
 #include <cpp-sort/sorter_facade.h>
 #include <cpp-sort/sorter_traits.h>
 #include <cpp-sort/utility/as_function.h>
@@ -29,6 +28,15 @@ namespace probe
 {
     namespace detail
     {
+        template<typename ForwardIterator, typename Compare, typename Projection>
+        constexpr auto compare_equivalent(ForwardIterator it1, ForwardIterator it2,
+                                          Compare compare, Projection projection)
+            -> bool
+        {
+            return not compare(projection(*it1), projection(*it2))
+                && not compare(projection(*it2), projection(*it1));
+        }
+
         template<typename ForwardIterator, typename Compare, typename Projection>
         auto exc_probe_algo(ForwardIterator first, ForwardIterator last,
                             cppsort::detail::difference_type_t<ForwardIterator> size,
@@ -61,48 +69,65 @@ namespace probe
             ////////////////////////////////////////////////////////////
             // Count the number of cycles
 
-            std::vector<bool> sorted(size, false);
-
             // Element where the current cycle starts
             auto start = first;
 
             difference_type cycles = 0;
-            while (start != last) {
+            do {
                 // Find the element to put in current's place
                 auto current = start;
                 auto next_pos = std::distance(first, current);
-                auto next = iterators[next_pos];
-                sorted[next_pos] = true;
+                // We replace all "sorted" iterators with last to make it
+                // possible to find unsorted iterators between cycles
+                auto next = std::exchange(iterators[next_pos], last);
 
                 // Process the current cycle
-                if (next != current) {
+                if (next == current) {
+                    // An element already in its final position counts as one cycle
+                    ++cycles;
+                } else {
+                    bool all_equivalent = true;
+
+                    // If an element is in the place of another element that compares
+                    // equivalent, it means that this element was actually already in
+                    // a suitable place, so we count one more cycle as if it was an
+                    // already suitably placed element, this handles collections with
+                    // several elements which compare equivalent
+                    if (compare_equivalent(current, next, comp, proj)) {
+                        ++cycles;
+                    } else {
+                        all_equivalent = false;
+                    }
+
                     while (next != start) {
-                        // If an element is in the place of another element that compares
-                        // equivalent, it means that this element was actually already in
-                        // a suitable place, so we count one more cycle as if it was an
-                        // already suitably placed element, this handles collections with
-                        // several elements which compare equivalent
-                        if (not comp(proj(*next), proj(*current)) &&
-                            not comp(proj(*current), proj(*next))) {
-                            ++cycles;
-                        }
                         // Locate the next element of the cycle
                         current = next;
                         auto next_pos = std::distance(first, next);
-                        next = iterators[next_pos];
-                        sorted[next_pos] = true;
+                        next = std::exchange(iterators[next_pos], last);
+
+                        if (compare_equivalent(current, next, comp, proj)) {
+                            ++cycles;
+                        } else {
+                            all_equivalent = false;
+                        }
                     }
-                }
 
-                ++cycles;
+                    // If all elements of a cycle compare equivalent, we already added one
+                    // cycle per element, so we only add one there if at least two elements
+                    // compared different
+                    if (not all_equivalent) {
+                        ++cycles;
+                    }
+                }
 
                 // Find the next cycle
-                auto&& sorted_it = sorted.begin() + std::distance(first, start);
+                auto&& iterators_it = iterators.begin() + std::distance(first, start);
                 do {
                     ++start;
-                    ++sorted_it;
-                } while (start != last && *sorted_it);
-            }
+                    ++iterators_it;
+                } while (start != last && *iterators_it == last);
+            } while (start != last);
+
             return size - cycles;
         }
 

tests/probes/exc.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2022 Morwenn
+ * Copyright (c) 2016-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #include <forward_list>
@@ -41,7 +41,7 @@ TEST_CASE( "presortedness measure: exc", "[probe][exc]" )
         CHECK( exc(li.begin(), li.end()) == max_n );
     }
 
-    SECTION( "regressions" )
+    SECTION( "regression: ascending duplicates" )
     {
         std::vector<int> collection;
         collection.reserve(100);
@@ -50,4 +50,10 @@ TEST_CASE( "presortedness measure: exc", "[probe][exc]" )
 
         CHECK( exc(collection) == 0 );
     }
+
+    SECTION( "regression: first and last elements of a cycle compare equal" )
+    {
+        std::vector<int> collection = { 0, 0, -1 };
+        CHECK( exc(collection) == 1 );
+    }
 }

tests/probes/relations.cpp

@@ -49,7 +49,11 @@ TEST_CASE( "relations between measures of presortedness", "[probe]" )
     // by Ola Petersson and Alistair Moffat
     CHECK( runs <= rem + 1 );
 
-    CHECK( exc + 1 <= ham );
+    if (exc == 0) {
+        CHECK( exc == ham );
+    } else {
+        CHECK( exc + 1 <= ham );
+    }
     CHECK( ham <= 2 * exc );
 
     CHECK( max <= dis );