Code review: Use a flat (u, v, filt) instead of (pair(u, v), filt)

1 files changed, 38 insertions, 32 deletions

diff --git a/src/Collapse/test/collapse_unit_test.cpp b/src/Collapse/test/collapse_unit_test.cpp
index a6d3ca1c..67f1a732 100644
--- a/src/Collapse/test/collapse_unit_test.cpp
+++ b/src/Collapse/test/collapse_unit_test.cpp
@@ -44,33 +44,31 @@ void trace_and_check_collapse(const Filtered_edge_range& filtered_edges, const F
   std::cout << "BEFORE COLLAPSE - Total number of edges: " << filtered_edges.size() << std::endl;
   BOOST_CHECK(filtered_edges.size() > 0);
   for (auto filtered_edge : filtered_edges) {
-    auto edge = std::get<0>(filtered_edge);
-    std::cout << "f[" << std::get<0>(edge) << ", " << std::get<1>(edge) << "] = " << std::get<1>(filtered_edge) << std::endl;
+    std::cout << "f[" << std::get<0>(filtered_edge) << ", " << std::get<1>(filtered_edge) << "] = "
+              << std::get<2>(filtered_edge) << std::endl;
   }
 
   std::cout << "COLLAPSE - keep edges: " << std::endl;
   Flag_complex_edge_collapser edge_collapser(filtered_edges.begin(), filtered_edges.end());
   Filtered_edge_list remaining_edges;
   edge_collapser.process_edges(
-    [&remaining_edges](std::pair<Vertex_handle, Vertex_handle> edge, Filtration_value filtration) {
-      std::cout << "f[" << std::get<0>(edge) << ", " << std::get<1>(edge) << "] = " << filtration << std::endl;
-        remaining_edges.emplace_back(Filtered_edge(edge, filtration));
+    [&remaining_edges](Vertex_handle u, Vertex_handle v, Filtration_value filtration) {
+      std::cout << "f[" << u << ", " << v << "] = " << filtration << std::endl;
+        remaining_edges.emplace_back(Filtered_edge(u, v, filtration));
       });
   std::cout << "AFTER COLLAPSE - Total number of edges: " << remaining_edges.size() << std::endl;
   BOOST_CHECK(remaining_edges.size() <= filtered_edges.size());
   for (auto filtered_edge_from_collapse : remaining_edges) {
-    auto edge_from_collapse = std::get<0>(filtered_edge_from_collapse);
-    std::cout << "f[" << std::get<0>(edge_from_collapse) << ", " << std::get<1>(edge_from_collapse) << "] = "
-              << std::get<1>(filtered_edge_from_collapse) << std::endl;
+    std::cout << "f[" << std::get<0>(filtered_edge_from_collapse) << ", " << std::get<1>(filtered_edge_from_collapse)
+              << "] = " << std::get<2>(filtered_edge_from_collapse) << std::endl;
     // Check each edge from collapse is in the input
     BOOST_CHECK(find_edge_in_list(filtered_edge_from_collapse, filtered_edges));
   }
 
   std::cout << "CHECK COLLAPSE - Total number of removed edges: " << removed_edges.size() << std::endl;
   for (auto removed_filtered_edge : removed_edges) {
-    auto removed_edge = std::get<0>(removed_filtered_edge);
-    std::cout << "f[" << std::get<0>(removed_edge) << ", " << std::get<1>(removed_edge) << "] = "
-              << std::get<1>(removed_filtered_edge) << std::endl;
+    std::cout << "f[" << std::get<0>(removed_filtered_edge) << ", " << std::get<1>(removed_filtered_edge) << "] = "
+              << std::get<2>(removed_filtered_edge) << std::endl;
     // Check each removed edge from collapse is in the input
     BOOST_CHECK(!find_edge_in_list(removed_filtered_edge, remaining_edges));
   }
@@ -86,7 +84,10 @@ BOOST_AUTO_TEST_CASE(collapse) {
   //  |   |
   //  o---o
   //  0   3
-  Filtered_edge_list edges {{{0, 1}, 1.}, {{1, 2}, 1.}, {{2, 3}, 1.}, {{3, 0}, 1.}};
+  Filtered_edge_list edges {{0, 1, 1.},
+                            {1, 2, 1.},
+                            {2, 3, 1.},
+                            {3, 0, 1.}};
   trace_and_check_collapse(edges, {});
   
   //  1   2
@@ -96,9 +97,9 @@ BOOST_AUTO_TEST_CASE(collapse) {
   //  |/ \|
   //  o---o
   //  0   3
-  edges.emplace_back(Filtered_edge({0, 2}, 2.));
-  edges.emplace_back(Filtered_edge({1, 3}, 2.));
-  trace_and_check_collapse(edges, {{{1, 3}, 2.}});
+  edges.emplace_back(Filtered_edge(0, 2, 2.));
+  edges.emplace_back(Filtered_edge(1, 3, 2.));
+  trace_and_check_collapse(edges, {{1, 3, 2.}});
 
   //  1   2   4
   //  o---o---o
@@ -107,10 +108,10 @@ BOOST_AUTO_TEST_CASE(collapse) {
   //  |/ \|   |
   //  o---o---o
   //  0   3   5
-  edges.emplace_back(Filtered_edge({2, 4}, 3.));
-  edges.emplace_back(Filtered_edge({4, 5}, 3.));
-  edges.emplace_back(Filtered_edge({5, 3}, 3.));
-  trace_and_check_collapse(edges, {{{1, 3}, 2.}});
+  edges.emplace_back(Filtered_edge(2, 4, 3.));
+  edges.emplace_back(Filtered_edge(4, 5, 3.));
+  edges.emplace_back(Filtered_edge(5, 3, 3.));
+  trace_and_check_collapse(edges, {{1, 3, 2.}});
 
   //  1   2   4
   //  o---o---o
@@ -119,9 +120,9 @@ BOOST_AUTO_TEST_CASE(collapse) {
   //  |/ \|/ \|
   //  o---o---o
   //  0   3   5
-  edges.emplace_back(Filtered_edge({2, 5}, 4.));
-  edges.emplace_back(Filtered_edge({4, 3}, 4.));
-  trace_and_check_collapse(edges, {{{1, 3}, 2.}, {{4, 3}, 4.}});
+  edges.emplace_back(Filtered_edge(2, 5, 4.));
+  edges.emplace_back(Filtered_edge(4, 3, 4.));
+  trace_and_check_collapse(edges, {{1, 3, 2.}, {4, 3, 4.}});
 
   //  1   2   4
   //  o---o---o
@@ -130,9 +131,9 @@ BOOST_AUTO_TEST_CASE(collapse) {
   //  |/ \|/ \|
   //  o---o---o
   //  0   3   5
-  edges.emplace_back(Filtered_edge({1, 5}, 5.));
-  edges.emplace_back(Filtered_edge({0, 4}, 5.));
-  trace_and_check_collapse(edges, {{{1, 3}, 2.}, {{4, 3}, 4.}, {{0, 4}, 5.}});
+  edges.emplace_back(Filtered_edge(1, 5, 5.));
+  edges.emplace_back(Filtered_edge(0, 4, 5.));
+  trace_and_check_collapse(edges, {{1, 3, 2.}, {4, 3, 4.}, {0, 4, 5.}});
 }
 
 BOOST_AUTO_TEST_CASE(collapse_from_array) {
@@ -144,8 +145,13 @@ BOOST_AUTO_TEST_CASE(collapse_from_array) {
   //  |/ \|
   //  o---o
   //  0   3
-  std::array<Filtered_edge, 6> f_edge_array = {{{{0, 1}, 1.}, {{1, 2}, 1.}, {{2, 3}, 1.}, {{3, 0}, 1.}, {{0, 2}, 2.}, {{1, 3}, 2.}}};
-  trace_and_check_collapse(f_edge_array, {{{1, 3}, 2.}});
+  std::array<Filtered_edge, 6> f_edge_array = {{{0, 1, 1.},
+                                                {1, 2, 1.},
+                                                {2, 3, 1.},
+                                                {3, 0, 1.},
+                                                {0, 2, 2.},
+                                                {1, 3, 2.}}};
+  trace_and_check_collapse(f_edge_array, {{1, 3, 2.}});
 }
 
 
@@ -171,9 +177,9 @@ BOOST_AUTO_TEST_CASE(collapse_from_proximity_graph) {
   Flag_complex_edge_collapser edge_collapser(proximity_graph);
   Filtered_edge_list remaining_edges;
   edge_collapser.process_edges(
-    [&remaining_edges](std::pair<Vertex_handle, Vertex_handle> edge, Filtration_value filtration) {
-      std::cout << "f[" << std::get<0>(edge) << ", " << std::get<1>(edge) << "] = " << filtration << std::endl;
-        remaining_edges.emplace_back(Filtered_edge(edge, filtration));
+    [&remaining_edges](Vertex_handle u, Vertex_handle v, Filtration_value filtration) {
+      std::cout << "f[" << u << ", " << v << "] = " << filtration << std::endl;
+        remaining_edges.emplace_back(Filtered_edge(u, v, filtration));
       });
   BOOST_CHECK(remaining_edges.size() == 5);
 
@@ -181,9 +187,9 @@ BOOST_AUTO_TEST_CASE(collapse_from_proximity_graph) {
   std::size_t filtration_is_diagonal_length_nb = 0;
   float epsilon = std::numeric_limits<Filtration_value>::epsilon();
   for (auto filtered_edge : remaining_edges) {
-    if (std::get<1>(filtered_edge) == 1.)
+    if (std::get<2>(filtered_edge) == 1.)
       filtration_is_edge_length_nb++;
-    if (std::fabs(std::get<1>(filtered_edge) - std::sqrt(2.)) <= epsilon)
+    if (std::fabs(std::get<2>(filtered_edge) - std::sqrt(2.)) <= epsilon)
       filtration_is_diagonal_length_nb++;
   }
   BOOST_CHECK(filtration_is_edge_length_nb == 4);