From e3d4dd49c848eedecd70bd743ae4a94b98b7f086 Mon Sep 17 00:00:00 2001
From: Marc Glisse <marc.glisse@inria.fr>
Date: Sat, 15 Oct 2022 15:38:01 +0200
Subject: Remove unnecessary includes

---
 src/Alpha_complex/test/Alpha_complex_unit_test.cpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'src/Alpha_complex')

diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
index f74ad217..1ac0093d 100644
--- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
@@ -13,18 +13,14 @@
 #include <boost/test/unit_test.hpp>
 #include <boost/mpl/list.hpp>
 
-#include <CGAL/Delaunay_triangulation.h>
 #include <CGAL/Epick_d.h>
 #include <CGAL/Epeck_d.h>
 
-#include <cmath>  // float comparison
-#include <limits>
+#include <stdexcept> // std::out_of_range
 #include <string>
 #include <vector>
 
 #include <gudhi/Alpha_complex.h>
-// to construct a simplex_tree from Delaunay_triangulation
-#include <gudhi/graph_simplicial_complex.h>
 #include <gudhi/Simplex_tree.h>
 #include <gudhi/Unitary_tests_utils.h>
 
-- 
cgit v1.2.3


From b3b5d1da1ad441c8a76e8137b25e752e5654b938 Mon Sep 17 00:00:00 2001
From: Marc Glisse <marc.glisse@inria.fr>
Date: Sat, 15 Oct 2022 15:40:41 +0200
Subject: Duplicate Alpha_complex_unit_test.cpp history in
 Alpha_complex_dim3_unit_test.cpp history.

---
 .../test/Alpha_complex_dim3_unit_test.cpp          | 308 +++++++++++++++++++++
 1 file changed, 308 insertions(+)
 create mode 100644 src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp

(limited to 'src/Alpha_complex')

