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

7 files changed, 160 insertions, 161 deletions

diff --git a/src/Simplex_tree/example/CMakeLists.txt b/src/Simplex_tree/example/CMakeLists.txt
index 8a8cac58..a0aabee2 100644
--- a/src/Simplex_tree/example/CMakeLists.txt
+++ b/src/Simplex_tree/example/CMakeLists.txt
@@ -35,7 +35,7 @@ endif()
 
 if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
   add_executable ( Simplex_tree_example_cech_complex_cgal_mini_sphere_3d cech_complex_cgal_mini_sphere_3d.cpp )
-  target_link_libraries(Simplex_tree_example_cech_complex_cgal_mini_sphere_3d ${Boost_PROGRAM_OPTIONS_LIBRARY} ${CGAL_LIBRARY})
+  target_link_libraries(Simplex_tree_example_cech_complex_cgal_mini_sphere_3d Boost::program_options ${CGAL_LIBRARY})
   if (TBB_FOUND)
     target_link_libraries(Simplex_tree_example_cech_complex_cgal_mini_sphere_3d ${TBB_LIBRARIES})
   endif()
diff --git a/src/Simplex_tree/example/cech_complex_cgal_mini_sphere_3d.cpp b/src/Simplex_tree/example/cech_complex_cgal_mini_sphere_3d.cpp
index d716fb1f..0e7e382b 100644
--- a/src/Simplex_tree/example/cech_complex_cgal_mini_sphere_3d.cpp
+++ b/src/Simplex_tree/example/cech_complex_cgal_mini_sphere_3d.cpp
@@ -55,18 +55,18 @@ class Cech_blocker {
   bool operator()(Simplex_handle sh) {
     std::vector<Point> points;
 #if DEBUG_TRACES
-    std::cout << "Cech_blocker on [";
+    std::clog << "Cech_blocker on [";
 #endif  // DEBUG_TRACES
     for (auto vertex : simplex_tree_.simplex_vertex_range(sh)) {
       points.push_back(point_cloud_[vertex]);
 #if DEBUG_TRACES
-      std::cout << vertex << ", ";
+      std::clog << vertex << ", ";
 #endif  // DEBUG_TRACES
     }
     Min_sphere ms(points.begin(), points.end());
     Filtration_value radius = ms.radius();
 #if DEBUG_TRACES
-    std::cout << "] - radius = " << radius << " - returns " << (radius > threshold_) << std::endl;
+    std::clog << "] - radius = " << radius << " - returns " << (radius > threshold_) << std::endl;
 #endif  // DEBUG_TRACES
     simplex_tree_.assign_filtration(sh, radius);
     return (radius > threshold_);
@@ -106,24 +106,24 @@ int main(int argc, char* argv[]) {
   // expand the graph until dimension dim_max
   st.expansion_with_blockers(dim_max, Cech_blocker(st, threshold, off_reader.get_point_cloud()));
 
-  std::cout << "The complex contains " << st.num_simplices() << " simplices \n";
-  std::cout << "   and has dimension " << st.dimension() << " \n";
+  std::clog << "The complex contains " << st.num_simplices() << " simplices \n";
+  std::clog << "   and has dimension " << st.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
   st.initialize_filtration();
 
 #if DEBUG_TRACES
-  std::cout << "********************************************************************\n";
+  std::clog << "********************************************************************\n";
   // Display the Simplex_tree - Can not be done in the middle of 2 inserts
-  std::cout << "* The complex contains " << st.num_simplices() << " simplices - dimension=" << st.dimension() << "\n";
-  std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
+  std::clog << "* The complex contains " << st.num_simplices() << " simplices - dimension=" << st.dimension() << "\n";
+  std::clog << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
   for (auto f_simplex : st.filtration_simplex_range()) {
-    std::cout << "   "
+    std::clog << "   "
               << "[" << st.filtration(f_simplex) << "] ";
     for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-      std::cout << static_cast<int>(vertex) << " ";
+      std::clog << static_cast<int>(vertex) << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 #endif  // DEBUG_TRACES
   return 0;
@@ -154,11 +154,11 @@ void program_options(int argc, char* argv[], std::string& off_file_points, Filtr
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Construct a Cech complex defined on a set of input points.\n \n";
+    std::clog << std::endl;
+    std::clog << "Construct a Cech complex defined on a set of input points.\n \n";
 
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
+    std::clog << visible << std::endl;
     exit(-1);
   }
 }
diff --git a/src/Simplex_tree/example/example_alpha_shapes_3_simplex_tree_from_off_file.cpp b/src/Simplex_tree/example/example_alpha_shapes_3_simplex_tree_from_off_file.cpp
index e455c426..8ee7ab74 100644
--- a/src/Simplex_tree/example/example_alpha_shapes_3_simplex_tree_from_off_file.cpp
+++ b/src/Simplex_tree/example/example_alpha_shapes_3_simplex_tree_from_off_file.cpp
@@ -63,7 +63,7 @@ Vertex_list from(const Cell_handle& ch) {
   Vertex_list the_list;
   for (auto i = 0; i < 4; i++) {
 #ifdef DEBUG_TRACES
-    std::cout << "from cell[" << i << "]=" << ch->vertex(i)->point() << std::endl;
+    std::clog << "from cell[" << i << "]=" << ch->vertex(i)->point() << std::endl;
 #endif  // DEBUG_TRACES
     the_list.push_back(ch->vertex(i));
   }
@@ -75,7 +75,7 @@ Vertex_list from(const Facet& fct) {
   for (auto i = 0; i < 4; i++) {
     if (fct.second != i) {
 #ifdef DEBUG_TRACES
-      std::cout << "from facet=[" << i << "]" << fct.first->vertex(i)->point() << std::endl;
+      std::clog << "from facet=[" << i << "]" << fct.first->vertex(i)->point() << std::endl;
 #endif  // DEBUG_TRACES
       the_list.push_back(fct.first->vertex(i));
     }
@@ -88,7 +88,7 @@ Vertex_list from(const Edge& edg) {
   for (auto i = 0; i < 4; i++) {
     if ((edg.second == i) || (edg.third == i)) {
 #ifdef DEBUG_TRACES
-      std::cout << "from edge[" << i << "]=" << edg.first->vertex(i)->point() << std::endl;
+      std::clog << "from edge[" << i << "]=" << edg.first->vertex(i)->point() << std::endl;
 #endif  // DEBUG_TRACES
       the_list.push_back(edg.first->vertex(i));
     }
@@ -99,7 +99,7 @@ Vertex_list from(const Edge& edg) {
 Vertex_list from(const Alpha_shape_3::Vertex_handle& vh) {
   Vertex_list the_list;
 #ifdef DEBUG_TRACES
-  std::cout << "from vertex=" << vh->point() << std::endl;
+  std::clog << "from vertex=" << vh->point() << std::endl;
 #endif  // DEBUG_TRACES
   the_list.push_back(vh);
   return the_list;
@@ -128,7 +128,7 @@ int main(int argc, char * const argv[]) {
   // alpha shape construction from points. CGAL has a strange behavior in REGULARIZED mode.
   Alpha_shape_3 as(lp.begin(), lp.end(), 0, Alpha_shape_3::GENERAL);
 #ifdef DEBUG_TRACES
-  std::cout << "Alpha shape computed in GENERAL mode" << std::endl;
+  std::clog << "Alpha shape computed in GENERAL mode" << std::endl;
 #endif  // DEBUG_TRACES
 
   // filtration with alpha values from alpha shape
@@ -140,7 +140,7 @@ int main(int argc, char * const argv[]) {
 
   as.filtration_with_alpha_values(disp);
 #ifdef DEBUG_TRACES
-  std::cout << "filtration_with_alpha_values returns : " << the_objects.size() << " objects" << std::endl;
+  std::clog << "filtration_with_alpha_values returns : " << the_objects.size() << " objects" << std::endl;
 #endif  // DEBUG_TRACES
 
   Alpha_shape_3::size_type count_vertices = 0;
@@ -177,7 +177,7 @@ int main(int argc, char * const argv[]) {
         // alpha shape not found
         Simplex_tree_vertex vertex = map_cgal_simplex_tree.size();
 #ifdef DEBUG_TRACES
-        std::cout << "vertex [" << the_alpha_shape_vertex->point() << "] not found - insert_simplex " << vertex << "\n";
+        std::clog << "vertex [" << the_alpha_shape_vertex->point() << "] not found - insert_simplex " << vertex << "\n";
 #endif  // DEBUG_TRACES
         the_simplex_tree.push_back(vertex);
         map_cgal_simplex_tree.insert(Alpha_shape_simplex_tree_pair(the_alpha_shape_vertex, vertex));
@@ -185,14 +185,14 @@ int main(int argc, char * const argv[]) {
         // alpha shape found
         Simplex_tree_vertex vertex = the_map_iterator->second;
 #ifdef DEBUG_TRACES
-        std::cout << "vertex [" << the_alpha_shape_vertex->point() << "] found in " << vertex << std::endl;
+        std::clog << "vertex [" << the_alpha_shape_vertex->point() << "] found in " << vertex << std::endl;
 #endif  // DEBUG_TRACES
         the_simplex_tree.push_back(vertex);
       }
     }
     // Construction of the simplex_tree
 #ifdef DEBUG_TRACES
-    std::cout << "filtration = " << *the_alpha_value_iterator << std::endl;
+    std::clog << "filtration = " << *the_alpha_value_iterator << std::endl;
 #endif  // DEBUG_TRACES
     simplex_tree.insert_simplex(the_simplex_tree, std::sqrt(*the_alpha_value_iterator));
     if (the_alpha_value_iterator != the_alpha_values.end())
@@ -201,61 +201,61 @@ int main(int argc, char * const argv[]) {
       std::cerr << "This shall not happen" << std::endl;
   }
 #ifdef DEBUG_TRACES
-  std::cout << "vertices \t\t" << count_vertices << std::endl;
-  std::cout << "edges \t\t" << count_edges << std::endl;
-  std::cout << "facets \t\t" << count_facets << std::endl;
-  std::cout << "cells \t\t" << count_cells << std::endl;
+  std::clog << "vertices \t\t" << count_vertices << std::endl;
+  std::clog << "edges \t\t" << count_edges << std::endl;
+  std::clog << "facets \t\t" << count_facets << std::endl;
+  std::clog << "cells \t\t" << count_cells << std::endl;
 
 
-  std::cout << "Information of the Simplex Tree:\n";
-  std::cout << "  Number of vertices = " << simplex_tree.num_vertices() << " ";
-  std::cout << "  Number of simplices = " << simplex_tree.num_simplices() << std::endl << std::endl;
+  std::clog << "Information of the Simplex Tree:\n";
+  std::clog << "  Number of vertices = " << simplex_tree.num_vertices() << " ";
+  std::clog << "  Number of simplices = " << simplex_tree.num_simplices() << std::endl << std::endl;
 #endif  // DEBUG_TRACES
 
 #ifdef DEBUG_TRACES
-  std::cout << "Iterator on vertices: \n";
+  std::clog << "Iterator on vertices: \n";
   for (auto vertex : simplex_tree.complex_vertex_range()) {
-    std::cout << vertex << " ";
+    std::clog << vertex << " ";
   }
 #endif  // DEBUG_TRACES
 
-  std::cout << simplex_tree << std::endl;
+  std::clog << simplex_tree << std::endl;
 
 #ifdef DEBUG_TRACES
-  std::cout << std::endl << std::endl << "Iterator on simplices:\n";
+  std::clog << std::endl << std::endl << "Iterator on simplices:\n";
   for (auto simplex : simplex_tree.complex_simplex_range()) {
-    std::cout << "   ";
+    std::clog << "   ";
     for (auto vertex : simplex_tree.simplex_vertex_range(simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 #endif  // DEBUG_TRACES
 #ifdef DEBUG_TRACES
-  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:\n";
+  std::clog << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:\n";
   for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
-    std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    std::clog << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
     for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 #endif  // DEBUG_TRACES
 #ifdef DEBUG_TRACES
-  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, and their boundary simplices:\n";
+  std::clog << std::endl << std::endl << "Iterator on Simplices in the filtration, and their boundary simplices:\n";
   for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
-    std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    std::clog << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
     for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
 
     for (auto b_simplex : simplex_tree.boundary_simplex_range(f_simplex)) {
-      std::cout << "      " << "[" << simplex_tree.filtration(b_simplex) << "] ";
+      std::clog << "      " << "[" << simplex_tree.filtration(b_simplex) << "] ";
       for (auto vertex : simplex_tree.simplex_vertex_range(b_simplex)) {
-        std::cout << vertex << " ";
+        std::clog << vertex << " ";
       }
-      std::cout << std::endl;
+      std::clog << std::endl;
     }
   }
 #endif  // DEBUG_TRACES
diff --git a/src/Simplex_tree/example/graph_expansion_with_blocker.cpp b/src/Simplex_tree/example/graph_expansion_with_blocker.cpp
index 494f8b1d..df52bf43 100644
--- a/src/Simplex_tree/example/graph_expansion_with_blocker.cpp
+++ b/src/Simplex_tree/example/graph_expansion_with_blocker.cpp
@@ -34,31 +34,31 @@ int main(int argc, char* const argv[]) {
 
   stree.expansion_with_blockers(3, [&](Simplex_handle sh) {
     bool result = false;
-    std::cout << "Blocker on [";
+    std::clog << "Blocker on [";
     // User can loop on the vertices from the given simplex_handle i.e.
     for (auto vertex : stree.simplex_vertex_range(sh)) {
       // We block the expansion, if the vertex '6' is in the given list of vertices
       if (vertex == 6) result = true;
-      std::cout << vertex << ", ";
+      std::clog << vertex << ", ";
     }
-    std::cout << "] ( " << stree.filtration(sh);
+    std::clog << "] ( " << stree.filtration(sh);
     // User can re-assign a new filtration value directly in the blocker (default is the maximal value of boudaries)
     stree.assign_filtration(sh, stree.filtration(sh) + 1.);
 
-    std::cout << " + 1. ) = " << result << std::endl;
+    std::clog << " + 1. ) = " << result << std::endl;
 
     return result;
   });
 
-  std::cout << "********************************************************************\n";
-  std::cout << "* The complex contains " << stree.num_simplices() << " simplices";
-  std::cout << "   - dimension " << stree.dimension() << "\n";
-  std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "* The complex contains " << stree.num_simplices() << " simplices";
+  std::clog << "   - dimension " << stree.dimension() << "\n";
+  std::clog << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
   for (auto f_simplex : stree.filtration_simplex_range()) {
-    std::cout << "   "
+    std::clog << "   "
               << "[" << stree.filtration(f_simplex) << "] ";
-    for (auto vertex : stree.simplex_vertex_range(f_simplex)) std::cout << "(" << vertex << ")";
-    std::cout << std::endl;
+    for (auto vertex : stree.simplex_vertex_range(f_simplex)) std::clog << "(" << vertex << ")";
+    std::clog << std::endl;
   }
 
   return 0;
diff --git a/src/Simplex_tree/example/mini_simplex_tree.cpp b/src/Simplex_tree/example/mini_simplex_tree.cpp
index bbc582c7..4043bffd 100644
--- a/src/Simplex_tree/example/mini_simplex_tree.cpp
+++ b/src/Simplex_tree/example/mini_simplex_tree.cpp
@@ -48,7 +48,7 @@ int main() {
   for (ST::Simplex_handle t : st.cofaces_simplex_range(e, 1)) {
     // Only coface is 012
     for (ST::Vertex_handle v : st.simplex_vertex_range(t))  // v in { 0, 1, 2 }
-        std::cout << v;
-      std::cout << '\n';
+        std::clog << v;
+      std::clog << '\n';
   }
 }
diff --git a/src/Simplex_tree/example/simple_simplex_tree.cpp b/src/Simplex_tree/example/simple_simplex_tree.cpp
index 4353939f..e8bec596 100644
--- a/src/Simplex_tree/example/simple_simplex_tree.cpp
+++ b/src/Simplex_tree/example/simple_simplex_tree.cpp
@@ -28,8 +28,8 @@ int main(int argc, char* const argv[]) {
   const Filtration_value FOURTH_FILTRATION_VALUE = 0.4;
 
   // TEST OF INSERTION
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "EXAMPLE OF SIMPLE INSERTION" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "EXAMPLE OF SIMPLE INSERTION" << std::endl;
   // Construct the Simplex Tree
   Simplex_tree simplexTree;
 
@@ -41,140 +41,139 @@ int main(int argc, char* const argv[]) {
   /*  2   0   3               */
 
   // ++ FIRST
-  std::cout << "   * INSERT 0" << std::endl;
+  std::clog << "   * INSERT 0" << std::endl;
   typeVectorVertex firstSimplexVector = {0};
   typePairSimplexBool returnValue =
       simplexTree.insert_simplex(firstSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + 0 INSERTED" << std::endl;
+    std::clog << "   + 0 INSERTED" << std::endl;
   } else {
-    std::cout << "   - 0 NOT INSERTED" << std::endl;
+    std::clog << "   - 0 NOT INSERTED" << std::endl;
   }
 
   // ++ SECOND
-  std::cout << "   * INSERT 1" << std::endl;
+  std::clog << "   * INSERT 1" << std::endl;
   typeVectorVertex secondSimplexVector = {1};
   returnValue = simplexTree.insert_simplex(secondSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + 1 INSERTED" << std::endl;
+    std::clog << "   + 1 INSERTED" << std::endl;
   } else {
-    std::cout << "   - 1 NOT INSERTED" << std::endl;
+    std::clog << "   - 1 NOT INSERTED" << std::endl;
   }
 
   // ++ THIRD
-  std::cout << "   * INSERT (0,1)" << std::endl;
+  std::clog << "   * INSERT (0,1)" << std::endl;
   typeVectorVertex thirdSimplexVector = {0, 1};
   returnValue = simplexTree.insert_simplex(thirdSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + (0,1) INSERTED" << std::endl;
+    std::clog << "   + (0,1) INSERTED" << std::endl;
   } else {
-    std::cout << "   - (0,1) NOT INSERTED" << std::endl;
+    std::clog << "   - (0,1) NOT INSERTED" << std::endl;
   }
 
   // ++ FOURTH
-  std::cout << "   * INSERT 2" << std::endl;
+  std::clog << "   * INSERT 2" << std::endl;
   typeVectorVertex fourthSimplexVector = {2};
   returnValue = simplexTree.insert_simplex(fourthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + 2 INSERTED" << std::endl;
+    std::clog << "   + 2 INSERTED" << std::endl;
   } else {
-    std::cout << "   - 2 NOT INSERTED" << std::endl;
+    std::clog << "   - 2 NOT INSERTED" << std::endl;
   }
 
   // ++ FIFTH
-  std::cout << "   * INSERT (2,0)" << std::endl;
+  std::clog << "   * INSERT (2,0)" << std::endl;
   typeVectorVertex fifthSimplexVector = {2, 0};
   returnValue = simplexTree.insert_simplex(fifthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + (2,0) INSERTED" << std::endl;
+    std::clog << "   + (2,0) INSERTED" << std::endl;
   } else {
-    std::cout << "   - (2,0) NOT INSERTED" << std::endl;
+    std::clog << "   - (2,0) NOT INSERTED" << std::endl;
   }
 
   // ++ SIXTH
-  std::cout << "   * INSERT (2,1)" << std::endl;
+  std::clog << "   * INSERT (2,1)" << std::endl;
   typeVectorVertex sixthSimplexVector = {2, 1};
   returnValue = simplexTree.insert_simplex(sixthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + (2,1) INSERTED" << std::endl;
+    std::clog << "   + (2,1) INSERTED" << std::endl;
   } else {
-    std::cout << "   - (2,1) NOT INSERTED" << std::endl;
+    std::clog << "   - (2,1) NOT INSERTED" << std::endl;
   }
 
   // ++ SEVENTH
-  std::cout << "   * INSERT (2,1,0)" << std::endl;
+  std::clog << "   * INSERT (2,1,0)" << std::endl;
   typeVectorVertex seventhSimplexVector = {2, 1, 0};
   returnValue = simplexTree.insert_simplex(seventhSimplexVector, Filtration_value(THIRD_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + (2,1,0) INSERTED" << std::endl;
+    std::clog << "   + (2,1,0) INSERTED" << std::endl;
   } else {
-    std::cout << "   - (2,1,0) NOT INSERTED" << std::endl;
+    std::clog << "   - (2,1,0) NOT INSERTED" << std::endl;
   }
 
   // ++ EIGHTH
-  std::cout << "   * INSERT 3" << std::endl;
+  std::clog << "   * INSERT 3" << std::endl;
   typeVectorVertex eighthSimplexVector = {3};
   returnValue = simplexTree.insert_simplex(eighthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + 3 INSERTED" << std::endl;
+    std::clog << "   + 3 INSERTED" << std::endl;
   } else {
-    std::cout << "   - 3 NOT INSERTED" << std::endl;
+    std::clog << "   - 3 NOT INSERTED" << std::endl;
   }
 
   // ++ NINETH
-  std::cout << "   * INSERT (3,0)" << std::endl;
+  std::clog << "   * INSERT (3,0)" << std::endl;
   typeVectorVertex ninethSimplexVector = {3, 0};
   returnValue = simplexTree.insert_simplex(ninethSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + (3,0) INSERTED" << std::endl;
+    std::clog << "   + (3,0) INSERTED" << std::endl;
   } else {
-    std::cout << "   - (3,0) NOT INSERTED" << std::endl;
+    std::clog << "   - (3,0) NOT INSERTED" << std::endl;
   }
 
   // ++ TENTH
-  std::cout << "   * INSERT 0 (already inserted)" << std::endl;
+  std::clog << "   * INSERT 0 (already inserted)" << std::endl;
   typeVectorVertex tenthSimplexVector = {0};
   // With a different filtration value
   returnValue = simplexTree.insert_simplex(tenthSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + 0 INSERTED" << std::endl;
+    std::clog << "   + 0 INSERTED" << std::endl;
   } else {
-    std::cout << "   - 0 NOT INSERTED" << std::endl;
+    std::clog << "   - 0 NOT INSERTED" << std::endl;
   }
 
   // ++ ELEVENTH
-  std::cout << "   * INSERT (2,1,0) (already inserted)" << std::endl;
+  std::clog << "   * INSERT (2,1,0) (already inserted)" << std::endl;
   typeVectorVertex eleventhSimplexVector = {2, 1, 0};
   returnValue = simplexTree.insert_simplex(eleventhSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
-    std::cout << "   + (2,1,0) INSERTED" << std::endl;
+    std::clog << "   + (2,1,0) INSERTED" << std::endl;
   } else {
-    std::cout << "   - (2,1,0) NOT INSERTED" << std::endl;
+    std::clog << "   - (2,1,0) NOT INSERTED" << std::endl;
   }
 
   // ++ GENERAL VARIABLE SET
 
-  std::cout << "********************************************************************\n";
-  // Display the Simplex_tree - Can not be done in the middle of 2 inserts
-  std::cout << "* The complex contains " << simplexTree.num_simplices() << " simplices\n";
-  std::cout << "   - dimension " << simplexTree.dimension() << "\n";
-  std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "* The complex contains " << simplexTree.num_simplices() << " simplices\n";
+  std::clog << "   - dimension " << simplexTree.dimension() << "\n";
+  std::clog << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
   for (auto f_simplex : simplexTree.filtration_simplex_range()) {
-    std::cout << "   "
+    std::clog << "   "
               << "[" << simplexTree.filtration(f_simplex) << "] ";
-    for (auto vertex : simplexTree.simplex_vertex_range(f_simplex)) std::cout << "(" << vertex << ")";
-    std::cout << std::endl;
+    for (auto vertex : simplexTree.simplex_vertex_range(f_simplex)) std::clog << "(" << vertex << ")";
+    std::clog << std::endl;
   }
   //   [0.1] 0
   //   [0.1] 1
@@ -190,66 +189,66 @@ int main(int argc, char* const argv[]) {
   // Find in the simplex_tree
   // ------------------------------------------------------------------------------------------------------------------
   Simplex_tree::Simplex_handle simplexFound = simplexTree.find(secondSimplexVector);
-  std::cout << "**************IS THE SIMPLEX {1} IN THE SIMPLEX TREE ?\n";
+  std::clog << "**************IS THE SIMPLEX {1} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
-    std::cout << "***+ YES IT IS!\n";
+    std::clog << "***+ YES IT IS!\n";
   else
-    std::cout << "***- NO IT ISN'T\n";
+    std::clog << "***- NO IT ISN'T\n";
 
   typeVectorVertex unknownSimplexVector = {15};
   simplexFound = simplexTree.find(unknownSimplexVector);
-  std::cout << "**************IS THE SIMPLEX {15} IN THE SIMPLEX TREE ?\n";
+  std::clog << "**************IS THE SIMPLEX {15} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
-    std::cout << "***+ YES IT IS!\n";
+    std::clog << "***+ YES IT IS!\n";
   else
-    std::cout << "***- NO IT ISN'T\n";
+    std::clog << "***- NO IT ISN'T\n";
 
   simplexFound = simplexTree.find(fifthSimplexVector);
-  std::cout << "**************IS THE SIMPLEX {2,0} IN THE SIMPLEX TREE ?\n";
+  std::clog << "**************IS THE SIMPLEX {2,0} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
-    std::cout << "***+ YES IT IS!\n";
+    std::clog << "***+ YES IT IS!\n";
   else
-    std::cout << "***- NO IT ISN'T\n";
+    std::clog << "***- NO IT ISN'T\n";
 
   typeVectorVertex otherSimplexVector = {1, 15};
   simplexFound = simplexTree.find(otherSimplexVector);
-  std::cout << "**************IS THE SIMPLEX {15,1} IN THE SIMPLEX TREE ?\n";
+  std::clog << "**************IS THE SIMPLEX {15,1} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
-    std::cout << "***+ YES IT IS!\n";
+    std::clog << "***+ YES IT IS!\n";
   else
-    std::cout << "***- NO IT ISN'T\n";
+    std::clog << "***- NO IT ISN'T\n";
 
   typeVectorVertex invSimplexVector = {1, 2, 0};
   simplexFound = simplexTree.find(invSimplexVector);
-  std::cout << "**************IS THE SIMPLEX {1,2,0} IN THE SIMPLEX TREE ?\n";
+  std::clog << "**************IS THE SIMPLEX {1,2,0} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
-    std::cout << "***+ YES IT IS!\n";
+    std::clog << "***+ YES IT IS!\n";
   else
-    std::cout << "***- NO IT ISN'T\n";
+    std::clog << "***- NO IT ISN'T\n";
 
   simplexFound = simplexTree.find({0, 1});
-  std::cout << "**************IS THE SIMPLEX {0,1} IN THE SIMPLEX TREE ?\n";
+  std::clog << "**************IS THE SIMPLEX {0,1} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
-    std::cout << "***+ YES IT IS!\n";
+    std::clog << "***+ YES IT IS!\n";
   else
-    std::cout << "***- NO IT ISN'T\n";
+    std::clog << "***- NO IT ISN'T\n";
 
-  std::cout << "**************COFACES OF {0,1} IN CODIMENSION 1 ARE\n";
+  std::clog << "**************COFACES OF {0,1} IN CODIMENSION 1 ARE\n";
   for (auto& simplex : simplexTree.cofaces_simplex_range(simplexTree.find({0, 1}), 1)) {
-    for (auto vertex : simplexTree.simplex_vertex_range(simplex)) std::cout << "(" << vertex << ")";
-    std::cout << std::endl;
+    for (auto vertex : simplexTree.simplex_vertex_range(simplex)) std::clog << "(" << vertex << ")";
+    std::clog << std::endl;
   }
 
-  std::cout << "**************STARS OF {0,1} ARE\n";
+  std::clog << "**************STARS OF {0,1} ARE\n";
   for (auto& simplex : simplexTree.star_simplex_range(simplexTree.find({0, 1}))) {
-    for (auto vertex : simplexTree.simplex_vertex_range(simplex)) std::cout << "(" << vertex << ")";
-    std::cout << std::endl;
+    for (auto vertex : simplexTree.simplex_vertex_range(simplex)) std::clog << "(" << vertex << ")";
+    std::clog << std::endl;
   }
 
-  std::cout << "**************BOUNDARIES OF {0,1,2} ARE\n";
+  std::clog << "**************BOUNDARIES OF {0,1,2} ARE\n";
   for (auto& simplex : simplexTree.boundary_simplex_range(simplexTree.find({0, 1, 2}))) {
-    for (auto vertex : simplexTree.simplex_vertex_range(simplex)) std::cout << "(" << vertex << ")";
-    std::cout << std::endl;
+    for (auto vertex : simplexTree.simplex_vertex_range(simplex)) std::clog << "(" << vertex << ")";
+    std::clog << std::endl;
   }
 
   return 0;
diff --git a/src/Simplex_tree/example/simplex_tree_from_cliques_of_graph.cpp b/src/Simplex_tree/example/simplex_tree_from_cliques_of_graph.cpp
index f6dfa53c..6278efa7 100644
--- a/src/Simplex_tree/example/simplex_tree_from_cliques_of_graph.cpp
+++ b/src/Simplex_tree/example/simplex_tree_from_cliques_of_graph.cpp
@@ -42,67 +42,67 @@ int main(int argc, char * const argv[]) {
   // insert the graph in the simplex tree as 1-skeleton
   st.insert_graph(g);
   end = clock();
-  std::cout << "Insert the 1-skeleton in the simplex tree in "
+  std::clog << "Insert the 1-skeleton in the simplex tree in "
       << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
 
   start = clock();
   // expand the 1-skeleton until dimension max_dim
   st.expansion(max_dim);
   end = clock();
-  std::cout << "max_dim = " << max_dim << "\n";
-  std::cout << "Expand the simplex tree in "
+  std::clog << "max_dim = " << max_dim << "\n";
+  std::clog << "Expand the simplex tree in "
       << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
 
-  std::cout << "Information of the Simplex Tree: " << std::endl;
-  std::cout << "  Number of vertices = " << st.num_vertices() << " ";
-  std::cout << "  Number of simplices = " << st.num_simplices() << std::endl;
-  std::cout << std::endl << std::endl;
+  std::clog << "Information of the Simplex Tree: " << std::endl;
+  std::clog << "  Number of vertices = " << st.num_vertices() << " ";
+  std::clog << "  Number of simplices = " << st.num_simplices() << std::endl;
+  std::clog << std::endl << std::endl;
 
-  std::cout << "Iterator on vertices: ";
+  std::clog << "Iterator on vertices: ";
   for (auto vertex : st.complex_vertex_range()) {
-    std::cout << vertex << " ";
+    std::clog << vertex << " ";
   }
 
-  std::cout << std::endl;
+  std::clog << std::endl;
 
-  std::cout << std::endl << std::endl;
+  std::clog << std::endl << std::endl;
 
-  std::cout << "Iterator on simplices: " << std::endl;
+  std::clog << "Iterator on simplices: " << std::endl;
   for (auto simplex : st.complex_simplex_range()) {
-    std::cout << "   ";
+    std::clog << "   ";
     for (auto vertex : st.simplex_vertex_range(simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
-  std::cout << std::endl << std::endl;
+  std::clog << std::endl << std::endl;
 
-  std::cout << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+  std::clog << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
   for (auto f_simplex : st.filtration_simplex_range()) {
-    std::cout << "   " << "[" << st.filtration(f_simplex) << "] ";
+    std::clog << "   " << "[" << st.filtration(f_simplex) << "] ";
     for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
-  std::cout << std::endl << std::endl;
+  std::clog << std::endl << std::endl;
 
-  std::cout << "Iterator on Simplices in the filtration, and their boundary simplices:" << std::endl;
+  std::clog << "Iterator on Simplices in the filtration, and their boundary simplices:" << std::endl;
   for (auto f_simplex : st.filtration_simplex_range()) {
-    std::cout << "   " << "[" << st.filtration(f_simplex) << "] ";
+    std::clog << "   " << "[" << st.filtration(f_simplex) << "] ";
     for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
 
     for (auto b_simplex : st.boundary_simplex_range(f_simplex)) {
-      std::cout << "      " << "[" << st.filtration(b_simplex) << "] ";
+      std::clog << "      " << "[" << st.filtration(b_simplex) << "] ";
       for (auto vertex : st.simplex_vertex_range(b_simplex)) {
-        std::cout << vertex << " ";
+        std::clog << vertex << " ";
       }
-      std::cout << std::endl;
+      std::clog << std::endl;
     }
   }
   return 0;