wip: flat incidence matrix impl

Author: SpectraL519

include/gl/impl/adjacency_matrix.hpp

@@ -107,17 +107,17 @@ class adjacency_matrix final {
     }
 
     [[nodiscard]] gl_attr_force_inline bool has_edge(id_type source_id, id_type target_id) const {
-        return this->_matrix[to_idx(source_id)][to_idx(target_id)] != invalid_id;
+        return specialized_impl::get_edge_id(*this, source_id, target_id) != invalid_id;
     }
 
     [[nodiscard]] bool has_edge(const edge_type& edge) const {
-        return this->_matrix[to_idx(edge.source())][to_idx(edge.target())] == edge.id();
+        return specialized_impl::get_edge_id(*this, edge.source(), edge.target()) == edge.id();
     }
 
     [[nodiscard]] std::optional<edge_type> get_edge(id_type source_id, id_type target_id) const
     requires(traits::c_has_empty_properties<edge_type>)
     {
-        const auto edge_id = this->_matrix[to_idx(source_id)][to_idx(target_id)];
+        const auto edge_id = specialized_impl::get_edge_id(*this, source_id, target_id);
         if (edge_id == invalid_id)
             return std::nullopt;
         return std::make_optional<edge_type>(edge_id, source_id, target_id);
@@ -128,7 +128,7 @@ class adjacency_matrix final {
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
-        const auto edge_id = this->_matrix[to_idx(source_id)][to_idx(target_id)];
+        const auto edge_id = specialized_impl::get_edge_id(*this, source_id, target_id);
         if (edge_id == invalid_id)
             return std::nullopt;
         return std::make_optional<edge_type>(
@@ -139,7 +139,7 @@ class adjacency_matrix final {
     [[nodiscard]] std::vector<edge_type> get_edges(id_type source_id, id_type target_id) const
     requires(traits::c_has_empty_properties<edge_type>)
     {
-        const auto edge_id = this->_matrix[to_idx(source_id)][to_idx(target_id)];
+        const auto edge_id = specialized_impl::get_edge_id(*this, source_id, target_id);
         if (edge_id == invalid_id)
             return std::vector<edge_type>();
         return std::vector<edge_type>{
@@ -152,7 +152,7 @@ class adjacency_matrix final {
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
-        const auto edge_id = this->_matrix[to_idx(source_id)][to_idx(target_id)];
+        const auto edge_id = specialized_impl::get_edge_id(*this, source_id, target_id);
         if (edge_id == invalid_id)
             return std::vector<edge_type>();
         return std::vector<edge_type>{

include/gl/impl/specialized/adjacency_matrix.hpp

@@ -165,6 +165,10 @@ struct directed_adjacency_matrix {
         return removed_edges;
     }
 
+    static id_type get_edge_id(const impl_type& self, id_type source_id, id_type target_id) {
+        return self._matrix[to_idx(source_id)][to_idx(target_id)];
+    }
+
     static inline void add_edge(
         impl_type& self, id_type edge_id, id_type source_id, id_type target_id
     ) {
@@ -285,6 +289,10 @@ struct undirected_adjacency_matrix {
         return removed_edges;
     }
 
+    static id_type get_edge_id(const impl_type& self, id_type source_id, id_type target_id) {
+        return self._matrix[to_idx(source_id)][to_idx(target_id)];
+    }
+
     static void add_edge(impl_type& self, id_type edge_id, id_type source_id, id_type target_id) {
         detail::check_edge_override(self._matrix, source_id, target_id);
 

include/gl/impl/specialized/flat_adjacency_matrix.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "gl/attributes/diagnostics.hpp"
 #include "gl/constants.hpp"
 #include "gl/decl/impl_tags.hpp"
 #include "gl/graph_traits.hpp"
@@ -19,6 +20,36 @@
 
 namespace gl::impl::specialized {
 
+namespace detail {
+
+template <traits::c_id_type IdType>
+[[nodiscard]] auto& strict_get(flat_matrix<IdType>& id_matrix, const auto& edge) {
+    // get the edge and validate the address
+    const auto [source_id, target_id] = edge.incident_vertices();
+    auto& edge_id = id_matrix[to_idx(source_id), to_idx(target_id)];
+    if (edge.id() != edge_id)
+        throw std::invalid_argument(std::format(
+            "Got invalid edge [id = {} | vertices = ({}, {})]", edge.id(), source_id, target_id
+        ));
+
+    return edge_id;
+}
+
+template <traits::c_id_type IdType>
+inline void check_edge_override(
+    const flat_matrix<IdType>& id_matrix, const IdType source_id, const IdType target_id
+) {
+    if (const auto edge_id = id_matrix[to_idx(source_id), to_idx(target_id)]; edge_id != invalid_id)
+        throw std::logic_error(std::format(
+            "Cannot override an existing edge: [id = {}, vertices = ({}, {})]",
+            edge_id,
+            source_id,
+            target_id
+        ));
+}
+
+} // namespace detail
+
 template <traits::c_instantiation_of<adjacency_matrix> AdjacencyMatrix>
 requires(traits::c_directed_edge<typename AdjacencyMatrix::edge_type>)
 struct directed_flat_adjacency_matrix {
@@ -133,6 +164,10 @@ struct directed_flat_adjacency_matrix {
         return removed_edges;
     }
 
+    static id_type get_edge_id(const impl_type& self, id_type source_id, id_type target_id) {
+        return self._matrix[to_idx(source_id), to_idx(target_id)];
+    }
+
     static inline void add_edge(
         impl_type& self, id_type edge_id, id_type source_id, id_type target_id
     ) {
@@ -151,7 +186,7 @@ struct directed_flat_adjacency_matrix {
 
         auto matrix_source_row = self._matrix[to_idx(source_id)];
         for (auto [edge_id, target_id] : std::views::zip(edge_ids, target_ids))
-            matrix_source_row[to_idx(target_id)] = edge_id;
+            matrix_source_row[to_diff(target_id)] = edge_id;
     }
 
     static inline void remove_edge(impl_type& self, const edge_type& edge) {
@@ -246,6 +281,10 @@ struct undirected_flat_adjacency_matrix {
         return removed_edges;
     }
 
+    static id_type get_edge_id(const impl_type& self, id_type source_id, id_type target_id) {
+        return self._matrix[to_idx(source_id), to_idx(target_id)];
+    }
+
     static void add_edge(impl_type& self, id_type edge_id, id_type source_id, id_type target_id) {
         detail::check_edge_override(self._matrix, source_id, target_id);
 
@@ -271,7 +310,7 @@ struct undirected_flat_adjacency_matrix {
 
         for (auto [edge_id, target_id] : std::views::zip(edge_ids, target_ids)) {
             const auto target_idx = to_idx(target_id);
-            matrix_source_row[target_idx] = edge_id;
+            matrix_source_row[to_diff(target_id)] = edge_id;
             if (target_idx != source_idx)
                 self._matrix[target_idx, source_idx] = edge_id;
         }

include/gl/types/core.hpp

@@ -7,6 +7,7 @@
 #include "gl/attributes/force_inline.hpp"
 
 #include <concepts>
+#include <cstddef>
 #include <cstdint>
 #include <optional>
 #include <utility>
@@ -27,6 +28,11 @@ concept c_id_type = std::unsigned_integral<T>;
     return static_cast<size_type>(id);
 }
 
+// TODO: replace static_cast calls with to_diff
+[[nodiscard]] gl_attr_force_inline constexpr std::ptrdiff_t to_diff(std::integral auto i) noexcept {
+    return static_cast<std::ptrdiff_t>(i);
+}
+
 template <typename T>
 using homogeneous_pair = std::pair<T, T>;