diff --git a/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp
new file mode 100644
index 00000000..1ac0093d
--- /dev/null
+++ b/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp
@@ -0,0 +1,308 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2015 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "alpha_complex"
+#include <boost/test/unit_test.hpp>
+#include <boost/mpl/list.hpp>
+
+#include <CGAL/Epick_d.h>
+#include <CGAL/Epeck_d.h>
+
+#include <stdexcept> // std::out_of_range
+#include <string>
+#include <vector>
+
+#include <gudhi/Alpha_complex.h>
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Unitary_tests_utils.h>
+
+// Use dynamic_dimension_tag for the user to be able to set dimension
+typedef CGAL::Epeck_d< CGAL::Dynamic_dimension_tag > Exact_kernel_d;
+// Use static dimension_tag for the user not to be able to set dimension
+typedef CGAL::Epeck_d< CGAL::Dimension_tag<3> > Exact_kernel_s;
+// Use dynamic_dimension_tag for the user to be able to set dimension
+typedef CGAL::Epick_d< CGAL::Dynamic_dimension_tag > Inexact_kernel_d;
+// Use static dimension_tag for the user not to be able to set dimension
+typedef CGAL::Epick_d< CGAL::Dimension_tag<3> > Inexact_kernel_s;
+// The triangulation uses the default instantiation of the TriangulationDataStructure template parameter
+
+typedef boost::mpl::list<Exact_kernel_d, Exact_kernel_s, Inexact_kernel_d, Inexact_kernel_s> list_of_kernel_variants;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of_kernel_variants) {
+  // ----------------------------------------------------------------------------
+  //
+  // Init of an alpha-complex from a OFF file
+  //
+  // ----------------------------------------------------------------------------
+  std::string off_file_name("alphacomplexdoc.off");
+  double max_alpha_square_value = 60.0;
+  std::clog << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" <<
+      max_alpha_square_value << "==========" << std::endl;
+
+  Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_file(off_file_name);
+
+  Gudhi::Simplex_tree<> simplex_tree_60;
+  BOOST_CHECK(alpha_complex_from_file.create_complex(simplex_tree_60, max_alpha_square_value));
+
+  std::clog << "alpha_complex_from_file.num_vertices()=" << alpha_complex_from_file.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_file.num_vertices() == 7);
+
+  std::clog << "simplex_tree_60.dimension()=" << simplex_tree_60.dimension() << std::endl;
+  BOOST_CHECK(simplex_tree_60.dimension() == 2);
+
+  std::clog << "simplex_tree_60.num_vertices()=" << simplex_tree_60.num_vertices() << std::endl;
+  BOOST_CHECK(simplex_tree_60.num_vertices() == 7);
+
+  std::clog << "simplex_tree_60.num_simplices()=" << simplex_tree_60.num_simplices() << std::endl;
+  BOOST_CHECK(simplex_tree_60.num_simplices() == 25);
+
+  max_alpha_square_value = 59.0;
+  std::clog << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" <<
+      max_alpha_square_value << "==========" << std::endl;
+
+  Gudhi::Simplex_tree<> simplex_tree_59;
+  BOOST_CHECK(alpha_complex_from_file.create_complex(simplex_tree_59, max_alpha_square_value));
+  
+  std::clog << "alpha_complex_from_file.num_vertices()=" << alpha_complex_from_file.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_file.num_vertices() == 7);
+
+  std::clog << "simplex_tree_59.dimension()=" << simplex_tree_59.dimension() << std::endl;
+  BOOST_CHECK(simplex_tree_59.dimension() == 2);
+
+  std::clog << "simplex_tree_59.num_vertices()=" << simplex_tree_59.num_vertices() << std::endl;
+  BOOST_CHECK(simplex_tree_59.num_vertices() == 7);
+
+  std::clog << "simplex_tree_59.num_simplices()=" << simplex_tree_59.num_simplices() << std::endl;
+  BOOST_CHECK(simplex_tree_59.num_simplices() == 23);
+}
+
+// Use static dimension_tag for the user not to be able to set dimension
+typedef CGAL::Epeck_d< CGAL::Dimension_tag<4> > Kernel_4;
+typedef Kernel_4::Point_d Point_4;
+typedef std::vector<Point_4> Vector_4_Points;
+
+bool is_point_in_list(Vector_4_Points points_list, Point_4 point) {
+  for (auto& point_in_list : points_list) {
+    if (point_in_list == point) {
+      return true;  // point found
+    }
+  }
+  return false;  // point not found
+}
+
+BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
+  // ----------------------------------------------------------------------------
+  // Init of a list of points
+  // ----------------------------------------------------------------------------
+  Vector_4_Points points;
+  std::vector<double> coords = { 0.0, 0.0, 0.0, 1.0 };
+  points.push_back(Point_4(coords.begin(), coords.end()));
+  coords = { 0.0, 0.0, 1.0, 0.0 };
+  points.push_back(Point_4(coords.begin(), coords.end()));
+  coords = { 0.0, 1.0, 0.0, 0.0 };
+  points.push_back(Point_4(coords.begin(), coords.end()));
+  coords = { 1.0, 0.0, 0.0, 0.0 };
+  points.push_back(Point_4(coords.begin(), coords.end()));
+
+  // ----------------------------------------------------------------------------
+  // Init of an alpha complex from the list of points
+  // ----------------------------------------------------------------------------
+  Gudhi::alpha_complex::Alpha_complex<Kernel_4> alpha_complex_from_points(points);
+
+  std::clog << "========== Alpha_complex_from_points ==========" << std::endl;
+
+  Gudhi::Simplex_tree<> simplex_tree;
+  BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree));
+  
+  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_points.num_vertices() == points.size());
+
+  // Another way to check num_simplices
+  std::clog << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  int num_simplices = 0;
+  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
+    num_simplices++;
+    std::clog << "   ( ";
+    for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex)) {
+      std::clog << vertex << " ";
+    }
+    std::clog << ") -> " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
+  }
+  BOOST_CHECK(num_simplices == 15);
+  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
+  BOOST_CHECK(simplex_tree.num_simplices() == 15);
+
+  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
+  BOOST_CHECK(simplex_tree.dimension() == 3);
+  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
+  BOOST_CHECK(simplex_tree.num_vertices() == points.size());
+
+  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
+    switch (simplex_tree.dimension(f_simplex)) {
+      case 0:
+        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 0.0);
+        break;
+      case 1:
+        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 1.0/2.0);
+        break;
+      case 2:
+        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 2.0/3.0);
+        break;
+      case 3:
+        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 3.0/4.0);
+        break;
+      default:
+        BOOST_CHECK(false);  // Shall not happen
+        break;
+    }
+  }
+
+  Point_4 p0 = alpha_complex_from_points.get_point(0);
+  std::clog << "alpha_complex_from_points.get_point(0)=" << p0 << std::endl;
+  BOOST_CHECK(4 == p0.dimension());
+  BOOST_CHECK(is_point_in_list(points, p0));
+
+  Point_4 p1 = alpha_complex_from_points.get_point(1);
+  std::clog << "alpha_complex_from_points.get_point(1)=" << p1 << std::endl;
+  BOOST_CHECK(4 == p1.dimension());
+  BOOST_CHECK(is_point_in_list(points, p1));
+
+  Point_4 p2 = alpha_complex_from_points.get_point(2);
+  std::clog << "alpha_complex_from_points.get_point(2)=" << p2 << std::endl;
+  BOOST_CHECK(4 == p2.dimension());
+  BOOST_CHECK(is_point_in_list(points, p2));
+
+  Point_4 p3 = alpha_complex_from_points.get_point(3);
+  std::clog << "alpha_complex_from_points.get_point(3)=" << p3 << std::endl;
+  BOOST_CHECK(4 == p3.dimension());
+  BOOST_CHECK(is_point_in_list(points, p3));
+
+  // Test to the limit
+  BOOST_CHECK_THROW (alpha_complex_from_points.get_point(4), std::out_of_range);
+  BOOST_CHECK_THROW (alpha_complex_from_points.get_point(-1), std::out_of_range);
+  BOOST_CHECK_THROW (alpha_complex_from_points.get_point(1234), std::out_of_range);
+  
+  // Test after prune_above_filtration
+  bool modified = simplex_tree.prune_above_filtration(0.6);
+  BOOST_CHECK(modified);
+  
+  // Another way to check num_simplices
+  std::clog << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  num_simplices = 0;
+  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
+    num_simplices++;
+    std::clog << "   ( ";
+    for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex)) {
+      std::clog << vertex << " ";
+    }
+    std::clog << ") -> " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
+  }
+  BOOST_CHECK(num_simplices == 10);
+  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
+  BOOST_CHECK(simplex_tree.num_simplices() == 10);
+
+  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
+  BOOST_CHECK(simplex_tree.dimension() == 1);
+  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
+  BOOST_CHECK(simplex_tree.num_vertices() == 4);
+
+  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
+    switch (simplex_tree.dimension(f_simplex)) {
+      case 0:
+        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 0.0);
+        break;
+      case 1:
+        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 1.0/2.0);
+        break;
+      default:
+        BOOST_CHECK(false);  // Shall not happen
+        break;
+    }
+  }
+
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, list_of_kernel_variants) {
+  std::clog << "========== Alpha_complex_from_empty_points ==========" << std::endl;
+
+  // ----------------------------------------------------------------------------
+  // Init of an empty list of points
+  // ----------------------------------------------------------------------------
+  std::vector<typename TestedKernel::Point_d> points;
+
+  // ----------------------------------------------------------------------------
+  // Init of an alpha complex from the list of points
+  // ----------------------------------------------------------------------------
+  Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_points(points);
+
+  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_points.num_vertices() == points.size());
+
+  // Test to the limit
+  BOOST_CHECK_THROW (alpha_complex_from_points.get_point(0), std::out_of_range);
+
+  Gudhi::Simplex_tree<> simplex_tree;
+  BOOST_CHECK(!alpha_complex_from_points.create_complex(simplex_tree));
+  
+  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
+  BOOST_CHECK(simplex_tree.num_simplices() == 0);
+
+  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
+  BOOST_CHECK(simplex_tree.dimension() == -1);
+  
+  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
+  BOOST_CHECK(simplex_tree.num_vertices() == points.size());
+}
+
+using Inexact_kernel_2 = CGAL::Epick_d< CGAL::Dimension_tag<2> >;
+using Exact_kernel_2 = CGAL::Epeck_d< CGAL::Dimension_tag<2> >;
+using list_of_kernel_2_variants = boost::mpl::list<Inexact_kernel_2, Exact_kernel_2>;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_with_duplicated_points, TestedKernel, list_of_kernel_2_variants) {
+  std::clog << "========== Alpha_complex_with_duplicated_points ==========" << std::endl;
+
+  using Point = typename TestedKernel::Point_d;
+  using Vector_of_points = std::vector<Point>;
+
+  // ----------------------------------------------------------------------------
+  // Init of a list of points
+  // ----------------------------------------------------------------------------
+  Vector_of_points points;
+  points.push_back(Point(1.0, 1.0));
+  points.push_back(Point(7.0, 0.0));
+  points.push_back(Point(4.0, 6.0));
+  points.push_back(Point(9.0, 6.0));
+  points.push_back(Point(0.0, 14.0));
+  points.push_back(Point(2.0, 19.0));
+  points.push_back(Point(9.0, 17.0));
+  // duplicated points
+  points.push_back(Point(1.0, 1.0));
+  points.push_back(Point(7.0, 0.0));
+
+  // ----------------------------------------------------------------------------
+  // Init of an alpha complex from the list of points
+  // ----------------------------------------------------------------------------
+  std::clog << "Init" << std::endl;
+  Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_points(points);
+
+  Gudhi::Simplex_tree<> simplex_tree;
+  std::clog << "create_complex" << std::endl;
+  BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree));
+  
+  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_points.num_vertices() < points.size());
+
+  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices()
+      << std::endl;
+  BOOST_CHECK(simplex_tree.num_vertices() < points.size());
+}
-- 
cgit v1.2.3


From b380380aecb601fbc601710da1a62cca202304db Mon Sep 17 00:00:00 2001
From: Marc Glisse <marc.glisse@inria.fr>
Date: Sat, 15 Oct 2022 15:46:09 +0200
Subject: Split Alpha_complex_unit_test.cpp into 2 files

