Merge tag 'tags/gudhi-release-3.2.0' into dfsg/latest

7 files changed, 154 insertions, 85 deletions

diff --git a/src/Alpha_complex/test/Alpha_complex_3d_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_3d_unit_test.cpp
index cd698a27..a4ecb6ad 100644
--- a/src/Alpha_complex/test/Alpha_complex_3d_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_3d_unit_test.cpp
@@ -54,7 +54,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_3d_from_points) {
   // -----------------
   // Fast version
   // -----------------
-  std::cout << "Fast alpha complex 3d" << std::endl;
+  std::clog << "Fast alpha complex 3d" << std::endl;
 
   std::vector<Fast_alpha_complex_3d::Bare_point_3> points = get_points<Fast_alpha_complex_3d::Bare_point_3>();
   Fast_alpha_complex_3d alpha_complex(points);
@@ -79,7 +79,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_3d_from_points) {
   // -----------------
   // Exact version
   // -----------------
-  std::cout << "Exact alpha complex 3d" << std::endl;
+  std::clog << "Exact alpha complex 3d" << std::endl;
 
   std::vector<Exact_alpha_complex_3d::Bare_point_3> exact_points = get_points<Exact_alpha_complex_3d::Bare_point_3>();
   Exact_alpha_complex_3d exact_alpha_complex(exact_points);
@@ -105,13 +105,13 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_3d_from_points) {
   // ---------------------
   // Compare both versions
   // ---------------------
-  std::cout << "Exact Alpha complex 3d is of dimension " << exact_stree.dimension() << " - Fast is "
+  std::clog << "Exact Alpha complex 3d is of dimension " << exact_stree.dimension() << " - Fast is "
             << stree.dimension() << std::endl;
   BOOST_CHECK(exact_stree.dimension() == stree.dimension());
-  std::cout << "Exact Alpha complex 3d num_simplices " << exact_stree.num_simplices() << " - Fast is "
+  std::clog << "Exact Alpha complex 3d num_simplices " << exact_stree.num_simplices() << " - Fast is "
             << stree.num_simplices() << std::endl;
   BOOST_CHECK(exact_stree.num_simplices() == stree.num_simplices());
-  std::cout << "Exact Alpha complex 3d num_vertices " << exact_stree.num_vertices() << " - Fast is "
+  std::clog << "Exact Alpha complex 3d num_vertices " << exact_stree.num_vertices() << " - Fast is "
             << stree.num_vertices() << std::endl;
   BOOST_CHECK(exact_stree.num_vertices() == stree.num_vertices());
 
@@ -119,18 +119,18 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_3d_from_points) {
   while (sh != stree.filtration_simplex_range().end()) {
     std::vector<int> simplex;
     std::vector<int> exact_simplex;
-    std::cout << "Fast ( ";
+    std::clog << "Fast ( ";
     for (auto vertex : stree.simplex_vertex_range(*sh)) {
       simplex.push_back(vertex);
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> [" << stree.filtration(*sh) << "] ";
+    std::clog << ") -> [" << stree.filtration(*sh) << "] ";
 
     // Find it in the exact structure
     auto sh_exact = exact_stree.find(simplex);
     BOOST_CHECK(sh_exact != exact_stree.null_simplex());
 
-    std::cout << " versus [" << exact_stree.filtration(sh_exact) << "] " << std::endl;
+    std::clog << " versus [" << exact_stree.filtration(sh_exact) << "] " << std::endl;
     // Exact and non-exact version is not exactly the same due to float comparison
     GUDHI_TEST_FLOAT_EQUALITY_CHECK(exact_stree.filtration(sh_exact), stree.filtration(*sh));
 
@@ -139,7 +139,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_3d_from_points) {
   // -----------------
   // Safe version
   // -----------------
-  std::cout << "Safe alpha complex 3d" << std::endl;
+  std::clog << "Safe alpha complex 3d" << std::endl;
 
   std::vector<Safe_alpha_complex_3d::Bare_point_3> safe_points = get_points<Safe_alpha_complex_3d::Bare_point_3>();
   Safe_alpha_complex_3d safe_alpha_complex(safe_points);
@@ -165,13 +165,13 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_3d_from_points) {
   // ---------------------
   // Compare both versions
   // ---------------------
-  std::cout << "Safe Alpha complex 3d is of dimension " << safe_stree.dimension() << " - Fast is "
+  std::clog << "Safe Alpha complex 3d is of dimension " << safe_stree.dimension() << " - Fast is "
             << stree.dimension() << std::endl;
   BOOST_CHECK(safe_stree.dimension() == stree.dimension());
-  std::cout << "Safe Alpha complex 3d num_simplices " << safe_stree.num_simplices() << " - Fast is "
+  std::clog << "Safe Alpha complex 3d num_simplices " << safe_stree.num_simplices() << " - Fast is "
             << stree.num_simplices() << std::endl;
   BOOST_CHECK(safe_stree.num_simplices() == stree.num_simplices());
-  std::cout << "Safe Alpha complex 3d num_vertices " << safe_stree.num_vertices() << " - Fast is "
+  std::clog << "Safe Alpha complex 3d num_vertices " << safe_stree.num_vertices() << " - Fast is "
             << stree.num_vertices() << std::endl;
   BOOST_CHECK(safe_stree.num_vertices() == stree.num_vertices());
 
@@ -179,18 +179,18 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_3d_from_points) {
   while (safe_sh != stree.filtration_simplex_range().end()) {
     std::vector<int> simplex;
     std::vector<int> exact_simplex;
-    std::cout << "Fast ( ";
+    std::clog << "Fast ( ";
     for (auto vertex : stree.simplex_vertex_range(*safe_sh)) {
       simplex.push_back(vertex);
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> [" << stree.filtration(*safe_sh) << "] ";
+    std::clog << ") -> [" << stree.filtration(*safe_sh) << "] ";
 
     // Find it in the exact structure
     auto sh_exact = safe_stree.find(simplex);
     BOOST_CHECK(sh_exact != safe_stree.null_simplex());
 
-    std::cout << " versus [" << safe_stree.filtration(sh_exact) << "] " << std::endl;
+    std::clog << " versus [" << safe_stree.filtration(sh_exact) << "] " << std::endl;
     // Exact and non-exact version is not exactly the same due to float comparison
     GUDHI_TEST_FLOAT_EQUALITY_CHECK(safe_stree.filtration(sh_exact), stree.filtration(*safe_sh), 1e-15);
 
diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
index 27b671dd..4b37e4bd 100644
--- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
@@ -48,7 +48,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of
   // ----------------------------------------------------------------------------
   std::string off_file_name("alphacomplexdoc.off");
   double max_alpha_square_value = 60.0;
-  std::cout << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" <<
+  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);
@@ -56,29 +56,29 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of
   Gudhi::Simplex_tree<> simplex_tree_60;
   BOOST_CHECK(alpha_complex_from_file.create_complex(simplex_tree_60, max_alpha_square_value));
 
-  std::cout << "simplex_tree_60.dimension()=" << simplex_tree_60.dimension() << std::endl;
+  std::clog << "simplex_tree_60.dimension()=" << simplex_tree_60.dimension() << std::endl;
   BOOST_CHECK(simplex_tree_60.dimension() == 2);
 
-  std::cout << "simplex_tree_60.num_vertices()=" << simplex_tree_60.num_vertices() << std::endl;
+  std::clog << "simplex_tree_60.num_vertices()=" << simplex_tree_60.num_vertices() << std::endl;
   BOOST_CHECK(simplex_tree_60.num_vertices() == 7);
 
-  std::cout << "simplex_tree_60.num_simplices()=" << simplex_tree_60.num_simplices() << std::endl;
+  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::cout << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" <<
+  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::cout << "simplex_tree_59.dimension()=" << simplex_tree_59.dimension() << std::endl;
+  std::clog << "simplex_tree_59.dimension()=" << simplex_tree_59.dimension() << std::endl;
   BOOST_CHECK(simplex_tree_59.dimension() == 2);
 
-  std::cout << "simplex_tree_59.num_vertices()=" << simplex_tree_59.num_vertices() << std::endl;
+  std::clog << "simplex_tree_59.num_vertices()=" << simplex_tree_59.num_vertices() << std::endl;
   BOOST_CHECK(simplex_tree_59.num_vertices() == 7);
 
-  std::cout << "simplex_tree_59.num_simplices()=" << simplex_tree_59.num_simplices() << std::endl;
+  std::clog << "simplex_tree_59.num_simplices()=" << simplex_tree_59.num_simplices() << std::endl;
   BOOST_CHECK(simplex_tree_59.num_simplices() == 23);
 }
 
@@ -115,30 +115,30 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
   // ----------------------------------------------------------------------------
   Gudhi::alpha_complex::Alpha_complex<Kernel_4> alpha_complex_from_points(points);
 
-  std::cout << "========== Alpha_complex_from_points ==========" << std::endl;
+  std::clog << "========== Alpha_complex_from_points ==========" << std::endl;
 
   Gudhi::Simplex_tree<> simplex_tree;
   BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree));
   
   // Another way to check num_simplices
-  std::cout << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  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::cout << "   ( ";
+    std::clog << "   ( ";
     for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> " << "[" << simplex_tree.filtration(f_simplex) << "] ";
-    std::cout << std::endl;
+    std::clog << ") -> " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
   }
   BOOST_CHECK(num_simplices == 15);
