hyperedge list alignment

Author: SpectraL519

include/hgl/hypergraph.hpp

@@ -368,6 +368,7 @@ class hypergraph final {
         this->_n_vertices--;
         if constexpr (type_traits::c_non_empty_properties<vertex_properties_type>)
             this->_vertex_properties.erase(this->_vertex_properties.begin() + vertex_id);
+        // TODO: impl::remove_vertex(vertex_id)
     }
 
     // --- hyperedge methods ---

include/hgl/hypergraph_traits.hpp

@@ -37,8 +37,8 @@ template <
     type_traits::c_hypergraph_directional_tag DirectionalTag = undirected_t,
     type_traits::c_properties VertexProperties = types::empty_properties,
     type_traits::c_properties HyperedgeProperties = types::empty_properties>
-using adjacency_list_hg_traits =
-    hypergraph_traits<DirectionalTag, VertexProperties, HyperedgeProperties, impl::adjacency_list_t>;
+using vertex_list_hg_traits =
+    hypergraph_traits<DirectionalTag, VertexProperties, HyperedgeProperties, impl::vertex_list_t>;
 
 template <
     type_traits::c_hypergraph_directional_tag DirectionalTag = undirected_t,
@@ -69,9 +69,9 @@ concept c_hyperedge_list_hg_traits =
     and std::same_as<typename TraitsType::implementation_tag, impl::hyperedge_list_t>;
 
 template <typename TraitsType>
-concept c_adjacency_list_hg_traits =
+concept c_vertex_list_hg_traits =
     c_instantiation_of<TraitsType, hypergraph_traits>
-    and std::same_as<typename TraitsType::implementation_tag, impl::adjacency_list_t>;
+    and std::same_as<typename TraitsType::implementation_tag, impl::vertex_list_t>;
 
 template <typename TraitsType>
 concept c_incidence_matrix_hg_traits =

include/hgl/impl/hyperedge_list.hpp

@@ -7,6 +7,7 @@
 #include "hgl/types/types.hpp"
 
 #include <algorithm>
+#include <ranges>
 #include <vector>
 
 #ifdef HGL_TESTING