It was taking too much memory to compile
---
 .../test/Alpha_complex_dim3_unit_test.cpp          | 191 ---------------------
 src/Alpha_complex/test/Alpha_complex_unit_test.cpp |  91 ----------
 src/Alpha_complex/test/CMakeLists.txt              |   6 +-
 3 files changed, 5 insertions(+), 283 deletions(-)

(limited to 'src/Alpha_complex')

diff --git a/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp
index 1ac0093d..0085ae67 100644
--- a/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp
@@ -22,7 +22,6 @@
 
 #include <gudhi/Alpha_complex.h>
 #include <gudhi/Simplex_tree.h>
-#include <gudhi/Unitary_tests_utils.h>
 
 // Use dynamic_dimension_tag for the user to be able to set dimension
 typedef CGAL::Epeck_d< CGAL::Dynamic_dimension_tag > Exact_kernel_d;
@@ -84,153 +83,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of
   BOOST_CHECK(simplex_tree_59.num_simplices() == 23);
 }
 
-// Use static dimension_tag for the user not to be able to set dimension
-typedef CGAL::Epeck_d< CGAL::Dimension_tag<4> > Kernel_4;
-typedef Kernel_4::Point_d Point_4;
-typedef std::vector<Point_4> Vector_4_Points;
-
-bool is_point_in_list(Vector_4_Points points_list, Point_4 point) {
-  for (auto& point_in_list : points_list) {
-    if (point_in_list == point) {
-      return true;  // point found
-    }
-  }
-  return false;  // point not found
-}
-
-BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
-  // ----------------------------------------------------------------------------
-  // Init of a list of points
-  // ----------------------------------------------------------------------------
-  Vector_4_Points points;
-  std::vector<double> coords = { 0.0, 0.0, 0.0, 1.0 };
-  points.push_back(Point_4(coords.begin(), coords.end()));
-  coords = { 0.0, 0.0, 1.0, 0.0 };
-  points.push_back(Point_4(coords.begin(), coords.end()));
-  coords = { 0.0, 1.0, 0.0, 0.0 };
-  points.push_back(Point_4(coords.begin(), coords.end()));
-  coords = { 1.0, 0.0, 0.0, 0.0 };
-  points.push_back(Point_4(coords.begin(), coords.end()));
-
-  // ----------------------------------------------------------------------------
-  // Init of an alpha complex from the list of points
-  // ----------------------------------------------------------------------------
-  Gudhi::alpha_complex::Alpha_complex<Kernel_4> alpha_complex_from_points(points);
-
-  std::clog << "========== Alpha_complex_from_points ==========" << std::endl;
-
-  Gudhi::Simplex_tree<> simplex_tree;
-  BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree));
-  
-  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
-  BOOST_CHECK(alpha_complex_from_points.num_vertices() == points.size());
-
-  // Another way to check num_simplices
-  std::clog << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl;
-  int num_simplices = 0;
-  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
-    num_simplices++;
-    std::clog << "   ( ";
-    for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex)) {
-      std::clog << vertex << " ";
-    }
-    std::clog << ") -> " << "[" << simplex_tree.filtration(f_simplex) << "] ";
-    std::clog << std::endl;
-  }
-  BOOST_CHECK(num_simplices == 15);
-  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
-  BOOST_CHECK(simplex_tree.num_simplices() == 15);
-
-  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
-  BOOST_CHECK(simplex_tree.dimension() == 3);
-  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
-  BOOST_CHECK(simplex_tree.num_vertices() == points.size());
-
-  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
-    switch (simplex_tree.dimension(f_simplex)) {
-      case 0:
-        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 0.0);
-        break;
-      case 1:
-        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 1.0/2.0);
-        break;
-      case 2:
-        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 2.0/3.0);
-        break;
-      case 3:
-        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 3.0/4.0);
-        break;
-      default:
-        BOOST_CHECK(false);  // Shall not happen
-        break;
-    }
-  }
-
-  Point_4 p0 = alpha_complex_from_points.get_point(0);
-  std::clog << "alpha_complex_from_points.get_point(0)=" << p0 << std::endl;
-  BOOST_CHECK(4 == p0.dimension());
-  BOOST_CHECK(is_point_in_list(points, p0));
-
-  Point_4 p1 = alpha_complex_from_points.get_point(1);
-  std::clog << "alpha_complex_from_points.get_point(1)=" << p1 << std::endl;
-  BOOST_CHECK(4 == p1.dimension());
-  BOOST_CHECK(is_point_in_list(points, p1));
-
-  Point_4 p2 = alpha_complex_from_points.get_point(2);
-  std::clog << "alpha_complex_from_points.get_point(2)=" << p2 << std::endl;
-  BOOST_CHECK(4 == p2.dimension());
-  BOOST_CHECK(is_point_in_list(points, p2));
-
-  Point_4 p3 = alpha_complex_from_points.get_point(3);
-  std::clog << "alpha_complex_from_points.get_point(3)=" << p3 << std::endl;
-  BOOST_CHECK(4 == p3.dimension());
-  BOOST_CHECK(is_point_in_list(points, p3));
-
-  // Test to the limit
-  BOOST_CHECK_THROW (alpha_complex_from_points.get_point(4), std::out_of_range);
-  BOOST_CHECK_THROW (alpha_complex_from_points.get_point(-1), std::out_of_range);
-  BOOST_CHECK_THROW (alpha_complex_from_points.get_point(1234), std::out_of_range);
-  
-  // Test after prune_above_filtration
-  bool modified = simplex_tree.prune_above_filtration(0.6);
-  BOOST_CHECK(modified);
-  
-  // Another way to check num_simplices
-  std::clog << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl;
-  num_simplices = 0;
-  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
-    num_simplices++;
-    std::clog << "   ( ";
-    for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex)) {
-      std::clog << vertex << " ";
-    }
-    std::clog << ") -> " << "[" << simplex_tree.filtration(f_simplex) << "] ";
-    std::clog << std::endl;
-  }
-  BOOST_CHECK(num_simplices == 10);
-  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
-  BOOST_CHECK(simplex_tree.num_simplices() == 10);
-
-  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
-  BOOST_CHECK(simplex_tree.dimension() == 1);
-  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
-  BOOST_CHECK(simplex_tree.num_vertices() == 4);
-
-  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
-    switch (simplex_tree.dimension(f_simplex)) {
-      case 0:
-        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 0.0);
-        break;
-      case 1:
-        GUDHI_TEST_FLOAT_EQUALITY_CHECK(simplex_tree.filtration(f_simplex), 1.0/2.0);
-        break;
-      default:
-        BOOST_CHECK(false);  // Shall not happen
-        break;
-    }
-  }
-
-}
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, list_of_kernel_variants) {
   std::clog << "========== Alpha_complex_from_empty_points ==========" << std::endl;
@@ -263,46 +115,3 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, lis
   std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
   BOOST_CHECK(simplex_tree.num_vertices() == points.size());
 }
