count_cycles: do not rely on IndexSpace with p key being registered

Author: evaleev

SeQuant/core/utility/permutation.hpp

@@ -1,7 +1,6 @@
 #ifndef SEQUANT_PERMUTATION_HPP
 #define SEQUANT_PERMUTATION_HPP
 
-#include <SeQuant/core/index.hpp>
 #include <SeQuant/core/utility/macros.hpp>
 
 #include <range/v3/algorithm.hpp>
@@ -10,76 +9,46 @@
 #include <cstddef>
 #include <cstdlib>
 #include <set>
-#include <type_traits>
-#include <utility>
+#include <vector>
 
 namespace sequant {
 
 /// @brief Returns the number of cycles
 
 /// Counts the number of cycles of a permutation represented in a 2-line form
 /// by stacking \p v0 and \p v1 on top of each other.
-/// @tparam Seq0 (reference to) a container type
-/// @tparam Seq1 (reference to) a container type
-/// @param v0 first sequence; if passed as an rvalue reference, it is moved from
+/// @tparam Seq0 a container type
+/// @tparam Seq1 a container type
+/// @param[in] v0 first sequence
 /// @param[in] v1 second sequence
 /// @pre \p v0 is a permutation of \p v1
 /// @return the number of cycles
 template <typename Seq0, typename Seq1>
-std::size_t count_cycles(Seq0&& v0, const Seq1& v1) {
-  std::remove_reference_t<Seq0> v(std::forward<Seq0>(v0));
-  using T = std::decay_t<decltype(v[0])>;
-  SEQUANT_ASSERT(ranges::is_permutation(v, v1));
+std::size_t count_cycles(const Seq0& v0, const Seq1& v1) {
+  SEQUANT_ASSERT(ranges::is_permutation(v0, v1));
   // This function can't deal with duplicate entries in v0 or v1
   SEQUANT_ASSERT(std::set(std::begin(v0), std::end(v0)).size() == v0.size());
   SEQUANT_ASSERT(std::set(std::begin(v1), std::end(v1)).size() == v1.size());
 
-  auto make_null = []() -> T {
-    if constexpr (std::is_arithmetic_v<T>) {
-      return -1;
-    } else if constexpr (std::is_same_v<T, Index>) {
-      return L"p_50";
-    }
-
-    SEQUANT_UNREACHABLE;
-  };
-
-  const auto null = make_null();
-  SEQUANT_ASSERT(ranges::contains(v, null) == false);
-  SEQUANT_ASSERT(ranges::contains(v1, null) == false);
-
+  const auto n = v0.size();
+  std::vector<bool> visited(n, false);
   std::size_t n_cycles = 0;
-  for (auto it = v.begin(); it != v.end(); ++it) {
-    if (*it != null) {
-      n_cycles++;
-
-      auto idx = std::distance(v.begin(), it);
-      SEQUANT_ASSERT(idx >= 0);
-
-      auto it0 = it;
-
-      auto it1 = std::find(v1.begin(), v1.end(), *it0);
-      SEQUANT_ASSERT(it1 != v1.end());
-
-      auto idx1 = std::distance(v1.begin(), it1);
-      SEQUANT_ASSERT(idx1 >= 0);
 
+  for (std::size_t i = 0; i < n; ++i) {
+    if (!visited[i]) {
+      ++n_cycles;
+      auto j = i;
       do {
-        it0 = std::find(v.begin(), v.end(), v[idx1]);
-        SEQUANT_ASSERT(it0 != v.end());
-
-        it1 = std::find(v1.begin(), v1.end(), *it0);
-        SEQUANT_ASSERT(it1 != v1.end());
-
-        idx1 = std::distance(v1.begin(), it1);
-        SEQUANT_ASSERT(idx1 >= 0);
-
-        *it0 = null;
-      } while (idx1 != idx);
+        visited[j] = true;
+        auto it = std::find(std::begin(v1), std::end(v1), v0[j]);
+        SEQUANT_ASSERT(it != std::end(v1));
+        j = static_cast<std::size_t>(std::distance(std::begin(v1), it));
+      } while (j != i);
     }
   }
+
   return n_cycles;
-};
+}
 
 /// computes parity of a permutation of 0 ... N-1
 ///