undirected incidence matrix size map getters

Author: SpectraL519

include/hgl/impl/incidence_matrix.hpp

@@ -68,6 +68,11 @@ class incidence_matrix<hgl::undirected_t, LayoutTag> final {
         return this->_count<impl::element_type::vertex>(vertex_id);
     }
 
+    [[nodiscard]] std::vector<types::size_type> degree_map(const types::size_type n_vertices
+    ) const noexcept {
+        return this->_count_map<impl::element_type::vertex>(n_vertices);
+    }
+
     // --- hyperedge methods ---
 
     gl_attr_force_inline void add_hyperedges(const types::size_type n) noexcept {
@@ -88,6 +93,12 @@ class incidence_matrix<hgl::undirected_t, LayoutTag> final {
         return this->_count<impl::element_type::hyperedge>(hyperedge_id);
     }
 
+    [[nodiscard]] std::vector<types::size_type> hyperedge_size_map(
+        const types::size_type n_hyperedges
+    ) const noexcept {
+        return this->_count_map<impl::element_type::hyperedge>(n_hyperedges);
+    }
+
     // --- binding methods ---
 
     gl_attr_force_inline void bind(
@@ -179,6 +190,26 @@ class incidence_matrix<hgl::undirected_t, LayoutTag> final {
         return count;
     }
 
+    template <impl::element_type Element>
+    [[nodiscard]] std::vector<types::size_type> _count_map(const types::size_type n_elements
+    ) const noexcept {
+        std::vector<types::size_type> size_map(this->_matrix.size(), 0uz);
+
+        if constexpr (Element == layout_tag::major_element) { // size map major
+            for (const auto& [i, row] : this->_matrix | std::views::enumerate)
+                size_map[i] = static_cast<types::size_type>(std::ranges::count(row, true));
+        }
+        else { // size map minor
+            for (const auto& row : this->_matrix)
+                for (types::size_type j = 0uz; j < this->_matrix_row_size; ++j)
+                    if (row[j])
+                        ++size_map[j];
+        }
+
+        size_map.resize(n_elements, 0uz);
+        return size_map;
+    }
+
     types::size_type _matrix_row_size = 0uz;
     hypergraph_storage_type _matrix;
 };

tests/source/hgl/test_incidence_matrix.cpp

@@ -306,6 +306,29 @@ TEST_CASE_FIXTURE(
     CHECK_FALSE(sut.are_bound(constants::id2, constants::id1));
 }
 
+TEST_CASE_FIXTURE(
+    test_undirected_vertex_major_incidence_matrix,
+    "element size map getters should return maps of properly calculated element sizes"
+) {
+    constexpr auto n_elements = 5ull;
+    sut_type sut{n_elements, n_elements};
+
+    constexpr auto is_zero = [](const auto& size) { return size == 0ull; };
+    REQUIRE(std::ranges::all_of(sut.degree_map(n_elements), is_zero));
+    REQUIRE(std::ranges::all_of(sut.hyperedge_size_map(n_elements), is_zero));
+
+    for (std::size_t i = 0uz; i < n_elements; i++)
+        for (std::size_t j = 0uz; j <= i; j++)
+            sut.bind(i, j);
+
+    const auto deg_map = sut.degree_map(n_elements);
+    const auto esize_map = sut.hyperedge_size_map(n_elements);
+    for (std::size_t i = 0uz; i < n_elements; i++) {
+        CHECK_EQ(deg_map[i], i + 1uz);
+        CHECK_EQ(esize_map[i], n_elements - i);
+    }
+}
+
 struct test_undirected_hyperedge_major_incidence_matrix : public test_incidence_matrix {
     using sut_type = hgl::impl::incidence_matrix<hgl::undirected_t, hgl::impl::hyperedge_major_t>;
 };
@@ -583,6 +606,29 @@ TEST_CASE_FIXTURE(
     CHECK_FALSE(sut.are_bound(constants::id2, constants::id1));
 }
 
+TEST_CASE_FIXTURE(
+    test_undirected_hyperedge_major_incidence_matrix,
+    "element size map getters should return maps of properly calculated element sizes"
+) {
+    constexpr auto n_elements = 5ull;
+    sut_type sut{n_elements, n_elements};
+
+    constexpr auto is_zero = [](const auto& size) { return size == 0ull; };
+    REQUIRE(std::ranges::all_of(sut.degree_map(n_elements), is_zero));
+    REQUIRE(std::ranges::all_of(sut.hyperedge_size_map(n_elements), is_zero));
+
+    for (std::size_t i = 0uz; i < n_elements; i++)
+        for (std::size_t j = 0uz; j <= i; j++)
+            sut.bind(i, j);
+
+    const auto deg_map = sut.degree_map(n_elements);
+    const auto esize_map = sut.hyperedge_size_map(n_elements);
+    for (std::size_t i = 0uz; i < n_elements; i++) {
+        CHECK_EQ(deg_map[i], i + 1uz);
+        CHECK_EQ(esize_map[i], n_elements - i);
+    }
+}
+
 struct test_bf_directed_incidence_matrix : public test_incidence_matrix {
     template <typename SutType>
     auto is_incident_pred() {