-
-using Inexact_kernel_2 = CGAL::Epick_d< CGAL::Dimension_tag<2> >;
-using Exact_kernel_2 = CGAL::Epeck_d< CGAL::Dimension_tag<2> >;
-using list_of_kernel_2_variants = boost::mpl::list<Inexact_kernel_2, Exact_kernel_2>;
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_with_duplicated_points, TestedKernel, list_of_kernel_2_variants) {
-  std::clog << "========== Alpha_complex_with_duplicated_points ==========" << std::endl;
-
-  using Point = typename TestedKernel::Point_d;
-  using Vector_of_points = std::vector<Point>;
-
-  // ----------------------------------------------------------------------------
-  // Init of a list of points
-  // ----------------------------------------------------------------------------
-  Vector_of_points points;
-  points.push_back(Point(1.0, 1.0));
-  points.push_back(Point(7.0, 0.0));
-  points.push_back(Point(4.0, 6.0));
-  points.push_back(Point(9.0, 6.0));
-  points.push_back(Point(0.0, 14.0));
-  points.push_back(Point(2.0, 19.0));
-  points.push_back(Point(9.0, 17.0));
-  // duplicated points
-  points.push_back(Point(1.0, 1.0));
-  points.push_back(Point(7.0, 0.0));
-
-  // ----------------------------------------------------------------------------
-  // Init of an alpha complex from the list of points
-  // ----------------------------------------------------------------------------
-  std::clog << "Init" << std::endl;
-  Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_points(points);
-
-  Gudhi::Simplex_tree<> simplex_tree;
-  std::clog << "create_complex" << std::endl;
-  BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree));
-  
-  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
-  BOOST_CHECK(alpha_complex_from_points.num_vertices() < points.size());
-
-  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices()
-      << std::endl;
-  BOOST_CHECK(simplex_tree.num_vertices() < points.size());
-}
diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
index 1ac0093d..b474917f 100644
--- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
@@ -24,66 +24,6 @@
 #include <gudhi/Simplex_tree.h>
 #include <gudhi/Unitary_tests_utils.h>
 
-// Use dynamic_dimension_tag for the user to be able to set dimension
-typedef CGAL::Epeck_d< CGAL::Dynamic_dimension_tag > Exact_kernel_d;
-// Use static dimension_tag for the user not to be able to set dimension
-typedef CGAL::Epeck_d< CGAL::Dimension_tag<3> > Exact_kernel_s;
-// Use dynamic_dimension_tag for the user to be able to set dimension
-typedef CGAL::Epick_d< CGAL::Dynamic_dimension_tag > Inexact_kernel_d;
-// Use static dimension_tag for the user not to be able to set dimension
-typedef CGAL::Epick_d< CGAL::Dimension_tag<3> > Inexact_kernel_s;
-// The triangulation uses the default instantiation of the TriangulationDataStructure template parameter
-
-typedef boost::mpl::list<Exact_kernel_d, Exact_kernel_s, Inexact_kernel_d, Inexact_kernel_s> list_of_kernel_variants;
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of_kernel_variants) {
-  // ----------------------------------------------------------------------------
-  //
-  // Init of an alpha-complex from a OFF file
-  //
-  // ----------------------------------------------------------------------------
-  std::string off_file_name("alphacomplexdoc.off");
-  double max_alpha_square_value = 60.0;
-  std::clog << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" <<
-      max_alpha_square_value << "==========" << std::endl;
-
-  Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_file(off_file_name);
-
-  Gudhi::Simplex_tree<> simplex_tree_60;
-  BOOST_CHECK(alpha_complex_from_file.create_complex(simplex_tree_60, max_alpha_square_value));
-
-  std::clog << "alpha_complex_from_file.num_vertices()=" << alpha_complex_from_file.num_vertices() << std::endl;
-  BOOST_CHECK(alpha_complex_from_file.num_vertices() == 7);
-
-  std::clog << "simplex_tree_60.dimension()=" << simplex_tree_60.dimension() << std::endl;
-  BOOST_CHECK(simplex_tree_60.dimension() == 2);
-
-  std::clog << "simplex_tree_60.num_vertices()=" << simplex_tree_60.num_vertices() << std::endl;
-  BOOST_CHECK(simplex_tree_60.num_vertices() == 7);
-
-  std::clog << "simplex_tree_60.num_simplices()=" << simplex_tree_60.num_simplices() << std::endl;
-  BOOST_CHECK(simplex_tree_60.num_simplices() == 25);
-
-  max_alpha_square_value = 59.0;
-  std::clog << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" <<
-      max_alpha_square_value << "==========" << std::endl;
-
-  Gudhi::Simplex_tree<> simplex_tree_59;
-  BOOST_CHECK(alpha_complex_from_file.create_complex(simplex_tree_59, max_alpha_square_value));
-  
-  std::clog << "alpha_complex_from_file.num_vertices()=" << alpha_complex_from_file.num_vertices() << std::endl;
-  BOOST_CHECK(alpha_complex_from_file.num_vertices() == 7);
-
-  std::clog << "simplex_tree_59.dimension()=" << simplex_tree_59.dimension() << std::endl;
-  BOOST_CHECK(simplex_tree_59.dimension() == 2);
-
-  std::clog << "simplex_tree_59.num_vertices()=" << simplex_tree_59.num_vertices() << std::endl;
-  BOOST_CHECK(simplex_tree_59.num_vertices() == 7);
-
-  std::clog << "simplex_tree_59.num_simplices()=" << simplex_tree_59.num_simplices() << std::endl;
-  BOOST_CHECK(simplex_tree_59.num_simplices() == 23);
-}
-
 // Use static dimension_tag for the user not to be able to set dimension
 typedef CGAL::Epeck_d< CGAL::Dimension_tag<4> > Kernel_4;
 typedef Kernel_4::Point_d Point_4;
@@ -232,37 +172,6 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
 
 }
 
-BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, list_of_kernel_variants) {
-  std::clog << "========== Alpha_complex_from_empty_points ==========" << std::endl;
-
-  // ----------------------------------------------------------------------------
-  // Init of an empty list of points
-  // ----------------------------------------------------------------------------
-  std::vector<typename TestedKernel::Point_d> points;
-
-  // ----------------------------------------------------------------------------
-  // Init of an alpha complex from the list of points
-  // ----------------------------------------------------------------------------
-  Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_points(points);
-
-  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
-  BOOST_CHECK(alpha_complex_from_points.num_vertices() == points.size());
-
-  // Test to the limit
-  BOOST_CHECK_THROW (alpha_complex_from_points.get_point(0), std::out_of_range);
-
-  Gudhi::Simplex_tree<> simplex_tree;
-  BOOST_CHECK(!alpha_complex_from_points.create_complex(simplex_tree));
-  
-  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
-  BOOST_CHECK(simplex_tree.num_simplices() == 0);
-
-  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
-  BOOST_CHECK(simplex_tree.dimension() == -1);
-  
-  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
-  BOOST_CHECK(simplex_tree.num_vertices() == points.size());
-}
 
 using Inexact_kernel_2 = CGAL::Epick_d< CGAL::Dimension_tag<2> >;
 using Exact_kernel_2 = CGAL::Epeck_d< CGAL::Dimension_tag<2> >;
