incident_edges directed logic error fix

SpectraL519 · SpectraL519 · commit 5539241ce32a · 2026-04-10T22:14:01.000+02:00
diff --git a/include/gl/algorithm/spanning_tree/prim_mst.hpp b/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.incident_edges(root_id))
+    for (const auto& edge : graph.out_edges(root_id))
         edge_queue.emplace(edge);
 
     // mark the root vertex as visited
diff --git a/include/gl/algorithm/templates/bfs.hpp b/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.incident_edges(node.vertex_id)) {
+        for (const auto& edge : graph.out_edges(node.vertex_id)) {
             const auto target_vertex_id = edge.other(node.vertex_id);
             const auto enqueue = enqueue_vertex_pred(target_vertex_id, edge);
             if (enqueue == decision::abort)
diff --git a/include/gl/algorithm/templates/dfs.hpp b/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.incident_edges(node.vertex_id)) {
+        for (const auto& edge : graph.out_edges(node.vertex_id)) {
             const auto target_vertex_id = edge.other(node.vertex_id);
             if (enqueue_vertex_pred(target_vertex_id, edge))
                 s.emplace(target_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.incident_edges(vertex_id)) {
+    for (const auto& edge : graph.out_edges(vertex_id)) {
         const auto target_vertex_id = edge.other(vertex_id);
         if (enqueue_vertex_pred(target_vertex_id, edge))
             r_dfs(
diff --git a/include/gl/algorithm/templates/pfs.hpp b/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.incident_edges(node.vertex_id)) {
+        for (const auto& edge : graph.out_edges(node.vertex_id)) {
             const auto target_vertex_id = edge.other(node.vertex_id);
             const auto enqueue = enqueue_vertex_pred(target_vertex_id, edge);
             if (enqueue == decision::abort)
diff --git a/include/gl/graph.hpp b/include/gl/graph.hpp
@@ -734,7 +734,7 @@ class graph final {
 
         for (const auto& vertex : this->vertices()) {
             os << "- " << vertex << "\n  incident edges:\n";
-            for (const auto& edge : this->incident_edges(vertex.id()))
+            for (const auto& edge : this->out_edges(vertex.id()))
                 os << "\t- " << edge << '\n';
         }
     }
@@ -744,7 +744,7 @@ class graph final {
 
         for (const auto& vertex : this->vertices()) {
             os << "- " << vertex << " :";
-            for (const auto& edge : this->incident_edges(vertex.id()))
+            for (const auto& edge : this->out_edges(vertex.id()))
                 os << ' ' << edge;
             os << '\n';
         }
@@ -773,8 +773,8 @@ 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->incident_edges(vertex_id)) {
+                const auto print_out_edges = [this, &os](const id_type vertex_id) {
+                    for (const auto& edge : this->out_edges(vertex_id)) {
                         if (edge.source() != vertex_id)
                             continue; // vertex is not the source
                         os << edge.source() << ' ' << edge.target() << ' ' << edge.properties()
@@ -783,22 +783,22 @@ class graph final {
                 };
 
                 for (const auto vertex_id : this->vertex_ids())
-                    print_incident_edges(vertex_id);
+                    print_out_edges(vertex_id);
 
                 return;
             }
         }
 
-        const auto print_incident_edges = [this, &os](const id_type vertex_id) {
-            for (const auto& edge : this->incident_edges(vertex_id)) {
+        const auto print_out_edges = [this, &os](const id_type vertex_id) {
+            for (const auto& edge : this->out_edges(vertex_id)) {
                 if (edge.source() != vertex_id)
                     continue; // vertex is not the source
                 os << edge.source() << ' ' << edge.target() << '\n';
             }
         };
 
         for (const auto vertex_id : this->vertex_ids())
-            print_incident_edges(vertex_id);
+            print_out_edges(vertex_id);
     }
 
     void _gsf_read(std::istream& is) {
diff --git a/include/gl/impl/adjacency_list.hpp b/include/gl/impl/adjacency_list.hpp
@@ -155,9 +155,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& incident_edges = this->_list[to_idx(source_id)];
-        const auto item_it = std::ranges::find(incident_edges, target_id, &item_type::vertex_id);
-        if (item_it == incident_edges.cend())
+        const auto& out_edges = this->_list[to_idx(source_id)];
+        const auto item_it = std::ranges::find(out_edges, target_id, &item_type::vertex_id);
+        if (item_it == out_edges.cend())
             return std::nullopt;
         return std::make_optional<edge_type>(item_it->edge_id, source_id, target_id);
     }
@@ -167,11 +167,11 @@ class adjacency_list final {
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
-        const auto& incident_edges = this->_list[to_idx(source_id)];
-        const auto item_it = std::ranges::find(incident_edges, target_id, [](const auto& item) {
+        const auto& out_edges = this->_list[to_idx(source_id)];
+        const auto item_it = std::ranges::find(out_edges, target_id, [](const auto& item) {
             return item.vertex_id;
         });
-        if (item_it == incident_edges.cend())
+        if (item_it == out_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)]
@@ -209,15 +209,15 @@ class adjacency_list final {
     [[nodiscard]] gl_attr_force_inline auto incident_edges(id_type vertex_id) const
     requires(traits::c_has_empty_properties<edge_type>)
     {
-        return this->out_edges(vertex_id);
+        return specialized_impl::incident_edges(*this, vertex_id);
     }
 
     [[nodiscard]] gl_attr_force_inline auto incident_edges(
         id_type vertex_id, const auto& edge_properties_map
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
-        return this->out_edges(vertex_id, edge_properties_map);
+        return specialized_impl::incident_edges(*this, vertex_id, edge_properties_map);
     }
 
     [[nodiscard]] gl_attr_force_inline auto in_edges(id_type vertex_id) const
@@ -275,14 +275,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->incident_edges(vertex_id);
+        return this->out_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->incident_edges(vertex_id, edge_properties_map);
+        return this->out_edges(vertex_id, edge_properties_map);
     }
 
     // --- comparison ---
diff --git a/include/gl/impl/adjacency_matrix.hpp b/include/gl/impl/adjacency_matrix.hpp
@@ -200,15 +200,15 @@ class adjacency_matrix final {
     [[nodiscard]] gl_attr_force_inline auto incident_edges(id_type vertex_id) const
     requires(traits::c_has_empty_properties<edge_type>)
     {
-        return this->out_edges(vertex_id);
+        return specialized_impl::incident_edges(*this, vertex_id);
     }
 
     [[nodiscard]] gl_attr_force_inline auto incident_edges(
         id_type vertex_id, const auto& edge_properties_map
     ) const
     requires(traits::c_has_non_empty_properties<edge_type>)
     {
-        return this->out_edges(vertex_id, edge_properties_map);
+        return specialized_impl::incident_edges(*this, vertex_id, edge_properties_map);
     }
 
     [[nodiscard]] gl_attr_force_inline auto in_edges(id_type vertex_id) const
diff --git a/include/gl/impl/specialized/adjacency_list.hpp b/include/gl/impl/specialized/adjacency_list.hpp
@@ -118,9 +118,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& incident_edges : self._list)
+        for (const auto& out_edges : self._list)
             in_deg += static_cast<size_type>(
-                std::ranges::count(incident_edges, vertex_id, &item_type::vertex_id)
+                std::ranges::count(out_edges, vertex_id, &item_type::vertex_id)
             );
 
         return in_deg;
@@ -191,6 +191,21 @@ struct directed_adjacency_list {
 
     // --- edge getters ---
 
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id
+    ) {
+        return util::concat(self.in_edges(vertex_id), self.out_edges(vertex_id));
+    }
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+    ) {
+        return util::concat(
+            self.in_edges(vertex_id, edge_properties_map),
+            self.out_edges(vertex_id, edge_properties_map)
+        );
+    }
+
     [[nodiscard]] static auto in_edges(const impl_type& self, id_type vertex_id) {
         std::vector<item_type> in_edges;
         for (id_type src_id = initial_id; src_id < self._list.size(); ++src_id) {
@@ -337,6 +352,18 @@ struct undirected_adjacency_list {
 
     // --- edge getters ---
 
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id
+    ) {
+        return self.out_edges(vertex_id);
+    }
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+    ) {
+        return self.out_edges(vertex_id, edge_properties_map);
+    }
+
     [[nodiscard]] gl_attr_force_inline static auto in_edges(
         const impl_type& self, id_type vertex_id
     ) {
diff --git a/include/gl/impl/specialized/adjacency_matrix.hpp b/include/gl/impl/specialized/adjacency_matrix.hpp
@@ -225,6 +225,23 @@ struct directed_adjacency_matrix {
     gl_attr_force_inline static void remove_edge(impl_type& self, const edge_type& edge) {
         detail::strict_get(self._matrix, edge) = invalid_id;
     }
+
+    // --- edge getters ---
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id
+    ) {
+        return util::concat(self.in_edges(vertex_id), self.out_edges(vertex_id));
+    }
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+    ) {
+        return util::concat(
+            self.in_edges(vertex_id, edge_properties_map),
+            self.out_edges(vertex_id, edge_properties_map)
+        );
+    }
 };
 
 template <traits::c_instantiation_of<adjacency_matrix> AdjacencyMatrix>
@@ -396,6 +413,20 @@ struct undirected_adjacency_matrix {
             self._matrix[to_idx(edge.target())][to_idx(edge.source())] = invalid_id;
         }
     }
+
+    // --- edge getters ---
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id
+    ) {
+        return self.out_edges(vertex_id);
+    }
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+    ) {
+        return self.out_edges(vertex_id, edge_properties_map);
+    }
 };
 
 template <traits::c_instantiation_of<adjacency_matrix> AdjacencyMatrix>
diff --git a/include/gl/impl/specialized/flat_adjacency_list.hpp b/include/gl/impl/specialized/flat_adjacency_list.hpp
@@ -154,6 +154,21 @@ struct directed_flat_adjacency_list {
 
     // --- edge getters ---
 
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id
+    ) {
+        return util::concat(self.in_edges(vertex_id), self.out_edges(vertex_id));
+    }
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+    ) {
+        return util::concat(
+            self.in_edges(vertex_id, edge_properties_map),
+            self.out_edges(vertex_id, edge_properties_map)
+        );
+    }
+
     [[nodiscard]] static auto in_edges(const impl_type& self, id_type vertex_id) {
         std::vector<item_type> in_edges;
         for (id_type src_id = initial_id; src_id < self._list.size(); ++src_id) {
@@ -318,6 +333,18 @@ struct undirected_flat_adjacency_list {
 
     // --- edge getters ---
 
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id
+    ) {
+        return self.out_edges(vertex_id);
+    }
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+    ) {
+        return self.out_edges(vertex_id, edge_properties_map);
+    }
+
     [[nodiscard]] gl_attr_force_inline static auto in_edges(
         const impl_type& self, id_type vertex_id
     ) {
diff --git a/include/gl/impl/specialized/flat_adjacency_matrix.hpp b/include/gl/impl/specialized/flat_adjacency_matrix.hpp
@@ -230,6 +230,23 @@ struct directed_flat_adjacency_matrix {
     gl_attr_force_inline static void remove_edge(impl_type& self, const edge_type& edge) {
         detail::strict_get(self._matrix, edge) = invalid_id;
     }
+
+    // --- edge getters ---
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id
+    ) {
+        return util::concat(self.in_edges(vertex_id), self.out_edges(vertex_id));
+    }
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+    ) {
+        return util::concat(
+            self.in_edges(vertex_id, edge_properties_map),
+            self.out_edges(vertex_id, edge_properties_map)
+        );
+    }
 };
 
 template <traits::c_instantiation_of<adjacency_matrix> AdjacencyMatrix>
@@ -396,6 +413,20 @@ struct undirected_flat_adjacency_matrix {
             self._matrix[to_idx(edge.target()), to_idx(edge.source())] = invalid_id;
         }
     }
+
+    // --- edge getters ---
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id
+    ) {
+        return self.out_edges(vertex_id);
+    }
+
+    [[nodiscard]] gl_attr_force_inline static auto incident_edges(
+        const impl_type& self, id_type vertex_id, const auto& edge_properties_map
+    ) {
+        return self.out_edges(vertex_id, edge_properties_map);
+    }
 };
 
 template <traits::c_instantiation_of<adjacency_matrix> AdjacencyMatrix>
diff --git a/tests/include/testing/gl/io_common.hpp b/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.incident_edges(v_actual), [&](const auto& edge) {
+        return std::ranges::all_of(actual.out_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.incident_edges(v_actual), [&](const auto& edge) {
+        return std::ranges::all_of(actual.out_edges(v_actual), [&](const auto& edge) {
             return edge.properties()
                 == expected.get_edge(edge.source(), edge.target())->properties();
         });
diff --git a/tests/source/gl/test_adjacency_list.cpp b/tests/source/gl/test_adjacency_list.cpp
diff --git a/tests/source/gl/test_adjacency_matrix.cpp b/tests/source/gl/test_adjacency_matrix.cpp
diff --git a/tests/source/gl/test_graph.cpp b/tests/source/gl/test_graph.cpp
diff --git a/tests/source/gl/test_graph_file_io.cpp b/tests/source/gl/test_graph_file_io.cpp
diff --git a/tests/source/gl/test_graph_io.cpp b/tests/source/gl/test_graph_io.cpp
diff --git a/tests/source/gl/test_graph_topology_builders.cpp b/tests/source/gl/test_graph_topology_builders.cpp

Original file line number	Diff line number	Diff line change
`@@ -155,9 +155,9 @@ class adjacency_list final {`
`155`	`155`	`[[nodiscard]] std::optional<edge_type> get_edge(id_type source_id, id_type target_id) const`
`156`	`156`	`requires(traits::c_has_empty_properties<edge_type>)`
`157`	`157`	`{`
`158`		`- const auto& incident_edges = this->_list[to_idx(source_id)];`
`159`		`- const auto item_it = std::ranges::find(incident_edges, target_id, &item_type::vertex_id);`
`160`		`- if (item_it == incident_edges.cend())`
	`158`	`+ const auto& out_edges = this->_list[to_idx(source_id)];`
	`159`	`+ const auto item_it = std::ranges::find(out_edges, target_id, &item_type::vertex_id);`
	`160`	`+ if (item_it == out_edges.cend())`
`161`	`161`	`return std::nullopt;`
`162`	`162`	`return std::make_optional<edge_type>(item_it->edge_id, source_id, target_id);`
`163`	`163`	`}`
`@@ -167,11 +167,11 @@ class adjacency_list final {`
`167`	`167`	`) const`
`168`	`168`	`requires(traits::c_has_non_empty_properties<edge_type>)`
`169`	`169`	`{`
`170`		`- const auto& incident_edges = this->_list[to_idx(source_id)];`
`171`		`- const auto item_it = std::ranges::find(incident_edges, target_id, [](const auto& item) {`
	`170`	`+ const auto& out_edges = this->_list[to_idx(source_id)];`
	`171`	`+ const auto item_it = std::ranges::find(out_edges, target_id, [](const auto& item) {`
`172`	`172`	`return item.vertex_id;`
`173`	`173`	`});`
`174`		`- if (item_it == incident_edges.cend())`
	`174`	`+ if (item_it == out_edges.cend())`
`175`	`175`	`return std::nullopt;`
`176`	`176`	`return std::make_optional<edge_type>(`
`177`	`177`	`item_it->edge_id, source_id, target_id, *edge_properties_map[to_idx(item_it->edge_id)]`
`@@ -209,15 +209,15 @@ class adjacency_list final {`
`209`	`209`	`[[nodiscard]] gl_attr_force_inline auto incident_edges(id_type vertex_id) const`
`210`	`210`	`requires(traits::c_has_empty_properties<edge_type>)`
`211`	`211`	`{`
`212`		`- return this->out_edges(vertex_id);`
	`212`	`+ return specialized_impl::incident_edges(*this, vertex_id);`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`[[nodiscard]] gl_attr_force_inline auto incident_edges(`
`216`	`216`	`id_type vertex_id, const auto& edge_properties_map`
`217`	`217`	`) const`
`218`	`218`	`requires(traits::c_has_non_empty_properties<edge_type>)`
`219`	`219`	`{`
`220`		`- return this->out_edges(vertex_id, edge_properties_map);`
	`220`	`+ return specialized_impl::incident_edges(*this, vertex_id, edge_properties_map);`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`[[nodiscard]] gl_attr_force_inline auto in_edges(id_type vertex_id) const`
`@@ -275,14 +275,14 @@ class adjacency_list final {`
`275`	`275`	`[[nodiscard]] gl_attr_force_inline auto at(id_type vertex_id) const`
`276`	`276`	`requires(traits::c_has_empty_properties<edge_type>)`
`277`	`277`	`{`
`278`		`- return this->incident_edges(vertex_id);`
	`278`	`+ return this->out_edges(vertex_id);`
`279`	`279`	`}`
`280`	`280`
`281`	`281`	`[[nodiscard]] gl_attr_force_inline auto at(id_type vertex_id, const auto& edge_properties_map)`
`282`	`282`	`const`
`283`	`283`	`requires(traits::c_has_non_empty_properties<edge_type>)`
`284`	`284`	`{`
`285`		`- return this->incident_edges(vertex_id, edge_properties_map);`
	`285`	`+ return this->out_edges(vertex_id, edge_properties_map);`
`286`	`286`	`}`
`287`	`287`
`288`	`288`	`// --- comparison ---`
Original file line number	Diff line number	Diff line change
`@@ -200,15 +200,15 @@ class adjacency_matrix final {`
`200`	`200`	`[[nodiscard]] gl_attr_force_inline auto incident_edges(id_type vertex_id) const`
`201`	`201`	`requires(traits::c_has_empty_properties<edge_type>)`
`202`	`202`	`{`
`203`		`- return this->out_edges(vertex_id);`
	`203`	`+ return specialized_impl::incident_edges(*this, vertex_id);`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`[[nodiscard]] gl_attr_force_inline auto incident_edges(`
`207`	`207`	`id_type vertex_id, const auto& edge_properties_map`
`208`	`208`	`) const`
`209`	`209`	`requires(traits::c_has_non_empty_properties<edge_type>)`
`210`	`210`	`{`
`211`		`- return this->out_edges(vertex_id, edge_properties_map);`
	`211`	`+ return specialized_impl::incident_edges(*this, vertex_id, edge_properties_map);`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`[[nodiscard]] gl_attr_force_inline auto in_edges(id_type vertex_id) const`