-  std::cout << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
+  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
   BOOST_CHECK(simplex_tree.num_simplices() == 15);
 
-  std::cout << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
+  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
   BOOST_CHECK(simplex_tree.dimension() == 3);
-  std::cout << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
+  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()) {
@@ -162,22 +162,22 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
   }
 
   Point_4 p0 = alpha_complex_from_points.get_point(0);
-  std::cout << "alpha_complex_from_points.get_point(0)=" << p0 << std::endl;
+  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::cout << "alpha_complex_from_points.get_point(1)=" << p1 << std::endl;
+  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::cout << "alpha_complex_from_points.get_point(2)=" << p2 << std::endl;
+  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::cout << "alpha_complex_from_points.get_point(3)=" << p3 << std::endl;
+  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));
 
@@ -188,30 +188,27 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
   
   // Test after prune_above_filtration
   bool modified = simplex_tree.prune_above_filtration(0.6);
-  if (modified) {
-    simplex_tree.initialize_filtration();
-  }
   BOOST_CHECK(modified);
   
   // Another way to check num_simplices
-  std::cout << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  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::cout << "   ( ";
+    std::clog << "   ( ";
     for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> " << "[" << simplex_tree.filtration(f_simplex) << "] ";
-    std::cout << std::endl;
+    std::clog << ") -> " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
   }
   BOOST_CHECK(num_simplices == 10);