diff --git a/src/Alpha_complex/test/CMakeLists.txt b/src/Alpha_complex/test/CMakeLists.txt
index 0595ca92..dd2c235f 100644
--- a/src/Alpha_complex/test/CMakeLists.txt
+++ b/src/Alpha_complex/test/CMakeLists.txt
@@ -8,14 +8,18 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
 
   add_executable ( Alpha_complex_test_unit Alpha_complex_unit_test.cpp )
   target_link_libraries(Alpha_complex_test_unit ${CGAL_LIBRARY})
+  add_executable ( Alpha_complex_dim3_test_unit Alpha_complex_dim3_unit_test.cpp )
+  target_link_libraries(Alpha_complex_dim3_test_unit ${CGAL_LIBRARY})
   add_executable ( Delaunay_complex_test_unit Delaunay_complex_unit_test.cpp )
   target_link_libraries(Delaunay_complex_test_unit ${CGAL_LIBRARY})
   if (TBB_FOUND)
     target_link_libraries(Alpha_complex_test_unit ${TBB_LIBRARIES})
+    target_link_libraries(Alpha_complex_dim3_test_unit ${TBB_LIBRARIES})
     target_link_libraries(Delaunay_complex_test_unit ${TBB_LIBRARIES})
   endif()
 
   gudhi_add_boost_test(Alpha_complex_test_unit)
+  gudhi_add_boost_test(Alpha_complex_dim3_test_unit)
   gudhi_add_boost_test(Delaunay_complex_test_unit)
 
 endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
@@ -73,4 +77,4 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
   endif()
   gudhi_add_boost_test(Zero_weighted_alpha_complex_test_unit)
 
-endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
\ No newline at end of file
+endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
-- 
cgit v1.2.3


From 0a183262e27e133bc8a77c91f5c97506497cd380 Mon Sep 17 00:00:00 2001
From: Vincent Rouvreau <vincent.rouvreau@inria.fr>
Date: Wed, 19 Oct 2022 08:28:02 +0200
Subject: persistence diagram default output is std::cout, not std::clog.
 Modify utilities help to be in agreement with this

---
 src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp          | 2 +-
 src/Alpha_complex/utilities/alpha_complex_persistence.cpp             | 2 +-
 src/Cech_complex/utilities/cech_persistence.cpp                       | 2 +-
 .../utilities/distance_matrix_edge_collapse_rips_persistence.cpp      | 2 +-
 src/Collapse/utilities/point_cloud_edge_collapse_rips_persistence.cpp | 2 +-
 src/Persistent_cohomology/example/persistence_from_file.cpp           | 2 +-
 src/Persistent_cohomology/example/rips_multifield_persistence.cpp     | 2 +-
 src/Persistent_cohomology/example/rips_persistence_step_by_step.cpp   | 2 +-
 .../example/rips_persistence_via_boundary_matrix.cpp                  | 2 +-
 src/Rips_complex/utilities/rips_correlation_matrix_persistence.cpp    | 2 +-
 src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp       | 2 +-
 src/Rips_complex/utilities/rips_persistence.cpp                       | 2 +-
 src/Rips_complex/utilities/sparse_rips_persistence.cpp                | 2 +-
 src/Witness_complex/utilities/strong_witness_persistence.cpp          | 2 +-
 src/Witness_complex/utilities/weak_witness_persistence.cpp            | 2 +-
 src/Witness_complex/utilities/witnesscomplex.md                       | 4 ++--
 16 files changed, 17 insertions(+), 17 deletions(-)

(limited to 'src/Alpha_complex')