@@ -45,11 +46,36 @@ class undirected_hyperedge_list final {
 
     // --- vertex methods ---
 
-    gl_attr_force_inline void add_vertices(const types::size_type) const noexcept {}
+    // clang-format off
+
+    gl_attr_force_inline void add_vertices([[maybe_unused]] const types::size_type) const noexcept {}
+
+    // clang-format on
 
     void remove_vertex(const types::id_type vertex_id) noexcept {
-        for (auto& hyperedge_vertices : this->_storage)
-            this->_unbind_impl(hyperedge_vertices, vertex_id);
+        for (auto& hyperedge : this->_storage) {
+            auto vertex_it = std::ranges::lower_bound(hyperedge, vertex_id);
+            if (vertex_it != hyperedge.end() and *vertex_it == vertex_id)
+                vertex_it = hyperedge.erase(vertex_it); // unbind the vertex
+            while (vertex_it != hyperedge.end())
+                --(*vertex_it++); // decrement ids > vertex_id
+        }
+    }
+
+    [[nodiscard]] gl_attr_force_inline auto incident_hyperedges(const types::id_type vertex_id
+    ) const noexcept {
+        return std::views::iota(0uz, this->_storage.size())
+             | std::views::filter([this, vertex_id](types::id_type hid) {
+                   return this->_are_bound_impl(this->_storage[hid], vertex_id);
+               });
+    }
+
+    [[nodiscard]] types::size_type degree(const types::id_type vertex_id) const noexcept {
+        types::size_type deg = 0uz;
+        for (const auto& hyperedge : this->_storage)
+            if (this->_are_bound_impl(hyperedge, vertex_id))
+                ++deg;
+        return deg;
     }
 
     // --- hyperedge methods ---
@@ -62,52 +88,53 @@ class undirected_hyperedge_list final {
         this->_storage.erase(this->_storage.begin() + hyperedge_id);
     }
 
-    [[nodiscard]] gl_attr_force_inline types::size_type hyperedge_size(
-        const types::id_type hyperedge_id
+    [[nodiscard]] gl_attr_force_inline auto incident_vertices(const types::id_type hyperedge_id
     ) const noexcept {
-        return this->_storage[hyperedge_id].size();
+        return std::views::all(this->_storage[hyperedge_id]);
     }
 
-    [[nodiscard]] gl_attr_force_inline auto hyperedge_vertices(const types::id_type hyperedge_id
+    [[nodiscard]] gl_attr_force_inline types::size_type hyperedge_size(
+        const types::id_type hyperedge_id
     ) const noexcept {
-        return std::views::all(this->_storage[hyperedge_id]);
+        return this->_storage[hyperedge_id].size();
     }
 
     // --- binding methods ---
 
-    void bind(const types::id_type hyperedge_id, const types::id_type vertex_id) noexcept {
-        auto& hyperedge_vertices = this->_storage[hyperedge_id];
+    void bind(const types::id_type vertex_id, const types::id_type hyperedge_id) noexcept {
+        auto& hyperedge = this->_storage[hyperedge_id];
 
         // insert the id at the correct position to keep the vertex-id collection sorted
-        const auto it = std::ranges::lower_bound(hyperedge_vertices, vertex_id);
-        if (it == hyperedge_vertices.end() or *it != vertex_id)
-            hyperedge_vertices.insert(it, vertex_id);
+        const auto it = std::ranges::lower_bound(hyperedge, vertex_id);
+        if (it == hyperedge.end() or *it != vertex_id)
+            hyperedge.insert(it, vertex_id);
     }
 
     gl_attr_force_inline void unbind(
-        const types::id_type hyperedge_id, const types::id_type vertex_id
+        const types::id_type vertex_id, const types::id_type hyperedge_id
     ) noexcept {
-        this->_unbind_impl(this->_storage[hyperedge_id], vertex_id);
+        auto& hyperedge = this->_storage[hyperedge_id];
+        const auto vertex_it = std::ranges::lower_bound(hyperedge, vertex_id);
+        if (vertex_it != hyperedge.end() and *vertex_it == vertex_id)
+            hyperedge.erase(vertex_it);
     }
 
-    [[nodiscard]] bool are_bound(const types::id_type hyperedge_id, const types::id_type vertex_id)
-        const noexcept {
-        auto& hyperedge_vertices = this->_storage[hyperedge_id];
-        const auto vertex_it = std::ranges::lower_bound(hyperedge_vertices, vertex_id);
-        return vertex_it != hyperedge_vertices.end() and *vertex_it == vertex_id;
+    [[nodiscard]] gl_attr_force_inline bool are_bound(
+        const types::id_type vertex_id, const types::id_type hyperedge_id
+    ) const noexcept {
+        return this->_are_bound_impl(this->_storage[hyperedge_id], vertex_id);
     }
 
 #ifdef HGL_TESTING
     friend struct hgl_testing::test_hyperedge_list;
 #endif
 
 private:
-    void _unbind_impl(
-        hyperedge_storage_type& hyperedge_vertices, const types::id_type vertex_id
-    ) noexcept {
-        const auto vertex_it = std::ranges::lower_bound(hyperedge_vertices, vertex_id);
-        if (vertex_it != hyperedge_vertices.end() and *vertex_it == vertex_id)
-            hyperedge_vertices.erase(vertex_it);
+    [[nodiscard]] bool _are_bound_impl(
+        const hyperedge_storage_type& hyperedge, const types::id_type vertex_id
+    ) const noexcept {
+        const auto vertex_it = std::ranges::lower_bound(hyperedge, vertex_id);
+        return vertex_it != hyperedge.end() and *vertex_it == vertex_id;
     }
 
     hypergraph_storage_type _storage;

include/hgl/impl/impl_tags.hpp

@@ -12,7 +12,7 @@ namespace impl {
 
 struct hyperedge_list_t {};
 
-struct adjacency_list_t {};
+struct vertex_list_t {};
 
 struct incidence_matrix_t {};
 
@@ -22,7 +22,7 @@ namespace type_traits {
 
 template <typename T>
 concept c_hypergraph_impl_tag =
-    c_one_of<T, impl::hyperedge_list_t, impl::adjacency_list_t, impl::incidence_matrix_t>;
+    c_one_of<T, impl::hyperedge_list_t, impl::vertex_list_t, impl::incidence_matrix_t>;
 
 } // namespace type_traits