-  std::cout << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
+  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
   BOOST_CHECK(simplex_tree.num_simplices() == 10);
 
-  std::cout << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
+  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
   BOOST_CHECK(simplex_tree.dimension() == 1);
-  std::cout << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
+  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()) {
@@ -231,7 +228,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, list_of_kernel_variants) {
-  std::cout << "========== Alpha_complex_from_empty_points ==========" << std::endl;
+  std::clog << "========== Alpha_complex_from_empty_points ==========" << std::endl;
 
   // ----------------------------------------------------------------------------
   // Init of an empty list of points
@@ -249,13 +246,13 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, lis
   Gudhi::Simplex_tree<> simplex_tree;
   BOOST_CHECK(!alpha_complex_from_points.create_complex(simplex_tree));
   
-  std::cout << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
+  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
   BOOST_CHECK(simplex_tree.num_simplices() == 0);
 
-  std::cout << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
+  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
   BOOST_CHECK(simplex_tree.dimension() == -1);
   
-  std::cout << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
+  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
   BOOST_CHECK(simplex_tree.num_vertices() == points.size());
 }
 
@@ -264,7 +261,7 @@ 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::cout << "========== Alpha_complex_with_duplicated_points ==========" << std::endl;
+  std::clog << "========== Alpha_complex_with_duplicated_points ==========" << std::endl;
 
   using Point = typename TestedKernel::Point_d;
   using Vector_of_points = std::vector<Point>;