diff --git a/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp b/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp
index 91899040..e65d8c6f 100644
--- a/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp
+++ b/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp
@@ -263,7 +263,7 @@ void program_options(int argc, char *argv[], std::string &off_file_points, bool
       "cuboid-file,c", po::value<std::string>(&cuboid_file),
       "Name of file describing the periodic domain. Format is:\n  min_hx min_hy min_hz\n  max_hx max_hy max_hz")(
       "output-file,o", po::value<std::string>(&output_file_diag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::clog")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "max-alpha-square-value,r",
       po::value<Filtration_value>(&alpha_square_max_value)
           ->default_value(std::numeric_limits<Filtration_value>::infinity()),
diff --git a/src/Alpha_complex/utilities/alpha_complex_persistence.cpp b/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
index e86b34e2..29edbd8e 100644
--- a/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
+++ b/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
@@ -163,7 +163,7 @@ void program_options(int argc, char *argv[], std::string &off_file_points, bool
       "weight-file,w", po::value<std::string>(&weight_file)->default_value(std::string()),
       "Name of file containing a point weights. Format is one weight per line:\n  W1\n  ...\n  Wn ")(
       "output-file,o", po::value<std::string>(&output_file_diag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::clog")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "max-alpha-square-value,r", po::value<Filtration_value>(&alpha_square_max_value)
                                       ->default_value(std::numeric_limits<Filtration_value>::infinity()),
       "Maximal alpha square value for the Alpha complex construction.")(
diff --git a/src/Cech_complex/utilities/cech_persistence.cpp b/src/Cech_complex/utilities/cech_persistence.cpp
index a07ba212..e6419f3d 100644
--- a/src/Cech_complex/utilities/cech_persistence.cpp
+++ b/src/Cech_complex/utilities/cech_persistence.cpp
@@ -118,7 +118,7 @@ void program_options(int argc, char* argv[], std::string& off_file_points, bool&
       "fast,f", po::bool_switch(&fast),
       "To activate fast version of Cech complex (default is false, not available if exact is set)")(
       "output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::clog")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "max-radius,r",
       po::value<Filtration_value>(&max_radius)->default_value(std::numeric_limits<Filtration_value>::infinity()),
       "Maximal length of an edge for the Cech complex construction.")(
diff --git a/src/Collapse/utilities/distance_matrix_edge_collapse_rips_persistence.cpp b/src/Collapse/utilities/distance_matrix_edge_collapse_rips_persistence.cpp
index 38efb9e6..70b489b5 100644
--- a/src/Collapse/utilities/distance_matrix_edge_collapse_rips_persistence.cpp
+++ b/src/Collapse/utilities/distance_matrix_edge_collapse_rips_persistence.cpp
@@ -111,7 +111,7 @@ void program_options(int argc, char* argv[], std::string& csv_matrix_file, std::
   po::options_description visible("Allowed options", 100);
   visible.add_options()("help,h", "produce help message")(
       "output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::cout")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "max-edge-length,r",
       po::value<Filtration_value>(&threshold)->default_value(std::numeric_limits<Filtration_value>::infinity()),
       "Maximal length of an edge for the Rips complex construction.")(
diff --git a/src/Collapse/utilities/point_cloud_edge_collapse_rips_persistence.cpp b/src/Collapse/utilities/point_cloud_edge_collapse_rips_persistence.cpp
index d8f42ab6..a8fd6f14 100644
--- a/src/Collapse/utilities/point_cloud_edge_collapse_rips_persistence.cpp
+++ b/src/Collapse/utilities/point_cloud_edge_collapse_rips_persistence.cpp
@@ -140,7 +140,7 @@ void program_options(int argc, char* argv[], std::string& off_file_points, std::
   po::options_description visible("Allowed options", 100);
   visible.add_options()("help,h", "produce help message")(
       "output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::cout")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "max-edge-length,r",
       po::value<Filtration_value>(&threshold)->default_value(std::numeric_limits<Filtration_value>::infinity()),
       "Maximal length of an edge for the Rips complex construction.")(
diff --git a/src/Persistent_cohomology/example/persistence_from_file.cpp b/src/Persistent_cohomology/example/persistence_from_file.cpp
index 38c44514..7f89c001 100644
--- a/src/Persistent_cohomology/example/persistence_from_file.cpp
+++ b/src/Persistent_cohomology/example/persistence_from_file.cpp
@@ -93,7 +93,7 @@ void program_options(int argc, char * argv[]
   visible.add_options()
       ("help,h", "produce help message")
       ("output-file,o", po::value<std::string>(&output_file)->default_value(std::string()),
-       "Name of file in which the persistence diagram is written. Default print in std::clog")
+       "Name of file in which the persistence diagram is written. Default print in standard output")
       ("field-charac,p", po::value<int>(&p)->default_value(11),
        "Characteristic p of the coefficient field Z/pZ for computing homology.")
       ("min-persistence,m", po::value<Filtration_value>(&min_persistence),
diff --git a/src/Persistent_cohomology/example/rips_multifield_persistence.cpp b/src/Persistent_cohomology/example/rips_multifield_persistence.cpp
index ca26a5b9..84453898 100644
--- a/src/Persistent_cohomology/example/rips_multifield_persistence.cpp
+++ b/src/Persistent_cohomology/example/rips_multifield_persistence.cpp
@@ -96,7 +96,7 @@ void program_options(int argc, char * argv[]
   visible.add_options()
       ("help,h", "produce help message")
       ("output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-       "Name of file in which the persistence diagram is written. Default print in std::clog")
+       "Name of file in which the persistence diagram is written. Default print in standard output")
       ("max-edge-length,r", po::value<Filtration_value>(&threshold)->default_value(0),
        "Maximal length of an edge for the Rips complex construction.")
       ("cpx-dimension,d", po::value<int>(&dim_max)->default_value(1),
diff --git a/src/Persistent_cohomology/example/rips_persistence_step_by_step.cpp b/src/Persistent_cohomology/example/rips_persistence_step_by_step.cpp
index a503d983..6f37cf5c 100644
--- a/src/Persistent_cohomology/example/rips_persistence_step_by_step.cpp
+++ b/src/Persistent_cohomology/example/rips_persistence_step_by_step.cpp
@@ -112,7 +112,7 @@ void program_options(int argc, char * argv[]
   visible.add_options()
       ("help,h", "produce help message")
       ("output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-       "Name of file in which the persistence diagram is written. Default print in std::clog")
+       "Name of file in which the persistence diagram is written. Default print in standard output")
       ("max-edge-length,r",
        po::value<Filtration_value>(&threshold)->default_value(std::numeric_limits<Filtration_value>::infinity()),
        "Maximal length of an edge for the Rips complex construction.")
diff --git a/src/Persistent_cohomology/example/rips_persistence_via_boundary_matrix.cpp b/src/Persistent_cohomology/example/rips_persistence_via_boundary_matrix.cpp
index 8c5742aa..6b60f603 100644
--- a/src/Persistent_cohomology/example/rips_persistence_via_boundary_matrix.cpp
+++ b/src/Persistent_cohomology/example/rips_persistence_via_boundary_matrix.cpp
@@ -109,7 +109,7 @@ void program_options(int argc, char * argv[]
   visible.add_options()
       ("help,h", "produce help message")
       ("output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-       "Name of file in which the persistence diagram is written. Default print in std::clog")
+       "Name of file in which the persistence diagram is written. Default print in standard output")
       ("max-edge-length,r", po::value<Filtration_value>(&threshold)->default_value(0),
        "Maximal length of an edge for the Rips complex construction.")
       ("cpx-dimension,d", po::value<int>(&dim_max)->default_value(1),
diff --git a/src/Rips_complex/utilities/rips_correlation_matrix_persistence.cpp b/src/Rips_complex/utilities/rips_correlation_matrix_persistence.cpp
index b473738e..72ddc797 100644
--- a/src/Rips_complex/utilities/rips_correlation_matrix_persistence.cpp
+++ b/src/Rips_complex/utilities/rips_correlation_matrix_persistence.cpp
@@ -118,7 +118,7 @@ void program_options(int argc, char* argv[], std::string& csv_matrix_file, std::
   po::options_description visible("Allowed options", 100);
   visible.add_options()("help,h", "produce help message")(
       "output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::clog")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "min-edge-corelation,c", po::value<Filtration_value>(&correlation_min)->default_value(0),
       "Minimal corelation of an edge for the Rips complex construction.")(
       "cpx-dimension,d", po::value<int>(&dim_max)->default_value(1),
diff --git a/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp b/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp
index 6306755d..77ad841a 100644
--- a/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp
+++ b/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp
@@ -79,7 +79,7 @@ void program_options(int argc, char* argv[], std::string& csv_matrix_file, std::
   po::options_description visible("Allowed options", 100);
   visible.add_options()("help,h", "produce help message")(
       "output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::clog")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "max-edge-length,r",
       po::value<Filtration_value>(&threshold)->default_value(std::numeric_limits<Filtration_value>::infinity()),
       "Maximal length of an edge for the Rips complex construction.")(
diff --git a/src/Rips_complex/utilities/rips_persistence.cpp b/src/Rips_complex/utilities/rips_persistence.cpp
index 9d7490b3..43194821 100644
--- a/src/Rips_complex/utilities/rips_persistence.cpp
+++ b/src/Rips_complex/utilities/rips_persistence.cpp
@@ -81,7 +81,7 @@ void program_options(int argc, char* argv[], std::string& off_file_points, std::
   po::options_description visible("Allowed options", 100);
   visible.add_options()("help,h", "produce help message")(
       "output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::clog")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "max-edge-length,r",
       po::value<Filtration_value>(&threshold)->default_value(std::numeric_limits<Filtration_value>::infinity()),
       "Maximal length of an edge for the Rips complex construction.")(
diff --git a/src/Rips_complex/utilities/sparse_rips_persistence.cpp b/src/Rips_complex/utilities/sparse_rips_persistence.cpp
index ac935b41..829c85e6 100644
--- a/src/Rips_complex/utilities/sparse_rips_persistence.cpp
+++ b/src/Rips_complex/utilities/sparse_rips_persistence.cpp
@@ -84,7 +84,7 @@ void program_options(int argc, char* argv[], std::string& off_file_points, std::
   po::options_description visible("Allowed options", 100);
   visible.add_options()("help,h", "produce help message")(
       "output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::clog")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "max-edge-length,r",
       po::value<Filtration_value>(&threshold)->default_value(std::numeric_limits<Filtration_value>::infinity()),
       "Maximal length of an edge for the Rips complex construction.")(
diff --git a/src/Witness_complex/utilities/strong_witness_persistence.cpp b/src/Witness_complex/utilities/strong_witness_persistence.cpp
index 614de0d4..b2ecad82 100644
--- a/src/Witness_complex/utilities/strong_witness_persistence.cpp
+++ b/src/Witness_complex/utilities/strong_witness_persistence.cpp
@@ -108,7 +108,7 @@ void program_options(int argc, char* argv[], int& nbL, std::string& file_name, s
   visible.add_options()("help,h", "produce help message")("landmarks,l", po::value<int>(&nbL),
                                                           "Number of landmarks to choose from the point cloud.")(
       "output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::clog")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "max-sq-alpha,a", po::value<Filtration_value>(&max_squared_alpha)->default_value(default_alpha),
       "Maximal squared relaxation parameter.")(
       "field-charac,p", po::value<int>(&p)->default_value(11),
diff --git a/src/Witness_complex/utilities/weak_witness_persistence.cpp b/src/Witness_complex/utilities/weak_witness_persistence.cpp
index 5ea31d6b..c7ead7de 100644
--- a/src/Witness_complex/utilities/weak_witness_persistence.cpp
+++ b/src/Witness_complex/utilities/weak_witness_persistence.cpp
@@ -108,7 +108,7 @@ void program_options(int argc, char* argv[], int& nbL, std::string& file_name, s
   visible.add_options()("help,h", "produce help message")("landmarks,l", po::value<int>(&nbL),
                                                           "Number of landmarks to choose from the point cloud.")(
       "output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
-      "Name of file in which the persistence diagram is written. Default print in std::clog")(
+      "Name of file in which the persistence diagram is written. Default print in standard output")(
       "max-sq-alpha,a", po::value<Filtration_value>(&max_squared_alpha)->default_value(default_alpha),
       "Maximal squared relaxation parameter.")(
       "field-charac,p", po::value<int>(&p)->default_value(11),
diff --git a/src/Witness_complex/utilities/witnesscomplex.md b/src/Witness_complex/utilities/witnesscomplex.md
index 3a3a7d83..e994e0b8 100644
--- a/src/Witness_complex/utilities/witnesscomplex.md
+++ b/src/Witness_complex/utilities/witnesscomplex.md
@@ -29,7 +29,7 @@ and `p` is the characteristic of the field *Z/pZ* used for homology coefficients
 
 * `-h [ --help ]` Produce help message
 * `-l [ --landmarks ]` Number of landmarks to choose from the point cloud.
-* `-o [ --output-file ]` Name of file in which the persistence diagram is written. By default, print in std::clog.
+* `-o [ --output-file ]` Name of file in which the persistence diagram is written. By default, print in standard output.
 * `-a [ --max-sq-alpha ]` (default = inf) Maximal squared relaxation parameter.
 * `-p [ --field-charac ]` (default = 11) Characteristic p of the coefficient field Z/pZ for computing homology.
 * `-m [ --min-persistence ]` (default = 0) Minimal lifetime of homology feature to be recorded. Enter a negative value to see zero length intervals.
@@ -60,7 +60,7 @@ and `p` is the characteristic of the field *Z/pZ* used for homology coefficients
 
 * `-h [ --help ]` Produce help message
 * `-l [ --landmarks ]` Number of landmarks to choose from the point cloud.
-* `-o [ --output-file ]` Name of file in which the persistence diagram is written. By default, print in std::clog.
+* `-o [ --output-file ]` Name of file in which the persistence diagram is written. By default, print in standard output.
 * `-a [ --max-sq-alpha ]` (default = inf) Maximal squared relaxation parameter.
 * `-p [ --field-charac ]` (default = 11) Characteristic p of the coefficient field Z/pZ for computing homology.
 * `-m [ --min-persistence ]` (default = 0) Minimal lifetime of homology feature to be recorded. Enter a negative value to see zero length intervals.
-- 
cgit v1.2.3


From 8227688cfb716bb881b836d245a869664bb10d36 Mon Sep 17 00:00:00 2001
From: Marc Glisse <marc.glisse@inria.fr>
Date: Wed, 19 Oct 2022 08:55:27 +0200
Subject: Update src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp

Co-authored-by: Vincent Rouvreau <10407034+VincentRouvreau@users.noreply.github.com>
---
 src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/Alpha_complex')

diff --git a/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp
index 0085ae67..e7c261f1 100644
--- a/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp
@@ -9,7 +9,7 @@
  */
 
 #define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE "alpha_complex"
+#define BOOST_TEST_MODULE "alpha_complex_dim3"
 #include <boost/test/unit_test.hpp>
 #include <boost/mpl/list.hpp>
 
-- 
cgit v1.2.3


From 0a1d09caba097117e08c16d12bf682d611454c02 Mon Sep 17 00:00:00 2001
From: Vincent Rouvreau <vincent.rouvreau@inria.fr>
Date: Fri, 21 Oct 2022 16:54:09 +0200
Subject: Stores vertices on init_from_range and insert all of them in the
 Simplex_tree to avoid quadratic behavior

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

(limited to 'src/Alpha_complex')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index aec8c1b1..d5d1a0f0 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -17,8 +17,7 @@
 // to construct Alpha_complex from a OFF file of points
 #include <gudhi/Points_off_io.h>
 
-#include <stdlib.h>
-#include <math.h>  // isnan, fmax
+#include <cmath>  // isnan, fmax
 #include <memory>  // for std::unique_ptr
 #include <cstddef>  // for std::size_t
 
@@ -45,6 +44,8 @@
 #include <utility>  // std::pair
 #include <stdexcept>
 #include <numeric>  // for std::iota
+#include <algorithm>  // for std::sort
+#include <initializer_list>  // for complex.insert_simplex_and_subfaces({...}, ...)
 
 // Make compilation fail - required for external projects - https://github.com/GUDHI/gudhi-devel/issues/10
 #if CGAL_VERSION_NR < 1041101000
@@ -146,6 +147,10 @@ class Alpha_complex {
   std::unique_ptr<Triangulation> triangulation_;
   /** \brief Kernel for triangulation_ functions access.*/
   A_kernel_d kernel_;
+  /** \brief Vertices to be inserted first by the create_complex method to avoid quadratic complexity.
+   * It isn't just [0, n) if some points have multiplicity (only one copy appears in the complex).
+  */
+  std::vector<std::size_t> vertices_;
 
   /** \brief Cache for geometric constructions: circumcenter and squared radius of a simplex.*/
   std::vector<Sphere> cache_, old_cache_;
@@ -279,6 +284,9 @@ class Alpha_complex {
       // structure to retrieve CGAL points from vertex handle - one vertex handle per point.
       // Needs to be constructed before as vertex handles arrives in no particular order.
       vertex_handle_to_iterator_.resize(point_cloud.size());
+      // List of sorted unique vertices in the triangulation. We take advantage of the existing loop to construct it
+      // Vertices list avoids quadratic complexity with the Simplex_tree. We should not fill it up with Toplex_map e.g.
+      vertices_.reserve(triangulation_->number_of_vertices());
       // Loop on triangulation vertices list
       for (CGAL_vertex_iterator vit = triangulation_->vertices_begin(); vit != triangulation_->vertices_end(); ++vit) {
         if (!triangulation_->is_infinite(*vit)) {
@@ -286,8 +294,10 @@ class Alpha_complex {
           std::clog << "Vertex insertion - " << vit->data() << " -> " << vit->point() << std::endl;
 #endif  // DEBUG_TRACES
           vertex_handle_to_iterator_[vit->data()] = vit;
+          vertices_.push_back(vit->data());
         }
       }
+      std::sort(vertices_.begin(), vertices_.end());
       // --------------------------------------------------------------------------------------------
     }
   }
@@ -384,12 +394,19 @@ class Alpha_complex {
     // --------------------------------------------------------------------------------------------
     // Simplex_tree construction from loop on triangulation finite full cells list
     if (num_vertices() > 0) {
+      for (auto vertex : vertices_) {
+#ifdef DEBUG_TRACES
+        std::clog << "SimplicialComplex insertion " << vertex << std::endl;
+#endif  // DEBUG_TRACES
+        complex.insert_simplex_and_subfaces({static_cast<Vertex_handle>(vertex)}, std::numeric_limits<double>::quiet_NaN());
+      }
+
       for (auto cit = triangulation_->finite_full_cells_begin();
            cit != triangulation_->finite_full_cells_end();
            ++cit) {
         Vector_vertex vertexVector;
 #ifdef DEBUG_TRACES
-        std::clog << "Simplex_tree insertion ";
+        std::clog << "SimplicialComplex insertion ";
 #endif  // DEBUG_TRACES
         for (auto vit = cit->vertices_begin(); vit != cit->vertices_end(); ++vit) {
           if (*vit != nullptr) {
-- 
cgit v1.2.3


From f4e90e943dd368b76f466c91075193124c191ef5 Mon Sep 17 00:00:00 2001
From: Vincent Rouvreau <vincent.rouvreau@inria.fr>
Date: Fri, 21 Oct 2022 17:16:01 +0200
Subject: Remove strange behavior with initializer list

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'src/Alpha_complex')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index d5d1a0f0..7b837ae0 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -45,7 +45,6 @@
 #include <stdexcept>
 #include <numeric>  // for std::iota
 #include <algorithm>  // for std::sort
-#include <initializer_list>  // for complex.insert_simplex_and_subfaces({...}, ...)
 
 // Make compilation fail - required for external projects - https://github.com/GUDHI/gudhi-devel/issues/10
 #if CGAL_VERSION_NR < 1041101000
@@ -394,11 +393,13 @@ class Alpha_complex {
     // --------------------------------------------------------------------------------------------
     // Simplex_tree construction from loop on triangulation finite full cells list
     if (num_vertices() > 0) {
+      std::vector<Vertex_handle> one_vertex(1);
       for (auto vertex : vertices_) {
 #ifdef DEBUG_TRACES
         std::clog << "SimplicialComplex insertion " << vertex << std::endl;
 #endif  // DEBUG_TRACES
-        complex.insert_simplex_and_subfaces({static_cast<Vertex_handle>(vertex)}, std::numeric_limits<double>::quiet_NaN());
+        one_vertex[0] = vertex;
+        complex.insert_simplex_and_subfaces(one_vertex, std::numeric_limits<double>::quiet_NaN());
       }
 
       for (auto cit = triangulation_->finite_full_cells_begin();
-- 
cgit v1.2.3


From 11dec62e555e446fb34a1f5ba3d0c9aba1a7e956 Mon Sep 17 00:00:00 2001
From: Vincent Rouvreau <vincent.rouvreau@inria.fr>
Date: Thu, 3 Nov 2022 17:49:33 +0100
Subject: code review: Use std::ptrdiff_t as internal vertex handle type when
 not yet known

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

(limited to 'src/Alpha_complex')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 7b837ae0..a7372f19 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -101,13 +101,17 @@ template<typename D> struct Is_Epeck_D<CGAL::Epeck_d<D>> { static const bool val
  */
 template<class Kernel = CGAL::Epeck_d<CGAL::Dynamic_dimension_tag>, bool Weighted = false>
 class Alpha_complex {
+ private:
+  // Vertex_handle internal type (required by triangulation_ and vertices_).
+  using Internal_vertex_handle = std::ptrdiff_t;
+
  public:
   /** \brief Geometric traits class that provides the geometric types and predicates needed by the triangulations.*/
   using Geom_traits = std::conditional_t<Weighted, CGAL::Regular_triangulation_traits_adapter<Kernel>, Kernel>;
 
   // Add an int in TDS to save point index in the structure
   using TDS = CGAL::Triangulation_data_structure<typename Geom_traits::Dimension,
-                                                 CGAL::Triangulation_vertex<Geom_traits, std::ptrdiff_t>,
+                                                 CGAL::Triangulation_vertex<Geom_traits, Internal_vertex_handle>,
                                                  CGAL::Triangulation_full_cell<Geom_traits> >;
 
   /** \brief A (Weighted or not) Delaunay triangulation of a set of points in \f$ \mathbb{R}^D\f$.*/
@@ -132,9 +136,6 @@ class Alpha_complex {
   // Vertex_iterator type from CGAL.
   using CGAL_vertex_iterator = typename Triangulation::Vertex_iterator;
 
-  // size_type type from CGAL.
-  using size_type = typename Triangulation::size_type;
-
   // Structure to switch from simplex tree vertex handle to CGAL vertex iterator.
   using Vector_vertex_iterator = std::vector< CGAL_vertex_iterator >;
 
@@ -149,7 +150,7 @@ class Alpha_complex {
   /** \brief Vertices to be inserted first by the create_complex method to avoid quadratic complexity.
    * It isn't just [0, n) if some points have multiplicity (only one copy appears in the complex).
   */
-  std::vector<std::size_t> vertices_;
+  std::vector<Internal_vertex_handle> vertices_;
 
   /** \brief Cache for geometric constructions: circumcenter and squared radius of a simplex.*/
   std::vector<Sphere> cache_, old_cache_;
@@ -261,11 +262,11 @@ class Alpha_complex {
       std::vector<Point_d> point_cloud(first, last);
 
       // Creates a vector {0, 1, ..., N-1}
-      std::vector<std::ptrdiff_t> indices(boost::counting_iterator<std::ptrdiff_t>(0),
-                                          boost::counting_iterator<std::ptrdiff_t>(point_cloud.size()));
+      std::vector<Internal_vertex_handle> indices(boost::counting_iterator<Internal_vertex_handle>(0),
+                                                  boost::counting_iterator<Internal_vertex_handle>(point_cloud.size()));
 
       using Point_property_map = boost::iterator_property_map<typename std::vector<Point_d>::iterator,
-                                                              CGAL::Identity_property_map<std::ptrdiff_t>>;
+                                                              CGAL::Identity_property_map<Internal_vertex_handle>>;
       using Search_traits_d = CGAL::Spatial_sort_traits_adapter_d<Geom_traits, Point_property_map>;
 
       CGAL::spatial_sort(indices.begin(), indices.end(), Search_traits_d(std::begin(point_cloud)));
-- 
cgit v1.2.3