Skip to content

Commit 8b2245c

Browse files
SpectraL519SpectraL519
committed
resolved comments by gemini
1 parent c7053d5 commit 8b2245c

5 files changed

Lines changed: 52 additions & 57 deletions

File tree

‎include/gl/graph.hpp‎

Lines changed: 9 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -524,17 +524,13 @@ class graph final {
524524

525525
// --- adjacency and incidence methods ---
526526

527-
[[nodiscard]] bool are_adjacent(const id_type source_id, const id_type target_id) const {
528-
this->_verify_vertex_id(source_id);
529-
if (source_id == target_id)
530-
return true;
531-
532-
this->_verify_vertex_id(target_id);
533-
534-
if constexpr (traits::c_directed_edge<edge_type>)
535-
return this->has_edge(source_id, target_id) or this->has_edge(target_id, source_id);
536-
else
527+
[[nodiscard]] gl_attr_force_inline bool are_adjacent(
528+
const id_type source_id, const id_type target_id
529+
) const {
530+
if constexpr (traits::c_undirected_graph<graph>)
537531
return this->has_edge(source_id, target_id);
532+
else
533+
return this->has_edge(source_id, target_id) or this->has_edge(target_id, source_id);
538534
}
539535

540536
[[nodiscard]] gl_attr_force_inline bool are_adjacent(
@@ -546,6 +542,9 @@ class graph final {
546542
[[nodiscard]] bool are_adjacent(const edge_type& edge_1, const edge_type& edge_2) const {
547543
this->_verify_edge(edge_1);
548544
this->_verify_edge(edge_2);
545+
546+
if (edge_1.id() == edge_2.id())
547+
return false;
549548
return edge_1.is_incident_with(edge_2.source()) or edge_1.is_incident_with(edge_2.target());
550549
}
551550

‎include/gl/impl/specialized/flat_adjacency_list.hpp‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -207,9 +207,7 @@ struct undirected_flat_adjacency_list {
207207
// rebuild the graph (faster then shifting the entire data block for each removed edge)
208208
typename impl_type::adjacency_storage_type new_list;
209209
new_list.reserve_segments(self._list.size() - 1uz);
210-
const auto estimated_new_size =
211-
self._list.data_size() - (self._list[vertex_idx].size() * 2uz);
212-
new_list.reserve_data(estimated_new_size);
210+
new_list.reserve_data(self._list.data_size() - self._list[vertex_idx].size());
213211

214212
std::vector<item_type> buffer;
215213
for (auto idx = 0uz; idx < self._list.size(); ++idx) {

‎include/gl/impl/specialized/flat_adjacency_matrix.hpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -88,7 +88,7 @@ struct directed_flat_adjacency_matrix {
8888
static std::vector<id_type> remove_vertex(impl_type& self, id_type vertex_id) {
8989
const auto vertex_idx = to_idx(vertex_id);
9090
std::vector<id_type> removed_edges;
91-
removed_edges.reserve(self._matrix.size());
91+
removed_edges.reserve(self._matrix.size() * 2uz);
9292

9393
// extract out-edges
9494
for (auto edge_id : self._matrix[vertex_idx])

‎tests/source/gl/test_adjacency_list.cpp‎

Lines changed: 29 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -113,7 +113,7 @@ TEST_CASE_TEMPLATE_INSTANTIATE(
113113

114114
namespace {
115115

116-
constexpr gl::size_type n_inc_edged_for_fully_connected_vertex = constants::n_elements - 1uz;
116+
constexpr gl::size_type n_inc_edges_for_fully_connected_vertex = constants::n_elements - 1uz;
117117

118118
} // namespace
119119

@@ -142,11 +142,11 @@ struct test_directed_adjacency_list : public test_adjacency_list {
142142

143143
if (no_loops)
144144
REQUIRE(std::ranges::all_of(get(sut), [&](const auto& adj_items) {
145-
return adj_items.size() == n_inc_edged_for_fully_connected_vertex;
145+
return adj_items.size() == n_inc_edges_for_fully_connected_vertex;
146146
}));
147147
else
148148
REQUIRE(std::ranges::all_of(get(sut), [&](const auto& adj_items) {
149-
return adj_items.size() == n_inc_edged_for_fully_connected_vertex + 1uz;
149+
return adj_items.size() == n_inc_edges_for_fully_connected_vertex + 1uz;
150150
}));
151151
}
152152

@@ -261,13 +261,13 @@ TEST_CASE_TEMPLATE_DEFINE("directed adjacency list tests", SutType, directed_adj
261261

262262
CHECK(std::ranges::all_of(
263263
constants::vertex_id_view,
264-
[](const auto deg) { return deg == 2uz * n_inc_edged_for_fully_connected_vertex; },
264+
[](const auto deg) { return deg == 2uz * n_inc_edges_for_fully_connected_vertex; },
265265
deg_proj
266266
));
267267

268268
add_edge(constants::v1_id, constants::v1_id);
269269

270-
CHECK_EQ(deg_proj(constants::v1_id), 2uz * (n_inc_edged_for_fully_connected_vertex + 1uz));
270+
CHECK_EQ(deg_proj(constants::v1_id), 2uz * (n_inc_edges_for_fully_connected_vertex + 1uz));
271271
}
272272

273273
SUBCASE("in/out_degree should return the number of edges incident {to/from} the given vertex") {
@@ -287,13 +287,13 @@ TEST_CASE_TEMPLATE_DEFINE("directed adjacency list tests", SutType, directed_adj
287287

288288
CHECK(std::ranges::all_of(
289289
constants::vertex_id_view,
290-
[](const auto deg) { return deg == n_inc_edged_for_fully_connected_vertex; },
290+
[](const auto deg) { return deg == n_inc_edges_for_fully_connected_vertex; },
291291
deg_proj
292292
));
293293

294294
add_edge(constants::v1_id, constants::v1_id);
295295

296-
CHECK_EQ(deg_proj(constants::v1_id), n_inc_edged_for_fully_connected_vertex + 1uz);
296+
CHECK_EQ(deg_proj(constants::v1_id), n_inc_edges_for_fully_connected_vertex + 1uz);
297297
}
298298

299299
SUBCASE("degree_map should return a map of the numbers of edges incident with the "
@@ -353,13 +353,13 @@ TEST_CASE_TEMPLATE_DEFINE("directed adjacency list tests", SutType, directed_adj
353353
fully_connect_vertex(constants::v1_id);
354354

355355
auto out_edges = sut.out_edges(constants::v1_id);
356-
REQUIRE_EQ(out_edges.size(), n_inc_edged_for_fully_connected_vertex);
356+
REQUIRE_EQ(out_edges.size(), n_inc_edges_for_fully_connected_vertex);
357357

358358
const auto& edge_to_remove = out_edges[0uz];
359359
sut.remove_edge(edge_to_remove);
360360

361361
out_edges = sut.out_edges(constants::v1_id);
362-
REQUIRE_EQ(out_edges.size(), n_inc_edged_for_fully_connected_vertex - 1uz);
362+
REQUIRE_EQ(out_edges.size(), n_inc_edges_for_fully_connected_vertex - 1uz);
363363
// validate that the incident edges list has been properly aligned
364364
CHECK_EQ(std::ranges::find(out_edges, edge_to_remove), out_edges.end());
365365
}
@@ -504,18 +504,18 @@ struct test_undirected_adjacency_list : public test_adjacency_list {
504504

505505
if (no_loops)
506506
REQUIRE(std::ranges::all_of(get(sut), [&](const auto& adj_items) {
507-
return adj_items.size() == n_inc_edged_for_fully_connected_vertex;
507+
return adj_items.size() == n_inc_edges_for_fully_connected_vertex;
508508
}));
509509
else
510510
REQUIRE(std::ranges::all_of(get(sut), [&](const auto& adj_items) {
511-
return adj_items.size() == n_inc_edged_for_fully_connected_vertex + 1uz;
511+
return adj_items.size() == n_inc_edges_for_fully_connected_vertex + 1uz;
512512
}));
513513
}
514514

515515
sut_type sut{constants::n_elements};
516516

517517
const gl::size_type n_unique_edges_in_full_graph =
518-
(n_inc_edged_for_fully_connected_vertex * constants::n_elements) / 2uz;
518+
(n_inc_edges_for_fully_connected_vertex * constants::n_elements) / 2uz;
519519
};
520520

521521
TEST_CASE_TEMPLATE_DEFINE("undirected adjacency list tests", SutType, undirected_adj_list_template) {
@@ -614,15 +614,15 @@ TEST_CASE_TEMPLATE_DEFINE("undirected adjacency list tests", SutType, undirected
614614

615615
CHECK(std::ranges::all_of(
616616
constants::vertex_id_view,
617-
[](const auto deg) { return deg == n_inc_edged_for_fully_connected_vertex; },
617+
[](const auto deg) { return deg == n_inc_edges_for_fully_connected_vertex; },
618618
deg_proj
619619
));
620620

621621
add_edge(constants::v1_id, constants::v1_id);
622622

623623
CHECK_EQ(
624624
deg_proj(constants::v1_id),
625-
n_inc_edged_for_fully_connected_vertex + 2uz // loops counted twice
625+
n_inc_edges_for_fully_connected_vertex + 2uz // loops counted twice
626626
);
627627
}
628628

@@ -658,16 +658,16 @@ TEST_CASE_TEMPLATE_DEFINE("undirected adjacency list tests", SutType, undirected
658658
REQUIRE(new_edge.is_incident_from(constants::v1_id));
659659
REQUIRE(new_edge.is_incident_to(constants::v2_id));
660660

661-
const auto inc_edged_1 = sut.incident_edges(constants::v1_id);
662-
const auto inc_edged_2 = sut.incident_edges(constants::v2_id);
661+
const auto inc_edges_1 = sut.incident_edges(constants::v1_id);
662+
const auto inc_edges_2 = sut.incident_edges(constants::v2_id);
663663

664-
REQUIRE_EQ(inc_edged_1.size(), 1uz);
665-
REQUIRE_EQ(inc_edged_2.size(), 1uz);
664+
REQUIRE_EQ(inc_edges_1.size(), 1uz);
665+
REQUIRE_EQ(inc_edges_2.size(), 1uz);
666666

667-
const auto& new_edge_extracted_1 = inc_edged_1[0uz];
667+
const auto& new_edge_extracted_1 = inc_edges_1[0uz];
668668
CHECK_EQ(new_edge_extracted_1, new_edge);
669669

670-
const auto& new_edge_extracted_2 = inc_edged_2[0uz];
670+
const auto& new_edge_extracted_2 = inc_edges_2[0uz];
671671
CHECK_EQ(new_edge_extracted_2, new_edge);
672672
}
673673

@@ -692,25 +692,25 @@ TEST_CASE_TEMPLATE_DEFINE("undirected adjacency list tests", SutType, undirected
692692
SUBCASE("remove_edge should remove the edge from both the first and second vertices' list") {
693693
fully_connect_vertex(constants::v1_id);
694694

695-
auto inc_edged_first = sut.incident_edges(constants::v1_id);
696-
REQUIRE_EQ(inc_edged_first.size(), n_inc_edged_for_fully_connected_vertex);
695+
auto inc_edges_first = sut.incident_edges(constants::v1_id);
696+
REQUIRE_EQ(inc_edges_first.size(), n_inc_edges_for_fully_connected_vertex);
697697

698-
const auto& edge_to_remove = inc_edged_first[0uz];
698+
const auto& edge_to_remove = inc_edges_first[0uz];
699699

700700
const auto target_id = edge_to_remove.target();
701701
REQUIRE_EQ(sut.incident_edges(target_id).size(), 1uz);
702702

703703
sut.remove_edge(edge_to_remove);
704704

705705
// validate that the first incident edges list has been properly aligned
706-
inc_edged_first = sut.incident_edges(0uz);
707-
REQUIRE_EQ(inc_edged_first.size(), n_inc_edged_for_fully_connected_vertex - 1uz);
708-
CHECK_EQ(std::ranges::find(inc_edged_first, edge_to_remove), inc_edged_first.end());
706+
inc_edges_first = sut.incident_edges(0uz);
707+
REQUIRE_EQ(inc_edges_first.size(), n_inc_edges_for_fully_connected_vertex - 1uz);
708+
CHECK_EQ(std::ranges::find(inc_edges_first, edge_to_remove), inc_edges_first.end());
709709

710710
// validate that the second adjacent edges list has been properly aligned
711-
const auto inc_edged_second = sut.incident_edges(target_id);
712-
REQUIRE_EQ(inc_edged_second.size(), 0uz);
713-
CHECK_EQ(std::ranges::find(inc_edged_second, edge_to_remove), inc_edged_second.end());
711+
const auto inc_edges_second = sut.incident_edges(target_id);
712+
REQUIRE_EQ(inc_edges_second.size(), 0uz);
713+
CHECK_EQ(std::ranges::find(inc_edges_second, edge_to_remove), inc_edges_second.end());
714714
}
715715

716716
// --- edge getters ---

‎tests/source/gl/test_graph.cpp‎

Lines changed: 12 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -926,13 +926,6 @@ TEST_CASE_TEMPLATE_DEFINE("common graph structure tests", TraitsType, common_gra
926926
);
927927
}
928928

929-
SUBCASE("are_adjacent(vertex_id, vertex_id) should return true the ids are the same and "
930-
"valid") {
931-
CHECK(std::ranges::all_of(constants::vertex_id_view, [&sut](const auto vertex_id) {
932-
return sut.are_adjacent(vertex_id, vertex_id);
933-
}));
934-
}
935-
936929
SUBCASE("are_adjacent(vertex_id, vertex_id) should return true if there is an edge "
937930
"connecting the given vertices") {
938931
sut.add_edge(v1, v2);
@@ -942,6 +935,11 @@ TEST_CASE_TEMPLATE_DEFINE("common graph structure tests", TraitsType, common_gra
942935

943936
CHECK_FALSE(sut.are_adjacent(constants::v1_id, constants::v3_id));
944937
CHECK_FALSE(sut.are_adjacent(constants::v2_id, constants::v3_id));
938+
939+
// self adjacency
940+
CHECK_FALSE(sut.are_adjacent(constants::v1_id, constants::v1_id));
941+
sut.add_edge(v1, v1);
942+
CHECK(sut.are_adjacent(constants::v1_id, constants::v1_id));
945943
}
946944

947945
SUBCASE("are_adjacent(vertex, vertex) should throw if at least one of the vertices is "
@@ -969,13 +967,11 @@ TEST_CASE_TEMPLATE_DEFINE("common graph structure tests", TraitsType, common_gra
969967

970968
CHECK_FALSE(sut.are_adjacent(v1, v3));
971969
CHECK_FALSE(sut.are_adjacent(v2, v3));
972-
}
973970

974-
SUBCASE("are_adjacent(vertex, vertex) should return true the vertices are the same and "
975-
"valid") {
976-
CHECK(std::ranges::all_of(sut.vertices(), [&sut](const auto& vertex) {
977-
return sut.are_adjacent(vertex, vertex);
978-
}));
971+
// self adjacency
972+
CHECK_FALSE(sut.are_adjacent(v1, v1));
973+
sut.add_edge(v1, v1);
974+
CHECK(sut.are_adjacent(v1, v1));
979975
}
980976

981977
SUBCASE("are_adjacent(edge, edge) should throw if either edge is invalid") {
@@ -990,11 +986,13 @@ TEST_CASE_TEMPLATE_DEFINE("common graph structure tests", TraitsType, common_gra
990986
);
991987
}
992988

993-
SUBCASE("are_adjacent(edge, edge) should return true only when the edges share a vertex") {
989+
SUBCASE("are_adjacent(edge, edge) should return true only when the edges are distinct and "
990+
"share a vertex") {
994991
const auto edge_1 = sut.add_edge(v1, v2);
995992
const auto edge_2 = sut.add_edge(v2, v3);
996993
const auto loop_3 = sut.add_edge(v3, v3);
997994

995+
CHECK_FALSE(sut.are_adjacent(edge_1, edge_1));
998996
CHECK(sut.are_adjacent(edge_1, edge_2));
999997
CHECK(sut.are_adjacent(edge_2, edge_1));
1000998
CHECK_FALSE(sut.are_adjacent(edge_1, loop_3));

0 commit comments

Comments
 (0)