@@ -287,14 +284,14 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_with_duplicated_points, TestedKernel
   // ----------------------------------------------------------------------------
   // Init of an alpha complex from the list of points
   // ----------------------------------------------------------------------------
-  std::cout << "Init" << std::endl;
+  std::clog << "Init" << std::endl;
   Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_points(points);
 
   Gudhi::Simplex_tree<> simplex_tree;
-  std::cout << "create_complex" << std::endl;
+  std::clog << "create_complex" << std::endl;
   BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree));
   
-  std::cout << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices()
+  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/CMakeLists.txt b/src/Alpha_complex/test/CMakeLists.txt
index 0476c6d4..fe4b23e4 100644
--- a/src/Alpha_complex/test/CMakeLists.txt
+++ b/src/Alpha_complex/test/CMakeLists.txt
@@ -8,11 +8,15 @@ 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 ( 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(Delaunay_complex_test_unit ${TBB_LIBRARIES})
   endif()
 
   gudhi_add_boost_test(Alpha_complex_test_unit)
+  gudhi_add_boost_test(Delaunay_complex_test_unit)
 
   add_executable ( Alpha_complex_3d_test_unit Alpha_complex_3d_unit_test.cpp )
   target_link_libraries(Alpha_complex_3d_test_unit ${CGAL_LIBRARY})
diff --git a/src/Alpha_complex/test/Delaunay_complex_unit_test.cpp b/src/Alpha_complex/test/Delaunay_complex_unit_test.cpp
new file mode 100644
index 00000000..c1cc1fab
--- /dev/null
+++ b/src/Alpha_complex/test/Delaunay_complex_unit_test.cpp
@@ -0,0 +1,68 @@
+/*    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) 2020 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "delaunay_complex"
+#include <boost/test/unit_test.hpp>
+#include <boost/mpl/list.hpp>
+
+#include <CGAL/Epick_d.h>
+#include <CGAL/Epeck_d.h>
+
+#include <vector>
+#include <limits>  // NaN
+#include <cmath>
+
+#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>
+#include <gudhi/random_point_generators.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<5> > 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<5> > 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;
+
+using Simplex_tree = Gudhi::Simplex_tree<>;
+using Simplex_handle = Simplex_tree::Simplex_handle;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of_kernel_variants) {
+  std::cout << "*****************************************************************************************************";
+  using Point = typename TestedKernel::Point_d;
+  std::vector<Point> points;
+  // 50 points on a 4-sphere
+  points = Gudhi::generate_points_on_sphere_d<TestedKernel>(10, 5, 1.);
+
+  Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex(points);
+
+  // Alpha complex
+  Simplex_tree stree_from_alpha_complex;
+  BOOST_CHECK(alpha_complex.create_complex(stree_from_alpha_complex));
+
+  // Delaunay complex
+  Simplex_tree stree_from_delaunay_complex;
+  BOOST_CHECK(alpha_complex.create_complex(stree_from_delaunay_complex, 0., false, true));
+
+  // Check all the simplices from alpha complex are in the Delaunay complex
+  for (auto f_simplex : stree_from_alpha_complex.complex_simplex_range()) {
+    Simplex_handle sh = stree_from_delaunay_complex.find(stree_from_alpha_complex.simplex_vertex_range(f_simplex));
+    BOOST_CHECK(std::isnan(stree_from_delaunay_complex.filtration(sh)));
+    BOOST_CHECK(sh != stree_from_delaunay_complex.null_simplex());
+  }
+}
diff --git a/src/Alpha_complex/test/Periodic_alpha_complex_3d_unit_test.cpp b/src/Alpha_complex/test/Periodic_alpha_complex_3d_unit_test.cpp
index 731763fa..9eef920b 100644
--- a/src/Alpha_complex/test/Periodic_alpha_complex_3d_unit_test.cpp
+++ b/src/Alpha_complex/test/Periodic_alpha_complex_3d_unit_test.cpp
@@ -43,14 +43,14 @@ typedef boost::mpl::list<Fast_periodic_alpha_complex_3d, Safe_periodic_alpha_com
     periodic_variants_type_list;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_periodic_throw, Periodic_alpha_complex_3d, periodic_variants_type_list) {
-  std::cout << "Periodic alpha complex 3d exception throw" << std::endl;
+  std::clog << "Periodic alpha complex 3d exception throw" << std::endl;
   using Bare_point_3 = typename Periodic_alpha_complex_3d::Bare_point_3;
   std::vector<Bare_point_3> p_points;
 
   // Not important, this is not what we want to check
   p_points.push_back(Bare_point_3(0.0, 0.0, 0.0));
 
-  std::cout << "Check exception throw in debug mode" << std::endl;
+  std::clog << "Check exception throw in debug mode" << std::endl;
   // Check it throws an exception when the cuboid is not iso
   BOOST_CHECK_THROW(Periodic_alpha_complex_3d periodic_alpha_complex(p_points, 0., 0., 0., 0.9, 1., 1.),
                     std::invalid_argument);
@@ -71,7 +71,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_periodic) {
   // ---------------------
   // Fast periodic version
   // ---------------------
-  std::cout << "Fast periodic alpha complex 3d" << std::endl;
+  std::clog << "Fast periodic alpha complex 3d" << std::endl;
 
   using Creator = CGAL::Creator_uniform_3<double, Fast_periodic_alpha_complex_3d::Bare_point_3>;
   CGAL::Random random(7);
@@ -106,7 +106,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_periodic) {
   // ----------------------
   // Exact periodic version
   // ----------------------
-  std::cout << "Exact periodic alpha complex 3d" << std::endl;
+  std::clog << "Exact periodic alpha complex 3d" << std::endl;
 
   std::vector<Exact_periodic_alpha_complex_3d::Bare_point_3> e_p_points;
 
@@ -122,13 +122,13 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_periodic) {
   // ---------------------
   // Compare both versions
   // ---------------------
-  std::cout << "Exact periodic alpha complex 3d is of dimension " << exact_stree.dimension() << " - Non exact is "
+  std::clog << "Exact periodic alpha complex 3d is of dimension " << exact_stree.dimension() << " - Non exact is "
             << stree.dimension() << std::endl;
   BOOST_CHECK(exact_stree.dimension() == stree.dimension());
-  std::cout << "Exact periodic alpha complex 3d num_simplices " << exact_stree.num_simplices() << " - Non exact is "
+  std::clog << "Exact periodic alpha complex 3d num_simplices " << exact_stree.num_simplices() << " - Non exact is "
             << stree.num_simplices() << std::endl;
   BOOST_CHECK(exact_stree.num_simplices() == stree.num_simplices());
-  std::cout << "Exact periodic alpha complex 3d num_vertices " << exact_stree.num_vertices() << " - Non exact is "
+  std::clog << "Exact periodic alpha complex 3d num_vertices " << exact_stree.num_vertices() << " - Non exact is "
             << stree.num_vertices() << std::endl;
   BOOST_CHECK(exact_stree.num_vertices() == stree.num_vertices());
 
@@ -155,7 +155,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_periodic) {
   // ----------------------
   // Safe periodic version
   // ----------------------
-  std::cout << "Safe periodic alpha complex 3d" << std::endl;
+  std::clog << "Safe periodic alpha complex 3d" << std::endl;
 
   std::vector<Safe_periodic_alpha_complex_3d::Bare_point_3> s_p_points;
 
diff --git a/src/Alpha_complex/test/Weighted_alpha_complex_3d_unit_test.cpp b/src/Alpha_complex/test/Weighted_alpha_complex_3d_unit_test.cpp
index 8035f6e8..6b31bea6 100644
--- a/src/Alpha_complex/test/Weighted_alpha_complex_3d_unit_test.cpp
+++ b/src/Alpha_complex/test/Weighted_alpha_complex_3d_unit_test.cpp
@@ -55,13 +55,13 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted_throw, Weighted_alpha_compl
   // weights size is different from w_points size to make weighted Alpha_complex_3d throw in debug mode
   std::vector<double> weights = {0.01, 0.005, 0.006, 0.01, 0.009, 0.001};
 
-  std::cout << "Check exception throw in debug mode" << std::endl;
+  std::clog << "Check exception throw in debug mode" << std::endl;
   BOOST_CHECK_THROW(Weighted_alpha_complex_3d wac(w_points, weights), std::invalid_argument);
 }
 #endif
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted, Weighted_alpha_complex_3d, weighted_variants_type_list) {
-  std::cout << "Weighted alpha complex 3d from points and weights" << std::endl;
+  std::clog << "Weighted alpha complex 3d from points and weights" << std::endl;
   using Bare_point_3 = typename Weighted_alpha_complex_3d::Bare_point_3;
   std::vector<Bare_point_3> w_points;
   w_points.push_back(Bare_point_3(0.0, 0.0, 0.0));
@@ -78,7 +78,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted, Weighted_alpha_complex_3d,
   Gudhi::Simplex_tree<> stree;
   alpha_complex_p_a_w.create_complex(stree);
 
-  std::cout << "Weighted alpha complex 3d from weighted points" << std::endl;
+  std::clog << "Weighted alpha complex 3d from weighted points" << std::endl;
   using Weighted_point_3 = typename Weighted_alpha_complex_3d::Weighted_point_3;
 
   std::vector<Weighted_point_3> weighted_points;
@@ -112,13 +112,13 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted, Weighted_alpha_complex_3d,
   // ---------------------
   // Compare both versions
   // ---------------------
-  std::cout << "Weighted alpha complex 3d is of dimension " << stree_bis.dimension() << " - versus "
+  std::clog << "Weighted alpha complex 3d is of dimension " << stree_bis.dimension() << " - versus "
             << stree.dimension() << std::endl;
   BOOST_CHECK(stree_bis.dimension() == stree.dimension());
-  std::cout << "Weighted alpha complex 3d num_simplices " << stree_bis.num_simplices() << " - versus "
+  std::clog << "Weighted alpha complex 3d num_simplices " << stree_bis.num_simplices() << " - versus "
             << stree.num_simplices() << std::endl;
   BOOST_CHECK(stree_bis.num_simplices() == stree.num_simplices());
-  std::cout << "Weighted alpha complex 3d num_vertices " << stree_bis.num_vertices() << " - versus "
+  std::clog << "Weighted alpha complex 3d num_vertices " << stree_bis.num_vertices() << " - versus "
             << stree.num_vertices() << std::endl;
   BOOST_CHECK(stree_bis.num_vertices() == stree.num_vertices());
 
@@ -127,18 +127,18 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted, Weighted_alpha_complex_3d,
     std::vector<int> simplex;
     std::vector<int> exact_simplex;
 #ifdef DEBUG_TRACES
-    std::cout << " ( ";
+    std::clog << " ( ";
 #endif
     for (auto vertex : stree.simplex_vertex_range(*sh)) {
       simplex.push_back(vertex);
 #ifdef DEBUG_TRACES
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
 #endif
     }
 #ifdef DEBUG_TRACES
-    std::cout << ") -> "
+    std::clog << ") -> "
               << "[" << stree.filtration(*sh) << "] ";
-    std::cout << std::endl;
+    std::clog << std::endl;
 #endif
 
     // Find it in the exact structure
diff --git a/src/Alpha_complex/test/Weighted_periodic_alpha_complex_3d_unit_test.cpp b/src/Alpha_complex/test/Weighted_periodic_alpha_complex_3d_unit_test.cpp
index b09e92d5..610b9f3d 100644
--- a/src/Alpha_complex/test/Weighted_periodic_alpha_complex_3d_unit_test.cpp
+++ b/src/Alpha_complex/test/Weighted_periodic_alpha_complex_3d_unit_test.cpp
@@ -45,7 +45,7 @@ typedef boost::mpl::list<Fast_weighted_periodic_alpha_complex_3d, Exact_weighted
 #ifdef GUDHI_DEBUG
 BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted_periodic_throw, Weighted_periodic_alpha_complex_3d,
                               wp_variants_type_list) {
-  std::cout << "Weighted periodic alpha complex 3d exception throw" << std::endl;
+  std::clog << "Weighted periodic alpha complex 3d exception throw" << std::endl;
 
   using Creator = CGAL::Creator_uniform_3<double, typename Weighted_periodic_alpha_complex_3d::Bare_point_3>;
   CGAL::Random random(7);
@@ -62,7 +62,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted_periodic_throw, Weighted_pe
     p_weights.push_back(random.get_double(0., 0.01));
   }
 
-  std::cout << "Cuboid is not iso exception" << std::endl;
+  std::clog << "Cuboid is not iso exception" << std::endl;
   // Check it throws an exception when the cuboid is not iso
   BOOST_CHECK_THROW(
       Weighted_periodic_alpha_complex_3d wp_alpha_complex(wp_points, p_weights, -1., -1., -1., 0.9, 1., 1.),
@@ -83,7 +83,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted_periodic_throw, Weighted_pe
       Weighted_periodic_alpha_complex_3d wp_alpha_complex(wp_points, p_weights, -1., -1., -1., 1., 1., 1.1),
       std::invalid_argument);
 
-  std::cout << "0 <= point.weight() < 1/64 * domain_size * domain_size exception" << std::endl;
+  std::clog << "0 <= point.weight() < 1/64 * domain_size * domain_size exception" << std::endl;
   // Weights must be in range ]0, 1/64 = 0.015625[
   double temp = p_weights[25];
   p_weights[25] = 1.0;
@@ -97,7 +97,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_weighted_periodic_throw, Weighted_pe
                     std::invalid_argument);
   p_weights[14] = temp;
 
-  std::cout << "wp_points and p_weights size exception" << std::endl;
+  std::clog << "wp_points and p_weights size exception" << std::endl;
   // Weights and points must have the same size
   // + 1
   p_weights.push_back(1e-10);
@@ -115,7 +115,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_weighted_periodic) {
   // ---------------------
   // Fast weighted periodic version
   // ---------------------
-  std::cout << "Fast weighted periodic alpha complex 3d" << std::endl;
+  std::clog << "Fast weighted periodic alpha complex 3d" << std::endl;
 
   using Creator = CGAL::Creator_uniform_3<double, Fast_weighted_periodic_alpha_complex_3d::Bare_point_3>;
   CGAL::Random random(7);
@@ -140,7 +140,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_weighted_periodic) {
   // ----------------------
   // Exact weighted periodic version
   // ----------------------
-  std::cout << "Exact weighted periodic alpha complex 3d" << std::endl;
+  std::clog << "Exact weighted periodic alpha complex 3d" << std::endl;
 
   std::vector<Exact_weighted_periodic_alpha_complex_3d::Bare_point_3> e_p_points;
 
@@ -156,13 +156,13 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_weighted_periodic) {
   // ---------------------
   // Compare both versions
   // ---------------------
-  std::cout << "Exact weighted periodic alpha complex 3d is of dimension " << exact_stree.dimension()
+  std::clog << "Exact weighted periodic alpha complex 3d is of dimension " << exact_stree.dimension()
             << " - Non exact is " << stree.dimension() << std::endl;
   BOOST_CHECK(exact_stree.dimension() == stree.dimension());
-  std::cout << "Exact weighted periodic alpha complex 3d num_simplices " << exact_stree.num_simplices()
+  std::clog << "Exact weighted periodic alpha complex 3d num_simplices " << exact_stree.num_simplices()
             << " - Non exact is " << stree.num_simplices() << std::endl;
   BOOST_CHECK(exact_stree.num_simplices() == stree.num_simplices());
-  std::cout << "Exact weighted periodic alpha complex 3d num_vertices " << exact_stree.num_vertices()
+  std::clog << "Exact weighted periodic alpha complex 3d num_vertices " << exact_stree.num_vertices()
             << " - Non exact is " << stree.num_vertices() << std::endl;
   BOOST_CHECK(exact_stree.num_vertices() == stree.num_vertices());
 
@@ -189,7 +189,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_weighted_periodic) {
   // ----------------------
   // Safe weighted periodic version
   // ----------------------
-  std::cout << "Safe weighted periodic alpha complex 3d" << std::endl;
+  std::clog << "Safe weighted periodic alpha complex 3d" << std::endl;
 
   std::vector<Safe_weighted_periodic_alpha_complex_3d::Bare_point_3> s_p_points;