hyperedge list alignment

Author: SpectraL519

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,30 @@ 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)
+            this->_unbind_impl(hyperedge, vertex_id);
+    }
+
+    [[nodiscard]] 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,26 +82,26 @@ 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];
+        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(
@@ -90,24 +110,28 @@ class undirected_hyperedge_list final {
         this->_unbind_impl(this->_storage[hyperedge_id], vertex_id);
     }
 
-    [[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 hyperedge_id, const types::id_type vertex_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);
+    void _unbind_impl(hyperedge_storage_type& hyperedge, const types::id_type vertex_id) noexcept {
+        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_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
 

tests/source/hgl/test_hyperedge_list.cpp

@@ -58,75 +58,72 @@ TEST_CASE_FIXTURE(
     CHECK_EQ(storage(sut).size(), constants::n_hyperedges - 1uz);
 }
 
-TEST_CASE_FIXTURE(test_undirected_hyperedge_list, "hyperedge_size should return 0 by default") {
+TEST_CASE_FIXTURE(
+    test_undirected_hyperedge_list, "incident_vertices should remove an empty view by default"
+) {
     sut_type sut{constants::n_vertices, constants::n_hyperedges};
     CHECK(std::ranges::all_of(constants::hyperedge_ids_view, [&sut](const auto hyperedge_id) {
-        return sut.hyperedge_size(hyperedge_id) == 0uz;
+        return std::ranges::empty(sut.incident_vertices(hyperedge_id));
     }));
 }
 
-TEST_CASE_FIXTURE(
-    test_undirected_hyperedge_list, "hyperedge_vertices should remove an empty view by default"
-) {
+TEST_CASE_FIXTURE(test_undirected_hyperedge_list, "hyperedge_size should return 0 by default") {
     sut_type sut{constants::n_vertices, constants::n_hyperedges};
     CHECK(std::ranges::all_of(constants::hyperedge_ids_view, [&sut](const auto hyperedge_id) {
-        return std::ranges::empty(sut.hyperedge_vertices(hyperedge_id));
+        return sut.hyperedge_size(hyperedge_id) == 0uz;
     }));
 }
 
 TEST_CASE_FIXTURE(
     test_undirected_hyperedge_list,
-    "bind(hyperedge, vertex) should add the vertex to the given hyperedge's storage only if the "
-    "they are not bound"
+    "bind should add the vertex to the given hyperedge's storage only if the they are not bound"
 ) {
     sut_type sut{constants::n_vertices, constants::n_hyperedges};
-    REQUIRE(std::ranges::empty(sut.hyperedge_vertices(constants::id1)));
+    REQUIRE(std::ranges::empty(sut.incident_vertices(constants::id1)));
 
     sut.bind(constants::id1, constants::id1);
-    const auto vertices1 = sut.hyperedge_vertices(constants::id1) | std::ranges::to<std::vector>();
+    const auto vertices1 = sut.incident_vertices(constants::id1) | std::ranges::to<std::vector>();
     CHECK_EQ(sut.hyperedge_size(constants::id1), 1uz);
     CHECK_EQ(std::ranges::size(vertices1), 1uz);
     CHECK(std::ranges::contains(vertices1, constants::id1));
     CHECK(std::ranges::equal(vertices1, storage(sut)[constants::id1]));
 
     sut.bind(constants::id1, constants::id1);
-    const auto vertices2 = sut.hyperedge_vertices(constants::id1) | std::ranges::to<std::vector>();
+    const auto vertices2 = sut.incident_vertices(constants::id1) | std::ranges::to<std::vector>();
     CHECK_EQ(std::ranges::size(vertices2), 1uz);
     CHECK(std::ranges::equal(vertices2, vertices1));
 }
 
 TEST_CASE_FIXTURE(
     test_undirected_hyperedge_list,
-    "unbind(hyperedge, vertex) should remove the vertex from the given hyperedge's storage only if "
-    "the they are bound"
+    "unbind should remove the vertex from the given hyperedge's storage only if the they are bound"
 ) {
     sut_type sut{constants::n_vertices, constants::n_hyperedges};
-    REQUIRE(std::ranges::empty(sut.hyperedge_vertices(constants::id1)));
+    REQUIRE(std::ranges::empty(sut.incident_vertices(constants::id1)));
 
     sut.bind(constants::id1, constants::id1);
-    const auto vertices1 = sut.hyperedge_vertices(constants::id1) | std::ranges::to<std::vector>();
+    const auto vertices1 = sut.incident_vertices(constants::id1) | std::ranges::to<std::vector>();
     REQUIRE_EQ(sut.hyperedge_size(constants::id1), 1uz);
     REQUIRE(std::ranges::contains(vertices1, constants::id1));
 
     sut.unbind(constants::id1, constants::id2);
-    const auto vertices2 = sut.hyperedge_vertices(constants::id1) | std::ranges::to<std::vector>();
+    const auto vertices2 = sut.incident_vertices(constants::id1) | std::ranges::to<std::vector>();
     REQUIRE_EQ(std::ranges::size(vertices2), 1uz);
     REQUIRE(std::ranges::equal(vertices2, vertices1));
 
     sut.unbind(constants::id1, constants::id1);
-    CHECK(std::ranges::empty(sut.hyperedge_vertices(constants::id1)));
+    CHECK(std::ranges::empty(sut.incident_vertices(constants::id1)));
 }
 
 TEST_CASE_FIXTURE(
     test_undirected_hyperedge_list,
-    "are_bound(hyperedge, vertex) should return true only when the given vertex is present in the "
-    "hyperedge's storage"
+    "are_bound should return true only when the given vertex is present in the hyperedge's storage"
 ) {
     sut_type sut{constants::n_vertices, constants::n_hyperedges};
-    REQUIRE(std::ranges::empty(sut.hyperedge_vertices(constants::id1)));
+    REQUIRE(std::ranges::empty(sut.incident_vertices(constants::id1)));
 
     sut.bind(constants::id1, constants::id1);
-    const auto vertices1 = sut.hyperedge_vertices(constants::id1) | std::ranges::to<std::vector>();
+    const auto vertices1 = sut.incident_vertices(constants::id1) | std::ranges::to<std::vector>();
     REQUIRE_EQ(sut.hyperedge_size(constants::id1), 1uz);
     REQUIRE(std::ranges::contains(vertices1, constants::id1));
 
@@ -135,6 +132,12 @@ TEST_CASE_FIXTURE(
     CHECK_FALSE(sut.are_bound(constants::id2, constants::id1));
 }
 
+TEST_CASE_FIXTURE(test_undirected_hyperedge_list, "add_vertices should do nothing") {
+    sut_type sut{};
+    sut.add_vertices(constants::n_vertices);
+    CHECK(storage(sut).empty());
+}
+
 TEST_CASE_FIXTURE(
     test_undirected_hyperedge_list,
     "remove_vertex should unbind the given vertex from all hyperedges"
@@ -148,10 +151,38 @@ TEST_CASE_FIXTURE(
 
     sut.remove_vertex(constants::id1);
     CHECK(std::ranges::all_of(constants::hyperedge_ids_view, [&sut](const auto hyperedge_id) {
-        return std::ranges::empty(sut.hyperedge_vertices(hyperedge_id));
+        return std::ranges::empty(sut.incident_vertices(hyperedge_id));
     }));
 }
 
+TEST_CASE_FIXTURE(
+    test_undirected_hyperedge_list,
+    "incident_hyperedges should return a view of the vertex's incident hyperedge ids"
+) {
+    sut_type sut{constants::n_vertices, constants::n_hyperedges};
+
+    constexpr auto vertex_id = constants::id1;
+    REQUIRE(std::ranges::empty(sut.incident_hyperedges(vertex_id)));
+
+    for (const auto hyperedge_id : constants::hyperedge_ids_view)
+        sut.bind(hyperedge_id, vertex_id);
+    CHECK(std::ranges::equal(sut.incident_hyperedges(vertex_id), constants::hyperedge_ids_view));
+}
+
+TEST_CASE_FIXTURE(
+    test_undirected_hyperedge_list,
+    "degree should return the number of the vertex's incident hyperedges"
+) {
+    sut_type sut{constants::n_vertices, constants::n_hyperedges};
+
+    constexpr auto vertex_id = constants::id1;
+    REQUIRE_EQ(sut.degree(vertex_id), 0uz);
+
+    for (const auto hyperedge_id : constants::hyperedge_ids_view)
+        sut.bind(hyperedge_id, vertex_id);
+    CHECK_EQ(sut.degree(vertex_id), constants::n_hyperedges);
+}
+
 TEST_SUITE_END(); // test_hyperedge_list
 
 } // namespace hgl_testing

tests/source/hgl/test_hypergraph.cpp

@@ -371,8 +371,8 @@ TEST_CASE_TEMPLATE_INSTANTIATE(
     hypergraph_traits_template,
     hgl::hyperedge_list_hg_traits<hgl::undirected_t>, // undirected edge list
     hgl::hyperedge_list_hg_traits<hgl::bf_directed_t>, // bf-directed edge list
-    hgl::adjacency_list_hg_traits<hgl::undirected_t>, // undirected adjacency list
-    hgl::adjacency_list_hg_traits<hgl::bf_directed_t>, // bf-directed adjacency list
+    hgl::vertex_list_hg_traits<hgl::undirected_t>, // undirected adjacency list
+    hgl::vertex_list_hg_traits<hgl::bf_directed_t>, // bf-directed adjacency list
     hgl::incidence_matrix_hg_traits<hgl::undirected_t>, // undirected incidence matrix
     hgl::incidence_matrix_hg_traits<hgl::bf_directed_t> // bf-directed incidence matrix
 );
@@ -422,11 +422,11 @@ TEST_CASE_TEMPLATE_INSTANTIATE(
         hgl::bf_directed_t,
         hgl::types::name_property,
         hgl::types::name_property>, // bf-directed hyperedge list
-    hgl::adjacency_list_hg_traits<
+    hgl::vertex_list_hg_traits<
         hgl::undirected_t,
         hgl::types::name_property,
         hgl::types::name_property>, // undirected adjacency list
-    hgl::adjacency_list_hg_traits<
+    hgl::vertex_list_hg_traits<
         hgl::bf_directed_t,
         hgl::types::name_property,
         hgl::types::name_property>, // bf-directed adjacency list