initial renaming

Author: SpectraL519

include/gl/algorithm/spanning_tree/prim_mst.hpp

@@ -51,7 +51,7 @@ template <traits::c_undirected_graph G>
     if (root_id == invalid_id)
         root_id = initial_id;
 
-    for (const auto& edge : graph.adjacent_edges(root_id))
+    for (const auto& edge : graph.incidenct_edges(root_id))
         edge_queue.emplace(edge);
 
     // mark the root vertex as visited
@@ -75,7 +75,7 @@ template <traits::c_undirected_graph G>
         ++n_vertices_in_mst;
 
         // enqueue all edges adjacent to the `target` vertex if they lead to unvisited verties
-        for (const auto& edge : graph.adjacent_edges(min_edge.target()))
+        for (const auto& edge : graph.incidenct_edges(min_edge.target()))
             if (not visited[to_idx(edge.incident_vertex(min_edge.target()))])
                 edge_queue.emplace(edge);
     }
@@ -132,7 +132,7 @@ requires traits::c_has_numeric_limits_max<vertex_distance_type<G>>
         }
 
         // Update adjacent vertices
-        for (const auto& edge : graph.adjacent_edges(vertex_id)) {
+        for (const auto& edge : graph.incidenct_edges(vertex_id)) {
             const auto edge_weight = get_weight<G>(edge);
             const auto incident_vertex_idx = to_idx(edge.incident_vertex(vertex_id));
 

include/gl/algorithm/templates/bfs.hpp

@@ -55,7 +55,7 @@ bool bfs(
             if (not visit(node.vertex_id, node.pred_id))
                 return false;
 
-        for (const auto& edge : graph.adjacent_edges(node.vertex_id)) {
+        for (const auto& edge : graph.incidenct_edges(node.vertex_id)) {
             const auto incident_vertex_id = edge.incident_vertex(node.vertex_id);
 
             const auto enqueue = enqueue_vertex_pred(incident_vertex_id, edge);

include/gl/algorithm/templates/dfs.hpp

@@ -55,7 +55,7 @@ bool dfs(
             if (not visit(node.vertex_id, node.pred_id))
                 return false;
 
-        for (const auto& edge : graph.adjacent_edges(node.vertex_id)) {
+        for (const auto& edge : graph.incidenct_edges(node.vertex_id)) {
             const auto incident_vertex_id = edge.incident_vertex(node.vertex_id);
             if (enqueue_vertex_pred(incident_vertex_id, edge))
                 s.emplace(incident_vertex_id, node.vertex_id);
@@ -96,7 +96,7 @@ void r_dfs(
     visit(vertex_id, pred_id);
 
     // recursively search vertices adjacent to the current vertex
-    for (const auto& edge : graph.adjacent_edges(vertex_id)) {
+    for (const auto& edge : graph.incidenct_edges(vertex_id)) {
         const auto& incident_vertex_id = edge.incident_vertex(vertex_id);
         if (enqueue_vertex_pred(incident_vertex_id, edge))
             r_dfs(

include/gl/algorithm/templates/pfs.hpp

@@ -59,7 +59,7 @@ bool pfs(
             if (not visit(node.vertex_id, node.pred_id))
                 return false;
 
-        for (const auto& edge : graph.adjacent_edges(node.vertex_id)) {
+        for (const auto& edge : graph.incidenct_edges(node.vertex_id)) {
             const auto incident_vertex_id = edge.incident_vertex(node.vertex_id);
 
             const auto enqueue = enqueue_vertex_pred(incident_vertex_id, edge);

include/gl/graph.hpp

@@ -293,18 +293,16 @@ class graph final {
         return this->at(vertex.id());
     }
 
-    // TODO: rename to incident_edges
-    [[nodiscard]] inline auto adjacent_edges(const id_type vertex_id) const {
+    [[nodiscard]] inline auto incidenct_edges(const id_type vertex_id) const {
         this->_verify_vertex_id(vertex_id);
         if constexpr (traits::c_non_empty_properties<edge_properties_type>)
-            return this->_impl.adjacent_edges(vertex_id, this->_edge_properties);
+            return this->_impl.incidenct_edges(vertex_id, this->_edge_properties);
         else
-            return this->_impl.adjacent_edges(vertex_id);
+            return this->_impl.incidenct_edges(vertex_id);
     }
 
-    // TODO: rename to incident_edges
-    [[nodiscard]] gl_attr_force_inline auto adjacent_edges(const vertex_type& vertex) const {
-        return this->adjacent_edges(vertex.id());
+    [[nodiscard]] gl_attr_force_inline auto incidenct_edges(const vertex_type& vertex) const {
+        return this->incidenct_edges(vertex.id());
     }
 
     [[nodiscard]] inline auto in_edges(const id_type vertex_id) const {
@@ -696,7 +694,7 @@ class graph final {
 
         for (const auto& vertex : this->vertices()) {
             os << "- " << vertex << "\n  adjacent edges:\n";
-            for (const auto& edge : this->adjacent_edges(vertex.id()))
+            for (const auto& edge : this->incidenct_edges(vertex.id()))
                 os << "\t- " << edge << '\n';
         }
     }
@@ -706,7 +704,7 @@ class graph final {
 
         for (const auto& vertex : this->vertices()) {
             os << "- " << vertex << " :";
-            for (const auto& edge : this->adjacent_edges(vertex.id()))
+            for (const auto& edge : this->incidenct_edges(vertex.id()))
                 os << ' ' << edge;
             os << '\n';
         }
@@ -736,7 +734,7 @@ class graph final {
         if constexpr (traits::c_writable<typename edge_type::properties_type>) {
             if (with_edge_properties) {
                 const auto print_incident_edges = [this, &os](const id_type vertex_id) {
-                    for (const auto& edge : this->adjacent_edges(vertex_id)) {
+                    for (const auto& edge : this->incidenct_edges(vertex_id)) {
                         if (edge.source() != vertex_id)
                             continue; // vertex is not the source
                         os << edge.source() << ' ' << edge.target() << ' ' << edge.properties()
@@ -752,7 +750,7 @@ class graph final {
         }
 
         const auto print_incident_edges = [this, &os](const id_type vertex_id) {
-            for (const auto& edge : this->adjacent_edges(vertex_id)) {
+            for (const auto& edge : this->incidenct_edges(vertex_id)) {
                 if (edge.source() != vertex_id)
                     continue; // vertex is not the source
                 os << edge.source() << ' ' << edge.target() << '\n';

include/gl/impl/adjacency_list.hpp

@@ -120,9 +120,9 @@ class adjacency_list final {
     [[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& adjacent_edges = this->_list[to_idx(source_id)];
-        const auto item_it = std::ranges::find(adjacent_edges, target_id, &item_type::vertex_id);
-        if (item_it == adjacent_edges.cend())
+        const auto& incidenct_edges = this->_list[to_idx(source_id)];
+        const auto item_it = std::ranges::find(incidenct_edges, target_id, &item_type::vertex_id);
+        if (item_it == incidenct_edges.cend())
             return std::nullopt;
         return std::make_optional<edge_type>(item_it->edge_id, source_id, target_id);
     }
@@ -132,11 +132,11 @@ class adjacency_list final {
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
-        const auto& adjacent_edges = this->_list[to_idx(source_id)];
-        const auto item_it = std::ranges::find(adjacent_edges, target_id, [](const auto& item) {
+        const auto& incidenct_edges = this->_list[to_idx(source_id)];
+        const auto item_it = std::ranges::find(incidenct_edges, target_id, [](const auto& item) {
             return item.vertex_id;
         });
-        if (item_it == adjacent_edges.cend())
+        if (item_it == incidenct_edges.cend())
             return std::nullopt;
         return std::make_optional<edge_type>(
             item_it->edge_id, source_id, target_id, *edge_properties_map[to_idx(item_it->edge_id)]
@@ -188,13 +188,13 @@ class adjacency_list final {
         return removed_edge_ids;
     }
 
-    [[nodiscard]] gl_attr_force_inline auto adjacent_edges(id_type vertex_id) const
+    [[nodiscard]] gl_attr_force_inline auto incidenct_edges(id_type vertex_id) const
     requires(traits::c_has_empty_properties<edge_type>)
     {
         return this->out_edges(vertex_id);
     }
 
-    [[nodiscard]] gl_attr_force_inline auto adjacent_edges(
+    [[nodiscard]] gl_attr_force_inline auto incidenct_edges(
         id_type vertex_id, const auto& edge_properties_map
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
@@ -257,14 +257,14 @@ class adjacency_list final {
     [[nodiscard]] gl_attr_force_inline auto at(id_type vertex_id) const
     requires(traits::c_has_empty_properties<edge_type>)
     {
-        return this->adjacent_edges(vertex_id);
+        return this->incidenct_edges(vertex_id);
     }
 
     [[nodiscard]] gl_attr_force_inline auto at(id_type vertex_id, const auto& edge_properties_map)
         const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
-        return this->adjacent_edges(vertex_id, edge_properties_map);
+        return this->incidenct_edges(vertex_id, edge_properties_map);
     }
 
     // --- comparison ---

include/gl/impl/adjacency_matrix.hpp

@@ -178,13 +178,13 @@ class adjacency_matrix final {
         return removed_edge_ids;
     }
 
-    [[nodiscard]] gl_attr_force_inline auto adjacent_edges(id_type vertex_id) const
+    [[nodiscard]] gl_attr_force_inline auto incidenct_edges(id_type vertex_id) const
     requires(traits::c_has_empty_properties<edge_type>)
     {
         return this->out_edges(vertex_id);
     }
 
-    [[nodiscard]] gl_attr_force_inline auto adjacent_edges(
+    [[nodiscard]] gl_attr_force_inline auto incidenct_edges(
         id_type vertex_id, const auto& edge_properties_map
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)

include/gl/impl/specialized/adjacency_list.hpp

@@ -78,9 +78,9 @@ struct directed_adjacency_list {
 
     [[nodiscard]] static size_type in_degree(const impl_type& self, id_type vertex_id) {
         size_type in_deg = 0uz;
-        for (const auto& adjacent_edges : self._list)
+        for (const auto& incidenct_edges : self._list)
             in_deg += static_cast<size_type>(
-                std::ranges::count(adjacent_edges, vertex_id, &item_type::vertex_id)
+                std::ranges::count(incidenct_edges, vertex_id, &item_type::vertex_id)
             );
 
         return in_deg;

tests/include/testing/gl/io_common.hpp

@@ -13,7 +13,7 @@ void verify_graph_structure(const GraphType& actual, const GraphType& expected)
 
     // verify that the edges of the in graph are equivalent to the edges of the out graph
     CHECK(std::ranges::all_of(actual.vertices(), [&](const auto& v_actual) {
-        return std::ranges::all_of(actual.adjacent_edges(v_actual), [&](const auto& edge) {
+        return std::ranges::all_of(actual.incidenct_edges(v_actual), [&](const auto& edge) {
             return expected.has_edge(edge.source(), edge.target());
         });
     }));
@@ -35,7 +35,7 @@ void verify_vertex_properties(const GraphType& actual, const GraphType& expected
 template <gl::traits::c_graph GraphType>
 void verify_edge_properties(const GraphType& actual, const GraphType& expected) {
     CHECK(std::ranges::all_of(actual.vertices(), [&](const auto& v_actual) {
-        return std::ranges::all_of(actual.adjacent_edges(v_actual), [&](const auto& edge) {
+        return std::ranges::all_of(actual.incidenct_edges(v_actual), [&](const auto& edge) {
             return edge.properties()
                 == expected.get_edge(edge.source(), edge.target())->properties();
         });