Merge master and resolve conflicts

217 files changed, 3034 insertions, 2445 deletions

diff --git a/src/Alpha_complex/benchmark/Alpha_complex_3d_benchmark.cpp b/src/Alpha_complex/benchmark/Alpha_complex_3d_benchmark.cpp
index 99ad94b9..e7d85686 100644
--- a/src/Alpha_complex/benchmark/Alpha_complex_3d_benchmark.cpp
+++ b/src/Alpha_complex/benchmark/Alpha_complex_3d_benchmark.cpp
@@ -19,7 +19,7 @@ std::ofstream results_csv("results.csv");
 
 template <typename Kernel>
 void benchmark_points_on_torus_dD(const std::string& msg) {
-  std::cout << "+ " << msg << std::endl;
+  std::clog << "+ " << msg << std::endl;
 
   results_csv << "\"" << msg << "\";" << std::endl;
   results_csv << "\"nb_points\";"
@@ -29,7 +29,7 @@ void benchmark_points_on_torus_dD(const std::string& msg) {
 
   using K = CGAL::Epick_d<CGAL::Dimension_tag<3>>;
   for (int nb_points = 1000; nb_points <= 125000; nb_points *= 5) {
-    std::cout << "  Alpha complex dD on torus with " << nb_points << " points." << std::endl;
+    std::clog << "  Alpha complex dD on torus with " << nb_points << " points." << std::endl;
     std::vector<K::Point_d> points_on_torus = Gudhi::generate_points_on_torus_3D<K>(nb_points, 1.0, 0.5);
     std::vector<typename Kernel::Point_d> points;
 
@@ -41,26 +41,26 @@ void benchmark_points_on_torus_dD(const std::string& msg) {
     ac_create_clock.begin();
     Gudhi::alpha_complex::Alpha_complex<Kernel> alpha_complex_from_points(points);
     ac_create_clock.end();
-    std::cout << ac_create_clock;
+    std::clog << ac_create_clock;
 
     Gudhi::Simplex_tree<> complex;
     Gudhi::Clock st_create_clock("    benchmark_points_on_torus_dD - complex creation");
     st_create_clock.begin();
     alpha_complex_from_points.create_complex(complex);
     st_create_clock.end();
-    std::cout << st_create_clock;
+    std::clog << st_create_clock;
 
     results_csv << nb_points << ";" << complex.num_simplices() << ";" << ac_create_clock.num_seconds() << ";"
                 << st_create_clock.num_seconds() << ";" << std::endl;
 
-    std::cout << "    benchmark_points_on_torus_dD - nb simplices = " << complex.num_simplices() << std::endl;
+    std::clog << "    benchmark_points_on_torus_dD - nb simplices = " << complex.num_simplices() << std::endl;
   }
 }
 
 template <typename Alpha_complex_3d>
 void benchmark_points_on_torus_3D(const std::string& msg) {
   using K = CGAL::Epick_d<CGAL::Dimension_tag<3>>;
-  std::cout << "+ " << msg << std::endl;
+  std::clog << "+ " << msg << std::endl;
 
   results_csv << "\"" << msg << "\";" << std::endl;
   results_csv << "\"nb_points\";"
@@ -69,7 +69,7 @@ void benchmark_points_on_torus_3D(const std::string& msg) {
               << "\"complex_creation_time(sec.)\";" << std::endl;
 
   for (int nb_points = 1000; nb_points <= 125000; nb_points *= 5) {
-    std::cout << "  Alpha complex 3d on torus with " << nb_points << " points." << std::endl;
+    std::clog << "  Alpha complex 3d on torus with " << nb_points << " points." << std::endl;
     std::vector<K::Point_d> points_on_torus = Gudhi::generate_points_on_torus_3D<K>(nb_points, 1.0, 0.5);
     std::vector<typename Alpha_complex_3d::Point_3> points;
 
@@ -81,19 +81,19 @@ void benchmark_points_on_torus_3D(const std::string& msg) {
     ac_create_clock.begin();
     Alpha_complex_3d alpha_complex_from_points(points);
     ac_create_clock.end();
-    std::cout << ac_create_clock;
+    std::clog << ac_create_clock;
 
     Gudhi::Simplex_tree<> complex;
     Gudhi::Clock st_create_clock("    benchmark_points_on_torus_3D - complex creation");
     st_create_clock.begin();
     alpha_complex_from_points.create_complex(complex);
     st_create_clock.end();
-    std::cout << st_create_clock;
+    std::clog << st_create_clock;
 
     results_csv << nb_points << ";" << complex.num_simplices() << ";" << ac_create_clock.num_seconds() << ";"
                 << st_create_clock.num_seconds() << ";" << std::endl;
 
-    std::cout << "    benchmark_points_on_torus_3D - nb simplices = " << complex.num_simplices() << std::endl;
+    std::clog << "    benchmark_points_on_torus_3D - nb simplices = " << complex.num_simplices() << std::endl;
   }
 }
 
@@ -101,7 +101,7 @@ template <typename Weighted_alpha_complex_3d>
 void benchmark_weighted_points_on_torus_3D(const std::string& msg) {
   using K = CGAL::Epick_d<CGAL::Dimension_tag<3>>;
 
-  std::cout << "+ " << msg << std::endl;
+  std::clog << "+ " << msg << std::endl;
 
   results_csv << "\"" << msg << "\";" << std::endl;
   results_csv << "\"nb_points\";"
@@ -112,7 +112,7 @@ void benchmark_weighted_points_on_torus_3D(const std::string& msg) {
   CGAL::Random random(8);
 
   for (int nb_points = 1000; nb_points <= 125000; nb_points *= 5) {
-    std::cout << "  Alpha complex 3d on torus with " << nb_points << " points." << std::endl;
+    std::clog << "  Alpha complex 3d on torus with " << nb_points << " points." << std::endl;
     std::vector<K::Point_d> points_on_torus = Gudhi::generate_points_on_torus_3D<K>(nb_points, 1.0, 0.5);
 
     using Point = typename Weighted_alpha_complex_3d::Bare_point_3;
@@ -128,25 +128,25 @@ void benchmark_weighted_points_on_torus_3D(const std::string& msg) {
     ac_create_clock.begin();
     Weighted_alpha_complex_3d alpha_complex_from_points(points);
     ac_create_clock.end();
-    std::cout << ac_create_clock;
+    std::clog << ac_create_clock;
 
     Gudhi::Simplex_tree<> complex;
     Gudhi::Clock st_create_clock("    benchmark_weighted_points_on_torus_3D - complex creation");
     st_create_clock.begin();
     alpha_complex_from_points.create_complex(complex);
     st_create_clock.end();
-    std::cout << st_create_clock;
+    std::clog << st_create_clock;
 
     results_csv << nb_points << ";" << complex.num_simplices() << ";" << ac_create_clock.num_seconds() << ";"
                 << st_create_clock.num_seconds() << ";" << std::endl;
 
-    std::cout << "    benchmark_weighted_points_on_torus_3D - nb simplices = " << complex.num_simplices() << std::endl;
+    std::clog << "    benchmark_weighted_points_on_torus_3D - nb simplices = " << complex.num_simplices() << std::endl;
   }
 }
 
 template <typename Periodic_alpha_complex_3d>
 void benchmark_periodic_points(const std::string& msg) {
-  std::cout << "+ " << msg << std::endl;
+  std::clog << "+ " << msg << std::endl;
 
   results_csv << "\"" << msg << "\";" << std::endl;
   results_csv << "\"nb_points\";"
@@ -157,7 +157,7 @@ void benchmark_periodic_points(const std::string& msg) {
   CGAL::Random random(8);
 
   for (double nb_points = 10.; nb_points <= 40.; nb_points += 10.) {
-    std::cout << "  Periodic alpha complex 3d with " << nb_points * nb_points * nb_points << " points." << std::endl;
+    std::clog << "  Periodic alpha complex 3d with " << nb_points * nb_points * nb_points << " points." << std::endl;
     using Point = typename Periodic_alpha_complex_3d::Point_3;
     std::vector<Point> points;
 
@@ -174,25 +174,25 @@ void benchmark_periodic_points(const std::string& msg) {
     ac_create_clock.begin();
     Periodic_alpha_complex_3d alpha_complex_from_points(points, 0., 0., 0., nb_points, nb_points, nb_points);
     ac_create_clock.end();
-    std::cout << ac_create_clock;
+    std::clog << ac_create_clock;
 
     Gudhi::Simplex_tree<> complex;
     Gudhi::Clock st_create_clock("    benchmark_periodic_points - complex creation");
     st_create_clock.begin();
     alpha_complex_from_points.create_complex(complex);
     st_create_clock.end();
-    std::cout << st_create_clock;
+    std::clog << st_create_clock;
 
     results_csv << nb_points * nb_points * nb_points << ";" << complex.num_simplices() << ";"
                 << ac_create_clock.num_seconds() << ";" << st_create_clock.num_seconds() << ";" << std::endl;
 
-    std::cout << "    benchmark_periodic_points - nb simplices = " << complex.num_simplices() << std::endl;
+    std::clog << "    benchmark_periodic_points - nb simplices = " << complex.num_simplices() << std::endl;
   }
 }
 
 template <typename Weighted_periodic_alpha_complex_3d>
 void benchmark_weighted_periodic_points(const std::string& msg) {
-  std::cout << "+ " << msg << std::endl;
+  std::clog << "+ " << msg << std::endl;
 
   results_csv << "\"" << msg << "\";" << std::endl;
   results_csv << "\"nb_points\";"
@@ -203,7 +203,7 @@ void benchmark_weighted_periodic_points(const std::string& msg) {
   CGAL::Random random(8);
 
   for (double nb_points = 10.; nb_points <= 40.; nb_points += 10.) {
-    std::cout << "  Weighted periodic alpha complex 3d with " << nb_points * nb_points * nb_points << " points."
+    std::clog << "  Weighted periodic alpha complex 3d with " << nb_points * nb_points * nb_points << " points."
               << std::endl;
 
     using Point = typename Weighted_periodic_alpha_complex_3d::Bare_point_3;
@@ -224,19 +224,19 @@ void benchmark_weighted_periodic_points(const std::string& msg) {
     ac_create_clock.begin();
     Weighted_periodic_alpha_complex_3d alpha_complex_from_points(points, 0., 0., 0., nb_points, nb_points, nb_points);
     ac_create_clock.end();
-    std::cout << ac_create_clock;
+    std::clog << ac_create_clock;
 
     Gudhi::Simplex_tree<> complex;
     Gudhi::Clock st_create_clock("    benchmark_weighted_periodic_points - complex creation");
     st_create_clock.begin();
     alpha_complex_from_points.create_complex(complex);
     st_create_clock.end();
-    std::cout << st_create_clock;
+    std::clog << st_create_clock;
 
     results_csv << nb_points * nb_points * nb_points << ";" << complex.num_simplices() << ";"
                 << ac_create_clock.num_seconds() << ";" << st_create_clock.num_seconds() << ";" << std::endl;
 
-    std::cout << "    benchmark_weighted_periodic_points - nb simplices = " << complex.num_simplices() << std::endl;
+    std::clog << "    benchmark_weighted_periodic_points - nb simplices = " << complex.num_simplices() << std::endl;
   }
 }
 
diff --git a/src/Alpha_complex/example/Alpha_complex_3d_from_points.cpp b/src/Alpha_complex/example/Alpha_complex_3d_from_points.cpp
index 0e359a27..a2c85138 100644
--- a/src/Alpha_complex/example/Alpha_complex_3d_from_points.cpp
+++ b/src/Alpha_complex/example/Alpha_complex_3d_from_points.cpp
@@ -38,18 +38,18 @@ int main(int argc, char **argv) {
     // ----------------------------------------------------------------------------
     // Display information about the alpha complex
     // ----------------------------------------------------------------------------
-    std::cout << "Alpha complex is of dimension " << simplex.dimension() << " - " << simplex.num_simplices()
+    std::clog << "Alpha complex is of dimension " << simplex.dimension() << " - " << simplex.num_simplices()
               << " simplices - " << simplex.num_vertices() << " vertices." << std::endl;
 
-    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;
     for (auto f_simplex : simplex.filtration_simplex_range()) {
-      std::cout << "   ( ";
+      std::clog << "   ( ";
       for (auto vertex : simplex.simplex_vertex_range(f_simplex)) {
-        std::cout << vertex << " ";
+        std::clog << vertex << " ";
       }
-      std::cout << ") -> "
+      std::clog << ") -> "
                 << "[" << simplex.filtration(f_simplex) << "] ";
-      std::cout << std::endl;
+      std::clog << std::endl;
     }
   }
   return 0;
diff --git a/src/Alpha_complex/example/Alpha_complex_from_off.cpp b/src/Alpha_complex/example/Alpha_complex_from_off.cpp
index 220a66de..dba1710e 100644
--- a/src/Alpha_complex/example/Alpha_complex_from_off.cpp
+++ b/src/Alpha_complex/example/Alpha_complex_from_off.cpp
@@ -30,7 +30,7 @@ int main(int argc, char **argv) {
     ouput_file_stream.open(std::string(argv[3]));
     streambuffer = ouput_file_stream.rdbuf();
   } else {
-    streambuffer = std::cout.rdbuf();
+    streambuffer = std::clog.rdbuf();
   }
 
   Gudhi::Simplex_tree<> simplex;
diff --git a/src/Alpha_complex/example/Alpha_complex_from_points.cpp b/src/Alpha_complex/example/Alpha_complex_from_points.cpp
index 6526ca3a..c79535bf 100644
--- a/src/Alpha_complex/example/Alpha_complex_from_points.cpp
+++ b/src/Alpha_complex/example/Alpha_complex_from_points.cpp
@@ -35,18 +35,18 @@ int main() {
     // ----------------------------------------------------------------------------
     // Display information about the alpha complex
     // ----------------------------------------------------------------------------
-    std::cout << "Alpha complex is of dimension " << simplex.dimension() <<
+    std::clog << "Alpha complex is of dimension " << simplex.dimension() <<
         " - " << simplex.num_simplices() << " simplices - " <<
         simplex.num_vertices() << " vertices." << std::endl;
 
-    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;
     for (auto f_simplex : simplex.filtration_simplex_range()) {
-      std::cout << "   ( ";
+      std::clog << "   ( ";
       for (auto vertex : simplex.simplex_vertex_range(f_simplex)) {
-        std::cout << vertex << " ";
+        std::clog << vertex << " ";
       }
-      std::cout << ") -> " << "[" << simplex.filtration(f_simplex) << "] ";
-      std::cout << std::endl;
+      std::clog << ") -> " << "[" << simplex.filtration(f_simplex) << "] ";
+      std::clog << std::endl;
     }
   }
   return 0;
diff --git a/src/Alpha_complex/example/CMakeLists.txt b/src/Alpha_complex/example/CMakeLists.txt
index b0337934..2eecd50c 100644
--- a/src/Alpha_complex/example/CMakeLists.txt
+++ b/src/Alpha_complex/example/CMakeLists.txt
@@ -32,14 +32,18 @@ if (DIFF_PATH)
 
     add_test(Alpha_complex_example_from_off_60_diff_files ${DIFF_PATH}
         ${CMAKE_CURRENT_BINARY_DIR}/alphaoffreader_result_60.txt ${CMAKE_CURRENT_BINARY_DIR}/alphaoffreader_for_doc_60.txt)
+    set_tests_properties(Alpha_complex_example_from_off_60_diff_files PROPERTIES DEPENDS Alpha_complex_example_from_off_60) 
     add_test(Alpha_complex_example_from_off_32_diff_files ${DIFF_PATH}
         ${CMAKE_CURRENT_BINARY_DIR}/alphaoffreader_result_32.txt ${CMAKE_CURRENT_BINARY_DIR}/alphaoffreader_for_doc_32.txt)
+    set_tests_properties(Alpha_complex_example_from_off_32_diff_files PROPERTIES DEPENDS Alpha_complex_example_from_off_32) 
 
     add_test(Alpha_complex_example_fast_from_off_60_diff_files ${DIFF_PATH}
         ${CMAKE_CURRENT_BINARY_DIR}/fastalphaoffreader_result_60.txt ${CMAKE_CURRENT_BINARY_DIR}/alphaoffreader_for_doc_60.txt)
+    set_tests_properties(Alpha_complex_example_fast_from_off_60_diff_files PROPERTIES DEPENDS Alpha_complex_example_fast_from_off_60) 
     add_test(Alpha_complex_example_fast_from_off_32_diff_files ${DIFF_PATH}
         ${CMAKE_CURRENT_BINARY_DIR}/fastalphaoffreader_result_32.txt ${CMAKE_CURRENT_BINARY_DIR}/alphaoffreader_for_doc_32.txt)
-  endif()
+    set_tests_properties(Alpha_complex_example_fast_from_off_32_diff_files PROPERTIES DEPENDS Alpha_complex_example_fast_from_off_32) 
+endif()
 
   add_executable ( Alpha_complex_example_weighted_3d_from_points Weighted_alpha_complex_3d_from_points.cpp )
   target_link_libraries(Alpha_complex_example_weighted_3d_from_points  ${CGAL_LIBRARY})
diff --git a/src/Alpha_complex/example/Fast_alpha_complex_from_off.cpp b/src/Alpha_complex/example/Fast_alpha_complex_from_off.cpp
index f181005a..64728470 100644
--- a/src/Alpha_complex/example/Fast_alpha_complex_from_off.cpp
+++ b/src/Alpha_complex/example/Fast_alpha_complex_from_off.cpp
@@ -35,7 +35,7 @@ int main(int argc, char **argv) {
     ouput_file_stream.open(std::string(argv[3]));
     streambuffer = ouput_file_stream.rdbuf();
   } else {
-    streambuffer = std::cout.rdbuf();
+    streambuffer = std::clog.rdbuf();
   }
 
   Gudhi::Simplex_tree<> simplex;
diff --git a/src/Alpha_complex/example/Weighted_alpha_complex_3d_from_points.cpp b/src/Alpha_complex/example/Weighted_alpha_complex_3d_from_points.cpp
index fcf80802..c044194e 100644
--- a/src/Alpha_complex/example/Weighted_alpha_complex_3d_from_points.cpp
+++ b/src/Alpha_complex/example/Weighted_alpha_complex_3d_from_points.cpp
@@ -34,18 +34,18 @@ int main(int argc, char **argv) {
     // ----------------------------------------------------------------------------
     // Display information about the alpha complex
     // ----------------------------------------------------------------------------
-    std::cout << "Alpha complex is of dimension " << simplex.dimension() << " - " << simplex.num_simplices()
+    std::clog << "Alpha complex is of dimension " << simplex.dimension() << " - " << simplex.num_simplices()
               << " simplices - " << simplex.num_vertices() << " vertices." << std::endl;
 
-    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;
     for (auto f_simplex : simplex.filtration_simplex_range()) {
-      std::cout << "   ( ";
+      std::clog << "   ( ";
       for (auto vertex : simplex.simplex_vertex_range(f_simplex)) {
-        std::cout << vertex << " ";
+        std::clog << vertex << " ";
       }
-      std::cout << ") -> "
+      std::clog << ") -> "
                 << "[" << simplex.filtration(f_simplex) << "] ";
-      std::cout << std::endl;
+      std::clog << std::endl;
     }
   }
   return 0;
diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 4c61ba73..65c969d2 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -237,7 +237,7 @@ class Alpha_complex {
       for (CGAL_vertex_iterator vit = triangulation_->vertices_begin(); vit != triangulation_->vertices_end(); ++vit) {
         if (!triangulation_->is_infinite(*vit)) {
 #ifdef DEBUG_TRACES
-          std::cout << "Vertex insertion - " << vit->data() << " -> " << vit->point() << std::endl;
+          std::clog << "Vertex insertion - " << vit->data() << " -> " << vit->point() << std::endl;
 #endif  // DEBUG_TRACES
           vertex_handle_to_iterator_[vit->data()] = vit;
         }
@@ -301,19 +301,19 @@ class Alpha_complex {
            ++cit) {
         Vector_vertex vertexVector;
 #ifdef DEBUG_TRACES
-        std::cout << "Simplex_tree insertion ";
+        std::clog << "Simplex_tree insertion ";
 #endif  // DEBUG_TRACES
         for (auto vit = cit->vertices_begin(); vit != cit->vertices_end(); ++vit) {
           if (*vit != nullptr) {
 #ifdef DEBUG_TRACES
-            std::cout << " " << (*vit)->data();
+            std::clog << " " << (*vit)->data();
 #endif  // DEBUG_TRACES
             // Vector of vertex construction for simplex_tree structure
             vertexVector.push_back((*vit)->data());
           }
         }
 #ifdef DEBUG_TRACES
-        std::cout << std::endl;
+        std::clog << std::endl;
 #endif  // DEBUG_TRACES
         // Insert each simplex and its subfaces in the simplex tree - filtration is NaN
         complex.insert_simplex_and_subfaces(vertexVector, std::numeric_limits<double>::quiet_NaN());
@@ -333,16 +333,16 @@ class Alpha_complex {
           if (decr_dim == f_simplex_dim) {
             pointVector.clear();
   #ifdef DEBUG_TRACES
-            std::cout << "Sigma of dim " << decr_dim << " is";
+            std::clog << "Sigma of dim " << decr_dim << " is";
   #endif  // DEBUG_TRACES
             for (auto vertex : complex.simplex_vertex_range(f_simplex)) {
               pointVector.push_back(get_point(vertex));
   #ifdef DEBUG_TRACES
-              std::cout << " " << vertex;
+              std::clog << " " << vertex;
   #endif  // DEBUG_TRACES
             }
   #ifdef DEBUG_TRACES
-            std::cout << std::endl;
+            std::clog << std::endl;
   #endif  // DEBUG_TRACES
             // ### If filt(Sigma) is NaN : filt(Sigma) = alpha(Sigma)
             if (std::isnan(complex.filtration(f_simplex))) {
@@ -361,7 +361,7 @@ class Alpha_complex {
               }
               complex.assign_filtration(f_simplex, alpha_complex_filtration);
   #ifdef DEBUG_TRACES
-              std::cout << "filt(Sigma) is NaN : filt(Sigma) =" << complex.filtration(f_simplex) << std::endl;
+              std::clog << "filt(Sigma) is NaN : filt(Sigma) =" << complex.filtration(f_simplex) << std::endl;
   #endif  // DEBUG_TRACES
             }
             // No need to propagate further, unweighted points all have value 0
@@ -394,13 +394,13 @@ class Alpha_complex {
     // ### Foreach Tau face of Sigma
     for (auto f_boundary : complex.boundary_simplex_range(f_simplex)) {
 #ifdef DEBUG_TRACES
-      std::cout << " | --------------------------------------------------\n";
-      std::cout << " | Tau ";
+      std::clog << " | --------------------------------------------------\n";
+      std::clog << " | Tau ";
       for (auto vertex : complex.simplex_vertex_range(f_boundary)) {
-        std::cout << vertex << " ";
+        std::clog << vertex << " ";
       }
-      std::cout << "is a face of Sigma\n";
-      std::cout << " | isnan(complex.filtration(Tau)=" << std::isnan(complex.filtration(f_boundary)) << std::endl;
+      std::clog << "is a face of Sigma\n";
+      std::clog << " | isnan(complex.filtration(Tau)=" << std::isnan(complex.filtration(f_boundary)) << std::endl;
 #endif  // DEBUG_TRACES
       // ### If filt(Tau) is not NaN
       if (!std::isnan(complex.filtration(f_boundary))) {
@@ -409,7 +409,7 @@ class Alpha_complex {
                                                                              complex.filtration(f_simplex));
         complex.assign_filtration(f_boundary, alpha_complex_filtration);
 #ifdef DEBUG_TRACES
-        std::cout << " | filt(Tau) = fmin(filt(Tau), filt(Sigma)) = " << complex.filtration(f_boundary) << std::endl;
+        std::clog << " | filt(Tau) = fmin(filt(Tau), filt(Sigma)) = " << complex.filtration(f_boundary) << std::endl;
 #endif  // DEBUG_TRACES
         // ### Else
       } else {
@@ -439,7 +439,7 @@ class Alpha_complex {
         bool is_gab = is_gabriel(pointVector.begin(), pointVector.end(), point_for_gabriel)
           != CGAL::ON_BOUNDED_SIDE;
 #ifdef DEBUG_TRACES
-        std::cout << " | Tau is_gabriel(Sigma)=" << is_gab << " - vertexForGabriel=" << vertexForGabriel << std::endl;
+        std::clog << " | Tau is_gabriel(Sigma)=" << is_gab << " - vertexForGabriel=" << vertexForGabriel << std::endl;
 #endif  // DEBUG_TRACES
         // ### If Tau is not Gabriel of Sigma
         if (false == is_gab) {
@@ -447,7 +447,7 @@ class Alpha_complex {
           Filtration_value alpha_complex_filtration = complex.filtration(f_simplex);
           complex.assign_filtration(f_boundary, alpha_complex_filtration);
 #ifdef DEBUG_TRACES
-          std::cout << " | filt(Tau) = filt(Sigma) = " << complex.filtration(f_boundary) << std::endl;
+          std::clog << " | filt(Tau) = filt(Sigma) = " << complex.filtration(f_boundary) << std::endl;
 #endif  // DEBUG_TRACES
         }
       }
diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex_3d.h b/src/Alpha_complex/include/gudhi/Alpha_complex_3d.h
index 7f96c94c..c19ebb79 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex_3d.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex_3d.h
@@ -61,10 +61,7 @@ namespace Gudhi {
 
 namespace alpha_complex {
 
-#ifdef GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-thread_local
-#endif  // GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    double RELATIVE_PRECISION_OF_TO_DOUBLE = 0.00001;
+thread_local double RELATIVE_PRECISION_OF_TO_DOUBLE = 0.00001;
 
 // Value_from_iterator returns the filtration value from an iterator on alpha shapes values
 //
@@ -472,7 +469,7 @@ Weighted_alpha_complex_3d::Weighted_point_3 wp0(Weighted_alpha_complex_3d::Bare_
 
     alpha_shape_3_ptr_->filtration_with_alpha_values(dispatcher);
 #ifdef DEBUG_TRACES
-    std::cout << "filtration_with_alpha_values returns : " << objects.size() << " objects" << std::endl;
+    std::clog << "filtration_with_alpha_values returns : " << objects.size() << " objects" << std::endl;
 #endif  // DEBUG_TRACES
 
     using Alpha_value_iterator = typename std::vector<FT>::const_iterator;
@@ -484,7 +481,7 @@ Weighted_alpha_complex_3d::Weighted_point_3 wp0(Weighted_alpha_complex_3d::Bare_
       if (const Cell_handle* cell = CGAL::object_cast<Cell_handle>(&object_iterator)) {
         for (auto i = 0; i < 4; i++) {
 #ifdef DEBUG_TRACES
-          std::cout << "from cell[" << i << "] - Point coordinates (" << (*cell)->vertex(i)->point() << ")"
+          std::clog << "from cell[" << i << "] - Point coordinates (" << (*cell)->vertex(i)->point() << ")"
                     << std::endl;
 #endif  // DEBUG_TRACES
           vertex_list.push_back((*cell)->vertex(i));
@@ -496,7 +493,7 @@ Weighted_alpha_complex_3d::Weighted_point_3 wp0(Weighted_alpha_complex_3d::Bare_
         for (auto i = 0; i < 4; i++) {
           if ((*facet).second != i) {
 #ifdef DEBUG_TRACES
-            std::cout << "from facet=[" << i << "] - Point coordinates (" << (*facet).first->vertex(i)->point() << ")"
+            std::clog << "from facet=[" << i << "] - Point coordinates (" << (*facet).first->vertex(i)->point() << ")"
                       << std::endl;
 #endif  // DEBUG_TRACES
             vertex_list.push_back((*facet).first->vertex(i));
@@ -508,7 +505,7 @@ Weighted_alpha_complex_3d::Weighted_point_3 wp0(Weighted_alpha_complex_3d::Bare_
       } else if (const Edge* edge = CGAL::object_cast<Edge>(&object_iterator)) {
         for (auto i : {(*edge).second, (*edge).third}) {
 #ifdef DEBUG_TRACES
-          std::cout << "from edge[" << i << "] - Point coordinates (" << (*edge).first->vertex(i)->point() << ")"
+          std::clog << "from edge[" << i << "] - Point coordinates (" << (*edge).first->vertex(i)->point() << ")"
                     << std::endl;
 #endif  // DEBUG_TRACES
           vertex_list.push_back((*edge).first->vertex(i));
@@ -519,7 +516,7 @@ Weighted_alpha_complex_3d::Weighted_point_3 wp0(Weighted_alpha_complex_3d::Bare_
       } else if (const Alpha_vertex_handle* vertex = CGAL::object_cast<Alpha_vertex_handle>(&object_iterator)) {
 #ifdef DEBUG_TRACES
         count_vertices++;
-        std::cout << "from vertex - Point coordinates (" << (*vertex)->point() << ")" << std::endl;
+        std::clog << "from vertex - Point coordinates (" << (*vertex)->point() << ")" << std::endl;
 #endif  // DEBUG_TRACES
         vertex_list.push_back((*vertex));
       }
@@ -531,7 +528,7 @@ Weighted_alpha_complex_3d::Weighted_point_3 wp0(Weighted_alpha_complex_3d::Bare_
           // alpha shape not found
           Complex_vertex_handle vertex = map_cgal_simplex_tree.size();
 #ifdef DEBUG_TRACES
-          std::cout << "Point (" << the_alpha_shape_vertex->point() << ") not found - insert new vertex id " << vertex
+          std::clog << "Point (" << the_alpha_shape_vertex->point() << ") not found - insert new vertex id " << vertex
                     << std::endl;
 #endif  // DEBUG_TRACES
           the_simplex.push_back(vertex);
@@ -540,7 +537,7 @@ Weighted_alpha_complex_3d::Weighted_point_3 wp0(Weighted_alpha_complex_3d::Bare_
           // alpha shape found
           Complex_vertex_handle vertex = the_map_iterator->second;
 #ifdef DEBUG_TRACES
-          std::cout << "Point (" << the_alpha_shape_vertex->point() << ") found as vertex id " << vertex << std::endl;
+          std::clog << "Point (" << the_alpha_shape_vertex->point() << ") found as vertex id " << vertex << std::endl;
 #endif  // DEBUG_TRACES
           the_simplex.push_back(vertex);
         }
@@ -549,7 +546,7 @@ Weighted_alpha_complex_3d::Weighted_point_3 wp0(Weighted_alpha_complex_3d::Bare_
       Filtration_value filtr = Value_from_iterator<Complexity>::perform(alpha_value_iterator);
 
 #ifdef DEBUG_TRACES
-      std::cout << "filtration = " << filtr << std::endl;
+      std::clog << "filtration = " << filtr << std::endl;
 #endif  // DEBUG_TRACES
       complex.insert_simplex(the_simplex, static_cast<Filtration_value>(filtr));
       GUDHI_CHECK(alpha_value_iterator != alpha_values.end(), "CGAL provided more simplices than values");
@@ -557,10 +554,10 @@ Weighted_alpha_complex_3d::Weighted_point_3 wp0(Weighted_alpha_complex_3d::Bare_
     }
 
 #ifdef DEBUG_TRACES
-    std::cout << "vertices \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" << 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;
 #endif  // DEBUG_TRACES
     // --------------------------------------------------------------------------------------------
     // As Alpha value is an approximation, we have to make filtration non decreasing while increasing the dimension
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..da1d8004 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));
 
@@ -194,24 +194,24 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
   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 +231,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 +249,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 +264,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 +287,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/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;
 
diff --git a/src/Alpha_complex/utilities/CMakeLists.txt b/src/Alpha_complex/utilities/CMakeLists.txt
index a3b0cc24..2ffbdde0 100644
--- a/src/Alpha_complex/utilities/CMakeLists.txt
+++ b/src/Alpha_complex/utilities/CMakeLists.txt
@@ -16,8 +16,14 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
   if (DIFF_PATH)
     add_test(Alpha_complex_utilities_diff_exact_alpha_complex ${DIFF_PATH}
              "exact.pers" "safe.pers")
+    set_tests_properties(Alpha_complex_utilities_diff_exact_alpha_complex PROPERTIES DEPENDS
+             "Alpha_complex_utilities_exact_alpha_complex_persistence;Alpha_complex_utilities_safe_alpha_complex_persistence")
+             
     add_test(Alpha_complex_utilities_diff_fast_alpha_complex ${DIFF_PATH}
              "fast.pers" "safe.pers")
+    set_tests_properties(Alpha_complex_utilities_diff_fast_alpha_complex PROPERTIES DEPENDS
+             "Alpha_complex_utilities_fast_alpha_complex_persistence;Alpha_complex_utilities_safe_alpha_complex_persistence")
+
   endif()
   
   install(TARGETS alpha_complex_persistence DESTINATION bin)
@@ -36,15 +42,19 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
           "${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off"
           "-p" "2" "-m" "0.45" "-o" "exact_3d.pers" "-e")
 
-  add_test(NAME Alpha_complex_utilities_safe_alpha_complex_3d COMMAND $<TARGET_FILE:alpha_complex_3d_persistence>
+  add_test(NAME Alpha_complex_utilities_fast_alpha_complex_3d COMMAND $<TARGET_FILE:alpha_complex_3d_persistence>
           "${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off"
           "-p" "2" "-m" "0.45" "-o" "fast_3d.pers" "-f")
 
   if (DIFF_PATH)
     add_test(Alpha_complex_utilities_diff_exact_alpha_complex_3d ${DIFF_PATH}
             "exact_3d.pers" "safe_3d.pers")
+    set_tests_properties(Alpha_complex_utilities_diff_exact_alpha_complex_3d PROPERTIES DEPENDS
+            "Alpha_complex_utilities_exact_alpha_complex_3d;Alpha_complex_utilities_alpha_complex_3d")
     add_test(Alpha_complex_utilities_diff_fast_alpha_complex_3d ${DIFF_PATH}
             "fast_3d.pers" "safe_3d.pers")
+    set_tests_properties(Alpha_complex_utilities_diff_fast_alpha_complex_3d PROPERTIES DEPENDS
+            "Alpha_complex_utilities_fast_alpha_complex_3d;Alpha_complex_utilities_alpha_complex_3d")
   endif()
 
   add_test(NAME Alpha_complex_utilities_periodic_alpha_complex_3d_persistence COMMAND $<TARGET_FILE:alpha_complex_3d_persistence>
diff --git a/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp b/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp
index 929fc2e8..e93c412e 100644
--- a/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp
+++ b/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp
@@ -225,7 +225,7 @@ int main(int argc, char **argv) {
   // Sort the simplices in the order of the filtration
   simplex_tree.initialize_filtration();
 
-  std::cout << "Simplex_tree dim: " << simplex_tree.dimension() << std::endl;
+  std::clog << "Simplex_tree dim: " << simplex_tree.dimension() << std::endl;
   // Compute the persistence diagram of the complex
   Persistent_cohomology pcoh(simplex_tree, true);
   // initializes the coefficient field for homology
@@ -237,7 +237,7 @@ int main(int argc, char **argv) {
   if (output_file_diag.empty()) {
     pcoh.output_diagram();
   } else {
-    std::cout << "Result in file: " << output_file_diag << std::endl;
+    std::clog << "Result in file: " << output_file_diag << std::endl;
     std::ofstream out(output_file_diag);
     pcoh.output_diagram(out);
     out.close();
@@ -266,7 +266,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::cout")(
+      "Name of file in which the persistence diagram is written. Default print in std::clog")(
       "max-alpha-square-value,r",
       po::value<Filtration_value>(&alpha_square_max_value)
           ->default_value(std::numeric_limits<Filtration_value>::infinity()),
@@ -288,18 +288,18 @@ void program_options(int argc, char *argv[], std::string &off_file_points, bool
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file") || !vm.count("weight-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a 3D Alpha complex defined on a set of input points.\n";
-    std::cout << "3D Alpha complex can be safe (by default) exact or fast, weighted and/or periodic\n\n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients.\n\n";
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a 3D Alpha complex defined on a set of input points.\n";
+    std::clog << "3D Alpha complex can be safe (by default) exact or fast, weighted and/or periodic\n\n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients.\n\n";
 
-    std::cout << "Usage: " << argv[0] << " [options] input-file weight-file\n\n";
-    std::cout << visible << std::endl;
+    std::clog << "Usage: " << argv[0] << " [options] input-file weight-file\n\n";
+    std::clog << visible << std::endl;
     exit(-1);
   }
 }
diff --git a/src/Alpha_complex/utilities/alpha_complex_persistence.cpp b/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
index 486347cc..be60ff78 100644
--- a/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
+++ b/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
@@ -72,13 +72,13 @@ int main(int argc, char **argv) {
   // ----------------------------------------------------------------------------
   // Display information about the alpha complex
   // ----------------------------------------------------------------------------
-  std::cout << "Simplicial complex is of dimension " << simplex.dimension() << " - " << simplex.num_simplices()
+  std::clog << "Simplicial complex is of dimension " << simplex.dimension() << " - " << simplex.num_simplices()
             << " simplices - " << simplex.num_vertices() << " vertices." << std::endl;
 
   // Sort the simplices in the order of the filtration
   simplex.initialize_filtration();
 
-  std::cout << "Simplex_tree dim: " << simplex.dimension() << std::endl;
+  std::clog << "Simplex_tree dim: " << simplex.dimension() << std::endl;
   // Compute the persistence diagram of the complex
   Gudhi::persistent_cohomology::Persistent_cohomology<Simplex_tree, Gudhi::persistent_cohomology::Field_Zp> pcoh(
       simplex);
@@ -91,7 +91,7 @@ int main(int argc, char **argv) {
   if (output_file_diag.empty()) {
     pcoh.output_diagram();
   } else {
-    std::cout << "Result in file: " << output_file_diag << std::endl;
+    std::clog << "Result in file: " << output_file_diag << std::endl;
     std::ofstream out(output_file_diag);
     pcoh.output_diagram(out);
     out.close();
@@ -114,7 +114,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 Alpha complex (default is false, not available if exact is set)")(
       "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::cout")(
+      "Name of file in which the persistence diagram is written. Default print in std::clog")(
       "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.")(
@@ -135,17 +135,17 @@ void program_options(int argc, char *argv[], std::string &off_file_points, bool
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of an Alpha complex defined on a set of input points.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of an Alpha complex defined on a set of input points.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Bitmap_cubical_complex/example/Random_bitmap_cubical_complex.cpp b/src/Bitmap_cubical_complex/example/Random_bitmap_cubical_complex.cpp
index 46ea8f2e..e5512418 100644
--- a/src/Bitmap_cubical_complex/example/Random_bitmap_cubical_complex.cpp
+++ b/src/Bitmap_cubical_complex/example/Random_bitmap_cubical_complex.cpp
@@ -21,7 +21,7 @@
 int main(int argc, char** argv) {
   srand(time(0));
 
-  std::cout
+  std::clog
       << "This program computes persistent homology, by using bitmap_cubical_complex class, of cubical "
       << "complexes. The first parameter of the program is the dimension D of the bitmap. The next D parameters are "
       << "number of top dimensional cubes in each dimension of the bitmap. The program will create random cubical "
diff --git a/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex.h b/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex.h
index 37514dee..aa255ec2 100644
--- a/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex.h
+++ b/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex.h
@@ -69,7 +69,7 @@ class Bitmap_cubical_complex : public T {
   Bitmap_cubical_complex(const char* perseus_style_file)
       : T(perseus_style_file), key_associated_to_simplex(this->total_number_of_cells + 1) {
     if (globalDbg) {
-      std::cerr << "Bitmap_cubical_complex( const char* perseus_style_file )\n";
+      std::clog << "Bitmap_cubical_complex( const char* perseus_style_file )\n";
     }
     for (std::size_t i = 0; i != this->total_number_of_cells; ++i) {
       this->key_associated_to_simplex[i] = i;
@@ -137,7 +137,7 @@ class Bitmap_cubical_complex : public T {
    **/
   static Simplex_handle null_simplex() {
     if (globalDbg) {
-      std::cerr << "Simplex_handle null_simplex()\n";
+      std::clog << "Simplex_handle null_simplex()\n";
     }
     return std::numeric_limits<Simplex_handle>::max();
   }
@@ -152,7 +152,7 @@ class Bitmap_cubical_complex : public T {
    **/
   inline unsigned dimension(Simplex_handle sh) const {
     if (globalDbg) {
-      std::cerr << "unsigned dimension(const Simplex_handle& sh)\n";
+      std::clog << "unsigned dimension(const Simplex_handle& sh)\n";
     }
     if (sh != null_simplex()) return this->get_dimension_of_a_cell(sh);
     return -1;
@@ -163,7 +163,7 @@ class Bitmap_cubical_complex : public T {
    **/
   Filtration_value filtration(Simplex_handle sh) {
     if (globalDbg) {
-      std::cerr << "Filtration_value filtration(const Simplex_handle& sh)\n";
+      std::clog << "Filtration_value filtration(const Simplex_handle& sh)\n";
     }
     // Returns the filtration value of a simplex.
     if (sh != null_simplex()) return this->data[sh];
@@ -175,7 +175,7 @@ class Bitmap_cubical_complex : public T {
    **/
   static Simplex_key null_key() {
     if (globalDbg) {
-      std::cerr << "Simplex_key null_key()\n";
+      std::clog << "Simplex_key null_key()\n";
     }
     return std::numeric_limits<Simplex_handle>::max();
   }
@@ -185,7 +185,7 @@ class Bitmap_cubical_complex : public T {
    **/
   Simplex_key key(Simplex_handle sh) const {
     if (globalDbg) {
-      std::cerr << "Simplex_key key(const Simplex_handle& sh)\n";
+      std::clog << "Simplex_key key(const Simplex_handle& sh)\n";
     }
     if (sh != null_simplex()) {
       return this->key_associated_to_simplex[sh];
@@ -198,7 +198,7 @@ class Bitmap_cubical_complex : public T {
    **/
   Simplex_handle simplex(Simplex_key key) {
     if (globalDbg) {
-      std::cerr << "Simplex_handle simplex(Simplex_key key)\n";
+      std::clog << "Simplex_handle simplex(Simplex_key key)\n";
     }
     if (key != null_key()) {
       return this->simplex_associated_to_key[key];
@@ -211,7 +211,7 @@ class Bitmap_cubical_complex : public T {
    **/
   void assign_key(Simplex_handle sh, Simplex_key key) {
     if (globalDbg) {
-      std::cerr << "void assign_key(Simplex_handle& sh, Simplex_key key)\n";
+      std::clog << "void assign_key(Simplex_handle& sh, Simplex_key key)\n";
     }
     if (key == null_key()) return;
     this->key_associated_to_simplex[sh] = key;
@@ -251,7 +251,7 @@ class Bitmap_cubical_complex : public T {
 
     Filtration_simplex_iterator operator++() {
       if (globalDbg) {
-        std::cerr << "Filtration_simplex_iterator operator++\n";
+        std::clog << "Filtration_simplex_iterator operator++\n";
       }
       ++this->position;
       return (*this);
@@ -265,7 +265,7 @@ class Bitmap_cubical_complex : public T {
 
     Filtration_simplex_iterator& operator=(const Filtration_simplex_iterator& rhs) {
       if (globalDbg) {
-        std::cerr << "Filtration_simplex_iterator operator =\n";
+        std::clog << "Filtration_simplex_iterator operator =\n";
       }
       this->b = rhs.b;
       this->position = rhs.position;
@@ -274,21 +274,21 @@ class Bitmap_cubical_complex : public T {
 
     bool operator==(const Filtration_simplex_iterator& rhs) const {
       if (globalDbg) {
-        std::cerr << "bool operator == ( const Filtration_simplex_iterator& rhs )\n";
+        std::clog << "bool operator == ( const Filtration_simplex_iterator& rhs )\n";
       }
       return (this->position == rhs.position);
     }
 
     bool operator!=(const Filtration_simplex_iterator& rhs) const {
       if (globalDbg) {
-        std::cerr << "bool operator != ( const Filtration_simplex_iterator& rhs )\n";
+        std::clog << "bool operator != ( const Filtration_simplex_iterator& rhs )\n";
       }
       return !(*this == rhs);
     }
 
     Simplex_handle operator*() {
       if (globalDbg) {
-        std::cerr << "Simplex_handle operator*()\n";
+        std::clog << "Simplex_handle operator*()\n";
       }
       return this->b->simplex_associated_to_key[this->position];
     }
@@ -314,14 +314,14 @@ class Bitmap_cubical_complex : public T {
 
     Filtration_simplex_iterator begin() {
       if (globalDbg) {
-        std::cerr << "Filtration_simplex_iterator begin() \n";
+        std::clog << "Filtration_simplex_iterator begin() \n";
       }
       return Filtration_simplex_iterator(this->b);
     }
 
     Filtration_simplex_iterator end() {
       if (globalDbg) {
-        std::cerr << "Filtration_simplex_iterator end()\n";
+        std::clog << "Filtration_simplex_iterator end()\n";
       }
       Filtration_simplex_iterator it(this->b);
       it.position = this->b->simplex_associated_to_key.size();
@@ -347,7 +347,7 @@ class Bitmap_cubical_complex : public T {
    **/
   Filtration_simplex_range filtration_simplex_range() {
     if (globalDbg) {
-      std::cerr << "Filtration_simplex_range filtration_simplex_range()\n";
+      std::clog << "Filtration_simplex_range filtration_simplex_range()\n";
     }
     // Returns a range over the simplices of the complex in the order of the filtration
     return Filtration_simplex_range(this);
@@ -370,8 +370,8 @@ class Bitmap_cubical_complex : public T {
   std::pair<Simplex_handle, Simplex_handle> endpoints(Simplex_handle sh) {
     std::vector<std::size_t> bdry = this->get_boundary_of_a_cell(sh);
     if (globalDbg) {
-      std::cerr << "std::pair<Simplex_handle, Simplex_handle> endpoints( Simplex_handle sh )\n";
-      std::cerr << "bdry.size() : " << bdry.size() << "\n";
+      std::clog << "std::pair<Simplex_handle, Simplex_handle> endpoints( Simplex_handle sh )\n";
+      std::clog << "bdry.size() : " << bdry.size() << "\n";
     }
     // this method returns two first elements from the boundary of sh.
     if (bdry.size() < 2)
@@ -392,7 +392,7 @@ class Bitmap_cubical_complex : public T {
    public:
     Skeleton_simplex_iterator(Bitmap_cubical_complex* b, std::size_t d) : b(b), dimension(d) {
       if (globalDbg) {
-        std::cerr << "Skeleton_simplex_iterator ( Bitmap_cubical_complex* b , std::size_t d )\n";
+        std::clog << "Skeleton_simplex_iterator ( Bitmap_cubical_complex* b , std::size_t d )\n";
       }
       // find the position of the first simplex of a dimension d
       this->position = 0;
@@ -406,7 +406,7 @@ class Bitmap_cubical_complex : public T {
 
     Skeleton_simplex_iterator operator++() {
       if (globalDbg) {
-        std::cerr << "Skeleton_simplex_iterator operator++()\n";
+        std::clog << "Skeleton_simplex_iterator operator++()\n";
       }
       // increment the position as long as you did not get to the next element of the dimension dimension.
       ++this->position;
@@ -425,7 +425,7 @@ class Bitmap_cubical_complex : public T {
 
     Skeleton_simplex_iterator& operator=(const Skeleton_simplex_iterator& rhs) {
       if (globalDbg) {
-        std::cerr << "Skeleton_simplex_iterator operator =\n";
+        std::clog << "Skeleton_simplex_iterator operator =\n";
       }
       this->b = rhs.b;
       this->position = rhs.position;
@@ -435,21 +435,21 @@ class Bitmap_cubical_complex : public T {
 
     bool operator==(const Skeleton_simplex_iterator& rhs) const {
       if (globalDbg) {
-        std::cerr << "bool operator ==\n";
+        std::clog << "bool operator ==\n";
       }
       return (this->position == rhs.position);
     }
 
     bool operator!=(const Skeleton_simplex_iterator& rhs) const {
       if (globalDbg) {
-        std::cerr << "bool operator != ( const Skeleton_simplex_iterator& rhs )\n";
+        std::clog << "bool operator != ( const Skeleton_simplex_iterator& rhs )\n";
       }
       return !(*this == rhs);
     }
 
     Simplex_handle operator*() {
       if (globalDbg) {
-        std::cerr << "Simplex_handle operator*() \n";
+        std::clog << "Simplex_handle operator*() \n";
       }
       return this->position;
     }
@@ -476,14 +476,14 @@ class Bitmap_cubical_complex : public T {
 
     Skeleton_simplex_iterator begin() {
       if (globalDbg) {
-        std::cerr << "Skeleton_simplex_iterator begin()\n";
+        std::clog << "Skeleton_simplex_iterator begin()\n";
       }
       return Skeleton_simplex_iterator(this->b, this->dimension);
     }
 
     Skeleton_simplex_iterator end() {
       if (globalDbg) {
-        std::cerr << "Skeleton_simplex_iterator end()\n";
+        std::clog << "Skeleton_simplex_iterator end()\n";
       }
       Skeleton_simplex_iterator it(this->b, this->dimension);
       it.position = this->b->data.size();
@@ -500,7 +500,7 @@ class Bitmap_cubical_complex : public T {
    **/
   Skeleton_simplex_range skeleton_simplex_range(unsigned dimension) {
     if (globalDbg) {
-      std::cerr << "Skeleton_simplex_range skeleton_simplex_range( unsigned dimension )\n";
+      std::clog << "Skeleton_simplex_range skeleton_simplex_range( unsigned dimension )\n";
     }
     return Skeleton_simplex_range(this, dimension);
   }
@@ -515,7 +515,7 @@ class Bitmap_cubical_complex : public T {
 template <typename T>
 void Bitmap_cubical_complex<T>::initialize_simplex_associated_to_key() {
   if (globalDbg) {
-    std::cerr << "void Bitmap_cubical_complex<T>::initialize_elements_ordered_according_to_filtration() \n";
+    std::clog << "void Bitmap_cubical_complex<T>::initialize_elements_ordered_according_to_filtration() \n";
   }
   this->simplex_associated_to_key = std::vector<std::size_t>(this->data.size());
   std::iota(std::begin(simplex_associated_to_key), std::end(simplex_associated_to_key), 0);
diff --git a/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex_base.h b/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex_base.h
index 0d6299d2..1eb77c9c 100644
--- a/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex_base.h
+++ b/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex_base.h
@@ -142,7 +142,7 @@ class Bitmap_cubical_complex_base {
       }
       if (coface_counter[i] != face_counter[i]) {
         if (number_of_position_in_which_counters_do_not_agree != -1) {
-          std::cout << "Cells given to compute_incidence_between_cells procedure do not form a pair of coface-face.\n";
+          std::cerr << "Cells given to compute_incidence_between_cells procedure do not form a pair of coface-face.\n";
           throw std::logic_error(
               "Cells given to compute_incidence_between_cells procedure do not form a pair of coface-face.");
         }
@@ -408,7 +408,7 @@ class Bitmap_cubical_complex_base {
 
     void print_counter() const {
       for (std::size_t i = 0; i != this->counter.size(); ++i) {
-        std::cout << this->counter[i] << " ";
+        std::clog << this->counter[i] << " ";
       }
     }
     friend class Bitmap_cubical_complex_base;
@@ -521,11 +521,11 @@ void Bitmap_cubical_complex_base<T>::put_data_to_bins(std::size_t number_of_bins
   // now put the data into the appropriate bins:
   for (std::size_t i = 0; i != this->data.size(); ++i) {
     if (dbg) {
-      std::cerr << "Before binning : " << this->data[i] << std::endl;
+      std::clog << "Before binning : " << this->data[i] << std::endl;
     }
     this->data[i] = min_max.first + dx * (this->data[i] - min_max.first) / number_of_bins;
     if (dbg) {
-      std::cerr << "After binning : " << this->data[i] << std::endl;
+      std::clog << "After binning : " << this->data[i] << std::endl;
     }
   }
 }
@@ -539,11 +539,11 @@ void Bitmap_cubical_complex_base<T>::put_data_to_bins(T diameter_of_bin) {
   // now put the data into the appropriate bins:
   for (std::size_t i = 0; i != this->data.size(); ++i) {
     if (dbg) {
-      std::cerr << "Before binning : " << this->data[i] << std::endl;
+      std::clog << "Before binning : " << this->data[i] << std::endl;
     }
     this->data[i] = min_max.first + diameter_of_bin * (this->data[i] - min_max.first) / number_of_bins;
     if (dbg) {
-      std::cerr << "After binning : " << this->data[i] << std::endl;
+      std::clog << "After binning : " << this->data[i] << std::endl;
     }
   }
 }
@@ -617,7 +617,7 @@ void Bitmap_cubical_complex_base<T>::read_perseus_style_file(const char* perseus
   inFiltration >> dimensionOfData;
 
   if (dbg) {
-    std::cerr << "dimensionOfData : " << dimensionOfData << std::endl;
+    std::clog << "dimensionOfData : " << dimensionOfData << std::endl;
   }
 
   std::vector<unsigned> sizes;
@@ -630,7 +630,7 @@ void Bitmap_cubical_complex_base<T>::read_perseus_style_file(const char* perseus
     sizes.push_back(size_in_this_dimension);
     dimensions *= size_in_this_dimension;
     if (dbg) {
-      std::cerr << "size_in_this_dimension : " << size_in_this_dimension << std::endl;
+      std::clog << "size_in_this_dimension : " << size_in_this_dimension << std::endl;
     }
   }
   this->set_up_containers(sizes);
@@ -651,7 +651,7 @@ void Bitmap_cubical_complex_base<T>::read_perseus_style_file(const char* perseus
       }
 
       if (dbg) {
-        std::cerr << "Cell of an index : " << it.compute_index_in_bitmap()
+        std::clog << "Cell of an index : " << it.compute_index_in_bitmap()
                   << " and dimension: " << this->get_dimension_of_a_cell(it.compute_index_in_bitmap())
                   << " get the value : " << filtrationLevel << std::endl;
       }
@@ -754,20 +754,20 @@ std::vector<std::size_t> Bitmap_cubical_complex_base<T>::get_coboundary_of_a_cel
 template <typename T>
 unsigned Bitmap_cubical_complex_base<T>::get_dimension_of_a_cell(std::size_t cell) const {
   bool dbg = false;
-  if (dbg) std::cerr << "\n\n\n Computing position o a cell of an index : " << cell << std::endl;
+  if (dbg) std::clog << "\n\n\n Computing position o a cell of an index : " << cell << std::endl;
   unsigned dimension = 0;
   for (std::size_t i = this->multipliers.size(); i != 0; --i) {
     unsigned position = cell / this->multipliers[i - 1];
 
     if (dbg) {
-      std::cerr << "i-1 :" << i - 1 << std::endl;
-      std::cerr << "cell : " << cell << std::endl;
-      std::cerr << "position : " << position << std::endl;
-      std::cerr << "multipliers[" << i - 1 << "] = " << this->multipliers[i - 1] << std::endl;
+      std::clog << "i-1 :" << i - 1 << std::endl;
+      std::clog << "cell : " << cell << std::endl;
+      std::clog << "position : " << position << std::endl;
+      std::clog << "multipliers[" << i - 1 << "] = " << this->multipliers[i - 1] << std::endl;
     }
 
     if (position % 2 == 1) {
-      if (dbg) std::cerr << "Nonzero length in this direction \n";
+      if (dbg) std::clog << "Nonzero length in this direction \n";
       dimension++;
     }
     cell = cell % this->multipliers[i - 1];
@@ -803,9 +803,9 @@ void Bitmap_cubical_complex_base<T>::impose_lower_star_filtration() {
 
   while (indices_to_consider.size()) {
     if (dbg) {
-      std::cerr << "indices_to_consider in this iteration \n";
+      std::clog << "indices_to_consider in this iteration \n";
       for (std::size_t i = 0; i != indices_to_consider.size(); ++i) {
-        std::cout << indices_to_consider[i] << "  ";
+        std::clog << indices_to_consider[i] << "  ";
       }
     }
     std::vector<std::size_t> new_indices_to_consider;
@@ -813,14 +813,14 @@ void Bitmap_cubical_complex_base<T>::impose_lower_star_filtration() {
       std::vector<std::size_t> bd = this->get_boundary_of_a_cell(indices_to_consider[i]);
       for (std::size_t boundaryIt = 0; boundaryIt != bd.size(); ++boundaryIt) {
         if (dbg) {
-          std::cerr << "filtration of a cell : " << bd[boundaryIt] << " is : " << this->data[bd[boundaryIt]]
+          std::clog << "filtration of a cell : " << bd[boundaryIt] << " is : " << this->data[bd[boundaryIt]]
                     << " while of a cell: " << indices_to_consider[i] << " is: " << this->data[indices_to_consider[i]]
                     << std::endl;
         }
         if (this->data[bd[boundaryIt]] > this->data[indices_to_consider[i]]) {
           this->data[bd[boundaryIt]] = this->data[indices_to_consider[i]];
           if (dbg) {
-            std::cerr << "Setting the value of a cell : " << bd[boundaryIt]
+            std::clog << "Setting the value of a cell : " << bd[boundaryIt]
                       << " to : " << this->data[indices_to_consider[i]] << std::endl;
           }
         }
diff --git a/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex_periodic_boundary_conditions_base.h b/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex_periodic_boundary_conditions_base.h
index edd794fe..18901469 100644
--- a/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex_periodic_boundary_conditions_base.h
+++ b/src/Bitmap_cubical_complex/include/gudhi/Bitmap_cubical_complex_periodic_boundary_conditions_base.h
@@ -128,7 +128,7 @@ class Bitmap_cubical_complex_periodic_boundary_conditions_base : public Bitmap_c
       }
       if (coface_counter[i] != face_counter[i]) {
         if (number_of_position_in_which_counters_do_not_agree != -1) {
-          std::cout << "Cells given to compute_incidence_between_cells procedure do not form a pair of coface-face.\n";
+          std::cerr << "Cells given to compute_incidence_between_cells procedure do not form a pair of coface-face.\n";
           throw std::logic_error(
               "Cells given to compute_incidence_between_cells procedure do not form a pair of coface-face.");
         }
@@ -237,7 +237,7 @@ Bitmap_cubical_complex_periodic_boundary_conditions_base<T>::Bitmap_cubical_comp
     if (inFiltration.eof()) break;
 
     if (dbg) {
-      std::cerr << "Cell of an index : " << it.compute_index_in_bitmap()
+      std::clog << "Cell of an index : " << it.compute_index_in_bitmap()
                 << " and dimension: " << this->get_dimension_of_a_cell(it.compute_index_in_bitmap())
                 << " get the value : " << filtrationLevel << std::endl;
     }
@@ -278,7 +278,7 @@ std::vector<std::size_t> Bitmap_cubical_complex_periodic_boundary_conditions_bas
     std::size_t cell) const {
   bool dbg = false;
   if (dbg) {
-    std::cerr << "Computations of boundary of a cell : " << cell << std::endl;
+    std::clog << "Computations of boundary of a cell : " << cell << std::endl;
   }
 
   std::vector<std::size_t> boundary_elements;
@@ -292,7 +292,6 @@ std::vector<std::size_t> Bitmap_cubical_complex_periodic_boundary_conditions_bas
     if (position % 2 == 1) {
       // if there are no periodic boundary conditions in this direction, we do not have to do anything.
       if (!directions_in_which_periodic_b_cond_are_to_be_imposed[i - 1]) {
-        // std::cerr << "A\n";
         if (sum_of_dimensions % 2) {
           boundary_elements.push_back(cell - this->multipliers[i - 1]);
           boundary_elements.push_back(cell + this->multipliers[i - 1]);
@@ -301,12 +300,11 @@ std::vector<std::size_t> Bitmap_cubical_complex_periodic_boundary_conditions_bas
           boundary_elements.push_back(cell - this->multipliers[i - 1]);
         }
         if (dbg) {
-          std::cerr << cell - this->multipliers[i - 1] << " " << cell + this->multipliers[i - 1] << " ";
+          std::clog << cell - this->multipliers[i - 1] << " " << cell + this->multipliers[i - 1] << " ";
         }
       } else {
         // in this direction we have to do boundary conditions. Therefore, we need to check if we are not at the end.
         if (position != 2 * this->sizes[i - 1] - 1) {
-          // std::cerr << "B\n";
           if (sum_of_dimensions % 2) {
             boundary_elements.push_back(cell - this->multipliers[i - 1]);
             boundary_elements.push_back(cell + this->multipliers[i - 1]);
@@ -315,10 +313,9 @@ std::vector<std::size_t> Bitmap_cubical_complex_periodic_boundary_conditions_bas
             boundary_elements.push_back(cell - this->multipliers[i - 1]);
           }
           if (dbg) {
-            std::cerr << cell - this->multipliers[i - 1] << " " << cell + this->multipliers[i - 1] << " ";
+            std::clog << cell - this->multipliers[i - 1] << " " << cell + this->multipliers[i - 1] << " ";
           }
         } else {
-          // std::cerr << "C\n";
           if (sum_of_dimensions % 2) {
             boundary_elements.push_back(cell - this->multipliers[i - 1]);
             boundary_elements.push_back(cell - (2 * this->sizes[i - 1] - 1) * this->multipliers[i - 1]);
@@ -327,7 +324,7 @@ std::vector<std::size_t> Bitmap_cubical_complex_periodic_boundary_conditions_bas
             boundary_elements.push_back(cell - this->multipliers[i - 1]);
           }
           if (dbg) {
-            std::cerr << cell - this->multipliers[i - 1] << " "
+            std::clog << cell - this->multipliers[i - 1] << " "
                       << cell - (2 * this->sizes[i - 1] - 1) * this->multipliers[i - 1] << " ";
           }
         }
diff --git a/src/Bitmap_cubical_complex/test/Bitmap_test.cpp b/src/Bitmap_cubical_complex/test/Bitmap_test.cpp
index f18adb36..6f35b6da 100644
--- a/src/Bitmap_cubical_complex/test/Bitmap_test.cpp
+++ b/src/Bitmap_cubical_complex/test/Bitmap_test.cpp
@@ -1402,12 +1402,12 @@ BOOST_AUTO_TEST_CASE(check_if_boundary_of_boundary_is_zero_periodic_case_2d) {
        it != ba.all_cells_iterator_end(); ++it) {    
     int i = 1;
 
-    // std::cout << "Element : " << *it << std::endl;
+    // std::clog << "Element : " << *it << std::endl;
 
     Bitmap_cubical_complex_periodic_boundary_conditions_base::Boundary_range bdrange = ba.boundary_range(*it);
     for (Bitmap_cubical_complex_periodic_boundary_conditions::Boundary_iterator bd = bdrange.begin();
          bd != bdrange.end(); ++bd) {
-      // std::cout <<  *bd << " ";
+      // std::clog <<  *bd << " ";
       Bitmap_cubical_complex_periodic_boundary_conditions::Boundary_range second_bdrange = ba.boundary_range(*bd);
       int j = 1;
       for (Bitmap_cubical_complex_periodic_boundary_conditions::Boundary_iterator bd2 = second_bdrange.begin();
@@ -1441,7 +1441,7 @@ BOOST_AUTO_TEST_CASE(check_if_boundary_of_boundary_is_zero_periodic_case_3d) {
   std::vector<int> elems_in_boundary(number_of_all_elements, 0);
   for (Bitmap_cubical_complex_periodic_boundary_conditions::All_cells_iterator it = ba.all_cells_iterator_begin();
        it != ba.all_cells_iterator_end(); ++it) {
-    // std::cout << "Element : " << *it << std::endl;
+    // std::clog << "Element : " << *it << std::endl;
     
     int i = 1;
 
@@ -1449,7 +1449,7 @@ BOOST_AUTO_TEST_CASE(check_if_boundary_of_boundary_is_zero_periodic_case_3d) {
     for (Bitmap_cubical_complex_periodic_boundary_conditions::Boundary_iterator bd = bdrange.begin();
          bd != bdrange.end(); ++bd) {
       Bitmap_cubical_complex_periodic_boundary_conditions::Boundary_range second_bdrange = ba.boundary_range(*bd);
-      // std::cout << *bd << " ";
+      // std::clog << *bd << " ";
       int j = 1;
       for (Bitmap_cubical_complex_periodic_boundary_conditions::Boundary_iterator bd2 = second_bdrange.begin();
            bd2 != second_bdrange.end(); ++bd2) {
@@ -1551,7 +1551,7 @@ BOOST_AUTO_TEST_CASE(compute_incidence_between_cells_test_periodic_boundary_cond
     Bitmap_cubical_complex_periodic_boundary_conditions_base::Boundary_range bdrange = ba.boundary_range(*it);
     for (Bitmap_cubical_complex_periodic_boundary_conditions::Boundary_iterator bd = bdrange.begin();
          bd != bdrange.end(); ++bd) {
-      // std::cout <<  *bd << " ";
+      // std::clog <<  *bd << " ";
       Bitmap_cubical_complex_periodic_boundary_conditions::Boundary_range second_bdrange = ba.boundary_range(*bd);
       for (Bitmap_cubical_complex_periodic_boundary_conditions::Boundary_iterator bd2 = second_bdrange.begin();
            bd2 != second_bdrange.end(); ++bd2) {
@@ -1571,11 +1571,11 @@ BOOST_AUTO_TEST_CASE(perseus_file_read) {
 
   auto it = increasing.top_dimensional_cells_iterator_begin();
   double value = increasing.get_cell_data(*it);
-  std::cout << "First value of sinusoid.txt is " << value << std::endl;
+  std::clog << "First value of sinusoid.txt is " << value << std::endl;
   BOOST_CHECK(value == 10.);
   // Next value
   ++it;
   value = increasing.get_cell_data(*it);
-  std::cout << "Second value of sinusoid.txt is " << value << std::endl;
+  std::clog << "Second value of sinusoid.txt is " << value << std::endl;
   BOOST_CHECK(value == std::numeric_limits<double>::infinity());
 }
diff --git a/src/Bitmap_cubical_complex/utilities/cubical_complex_persistence.cpp b/src/Bitmap_cubical_complex/utilities/cubical_complex_persistence.cpp
index a9792c2d..510861cd 100644
--- a/src/Bitmap_cubical_complex/utilities/cubical_complex_persistence.cpp
+++ b/src/Bitmap_cubical_complex/utilities/cubical_complex_persistence.cpp
@@ -19,7 +19,7 @@
 #include <cstddef>
 
 int main(int argc, char** argv) {
-  std::cout
+  std::clog
       << "This program computes persistent homology, by using bitmap_cubical_complex class, of cubical "
       << "complexes provided in text files in Perseus style (the only numbered in the first line is a dimension D of a"
       << "bitmap. In the lines I between 2 and D+1 there are numbers of top dimensional cells in the direction I. Let "
@@ -62,7 +62,7 @@ int main(int argc, char** argv) {
   pcoh.output_diagram(out);
   out.close();
 
-  std::cout << "Result in file: " << output_file_name << "\n";
+  std::clog << "Result in file: " << output_file_name << "\n";
 
   return 0;
 }
diff --git a/src/Bitmap_cubical_complex/utilities/periodic_cubical_complex_persistence.cpp b/src/Bitmap_cubical_complex/utilities/periodic_cubical_complex_persistence.cpp
index fa97bac0..86816417 100644
--- a/src/Bitmap_cubical_complex/utilities/periodic_cubical_complex_persistence.cpp
+++ b/src/Bitmap_cubical_complex/utilities/periodic_cubical_complex_persistence.cpp
@@ -20,7 +20,7 @@
 #include <string>
 
 int main(int argc, char** argv) {
-  std::cout
+  std::clog
       << "This program computes persistent homology, by using "
       << "Bitmap_cubical_complex_periodic_boundary_conditions class, of cubical complexes provided in text files in "
       << "Perseus style (the only numbered in the first line is a dimension D of a bitmap. In the lines I between 2 "
@@ -64,7 +64,7 @@ int main(int argc, char** argv) {
   pcoh.output_diagram(out);
   out.close();
 
-  std::cout << "Result in file: " << output_file_name << "\n";
+  std::clog << "Result in file: " << output_file_name << "\n";
 
   return 0;
 }
diff --git a/src/Bottleneck_distance/doc/Intro_bottleneck_distance.h b/src/Bottleneck_distance/doc/Intro_bottleneck_distance.h
index bbc952e1..2a988b4b 100644
--- a/src/Bottleneck_distance/doc/Intro_bottleneck_distance.h
+++ b/src/Bottleneck_distance/doc/Intro_bottleneck_distance.h
@@ -52,7 +52,7 @@ int main() {
   diag2.emplace_back(0., 13.);
 
   double b = Gudhi::persistence_diagram::bottleneck_distance(diag1, diag2);
-  std::cout << "Bottleneck distance = " << b << std::endl;
+  std::clog << "Bottleneck distance = " << b << std::endl;
 }
  * \endcode
  *
diff --git a/src/Bottleneck_distance/example/alpha_rips_persistence_bottleneck_distance.cpp b/src/Bottleneck_distance/example/alpha_rips_persistence_bottleneck_distance.cpp
index 6c0dc9bf..4769eca3 100644
--- a/src/Bottleneck_distance/example/alpha_rips_persistence_bottleneck_distance.cpp
+++ b/src/Bottleneck_distance/example/alpha_rips_persistence_bottleneck_distance.cpp
@@ -68,7 +68,7 @@ int main(int argc, char * argv[]) {
   Simplex_tree rips_stree;
 
   rips_complex.create_complex(rips_stree, dim_max);
-  std::cout << "The Rips complex contains " << rips_stree.num_simplices() << " simplices and has dimension "
+  std::clog << "The Rips complex contains " << rips_stree.num_simplices() << " simplices and has dimension "
             << rips_stree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
@@ -89,7 +89,7 @@ int main(int argc, char * argv[]) {
 
   Simplex_tree alpha_stree;
   alpha_complex.create_complex(alpha_stree, threshold * threshold);
-  std::cout << "The Alpha complex contains " << alpha_stree.num_simplices() << " simplices and has dimension "
+  std::clog << "The Alpha complex contains " << alpha_stree.num_simplices() << " simplices and has dimension "
             << alpha_stree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
@@ -115,12 +115,12 @@ int main(int argc, char * argv[]) {
     std::transform(alpha_intervals.begin(), alpha_intervals.end(), alpha_intervals.begin(), compute_root_square);
 
     double bottleneck_distance = Gudhi::persistence_diagram::bottleneck_distance(rips_intervals, alpha_intervals);
-    std::cout << "In dimension " << dim << ", bottleneck distance = " << bottleneck_distance << std::endl;
+    std::clog << "In dimension " << dim << ", bottleneck distance = " << bottleneck_distance << std::endl;
     if (bottleneck_distance > max_b_distance)
       max_b_distance = bottleneck_distance;
   }
-  std::cout << "================================================================================" << std::endl;
-  std::cout << "Bottleneck distance is " << max_b_distance << std::endl;
+  std::clog << "================================================================================" << std::endl;
+  std::clog << "Bottleneck distance is " << max_b_distance << std::endl;
 
   return 0;
 }
@@ -162,17 +162,17 @@ void program_options(int argc, char * argv[]
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a Rips complex defined on a set of input points.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a Rips complex defined on a set of input points.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Bottleneck_distance/example/bottleneck_basic_example.cpp b/src/Bottleneck_distance/example/bottleneck_basic_example.cpp
index 61778a55..e8632a4f 100644
--- a/src/Bottleneck_distance/example/bottleneck_basic_example.cpp
+++ b/src/Bottleneck_distance/example/bottleneck_basic_example.cpp
@@ -20,9 +20,9 @@ int main() {
 
   double b = Gudhi::persistence_diagram::bottleneck_distance(v1, v2);
 
-  std::cout << "Bottleneck distance = " << b << std::endl;
+  std::clog << "Bottleneck distance = " << b << std::endl;
 
   b = Gudhi::persistence_diagram::bottleneck_distance(v1, v2, 0.1);
 
-  std::cout << "Approx bottleneck distance = " << b << std::endl;
+  std::clog << "Approx bottleneck distance = " << b << std::endl;
 }
diff --git a/src/Bottleneck_distance/utilities/bottleneck_distance.cpp b/src/Bottleneck_distance/utilities/bottleneck_distance.cpp
index d88a8a0b..01813ba1 100644
--- a/src/Bottleneck_distance/utilities/bottleneck_distance.cpp
+++ b/src/Bottleneck_distance/utilities/bottleneck_distance.cpp
@@ -18,7 +18,7 @@
 
 int main(int argc, char** argv) {
   if (argc < 3) {
-    std::cout << "To run this program please provide as an input two files with persistence diagrams. Each file" <<
+    std::clog << "To run this program please provide as an input two files with persistence diagrams. Each file" <<
         " should contain a birth-death pair per line. Third, optional parameter is an error bound on the bottleneck" <<
         " distance (set by default to the smallest positive double value). If you set the error bound to 0, be" <<
         " aware this version is exact but expensive. The program will now terminate \n";
@@ -32,7 +32,7 @@ int main(int argc, char** argv) {
     tolerance = atof(argv[3]);
   }
   double b = Gudhi::persistence_diagram::bottleneck_distance(diag1, diag2, tolerance);
-  std::cout << "The distance between the diagrams is : " << b << ". The tolerance is : " << tolerance << std::endl;
+  std::clog << "The distance between the diagrams is : " << b << ". The tolerance is : " << tolerance << std::endl;
 
   return 0;
 }
diff --git a/src/Cech_complex/benchmark/cech_complex_benchmark.cpp b/src/Cech_complex/benchmark/cech_complex_benchmark.cpp
index d2d71dbf..e489e8a4 100644
--- a/src/Cech_complex/benchmark/cech_complex_benchmark.cpp
+++ b/src/Cech_complex/benchmark/cech_complex_benchmark.cpp
@@ -68,24 +68,24 @@ int main(int argc, char* argv[]) {
   Proximity_graph euclidean_prox_graph = Gudhi::compute_proximity_graph<Simplex_tree>(
       off_reader.get_point_cloud(), threshold, Gudhi::Euclidean_distance());
 
-  std::cout << euclidean_clock << std::endl;
+  std::clog << euclidean_clock << std::endl;
 
   Gudhi::Clock miniball_clock("Minimal_enclosing_ball_radius");
   // Compute the proximity graph of the points
   Proximity_graph miniball_prox_graph = Gudhi::compute_proximity_graph<Simplex_tree>(
       off_reader.get_point_cloud(), threshold, Minimal_enclosing_ball_radius());
-  std::cout << miniball_clock << std::endl;
+  std::clog << miniball_clock << std::endl;
 
   Gudhi::Clock common_miniball_clock("Gudhi::Minimal_enclosing_ball_radius()");
   // Compute the proximity graph of the points
   Proximity_graph common_miniball_prox_graph = Gudhi::compute_proximity_graph<Simplex_tree>(
       off_reader.get_point_cloud(), threshold, Gudhi::Minimal_enclosing_ball_radius());
-  std::cout << common_miniball_clock << std::endl;
+  std::clog << common_miniball_clock << std::endl;
 
   boost::filesystem::path full_path(boost::filesystem::current_path());
-  std::cout << "Current path is : " << full_path << std::endl;
+  std::clog << "Current path is : " << full_path << std::endl;
 
-  std::cout << "File name;Radius;Rips time;Cech time; Ratio Rips/Cech time;Rips nb simplices;Cech nb simplices;"
+  std::clog << "File name;Radius;Rips time;Cech time; Ratio Rips/Cech time;Rips nb simplices;Cech nb simplices;"
             << std::endl;
   boost::filesystem::directory_iterator end_itr;  // default construction yields past-the-end
   for (boost::filesystem::directory_iterator itr(boost::filesystem::current_path()); itr != end_itr; ++itr) {
@@ -96,8 +96,8 @@ int main(int argc, char* argv[]) {
         Point p0 = off_reader.get_point_cloud()[0];
 
         for (Filtration_value radius = 0.1; radius < 0.4; radius += 0.1) {
-          std::cout << itr->path().stem() << ";";
-          std::cout << radius << ";";
+          std::clog << itr->path().stem() << ";";
+          std::clog << radius << ";";
           Gudhi::Clock rips_clock("Rips computation");
           Rips_complex rips_complex_from_points(off_reader.get_point_cloud(), radius,
                                                 Gudhi::Minimal_enclosing_ball_radius());
@@ -107,7 +107,7 @@ int main(int argc, char* argv[]) {
           // Display information about the Rips complex
           // ------------------------------------------
           double rips_sec = rips_clock.num_seconds();
-          std::cout << rips_sec << ";";
+          std::clog << rips_sec << ";";
 
           Gudhi::Clock cech_clock("Cech computation");
           Cech_complex cech_complex_from_points(off_reader.get_point_cloud(), radius);
@@ -117,12 +117,12 @@ int main(int argc, char* argv[]) {
           // Display information about the Cech complex
           // ------------------------------------------
           double cech_sec = cech_clock.num_seconds();
-          std::cout << cech_sec << ";";
-          std::cout << cech_sec / rips_sec << ";";
+          std::clog << cech_sec << ";";
+          std::clog << cech_sec / rips_sec << ";";
 
           assert(rips_stree.num_simplices() >= cech_stree.num_simplices());
-          std::cout << rips_stree.num_simplices() << ";";
-          std::cout << cech_stree.num_simplices() << ";" << std::endl;
+          std::clog << rips_stree.num_simplices() << ";";
+          std::clog << cech_stree.num_simplices() << ";" << std::endl;
         }
       }
     }
diff --git a/src/Cech_complex/example/cech_complex_example_from_points.cpp b/src/Cech_complex/example/cech_complex_example_from_points.cpp
index 3cc5a4df..1a1f708c 100644
--- a/src/Cech_complex/example/cech_complex_example_from_points.cpp
+++ b/src/Cech_complex/example/cech_complex_example_from_points.cpp
@@ -37,18 +37,18 @@ int main() {
   // ----------------------------------------------------------------------------
   // Display information about the one skeleton Cech complex
   // ----------------------------------------------------------------------------
-  std::cout << "Cech complex is of dimension " << stree.dimension() << " - " << stree.num_simplices() << " simplices - "
+  std::clog << "Cech complex is of dimension " << stree.dimension() << " - " << stree.num_simplices() << " simplices - "
             << stree.num_vertices() << " vertices." << std::endl;
 
-  std::cout << "Iterator on Cech complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  std::clog << "Iterator on Cech complex simplices in the filtration order, with [filtration value]:" << std::endl;
   for (auto f_simplex : stree.filtration_simplex_range()) {
-    std::cout << "   ( ";
+    std::clog << "   ( ";
     for (auto vertex : stree.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> "
+    std::clog << ") -> "
               << "[" << stree.filtration(f_simplex) << "] ";
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
   return 0;
 }
diff --git a/src/Cech_complex/example/cech_complex_step_by_step.cpp b/src/Cech_complex/example/cech_complex_step_by_step.cpp
index b3d05697..f59f0293 100644
--- a/src/Cech_complex/example/cech_complex_step_by_step.cpp
+++ b/src/Cech_complex/example/cech_complex_step_by_step.cpp
@@ -51,12 +51,12 @@ class Cech_blocker {
     for (auto vertex : simplex_tree_.simplex_vertex_range(sh)) {
       points.push_back(point_cloud_[vertex]);
 #ifdef DEBUG_TRACES
-      std::cout << "#(" << vertex << ")#";
+      std::clog << "#(" << vertex << ")#";
 #endif  // DEBUG_TRACES
     }
     Filtration_value radius = Gudhi::Minimal_enclosing_ball_radius()(points);
 #ifdef DEBUG_TRACES
-    std::cout << "radius = " << radius << " - " << (radius > max_radius_) << std::endl;
+    std::clog << "radius = " << radius << " - " << (radius > max_radius_) << std::endl;
 #endif  // DEBUG_TRACES
     simplex_tree_.assign_filtration(sh, radius);
     return (radius > max_radius_);
@@ -96,23 +96,23 @@ int main(int argc, char* argv[]) {
   // expand the graph until dimension dim_max
   st.expansion_with_blockers(dim_max, Cech_blocker(st, max_radius, 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::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 << "********************************************************************\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
 
@@ -144,11 +144,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/Cech_complex/include/gudhi/Cech_complex_blocker.h b/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
index 068cdde3..31b9aab5 100644
--- a/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
+++ b/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
@@ -53,12 +53,12 @@ class Cech_blocker {
     for (auto vertex : sc_ptr_->simplex_vertex_range(sh)) {
       points.push_back(cc_ptr_->get_point(vertex));
 #ifdef DEBUG_TRACES
-      std::cout << "#(" << vertex << ")#";
+      std::clog << "#(" << vertex << ")#";
 #endif  // DEBUG_TRACES
     }
     Filtration_value radius = Gudhi::Minimal_enclosing_ball_radius()(points);
 #ifdef DEBUG_TRACES
-    if (radius > cc_ptr_->max_radius()) std::cout << "radius > max_radius => expansion is blocked\n";
+    if (radius > cc_ptr_->max_radius()) std::clog << "radius > max_radius => expansion is blocked\n";
 #endif  // DEBUG_TRACES
     sc_ptr_->assign_filtration(sh, radius);
     return (radius > cc_ptr_->max_radius());
diff --git a/src/Cech_complex/test/test_cech_complex.cpp b/src/Cech_complex/test/test_cech_complex.cpp
index c6b15d7f..6e00d7b5 100644
--- a/src/Cech_complex/test/test_cech_complex.cpp
+++ b/src/Cech_complex/test/test_cech_complex.cpp
@@ -58,7 +58,7 @@ BOOST_AUTO_TEST_CASE(Cech_complex_for_documentation) {
   points.push_back({-0.5, 2.});                // 10
 
   Filtration_value max_radius = 1.0;
-  std::cout << "========== NUMBER OF POINTS = " << points.size() << " - Cech max_radius = " << max_radius
+  std::clog << "========== NUMBER OF POINTS = " << points.size() << " - Cech max_radius = " << max_radius
             << "==========" << std::endl;
 
   Cech_complex cech_complex_for_doc(points, max_radius);
@@ -72,14 +72,14 @@ BOOST_AUTO_TEST_CASE(Cech_complex_for_documentation) {
   const int DIMENSION_1 = 1;
   Simplex_tree st;
   cech_complex_for_doc.create_complex(st, DIMENSION_1);
-  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+  std::clog << "st.dimension()=" << st.dimension() << std::endl;
   BOOST_CHECK(st.dimension() == DIMENSION_1);
 
   const int NUMBER_OF_VERTICES = 11;
-  std::cout << "st.num_vertices()=" << st.num_vertices() << std::endl;
+  std::clog << "st.num_vertices()=" << st.num_vertices() << std::endl;
   BOOST_CHECK(st.num_vertices() == NUMBER_OF_VERTICES);
 
-  std::cout << "st.num_simplices()=" << st.num_simplices() << std::endl;
+  std::clog << "st.num_simplices()=" << st.num_simplices() << std::endl;
   BOOST_CHECK(st.num_simplices() == 27);
 
   // Check filtration values of vertices is 0.0
@@ -91,12 +91,12 @@ BOOST_AUTO_TEST_CASE(Cech_complex_for_documentation) {
   for (auto f_simplex : st.skeleton_simplex_range(DIMENSION_1)) {
     if (DIMENSION_1 == st.dimension(f_simplex)) {
       std::vector<Point> vp;
-      std::cout << "vertex = (";
+      std::clog << "vertex = (";
       for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-        std::cout << vertex << ",";
+        std::clog << vertex << ",";
         vp.push_back(points.at(vertex));
       }
-      std::cout << ") - distance =" << Gudhi::Minimal_enclosing_ball_radius()(vp.at(0), vp.at(1))
+      std::clog << ") - distance =" << Gudhi::Minimal_enclosing_ball_radius()(vp.at(0), vp.at(1))
                 << " - filtration =" << st.filtration(f_simplex) << std::endl;
       BOOST_CHECK(vp.size() == 2);
       GUDHI_TEST_FLOAT_EQUALITY_CHECK(st.filtration(f_simplex),
@@ -112,13 +112,13 @@ BOOST_AUTO_TEST_CASE(Cech_complex_for_documentation) {
 
   Simplex_tree st2;
   cech_complex_for_doc.create_complex(st2, DIMENSION_2);
-  std::cout << "st2.dimension()=" << st2.dimension() << std::endl;
+  std::clog << "st2.dimension()=" << st2.dimension() << std::endl;
   BOOST_CHECK(st2.dimension() == DIMENSION_2);
 
-  std::cout << "st2.num_vertices()=" << st2.num_vertices() << std::endl;
+  std::clog << "st2.num_vertices()=" << st2.num_vertices() << std::endl;
   BOOST_CHECK(st2.num_vertices() == NUMBER_OF_VERTICES);
 
-  std::cout << "st2.num_simplices()=" << st2.num_simplices() << std::endl;
+  std::clog << "st2.num_simplices()=" << st2.num_simplices() << std::endl;
   BOOST_CHECK(st2.num_simplices() == 30);
 
   Point_cloud points012;
@@ -129,7 +129,7 @@ BOOST_AUTO_TEST_CASE(Cech_complex_for_documentation) {
   Min_sphere ms012(dimension, points012.begin(), points012.end());
 
   Simplex_tree::Filtration_value f012 = st2.filtration(st2.find({0, 1, 2}));
-  std::cout << "f012= " << f012 << " | ms012_radius= " << std::sqrt(ms012.squared_radius()) << std::endl;
+  std::clog << "f012= " << f012 << " | ms012_radius= " << std::sqrt(ms012.squared_radius()) << std::endl;
 
   GUDHI_TEST_FLOAT_EQUALITY_CHECK(f012, std::sqrt(ms012.squared_radius()));
 
@@ -140,7 +140,7 @@ BOOST_AUTO_TEST_CASE(Cech_complex_for_documentation) {
   Min_sphere ms1410(dimension, points1410.begin(), points1410.end());
 
   Simplex_tree::Filtration_value f1410 = st2.filtration(st2.find({1, 4, 10}));
-  std::cout << "f1410= " << f1410 << " | ms1410_radius= " << std::sqrt(ms1410.squared_radius()) << std::endl;
+  std::clog << "f1410= " << f1410 << " | ms1410_radius= " << std::sqrt(ms1410.squared_radius()) << std::endl;
 
   GUDHI_TEST_FLOAT_EQUALITY_CHECK(f1410, std::sqrt(ms1410.squared_radius()));
 
@@ -151,7 +151,7 @@ BOOST_AUTO_TEST_CASE(Cech_complex_for_documentation) {
   Min_sphere ms469(dimension, points469.begin(), points469.end());
 
   Simplex_tree::Filtration_value f469 = st2.filtration(st2.find({4, 6, 9}));
-  std::cout << "f469= " << f469 << " | ms469_radius= " << std::sqrt(ms469.squared_radius()) << std::endl;
+  std::clog << "f469= " << f469 << " | ms469_radius= " << std::sqrt(ms469.squared_radius()) << std::endl;
 
   GUDHI_TEST_FLOAT_EQUALITY_CHECK(f469, std::sqrt(ms469.squared_radius()));
 
@@ -178,35 +178,35 @@ BOOST_AUTO_TEST_CASE(Cech_complex_from_points) {
   // ----------------------------------------------------------------------------
   Cech_complex cech_complex_from_points(points, 2.0);
 
-  std::cout << "========== cech_complex_from_points ==========" << std::endl;
+  std::clog << "========== cech_complex_from_points ==========" << std::endl;
   Simplex_tree st;
   const int DIMENSION = 3;
   cech_complex_from_points.create_complex(st, DIMENSION);
 
   // Another way to check num_simplices
-  std::cout << "Iterator on Cech complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  std::clog << "Iterator on Cech complex simplices in the filtration order, with [filtration value]:" << std::endl;
   int num_simplices = 0;
   for (auto f_simplex : st.filtration_simplex_range()) {
     num_simplices++;
-    std::cout << "   ( ";
+    std::clog << "   ( ";
     for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> "
+    std::clog << ") -> "
               << "[" << st.filtration(f_simplex) << "] ";
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
   BOOST_CHECK(num_simplices == 15);
-  std::cout << "st.num_simplices()=" << st.num_simplices() << std::endl;
+  std::clog << "st.num_simplices()=" << st.num_simplices() << std::endl;
   BOOST_CHECK(st.num_simplices() == 15);
 
-  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+  std::clog << "st.dimension()=" << st.dimension() << std::endl;
   BOOST_CHECK(st.dimension() == DIMENSION);
-  std::cout << "st.num_vertices()=" << st.num_vertices() << std::endl;
+  std::clog << "st.num_vertices()=" << st.num_vertices() << std::endl;
   BOOST_CHECK(st.num_vertices() == 4);
 
   for (auto f_simplex : st.filtration_simplex_range()) {
-    std::cout << "dimension(" << st.dimension(f_simplex) << ") - f = " << st.filtration(f_simplex) << std::endl;
+    std::clog << "dimension(" << st.dimension(f_simplex) << ") - f = " << st.filtration(f_simplex) << std::endl;
     switch (st.dimension(f_simplex)) {
       case 0:
         GUDHI_TEST_FLOAT_EQUALITY_CHECK(st.filtration(f_simplex), 0.0);
@@ -236,7 +236,7 @@ BOOST_AUTO_TEST_CASE(Cech_create_complex_throw) {
   // ----------------------------------------------------------------------------
   std::string off_file_name("alphacomplexdoc.off");
   double max_radius = 12.0;
-  std::cout << "========== OFF FILE NAME = " << off_file_name << " - Cech max_radius=" << max_radius
+  std::clog << "========== OFF FILE NAME = " << off_file_name << " - Cech max_radius=" << max_radius
             << "==========" << std::endl;
 
   Gudhi::Points_off_reader<Point> off_reader(off_file_name);
@@ -245,7 +245,7 @@ BOOST_AUTO_TEST_CASE(Cech_create_complex_throw) {
   Simplex_tree stree;
   std::vector<int> simplex = {0, 1, 2};
   stree.insert_simplex_and_subfaces(simplex);
-  std::cout << "Check exception throw in debug mode" << std::endl;
+  std::clog << "Check exception throw in debug mode" << std::endl;
   // throw excpt because stree is not empty
   BOOST_CHECK_THROW(cech_complex_from_file.create_complex(stree, 1), std::invalid_argument);
 }
diff --git a/src/Cech_complex/utilities/cech_persistence.cpp b/src/Cech_complex/utilities/cech_persistence.cpp
index 8cfe018b..daea08e2 100644
--- a/src/Cech_complex/utilities/cech_persistence.cpp
+++ b/src/Cech_complex/utilities/cech_persistence.cpp
@@ -50,8 +50,8 @@ int main(int argc, char* argv[]) {
   Simplex_tree simplex_tree;
 
   cech_complex_from_file.create_complex(simplex_tree, dim_max);
-  std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
-  std::cout << "   and has dimension " << simplex_tree.dimension() << " \n";
+  std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
+  std::clog << "   and has dimension " << simplex_tree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
   simplex_tree.initialize_filtration();
@@ -85,7 +85,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 std::clog")(
       "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.")(
@@ -108,17 +108,17 @@ void program_options(int argc, char* argv[], std::string& off_file_points, std::
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a Cech complex defined on a set of input points.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a Cech complex defined on a set of input points.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Contraction/example/Garland_heckbert.cpp b/src/Contraction/example/Garland_heckbert.cpp
index 9c0b5205..489ef5d0 100644
--- a/src/Contraction/example/Garland_heckbert.cpp
+++ b/src/Contraction/example/Garland_heckbert.cpp
@@ -147,7 +147,7 @@ int main(int argc, char *argv[]) {
     return EXIT_FAILURE;
   }
 
-  std::cout << "Load complex with " << complex.num_vertices() << " vertices" << std::endl;
+  std::clog << "Load complex with " << complex.num_vertices() << " vertices" << std::endl;
 
   int num_contractions = atoi(argv[3]);
 
@@ -158,10 +158,10 @@ int main(int argc, char *argv[]) {
                                 Gudhi::contraction::make_link_valid_contraction<EdgeProfile>(),
                                 new GH_visitor(complex));
 
-  std::cout << "Contract " << num_contractions << " edges" << std::endl;
+  std::clog << "Contract " << num_contractions << " edges" << std::endl;
   contractor.contract_edges(num_contractions);
 
-  std::cout << "Final complex has " <<
+  std::clog << "Final complex has " <<
       complex.num_vertices() << " vertices, " <<
       complex.num_edges() << " edges and " <<
       complex.num_triangles() << " triangles." << std::endl;
diff --git a/src/Contraction/example/Rips_contraction.cpp b/src/Contraction/example/Rips_contraction.cpp
index b5ce06c1..42dd0910 100644
--- a/src/Contraction/example/Rips_contraction.cpp
+++ b/src/Contraction/example/Rips_contraction.cpp
@@ -52,13 +52,13 @@ int main(int argc, char *argv[]) {
     return EXIT_FAILURE;
   }
 
-  std::cout << "Build the Rips complex with " << complex.num_vertices() << " vertices" << std::endl;
+  std::clog << "Build the Rips complex with " << complex.num_vertices() << " vertices" << std::endl;
 
   build_rips(complex, atof(argv[2]));
 
   Gudhi::Clock contraction_chrono("Time to simplify and enumerate simplices");
 
-  std::cout << "Initial complex has " <<
+  std::clog << "Initial complex has " <<
       complex.num_vertices() << " vertices and " <<
       complex.num_edges() << " edges" << std::endl;
 
@@ -69,16 +69,16 @@ int main(int argc, char *argv[]) {
                                 Gudhi::contraction::make_remove_popable_blockers_visitor<Profile>());
   contractor.contract_edges();
 
-  std::cout << "Counting final number of simplices \n";
+  std::clog << "Counting final number of simplices \n";
   unsigned num_simplices = std::distance(complex.complex_simplex_range().begin(), complex.complex_simplex_range().end());
 
-  std::cout << "Final complex has " <<
+  std::clog << "Final complex has " <<
       complex.num_vertices() << " vertices, " <<
       complex.num_edges() << " edges, " <<
       complex.num_blockers() << " blockers and " <<
       num_simplices << " simplices" << std::endl;
 
-  std::cout << contraction_chrono;
+  std::clog << contraction_chrono;
 
   return EXIT_SUCCESS;
 }
diff --git a/src/Contraction/include/gudhi/Edge_contraction.h b/src/Contraction/include/gudhi/Edge_contraction.h
index 6058d64b..6c0f4c78 100644
--- a/src/Contraction/include/gudhi/Edge_contraction.h
+++ b/src/Contraction/include/gudhi/Edge_contraction.h
@@ -164,13 +164,13 @@ int main (int argc, char *argv[])
 		std::cerr << "Unable to read file:"<<argv[1]<<std::endl;
 		return EXIT_FAILURE;
 	}
-	std::cout << "Build the Rips complex"<<std::endl;
+	std::clog << "Build the Rips complex"<<std::endl;
 
 	build_rips(complex,atof(argv[2]));
 
 	boost::timer::auto_cpu_timer t;
 
-	std::cout << "Initial complex has "<<
+	std::clog << "Initial complex has "<<
 			complex.num_vertices()<<" vertices and "<<
 			complex.num_edges()<<" edges"<<std::endl;
 
@@ -181,17 +181,17 @@ int main (int argc, char *argv[])
 			contraction::make_remove_popable_blockers_visitor<Profile>());
 	contractor.contract_edges();
 
-	std::cout << "Counting final number of simplices \n";
+	std::clog << "Counting final number of simplices \n";
 	unsigned num_simplices = std::distance(complex.star_simplex_range().begin(),complex.star_simplex_range().end());
 
-	std::cout << "Final complex has "<<
+	std::clog << "Final complex has "<<
 			complex.num_vertices()<<" vertices, "<<
 			complex.num_edges()<<" edges, "<<
 			complex.num_blockers()<<" blockers and "<<
 			num_simplices<<" simplices"<<std::endl;
 
 
-	std::cout << "Time to simplify and enumerate simplices:\n";
+	std::clog << "Time to simplify and enumerate simplices:\n";
 
 	return EXIT_SUCCESS;
 }
diff --git a/src/Doxyfile.in b/src/Doxyfile.in
index ec551882..49e781bd 100644
--- a/src/Doxyfile.in
+++ b/src/Doxyfile.in
@@ -785,6 +785,7 @@ EXCLUDE                = data/                   \
 	                     GudhUI/                 \
                          cmake/                  \
                          python/                 \
+                         ext/                    \
                          README.md
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
diff --git a/src/GudhUI/model/Model.h b/src/GudhUI/model/Model.h
index dd9bdaab..626ef59d 100644
--- a/src/GudhUI/model/Model.h
+++ b/src/GudhUI/model/Model.h
@@ -60,7 +60,7 @@ class CGAL_geometric_flag_complex_wrapper {
 
   void maximal_face(std::vector<int> vertices) {
     if (!load_only_points_) {
-      // std::cout << "size:" << vertices.size() << std::endl;
+      // std::clog << "size:" << vertices.size() << std::endl;
       for (std::size_t i = 0; i < vertices.size(); ++i)
         for (std::size_t j = i + 1; j < vertices.size(); ++j)
           complex_.add_edge_without_blockers(Vertex_handle(vertices[i]), Vertex_handle(vertices[j]));
@@ -178,7 +178,7 @@ class Model {
   void contract_edges(unsigned num_contractions) {
     Gudhi::Clock c;
     Edge_contractor<Complex> contractor(complex_, num_contractions);
-    std::cout << "Time to simplify: " << c.num_seconds() << "s" << std::endl;
+    std::clog << "Time to simplify: " << c.num_seconds() << "s" << std::endl;
   }
 
   void collapse_vertices(unsigned num_collapses) {
@@ -192,14 +192,14 @@ class Model {
   }
 
   void show_graph_stats() {
-    std::cout << "++++++ Graph stats +++++++" << std::endl;
-    std::cout << "Num vertices : " << complex_.num_vertices() << std::endl;
-    std::cout << "Num edges : " << complex_.num_edges() << std::endl;
-    std::cout << "Num connected components : " << complex_.num_connected_components() << std::endl;
-    std::cout << "Min/avg/max degree : " << min_degree() << "/" << avg_degree() << "/" << max_degree() << std::endl;
-    std::cout << "Num connected components : " << complex_.num_connected_components() << std::endl;
-    std::cout << "Num connected components : " << complex_.num_connected_components() << std::endl;
-    std::cout << "+++++++++++++++++++++++++" << std::endl;
+    std::clog << "++++++ Graph stats +++++++" << std::endl;
+    std::clog << "Num vertices : " << complex_.num_vertices() << std::endl;
+    std::clog << "Num edges : " << complex_.num_edges() << std::endl;
+    std::clog << "Num connected components : " << complex_.num_connected_components() << std::endl;
+    std::clog << "Min/avg/max degree : " << min_degree() << "/" << avg_degree() << "/" << max_degree() << std::endl;
+    std::clog << "Num connected components : " << complex_.num_connected_components() << std::endl;
+    std::clog << "Num connected components : " << complex_.num_connected_components() << std::endl;
+    std::clog << "+++++++++++++++++++++++++" << std::endl;
   }
 
  private:
@@ -226,11 +226,11 @@ class Model {
 
  public:
   void show_complex_stats() {
-    std::cout << "++++++ Mesh stats +++++++" << std::endl;
-    std::cout << "Num vertices : " << complex_.num_vertices() << std::endl;
-    std::cout << "Num edges : " << complex_.num_edges() << std::endl;
-    std::cout << "Num connected components : " << complex_.num_connected_components() << std::endl;
-    std::cout << "+++++++++++++++++++++++++" << std::endl;
+    std::clog << "++++++ Mesh stats +++++++" << std::endl;
+    std::clog << "Num vertices : " << complex_.num_vertices() << std::endl;
+    std::clog << "Num edges : " << complex_.num_edges() << std::endl;
+    std::clog << "Num connected components : " << complex_.num_connected_components() << std::endl;
+    std::clog << "+++++++++++++++++++++++++" << std::endl;
   }
 
   void show_complex_dimension() {
@@ -247,18 +247,18 @@ class Model {
         euler -= 1;
     }
     clock.end();
-    std::cout << "++++++ Mesh dimension +++++++" << std::endl;
-    std::cout << "Dimension : " << dimension << std::endl;
-    std::cout << "Euler characteristic : " << euler << std::endl;
-    std::cout << "Num simplices : " << num_simplices << std::endl;
-    std::cout << "Total time: " << clock << std::endl;
-    std::cout << "Time per simplex: " << clock.num_seconds() / num_simplices << " s" << std::endl;
-    std::cout << "+++++++++++++++++++++++++" << std::endl;
+    std::clog << "++++++ Mesh dimension +++++++" << std::endl;
+    std::clog << "Dimension : " << dimension << std::endl;
+    std::clog << "Euler characteristic : " << euler << std::endl;
+    std::clog << "Num simplices : " << num_simplices << std::endl;
+    std::clog << "Total time: " << clock << std::endl;
+    std::clog << "Time per simplex: " << clock.num_seconds() / num_simplices << " s" << std::endl;
+    std::clog << "+++++++++++++++++++++++++" << std::endl;
   }
 
   void show_homology_group() {
 #ifdef _WIN32
-    std::cout << "Works only on linux x64 for the moment\n";
+    std::clog << "Works only on linux x64 for the moment\n";
 #else
     Gudhi::Clock clock;
     run_chomp();
@@ -278,16 +278,16 @@ class Model {
       else
         euler -= 1;
     }
-    std::cout << "Saw " << num_simplices << " simplices with maximum dimension " << dimension << std::endl;
-    std::cout << "The euler characteristic is : " << euler << std::endl;
+    std::clog << "Saw " << num_simplices << " simplices with maximum dimension " << dimension << std::endl;
+    std::clog << "The euler characteristic is : " << euler << std::endl;
   }
 
   void show_persistence(int p, double threshold, int max_dim, double min_pers) {
-    Persistence_compute<Complex> persistence(complex_, std::cout, Persistence_params(p, threshold, max_dim, min_pers));
+    Persistence_compute<Complex> persistence(complex_, std::clog, Persistence_params(p, threshold, max_dim, min_pers));
   }
 
   void show_critical_points(double max_distance) {
-    Critical_points<Complex> critical_points(complex_, std::cout, max_distance);
+    Critical_points<Complex> critical_points(complex_, std::clog, max_distance);
   }
 
   void show_is_manifold() {
@@ -296,12 +296,12 @@ class Model {
     Is_manifold<Complex> test_manifold(complex_, dim, is_manifold);
 
     if (is_manifold) {
-      std::cout << "The complex is a " << dim << "-manifold\n";
+      std::clog << "The complex is a " << dim << "-manifold\n";
     } else {
       if (dim < 4) {
-        std::cout << "The complex has dimension greater than " << dim << " and is not a manifold\n";
+        std::clog << "The complex has dimension greater than " << dim << " and is not a manifold\n";
       } else {
-        std::cout << "The complex has dimension>=4 and may or may not be a manifold\n";
+        std::clog << "The complex has dimension>=4 and may or may not be a manifold\n";
       }
     }
   }
@@ -309,10 +309,10 @@ class Model {
  private:
   void run_chomp() {
     save_complex_in_file_for_chomp();
-    std::cout << "Call CHOMP library\n";
+    std::clog << "Call CHOMP library\n";
     int returnValue = system("homsimpl chomp.sim");
     if (returnValue != 0) {
-        std::cout << "homsimpl (from CHOMP) failed. Please check it is installed or available in the PATH."
+        std::cerr << "homsimpl (from CHOMP) failed. Please check it is installed or available in the PATH."
                   << std::endl;
     }
   }
diff --git a/src/GudhUI/utils/Bar_code_persistence.h b/src/GudhUI/utils/Bar_code_persistence.h
index cd9b009f..b526017a 100644
--- a/src/GudhUI/utils/Bar_code_persistence.h
+++ b/src/GudhUI/utils/Bar_code_persistence.h
@@ -58,13 +58,13 @@ class Bar_code_persistence {
     QGraphicsScene * scene = new QGraphicsScene();
     view->setScene(scene);
     double ratio = 600.0 / (max_death - min_birth);
-    // std::cout << "min_birth=" << min_birth << " - max_death=" << max_death << " - ratio=" << ratio << std::endl;
+    // std::clog << "min_birth=" << min_birth << " - max_death=" << max_death << " - ratio=" << ratio << std::endl;
 
     double height = 0.0, birth = 0.0, death = 0.0;
     int pers_num = 1;
     for (auto& persistence : persistence_vector) {
       height = 5.0 * pers_num;
-      // std::cout << "[" << pers_num << "] birth=" << persistence.first << " - death=" << persistence.second << std::endl;
+      // std::clog << "[" << pers_num << "] birth=" << persistence.first << " - death=" << persistence.second << std::endl;
       if (std::isfinite(persistence.first))
         birth = ((persistence.first - min_birth) * ratio) + 50.0;
       else
diff --git a/src/GudhUI/utils/Critical_points.h b/src/GudhUI/utils/Critical_points.h
index 32fcf32e..97e58737 100644
--- a/src/GudhUI/utils/Critical_points.h
+++ b/src/GudhUI/utils/Critical_points.h
@@ -65,7 +65,7 @@ template<typename SkBlComplex> class Critical_points {
   void anti_collapse_edges(const std::deque<Edge>& edges) {
     unsigned pos = 0;
     for (Edge e : edges) {
-      std::cout << "edge " << pos++ << "/" << edges.size() << "\n";
+      std::clog << "edge " << pos++ << "/" << edges.size() << "\n";
       auto eh = filled_complex_.add_edge_without_blockers(e.first, e.second);
       int is_contractible(is_link_reducible(eh));
 
diff --git a/src/GudhUI/utils/Rips_builder.h b/src/GudhUI/utils/Rips_builder.h
index aba1a8e4..0300190c 100644
--- a/src/GudhUI/utils/Rips_builder.h
+++ b/src/GudhUI/utils/Rips_builder.h
@@ -43,13 +43,13 @@ template<typename SkBlComplex> class Rips_builder {
   void compute_edges(double alpha) {
     auto vertices = complex_.vertex_range();
     for (auto p = vertices.begin(); p != vertices.end(); ++p) {
-      std::cout << *p << " ";
-      std::cout.flush();
+      std::clog << *p << " ";
+      std::clog.flush();
       for (auto q = p; ++q != vertices.end(); /**/)
         if (squared_eucl_distance(complex_.point(*p), complex_.point(*q)) < 4 * alpha * alpha)
           complex_.add_edge_without_blockers(*p, *q);
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 };
 
diff --git a/src/GudhUI/view/View_parameter.h b/src/GudhUI/view/View_parameter.h
index dfd3aa41..3671f4fb 100644
--- a/src/GudhUI/view/View_parameter.h
+++ b/src/GudhUI/view/View_parameter.h
@@ -52,13 +52,13 @@ class View_parameter {
   void change_vertex_mode() {
     int current_value = vertex_mode;
     vertex_mode = static_cast<VERTEX_MODE> (++current_value % V_COUNT);
-    std::cout << "Vertex mode : ";
+    std::clog << "Vertex mode : ";
     switch (vertex_mode) {
       case V_NONE:
-        std::cout << "empty\n";
+        std::clog << "empty\n";
         break;
       case V_SIMPLE:
-        std::cout << "simple\n";
+        std::clog << "simple\n";
         break;
       default:
         break;
diff --git a/src/Hasse_complex/include/gudhi/Hasse_complex.h b/src/Hasse_complex/include/gudhi/Hasse_complex.h
index 209fd0b9..8ce8c36f 100644
--- a/src/Hasse_complex/include/gudhi/Hasse_complex.h
+++ b/src/Hasse_complex/include/gudhi/Hasse_complex.h
@@ -173,9 +173,9 @@ class Hasse_complex {
   }
 
   void display_simplex(Simplex_handle sh) {
-    std::cout << dimension(sh) << "  ";
-    for (auto sh_b : boundary_simplex_range(sh)) std::cout << sh_b << " ";
-    std::cout << "  " << filtration(sh) << "         key=" << key(sh);
+    std::clog << dimension(sh) << "  ";
+    for (auto sh_b : boundary_simplex_range(sh)) std::clog << sh_b << " ";
+    std::clog << "  " << filtration(sh) << "         key=" << key(sh);
   }
 
   void initialize_filtration() {
diff --git a/src/Nerve_GIC/example/CoordGIC.cpp b/src/Nerve_GIC/example/CoordGIC.cpp
index fd9c224a..f0afdca5 100644
--- a/src/Nerve_GIC/example/CoordGIC.cpp
+++ b/src/Nerve_GIC/example/CoordGIC.cpp
@@ -40,7 +40,7 @@ int main(int argc, char **argv) {
   bool check = GIC.read_point_cloud(off_file_name);
 
   if (!check) {
-    std::cout << "Incorrect OFF file." << std::endl;
+    std::clog << "Incorrect OFF file." << std::endl;
   } else {
     GIC.set_type("GIC");
 
@@ -67,15 +67,15 @@ int main(int argc, char **argv) {
     // --------------------------------------------
 
     if (verb) {
-      std::cout << "Coordinate GIC is of dimension " << stree.dimension() << " - " << stree.num_simplices()
+      std::clog << "Coordinate GIC is of dimension " << stree.dimension() << " - " << stree.num_simplices()
                 << " simplices - " << stree.num_vertices() << " vertices." << std::endl;
 
-      std::cout << "Iterator on coordinate GIC simplices" << std::endl;
+      std::clog << "Iterator on coordinate GIC simplices" << std::endl;
       for (auto f_simplex : stree.filtration_simplex_range()) {
         for (auto vertex : stree.simplex_vertex_range(f_simplex)) {
-          std::cout << vertex << " ";
+          std::clog << vertex << " ";
         }
-        std::cout << std::endl;
+        std::clog << std::endl;
       }
     }
   }
diff --git a/src/Nerve_GIC/example/FuncGIC.cpp b/src/Nerve_GIC/example/FuncGIC.cpp
index 5a323795..518e1826 100644
--- a/src/Nerve_GIC/example/FuncGIC.cpp
+++ b/src/Nerve_GIC/example/FuncGIC.cpp
@@ -41,7 +41,7 @@ int main(int argc, char **argv) {
   bool check = GIC.read_point_cloud(off_file_name);
 
   if (!check) {
-    std::cout << "Incorrect OFF file." << std::endl;
+    std::clog << "Incorrect OFF file." << std::endl;
   } else {
     GIC.set_type("GIC");
 
@@ -65,15 +65,15 @@ int main(int argc, char **argv) {
     // --------------------------------------------
 
     if (verb) {
-      std::cout << "Functional GIC is of dimension " << stree.dimension() << " - " << stree.num_simplices()
+      std::clog << "Functional GIC is of dimension " << stree.dimension() << " - " << stree.num_simplices()
                 << " simplices - " << stree.num_vertices() << " vertices." << std::endl;
 
-      std::cout << "Iterator on functional GIC simplices" << std::endl;
+      std::clog << "Iterator on functional GIC simplices" << std::endl;
       for (auto f_simplex : stree.filtration_simplex_range()) {
         for (auto vertex : stree.simplex_vertex_range(f_simplex)) {
-          std::cout << vertex << " ";
+          std::clog << vertex << " ";
         }
-        std::cout << std::endl;
+        std::clog << std::endl;
       }
     }
   }
diff --git a/src/Nerve_GIC/include/gudhi/GIC.h b/src/Nerve_GIC/include/gudhi/GIC.h
index 2a6d4788..1b1f9323 100644
--- a/src/Nerve_GIC/include/gudhi/GIC.h
+++ b/src/Nerve_GIC/include/gudhi/GIC.h
@@ -139,19 +139,9 @@ class Cover_complex {
     for (boost::tie(ei, ei_end) = boost::edges(G); ei != ei_end; ++ei) boost::remove_edge(*ei, G);
   }
 
-  // Thread local is not available on XCode version < V.8
-  // If not available, random engine is a class member.
-#ifndef GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-  std::default_random_engine re;
-#endif  // GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-
   // Find random number in [0,1].
   double GetUniform() {
-    // Thread local is not available on XCode version < V.8
-    // If available, random engine is defined for each thread.
-#ifdef GUDHI_CAN_USE_CXX11_THREAD_LOCAL
     thread_local std::default_random_engine re;
-#endif  // GUDHI_CAN_USE_CXX11_THREAD_LOCAL
     std::uniform_real_distribution<double> Dist(0, 1);
     return Dist(re);
   }
@@ -344,7 +334,7 @@ class Cover_complex {
     if (num_edges(one_skeleton_OFF))
       one_skeleton = one_skeleton_OFF;
     else
-      std::cout << "No triangulation read in OFF file!" << std::endl;
+      std::cerr << "No triangulation read in OFF file!" << std::endl;
   }
 
  public:  // Set graph from Rips complex.
@@ -407,7 +397,7 @@ class Cover_complex {
     std::ifstream input(distance, std::ios::out | std::ios::binary);
 
     if (input.good()) {
-      if (verbose) std::cout << "Reading distances..." << std::endl;
+      if (verbose) std::clog << "Reading distances..." << std::endl;
       for (int i = 0; i < n; i++) {
         for (int j = i; j < n; j++) {
           input.read((char*)&d, 8);
@@ -417,12 +407,12 @@ class Cover_complex {
       }
       input.close();
     } else {
-      if (verbose) std::cout << "Computing distances..." << std::endl;
+      if (verbose) std::clog << "Computing distances..." << std::endl;
       input.close();
       std::ofstream output(distance, std::ios::out | std::ios::binary);
       for (int i = 0; i < n; i++) {
         int state = (int)floor(100 * (i * 1.0 + 1) / n) % 10;
-        if (state == 0 && verbose) std::cout << "\r" << state << "%" << std::flush;
+        if (state == 0 && verbose) std::clog << "\r" << state << "%" << std::flush;
         for (int j = i; j < n; j++) {
           double dis = ref_distance(point_cloud[i], point_cloud[j]);
           distances[i][j] = dis;
@@ -431,7 +421,7 @@ class Cover_complex {
         }
       }
       output.close();
-      if (verbose) std::cout << std::endl;
+      if (verbose) std::clog << std::endl;
     }
   }
 
@@ -451,14 +441,12 @@ class Cover_complex {
     m = (std::min)(m, n - 1);
     double delta = 0;
 
-    if (verbose) std::cout << n << " points in R^" << data_dimension << std::endl;
-    if (verbose) std::cout << "Subsampling " << m << " points" << std::endl;
+    if (verbose) std::clog << n << " points in R^" << data_dimension << std::endl;
+    if (verbose) std::clog << "Subsampling " << m << " points" << std::endl;
 
     if (distances.size() == 0) compute_pairwise_distances(distance);
 
-    // This cannot be parallelized if thread_local is not defined
-    // thread_local is not defined for XCode < v.8
-    #if defined(GUDHI_USE_TBB) && defined(GUDHI_CAN_USE_CXX11_THREAD_LOCAL)
+    #ifdef GUDHI_USE_TBB
     std::mutex deltamutex;
     tbb::parallel_for(0, N, [&](int i){
         std::vector<int> samples(m);
@@ -487,7 +475,7 @@ class Cover_complex {
       }
     #endif
 
-    if (verbose) std::cout << "delta = " << delta << std::endl;
+    if (verbose) std::clog << "delta = " << delta << std::endl;
     set_graph_from_rips(delta, distance);
     return delta;
   }
@@ -530,7 +518,7 @@ class Cover_complex {
       cover_name = "coordinate " + std::to_string(k);
     }
     else{
-      std::cout << "Only pairwise distances provided---cannot access " << k << "th coordinate; returning null vector instead" << std::endl;
+      std::cerr << "Only pairwise distances provided---cannot access " << k << "th coordinate; returning null vector instead" << std::endl;
       for (int i = 0; i < n; i++) func.push_back(0.0);
       functional_cover = true;
       cover_name = "null";
@@ -563,11 +551,11 @@ class Cover_complex {
            */
   double set_automatic_resolution() {
     if (!functional_cover) {
-      std::cout << "Cover needs to come from the preimages of a function." << std::endl;
+      std::cerr << "Cover needs to come from the preimages of a function." << std::endl;
       return 0;
     }
     if (type != "Nerve" && type != "GIC") {
-      std::cout << "Type of complex needs to be specified." << std::endl;
+      std::cerr << "Type of complex needs to be specified." << std::endl;
       return 0;
     }
 
@@ -579,7 +567,7 @@ class Cover_complex {
       for (boost::tie(ei, ei_end) = boost::edges(one_skeleton); ei != ei_end; ++ei)
         reso = (std::max)(reso, std::abs(func[index[boost::source(*ei, one_skeleton)]] -
                                        func[index[boost::target(*ei, one_skeleton)]]));
-      if (verbose) std::cout << "resolution = " << reso << std::endl;
+      if (verbose) std::clog << "resolution = " << reso << std::endl;
       resolution_double = reso;
     }
 
@@ -589,7 +577,7 @@ class Cover_complex {
         reso = (std::max)(reso, std::abs(func[index[boost::source(*ei, one_skeleton)]] -
                                        func[index[boost::target(*ei, one_skeleton)]]) /
                                   gain);
-      if (verbose) std::cout << "resolution = " << reso << std::endl;
+      if (verbose) std::clog << "resolution = " << reso << std::endl;
       resolution_double = reso;
     }
 
@@ -622,11 +610,11 @@ class Cover_complex {
            */
   void set_cover_from_function() {
     if (resolution_double == -1 && resolution_int == -1) {
-      std::cout << "Number and/or length of intervals not specified" << std::endl;
+      std::cerr << "Number and/or length of intervals not specified" << std::endl;
       return;
     }
     if (gain == -1) {
-      std::cout << "Gain not specified" << std::endl;
+      std::cerr << "Gain not specified" << std::endl;
       return;
     }
 
@@ -637,7 +625,7 @@ class Cover_complex {
       minf = (std::min)(minf, func[i]);
       maxf = (std::max)(maxf, func[i]);
     }
-    if (verbose) std::cout << "Min function value = " << minf << " and Max function value = " << maxf << std::endl;
+    if (verbose) std::clog << "Min function value = " << minf << " and Max function value = " << maxf << std::endl;
 
     // Compute cover of im(f)
     std::vector<std::pair<double, double> > intervals;
@@ -663,7 +651,7 @@ class Cover_complex {
       res = intervals.size();
       if (verbose) {
         for (int i = 0; i < res; i++)
-          std::cout << "Interval " << i << " = [" << intervals[i].first << ", " << intervals[i].second << "]"
+          std::clog << "Interval " << i << " = [" << intervals[i].first << ", " << intervals[i].second << "]"
                     << std::endl;
       }
     } else {
@@ -681,7 +669,7 @@ class Cover_complex {
         res = intervals.size();
         if (verbose) {
           for (int i = 0; i < res; i++)
-            std::cout << "Interval " << i << " = [" << intervals[i].first << ", " << intervals[i].second << "]"
+            std::clog << "Interval " << i << " = [" << intervals[i].first << ", " << intervals[i].second << "]"
                       << std::endl;
         }
       } else {  // Case we use an integer and a double for the length of the intervals.
@@ -698,7 +686,7 @@ class Cover_complex {
         res = intervals.size();
         if (verbose) {
           for (int i = 0; i < res; i++)
-            std::cout << "Interval " << i << " = [" << intervals[i].first << ", " << intervals[i].second << "]"
+            std::clog << "Interval " << i << " = [" << intervals[i].first << ", " << intervals[i].second << "]"
                       << std::endl;
         }
       }
@@ -715,7 +703,7 @@ class Cover_complex {
     std::map<int, std::vector<int> > preimages;
     std::map<int, double> funcstd;
 
-    if (verbose) std::cout << "Computing preimages..." << std::endl;
+    if (verbose) std::clog << "Computing preimages..." << std::endl;
     for (int i = 0; i < res; i++) {
       // Find points in the preimage
       std::pair<double, double> inter1 = intervals[i];
@@ -764,7 +752,7 @@ class Cover_complex {
     }
 
     #ifdef GUDHI_USE_TBB
-      if (verbose) std::cout << "Computing connected components (parallelized)..." << std::endl;
+      if (verbose) std::clog << "Computing connected components (parallelized)..." << std::endl;
       std::mutex covermutex, idmutex;
       tbb::parallel_for(0, res, [&](int i){
         // Compute connected components
@@ -800,7 +788,7 @@ class Cover_complex {
         idmutex.unlock();
       });
     #else
-      if (verbose) std::cout << "Computing connected components..." << std::endl;
+      if (verbose) std::clog << "Computing connected components..." << std::endl;
       for (int i = 0; i < res; i++) {
         // Compute connected components
         Graph G = one_skeleton.create_subgraph();
@@ -894,7 +882,7 @@ class Cover_complex {
 
     // Compute the geodesic distances to subsamples with Dijkstra
     #ifdef GUDHI_USE_TBB
-      if (verbose) std::cout << "Computing geodesic distances (parallelized)..." << std::endl;
+      if (verbose) std::clog << "Computing geodesic distances (parallelized)..." << std::endl;
       std::mutex coverMutex; std::mutex mindistMutex;
       tbb::parallel_for(0, m, [&](int i){
         int seed = voronoi_subsamples[i];
@@ -916,7 +904,7 @@ class Cover_complex {
       });
     #else
       for (int i = 0; i < m; i++) {
-        if (verbose) std::cout << "Computing geodesic distances to seed " << i << "..." << std::endl;
+        if (verbose) std::clog << "Computing geodesic distances to seed " << i << "..." << std::endl;
         int seed = voronoi_subsamples[i];
         std::vector<double> dmap(n);
         boost::dijkstra_shortest_paths(
@@ -991,7 +979,7 @@ class Cover_complex {
       color_name.append(std::to_string(k));
     }
     else{
-      std::cout << "Only pairwise distances provided---cannot access " << k << "th coordinate; returning null vector instead" << std::endl;
+      std::cerr << "Only pairwise distances provided---cannot access " << k << "th coordinate; returning null vector instead" << std::endl;
       for (int i = 0; i < n; i++) func.push_back(0.0);
       functional_cover = true;
       cover_name = "null";
@@ -1054,7 +1042,7 @@ class Cover_complex {
       }
     graphic << "}";
     graphic.close();
-    std::cout << mapp << " file generated. It can be visualized with e.g. neato." << std::endl;
+    std::clog << mapp << " file generated. It can be visualized with e.g. neato." << std::endl;
   }
 
  public:  // Create a .txt file that can be compiled with KeplerMapper.
@@ -1090,7 +1078,7 @@ class Cover_complex {
         if (cover_color[simplices[i][0]].first > mask && cover_color[simplices[i][1]].first > mask)
           graphic << name2id[simplices[i][0]] << " " << name2id[simplices[i][1]] << std::endl;
     graphic.close();
-    std::cout << mapp
+    std::clog << mapp
               << " generated. It can be visualized with e.g. python KeplerMapperVisuFromTxtFile.py and firefox."
               << std::endl;
   }
@@ -1137,7 +1125,7 @@ class Cover_complex {
     for (int i = 0; i < numfaces; i++)
       graphic << 3 << " " << faces[i][0] << " " << faces[i][1] << " " << faces[i][2] << std::endl;
     graphic.close();
-    std::cout << mapp << " generated. It can be visualized with e.g. geomview." << std::endl;
+    std::clog << mapp << " generated. It can be visualized with e.g. geomview." << std::endl;
   }
 
   // *******************************************************************************************************************
@@ -1185,7 +1173,7 @@ class Cover_complex {
     for (int i = 0; i < max_dim; i++) {
       std::vector<std::pair<double, double> > bars = pcoh.intervals_in_dimension(i);
       int num_bars = bars.size(); if(i == 0)  num_bars -= 1;
-      if(verbose)  std::cout << num_bars << " interval(s) in dimension " << i << ":" << std::endl;
+      if(verbose)  std::clog << num_bars << " interval(s) in dimension " << i << ":" << std::endl;
       for (int j = 0; j < num_bars; j++) {
         double birth = bars[j].first;
         double death = bars[j].second;
@@ -1199,7 +1187,7 @@ class Cover_complex {
         else
           death = minf + (2 - death) * (maxf - minf);
         PD.push_back(std::pair<double, double>(birth, death));
-        if (verbose) std::cout << "  [" << birth << ", " << death << "]" << std::endl;
+        if (verbose) std::clog << "  [" << birth << ", " << death << "]" << std::endl;
       }
     }
     return PD;
@@ -1213,11 +1201,9 @@ class Cover_complex {
    */
   void compute_distribution(unsigned int N = 100) {
     unsigned int sz = distribution.size();
-    if (sz >= N) {
-      std::cout << "Already done!" << std::endl;
-    } else {
+    if (sz < N) {
       for (unsigned int i = 0; i < N - sz; i++) {
-        if (verbose)  std::cout << "Computing " << i << "th bootstrap, bottleneck distance = ";
+        if (verbose)  std::clog << "Computing " << i << "th bootstrap, bottleneck distance = ";
 
         Cover_complex Cboot; Cboot.n = this->n; Cboot.data_dimension = this->data_dimension; Cboot.type = this->type; Cboot.functional_cover = true;
 
@@ -1243,7 +1229,7 @@ class Cover_complex {
         Cboot.find_simplices();
         Cboot.compute_PD();
         double db = Gudhi::persistence_diagram::bottleneck_distance(this->PD, Cboot.PD);
-        if (verbose)  std::cout << db << std::endl;
+        if (verbose)  std::clog << db << std::endl;
         distribution.push_back(db);
       }
 
@@ -1260,7 +1246,7 @@ class Cover_complex {
   double compute_distance_from_confidence_level(double alpha) {
     unsigned int N = distribution.size();
     double d = distribution[std::floor(alpha * N)];
-    if (verbose)  std::cout << "Distance corresponding to confidence " << alpha << " is " << d << std::endl;
+    if (verbose)  std::clog << "Distance corresponding to confidence " << alpha << " is " << d << std::endl;
     return d;
   }
 
@@ -1275,7 +1261,7 @@ class Cover_complex {
     double level = 1;
     for (unsigned int i = 0; i < N; i++)
       if (distribution[i] >= d){ level = i * 1.0 / N; break; }
-    if (verbose)  std::cout << "Confidence level of distance " << d << " is " << level << std::endl;
+    if (verbose)  std::clog << "Confidence level of distance " << d << " is " << level << std::endl;
     return level;
   }
 
@@ -1288,7 +1274,7 @@ class Cover_complex {
     double distancemin = (std::numeric_limits<double>::max)(); int N = PD.size();
     for (int i = 0; i < N; i++) distancemin = (std::min)(distancemin, 0.5 * std::abs(PD[i].second - PD[i].first));
     double p_value = 1 - compute_confidence_level_from_distance(distancemin);
-    if (verbose)  std::cout << "p value = " << p_value << std::endl;
+    if (verbose)  std::clog << "p value = " << p_value << std::endl;
     return p_value;
   }
 
@@ -1319,7 +1305,7 @@ class Cover_complex {
    */
   void find_simplices() {
     if (type != "Nerve" && type != "GIC") {
-      std::cout << "Type of complex needs to be specified." << std::endl;
+      std::cerr << "Type of complex needs to be specified." << std::endl;
       return;
     }
 
diff --git a/src/Nerve_GIC/utilities/Nerve.cpp b/src/Nerve_GIC/utilities/Nerve.cpp
index d34e922c..7b09f89d 100644
--- a/src/Nerve_GIC/utilities/Nerve.cpp
+++ b/src/Nerve_GIC/utilities/Nerve.cpp
@@ -42,7 +42,7 @@ int main(int argc, char **argv) {
   bool check = SC.read_point_cloud(off_file_name);
 
   if (!check) {
-    std::cout << "Incorrect OFF file." << std::endl;
+    std::clog << "Incorrect OFF file." << std::endl;
   } else {
     SC.set_type("Nerve");
 
@@ -67,15 +67,15 @@ int main(int argc, char **argv) {
     // ----------------------------------------------------------------------------
 
     if (verb) {
-      std::cout << "Nerve is of dimension " << stree.dimension() << " - " << stree.num_simplices() << " simplices - "
+      std::clog << "Nerve is of dimension " << stree.dimension() << " - " << stree.num_simplices() << " simplices - "
                 << stree.num_vertices() << " vertices." << std::endl;
 
-      std::cout << "Iterator on Nerve simplices" << std::endl;
+      std::clog << "Iterator on Nerve simplices" << std::endl;
       for (auto f_simplex : stree.filtration_simplex_range()) {
         for (auto vertex : stree.simplex_vertex_range(f_simplex)) {
-          std::cout << vertex << " ";
+          std::clog << vertex << " ";
         }
-        std::cout << std::endl;
+        std::clog << std::endl;
       }
     }
   }
diff --git a/src/Nerve_GIC/utilities/VoronoiGIC.cpp b/src/Nerve_GIC/utilities/VoronoiGIC.cpp
index 0182c948..117c89fb 100644
--- a/src/Nerve_GIC/utilities/VoronoiGIC.cpp
+++ b/src/Nerve_GIC/utilities/VoronoiGIC.cpp
@@ -40,7 +40,7 @@ int main(int argc, char **argv) {
   bool check = GIC.read_point_cloud(off_file_name);
 
   if (!check) {
-    std::cout << "Incorrect OFF file." << std::endl;
+    std::clog << "Incorrect OFF file." << std::endl;
   } else {
     GIC.set_type("GIC");
 
@@ -61,15 +61,15 @@ int main(int argc, char **argv) {
     // ----------------------------------------------------------------------------
 
     if (verb) {
-      std::cout << "Graph induced complex is of dimension " << stree.dimension() << " - " << stree.num_simplices()
+      std::clog << "Graph induced complex is of dimension " << stree.dimension() << " - " << stree.num_simplices()
                 << " simplices - " << stree.num_vertices() << " vertices." << std::endl;
 
-      std::cout << "Iterator on graph induced complex simplices" << std::endl;
+      std::clog << "Iterator on graph induced complex simplices" << std::endl;
       for (auto f_simplex : stree.filtration_simplex_range()) {
         for (auto vertex : stree.simplex_vertex_range(f_simplex)) {
-          std::cout << vertex << " ";
+          std::clog << vertex << " ";
         }
-        std::cout << std::endl;
+        std::clog << std::endl;
       }
     }
   }
diff --git a/src/Persistence_representations/example/persistence_heat_maps.cpp b/src/Persistence_representations/example/persistence_heat_maps.cpp
index 1bf3a637..9fd6779a 100644
--- a/src/Persistence_representations/example/persistence_heat_maps.cpp
+++ b/src/Persistence_representations/example/persistence_heat_maps.cpp
@@ -65,7 +65,7 @@ int main(int argc, char** argv) {
   median.compute_median(vector_of_maps);
 
   // to compute L^1 distance between hm1 and hm2:
-  std::cout << "The L^1 distance is : " << hm1.distance(hm2, 1) << std::endl;
+  std::clog << "The L^1 distance is : " << hm1.distance(hm2, 1) << std::endl;
 
   // to average of hm1 and hm2:
   std::vector<Persistence_heat_maps*> to_average;
@@ -75,15 +75,15 @@ int main(int argc, char** argv) {
   av.compute_average(to_average);
 
   // to compute scalar product of hm1 and hm2:
-  std::cout << "Scalar product is : " << hm1.compute_scalar_product(hm2) << std::endl;
+  std::clog << "Scalar product is : " << hm1.compute_scalar_product(hm2) << std::endl;
 
   Persistence_heat_maps hm1k(persistence1, Gaussian_function(1.0));
   Persistence_heat_maps hm2k(persistence2, Gaussian_function(1.0));
   Persistence_heat_maps hm1i(persistence1, Gaussian_function(1.0), 20, 20, 0, 11, 0, 11);
   Persistence_heat_maps hm2i(persistence2, Gaussian_function(1.0), 20, 20, 0, 11, 0, 11);
-  std::cout << "Scalar product computed with exact 2D kernel on grid is : " << hm1i.compute_scalar_product(hm2i)
+  std::clog << "Scalar product computed with exact 2D kernel on grid is : " << hm1i.compute_scalar_product(hm2i)
             << std::endl;
-  std::cout << "Scalar product computed with exact 2D kernel is : " << hm1k.compute_scalar_product(hm2k) << std::endl;
+  std::clog << "Scalar product computed with exact 2D kernel is : " << hm1k.compute_scalar_product(hm2k) << std::endl;
 
   return 0;
 }
diff --git a/src/Persistence_representations/example/persistence_intervals.cpp b/src/Persistence_representations/example/persistence_intervals.cpp
index c908581c..748b9ae4 100644
--- a/src/Persistence_representations/example/persistence_intervals.cpp
+++ b/src/Persistence_representations/example/persistence_intervals.cpp
@@ -18,59 +18,59 @@ using Persistence_intervals = Gudhi::Persistence_representations::Persistence_in
 
 int main(int argc, char** argv) {
   if (argc != 2) {
-    std::cout << "To run this program, please provide the name of a file with persistence diagram \n";
+    std::clog << "To run this program, please provide the name of a file with persistence diagram \n";
     return 1;
   }
 
   Persistence_intervals p(argv[1]);
   std::pair<double, double> min_max_ = p.get_x_range();
-  std::cout << "Birth-death range : " << min_max_.first << " " << min_max_.second << std::endl;
+  std::clog << "Birth-death range : " << min_max_.first << " " << min_max_.second << std::endl;
 
   std::vector<double> dominant_ten_intervals_length = p.length_of_dominant_intervals(10);
-  std::cout << "Length of ten dominant intervals : " << std::endl;
+  std::clog << "Length of ten dominant intervals : " << std::endl;
   for (size_t i = 0; i != dominant_ten_intervals_length.size(); ++i) {
-    std::cout << dominant_ten_intervals_length[i] << std::endl;
+    std::clog << dominant_ten_intervals_length[i] << std::endl;
   }
 
   std::vector<std::pair<double, double> > ten_dominant_intervals = p.dominant_intervals(10);
-  std::cout << "Here are the dominant intervals : " << std::endl;
+  std::clog << "Here are the dominant intervals : " << std::endl;
   for (size_t i = 0; i != ten_dominant_intervals.size(); ++i) {
-    std::cout << "( " << ten_dominant_intervals[i].first << "," << ten_dominant_intervals[i].second << std::endl;
+    std::clog << "( " << ten_dominant_intervals[i].first << "," << ten_dominant_intervals[i].second << std::endl;
   }
 
   std::vector<size_t> histogram = p.histogram_of_lengths(10);
-  std::cout << "Here is the histogram of barcode's length : " << std::endl;
+  std::clog << "Here is the histogram of barcode's length : " << std::endl;
   for (size_t i = 0; i != histogram.size(); ++i) {
-    std::cout << histogram[i] << " ";
+    std::clog << histogram[i] << " ";
   }
-  std::cout << std::endl;
+  std::clog << std::endl;
 
   std::vector<size_t> cumulative_histogram = p.cumulative_histogram_of_lengths(10);
-  std::cout << "Cumulative histogram : " << std::endl;
+  std::clog << "Cumulative histogram : " << std::endl;
   for (size_t i = 0; i != cumulative_histogram.size(); ++i) {
-    std::cout << cumulative_histogram[i] << " ";
+    std::clog << cumulative_histogram[i] << " ";
   }
-  std::cout << std::endl;
+  std::clog << std::endl;
 
   std::vector<double> char_funct_diag = p.characteristic_function_of_diagram(min_max_.first, min_max_.second);
-  std::cout << "Characteristic function of diagram : " << std::endl;
+  std::clog << "Characteristic function of diagram : " << std::endl;
   for (size_t i = 0; i != char_funct_diag.size(); ++i) {
-    std::cout << char_funct_diag[i] << " ";
+    std::clog << char_funct_diag[i] << " ";
   }
-  std::cout << std::endl;
+  std::clog << std::endl;
 
   std::vector<double> cumul_char_funct_diag =
       p.cumulative_characteristic_function_of_diagram(min_max_.first, min_max_.second);
-  std::cout << "Cumulative characteristic function of diagram : " << std::endl;
+  std::clog << "Cumulative characteristic function of diagram : " << std::endl;
   for (size_t i = 0; i != cumul_char_funct_diag.size(); ++i) {
-    std::cout << cumul_char_funct_diag[i] << " ";
+    std::clog << cumul_char_funct_diag[i] << " ";
   }
-  std::cout << std::endl;
+  std::clog << std::endl;
 
-  std::cout << "Persistence Betti numbers \n";
+  std::clog << "Persistence Betti numbers \n";
   std::vector<std::pair<double, size_t> > pbns = p.compute_persistent_betti_numbers();
   for (size_t i = 0; i != pbns.size(); ++i) {
-    std::cout << pbns[i].first << " " << pbns[i].second << std::endl;
+    std::clog << pbns[i].first << " " << pbns[i].second << std::endl;
   }
 
   return 0;
diff --git a/src/Persistence_representations/example/persistence_landscape.cpp b/src/Persistence_representations/example/persistence_landscape.cpp
index ff18d105..d39ae0b8 100644
--- a/src/Persistence_representations/example/persistence_landscape.cpp
+++ b/src/Persistence_representations/example/persistence_landscape.cpp
@@ -37,35 +37,35 @@ int main(int argc, char** argv) {
   Persistence_landscape l2(persistence2);
 
   // This is how to compute integral of landscapes:
-  std::cout << "Integral of the first landscape : " << l1.compute_integral_of_landscape() << std::endl;
-  std::cout << "Integral of the second landscape : " << l2.compute_integral_of_landscape() << std::endl;
+  std::clog << "Integral of the first landscape : " << l1.compute_integral_of_landscape() << std::endl;
+  std::clog << "Integral of the second landscape : " << l2.compute_integral_of_landscape() << std::endl;
 
   // And here how to write landscapes to stream:
-  std::cout << "l1 : " << l1 << std::endl;
-  std::cout << "l2 : " << l2 << std::endl;
+  std::clog << "l1 : " << l1 << std::endl;
+  std::clog << "l2 : " << l2 << std::endl;
 
   // Arithmetic operations on landscapes:
   Persistence_landscape sum = l1 + l2;
-  std::cout << "sum : " << sum << std::endl;
+  std::clog << "sum : " << sum << std::endl;
 
   // here are the maxima of the functions:
-  std::cout << "Maximum of l1 : " << l1.compute_maximum() << std::endl;
-  std::cout << "Maximum of l2 : " << l2.compute_maximum() << std::endl;
+  std::clog << "Maximum of l1 : " << l1.compute_maximum() << std::endl;
+  std::clog << "Maximum of l2 : " << l2.compute_maximum() << std::endl;
 
   // here are the norms of landscapes:
-  std::cout << "L^1 Norm of l1 : " << l1.compute_norm_of_landscape(1.) << std::endl;
-  std::cout << "L^1 Norm of l2 : " << l2.compute_norm_of_landscape(1.) << std::endl;
+  std::clog << "L^1 Norm of l1 : " << l1.compute_norm_of_landscape(1.) << std::endl;
+  std::clog << "L^1 Norm of l2 : " << l2.compute_norm_of_landscape(1.) << std::endl;
 
   // here is the average of landscapes:
   Persistence_landscape average;
   average.compute_average({&l1, &l2});
-  std::cout << "average : " << average << std::endl;
+  std::clog << "average : " << average << std::endl;
 
   // here is the distance of landscapes:
-  std::cout << "Distance : " << l1.distance(l2) << std::endl;
+  std::clog << "Distance : " << l1.distance(l2) << std::endl;
 
   // here is the scalar product of landscapes:
-  std::cout << "Scalar product : " << l1.compute_scalar_product(l2) << std::endl;
+  std::clog << "Scalar product : " << l1.compute_scalar_product(l2) << std::endl;
 
   // here is how to create a file which is suitable for visualization via gnuplot:
   average.plot("average_landscape");
diff --git a/src/Persistence_representations/example/persistence_landscape_on_grid.cpp b/src/Persistence_representations/example/persistence_landscape_on_grid.cpp
index 16a58e1d..6d58e167 100644
--- a/src/Persistence_representations/example/persistence_landscape_on_grid.cpp
+++ b/src/Persistence_representations/example/persistence_landscape_on_grid.cpp
@@ -37,31 +37,31 @@ int main(int argc, char** argv) {
   Persistence_landscape_on_grid l2(persistence2, 0, 11, 20);
 
   // This is how to compute integral of landscapes:
-  std::cout << "Integral of the first landscape : " << l1.compute_integral_of_landscape() << std::endl;
-  std::cout << "Integral of the second landscape : " << l2.compute_integral_of_landscape() << std::endl;
+  std::clog << "Integral of the first landscape : " << l1.compute_integral_of_landscape() << std::endl;
+  std::clog << "Integral of the second landscape : " << l2.compute_integral_of_landscape() << std::endl;
 
   // And here how to write landscapes to stream:
-  std::cout << "l1 : " << l1 << std::endl;
-  std::cout << "l2 : " << l2 << std::endl;
+  std::clog << "l1 : " << l1 << std::endl;
+  std::clog << "l2 : " << l2 << std::endl;
 
   // here are the maxima of the functions:
-  std::cout << "Maximum of l1 : " << l1.compute_maximum() << std::endl;
-  std::cout << "Maximum of l2 : " << l2.compute_maximum() << std::endl;
+  std::clog << "Maximum of l1 : " << l1.compute_maximum() << std::endl;
+  std::clog << "Maximum of l2 : " << l2.compute_maximum() << std::endl;
 
   // here are the norms of landscapes:
-  std::cout << "L^1 Norm of l1 : " << l1.compute_norm_of_landscape(1.) << std::endl;
-  std::cout << "L^1 Norm of l2 : " << l2.compute_norm_of_landscape(1.) << std::endl;
+  std::clog << "L^1 Norm of l1 : " << l1.compute_norm_of_landscape(1.) << std::endl;
+  std::clog << "L^1 Norm of l2 : " << l2.compute_norm_of_landscape(1.) << std::endl;
 
   // here is the average of landscapes:
   Persistence_landscape_on_grid average;
   average.compute_average({&l1, &l2});
-  std::cout << "average : " << average << std::endl;
+  std::clog << "average : " << average << std::endl;
 
   // here is the distance of landscapes:
-  std::cout << "Distance : " << l1.distance(l2) << std::endl;
+  std::clog << "Distance : " << l1.distance(l2) << std::endl;
 
   // here is the scalar product of landscapes:
-  std::cout << "Scalar product : " << l1.compute_scalar_product(l2) << std::endl;
+  std::clog << "Scalar product : " << l1.compute_scalar_product(l2) << std::endl;
 
   // here is how to create a file which is suitable for visualization via gnuplot:
   average.plot("average_landscape");
diff --git a/src/Persistence_representations/example/persistence_vectors.cpp b/src/Persistence_representations/example/persistence_vectors.cpp
index b27e52d2..89e2fb83 100644
--- a/src/Persistence_representations/example/persistence_vectors.cpp
+++ b/src/Persistence_representations/example/persistence_vectors.cpp
@@ -41,19 +41,19 @@ int main(int argc, char** argv) {
   Vector_distances_in_diagram v2(persistence2, std::numeric_limits<size_t>::max());
 
   // writing to a stream:
-  std::cout << "v1 : " << v1 << std::endl;
-  std::cout << "v2 : " << v2 << std::endl;
+  std::clog << "v1 : " << v1 << std::endl;
+  std::clog << "v2 : " << v2 << std::endl;
 
   // averages:
   Vector_distances_in_diagram average;
   average.compute_average({&v1, &v2});
-  std::cout << "Average : " << average << std::endl;
+  std::clog << "Average : " << average << std::endl;
 
   // computations of distances:
-  std::cout << "l^1 distance : " << v1.distance(v2) << std::endl;
+  std::clog << "l^1 distance : " << v1.distance(v2) << std::endl;
 
   // computations of scalar product:
-  std::cout << "Scalar product of l1 and l2 : " << v1.compute_scalar_product(v2) << std::endl;
+  std::clog << "Scalar product of l1 and l2 : " << v1.compute_scalar_product(v2) << std::endl;
 
   // create a file with a gnuplot script:
   v1.plot("plot_of_vector_representation");
diff --git a/src/Persistence_representations/example/sliced_wasserstein.cpp b/src/Persistence_representations/example/sliced_wasserstein.cpp
index d5414d00..d4e31ebf 100644
--- a/src/Persistence_representations/example/sliced_wasserstein.cpp
+++ b/src/Persistence_representations/example/sliced_wasserstein.cpp
@@ -38,10 +38,10 @@ int main(int argc, char** argv) {
   SW swex1(persistence1, 1, -1);
   SW swex2(persistence2, 1, -1);
 
-  std::cout << "Approx SW kernel: " << sw1.compute_scalar_product(sw2) << std::endl;
-  std::cout << "Exact  SW kernel: " << swex1.compute_scalar_product(swex2) << std::endl;
-  std::cout << "Distance induced by approx SW kernel: " << sw1.distance(sw2) << std::endl;
-  std::cout << "Distance induced by exact  SW kernel: " << swex1.distance(swex2) << std::endl;
+  std::clog << "Approx SW kernel: " << sw1.compute_scalar_product(sw2) << std::endl;
+  std::clog << "Exact  SW kernel: " << swex1.compute_scalar_product(swex2) << std::endl;
+  std::clog << "Distance induced by approx SW kernel: " << sw1.distance(sw2) << std::endl;
+  std::clog << "Distance induced by exact  SW kernel: " << swex1.distance(swex2) << std::endl;
 
   return 0;
 }
diff --git a/src/Persistence_representations/include/gudhi/Persistence_heat_maps.h b/src/Persistence_representations/include/gudhi/Persistence_heat_maps.h
index b1af3503..fab88489 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_heat_maps.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_heat_maps.h
@@ -55,9 +55,9 @@ std::vector<std::vector<double> > create_Gaussian_filter(size_t pixel_radius, do
   }
 
   if (dbg) {
-    std::cerr << "Kernel initialize \n";
-    std::cerr << "pixel_radius : " << pixel_radius << std::endl;
-    std::cerr << "kernel.size() : " << kernel.size() << std::endl;
+    std::clog << "Kernel initialize \n";
+    std::clog << "pixel_radius : " << pixel_radius << std::endl;
+    std::clog << "kernel.size() : " << kernel.size() << std::endl;
     getchar();
   }
 
@@ -79,12 +79,12 @@ std::vector<std::vector<double> > create_Gaussian_filter(size_t pixel_radius, do
   }
 
   if (dbg) {
-    std::cerr << "Here is the kernel : \n";
+    std::clog << "Here is the kernel : \n";
     for (size_t i = 0; i != kernel.size(); ++i) {
       for (size_t j = 0; j != kernel[i].size(); ++j) {
-        std::cerr << kernel[i][j] << " ";
+        std::clog << kernel[i][j] << " ";
       }
-      std::cerr << std::endl;
+      std::clog << std::endl;
     }
   }
   return kernel;
@@ -290,16 +290,16 @@ class Persistence_heat_maps {
     bool dbg = false;
     if (this->heat_map.size() != second.heat_map.size()) {
       if (dbg)
-        std::cerr << "this->heat_map.size() : " << this->heat_map.size()
+        std::clog << "this->heat_map.size() : " << this->heat_map.size()
                   << " \n second.heat_map.size() : " << second.heat_map.size() << std::endl;
       return false;
     }
     if (this->min_ != second.min_) {
-      if (dbg) std::cerr << "this->min_ : " << this->min_ << ", second.min_ : " << second.min_ << std::endl;
+      if (dbg) std::clog << "this->min_ : " << this->min_ << ", second.min_ : " << second.min_ << std::endl;
       return false;
     }
     if (this->max_ != second.max_) {
-      if (dbg) std::cerr << "this->max_ : " << this->max_ << ", second.max_ : " << second.max_ << std::endl;
+      if (dbg) std::clog << "this->max_ : " << this->max_ << ", second.max_ : " << second.max_ << std::endl;
       return false;
     }
     // in the other case we may assume that the persistence images are defined on the same domain.
@@ -322,15 +322,15 @@ class Persistence_heat_maps {
   bool operator==(const Persistence_heat_maps& rhs) const {
     bool dbg = false;
     if (!this->check_if_the_same(rhs)) {
-      if (dbg) std::cerr << "The domains are not the same \n";
+      if (dbg) std::clog << "The domains are not the same \n";
       return false;  // in this case, the domains are not the same, so the maps cannot be the same.
     }
     for (size_t i = 0; i != this->heat_map.size(); ++i) {
       for (size_t j = 0; j != this->heat_map[i].size(); ++j) {
         if (!almost_equal(this->heat_map[i][j], rhs.heat_map[i][j])) {
           if (dbg) {
-            std::cerr << "this->heat_map[" << i << "][" << j << "] = " << this->heat_map[i][j] << std::endl;
-            std::cerr << "rhs.heat_map[" << i << "][" << j << "] = " << rhs.heat_map[i][j] << std::endl;
+            std::clog << "this->heat_map[" << i << "][" << j << "] = " << this->heat_map[i][j] << std::endl;
+            std::clog << "rhs.heat_map[" << i << "][" << j << "] = " << rhs.heat_map[i][j] << std::endl;
           }
           return false;
         }
@@ -586,14 +586,14 @@ void Persistence_heat_maps<Scalling_of_kernels>::construct(const std::vector<std
                                                            bool erase_below_diagonal, size_t number_of_pixels,
                                                            double min_, double max_) {
   bool dbg = false;
-  if (dbg) std::cerr << "Entering construct procedure \n";
+  if (dbg) std::clog << "Entering construct procedure \n";
   Scalling_of_kernels f;
   this->f = f;
 
-  if (dbg) std::cerr << "min and max passed to construct() procedure: " << min_ << " " << max_ << std::endl;
+  if (dbg) std::clog << "min and max passed to construct() procedure: " << min_ << " " << max_ << std::endl;
 
   if (min_ == max_) {
-    if (dbg) std::cerr << "min and max parameters will be determined based on intervals \n";
+    if (dbg) std::clog << "min and max parameters will be determined based on intervals \n";
     // in this case, we want the program to set up the min_ and max_ values by itself.
     min_ = std::numeric_limits<int>::max();
     max_ = -std::numeric_limits<int>::max();
@@ -611,9 +611,9 @@ void Persistence_heat_maps<Scalling_of_kernels>::construct(const std::vector<std
   }
 
   if (dbg) {
-    std::cerr << "min_ : " << min_ << std::endl;
-    std::cerr << "max_ : " << max_ << std::endl;
-    std::cerr << "number_of_pixels : " << number_of_pixels << std::endl;
+    std::clog << "min_ : " << min_ << std::endl;
+    std::clog << "max_ : " << max_ << std::endl;
+    std::clog << "number_of_pixels : " << number_of_pixels << std::endl;
     getchar();
   }
 
@@ -628,7 +628,7 @@ void Persistence_heat_maps<Scalling_of_kernels>::construct(const std::vector<std
   }
   this->heat_map = heat_map_;
 
-  if (dbg) std::cerr << "Done creating of the heat map, now we will fill in the structure \n";
+  if (dbg) std::clog << "Done creating of the heat map, now we will fill in the structure \n";
 
   for (size_t pt_nr = 0; pt_nr != intervals_.size(); ++pt_nr) {
     // compute the value of intervals_[pt_nr] in the grid:
@@ -638,9 +638,9 @@ void Persistence_heat_maps<Scalling_of_kernels>::construct(const std::vector<std
         static_cast<int>((intervals_[pt_nr].second - this->min_) / (this->max_ - this->min_) * number_of_pixels);
 
     if (dbg) {
-      std::cerr << "point : " << intervals_[pt_nr].first << " , " << intervals_[pt_nr].second << std::endl;
-      std::cerr << "x_grid : " << x_grid << std::endl;
-      std::cerr << "y_grid : " << y_grid << std::endl;
+      std::clog << "point : " << intervals_[pt_nr].first << " , " << intervals_[pt_nr].second << std::endl;
+      std::clog << "x_grid : " << x_grid << std::endl;
+      std::clog << "y_grid : " << y_grid << std::endl;
     }
 
     // x_grid and y_grid gives a center of the kernel. We want to have its lower left corner. To get this, we need to
@@ -650,9 +650,9 @@ void Persistence_heat_maps<Scalling_of_kernels>::construct(const std::vector<std
     // note that the numbers x_grid and y_grid may be negative.
 
     if (dbg) {
-      std::cerr << "After shift : \n";
-      std::cerr << "x_grid : " << x_grid << std::endl;
-      std::cerr << "y_grid : " << y_grid << std::endl;
+      std::clog << "After shift : \n";
+      std::clog << "x_grid : " << x_grid << std::endl;
+      std::clog << "y_grid : " << y_grid << std::endl;
     }
 
     double scaling_value = this->f(intervals_[pt_nr]);
@@ -663,11 +663,11 @@ void Persistence_heat_maps<Scalling_of_kernels>::construct(const std::vector<std
         if (((x_grid + i) >= 0) && (x_grid + i < this->heat_map.size()) && ((y_grid + j) >= 0) &&
             (y_grid + j < this->heat_map.size())) {
           if (dbg) {
-            std::cerr << y_grid + j << " " << x_grid + i << std::endl;
+            std::clog << y_grid + j << " " << x_grid + i << std::endl;
           }
           this->heat_map[y_grid + j][x_grid + i] += scaling_value * filter[i][j];
           if (dbg) {
-            std::cerr << "Position : (" << x_grid + i << "," << y_grid + j
+            std::clog << "Position : (" << x_grid + i << "," << y_grid + j
                       << ") got increased by the value : " << filter[i][j] << std::endl;
           }
         }
@@ -805,7 +805,7 @@ void Persistence_heat_maps<Scalling_of_kernels>::plot(const char* filename) cons
     out << std::endl;
   }
   out.close();
-  std::cout << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
+  std::clog << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
             << gnuplot_script.str().c_str() << "\'\"" << std::endl;
 }
 
@@ -842,7 +842,7 @@ void Persistence_heat_maps<Scalling_of_kernels>::load_from_file(const char* file
 
   in >> this->min_ >> this->max_;
   if (dbg) {
-    std::cerr << "Reading the following values of min and max : " << this->min_ << " , " << this->max_ << std::endl;
+    std::clog << "Reading the following values of min and max : " << this->min_ << " , " << this->max_ << std::endl;
   }
 
   std::string temp;
@@ -859,18 +859,18 @@ void Persistence_heat_maps<Scalling_of_kernels>::load_from_file(const char* file
       lineSS >> point;
       line_of_heat_map.push_back(point);
       if (dbg) {
-        std::cout << point << " ";
+        std::clog << point << " ";
       }
     }
     if (dbg) {
-      std::cout << std::endl;
+      std::clog << std::endl;
       getchar();
     }
 
     if (in.good()) this->heat_map.push_back(line_of_heat_map);
   }
   in.close();
-  if (dbg) std::cout << "Done \n";
+  if (dbg) std::clog << "Done \n";
 }
 
 // Concretizations of virtual methods:
@@ -878,7 +878,7 @@ template <typename Scalling_of_kernels>
 std::vector<double> Persistence_heat_maps<Scalling_of_kernels>::vectorize(int number_of_function) const {
   std::vector<double> result;
   if (!discrete) {
-    std::cout << "No vectorize method in case of infinite dimensional vectorization" << std::endl;
+    std::cerr << "No vectorize method in case of infinite dimensional vectorization" << std::endl;
     return result;
   }
 
diff --git a/src/Persistence_representations/include/gudhi/Persistence_intervals.h b/src/Persistence_representations/include/gudhi/Persistence_intervals.h
index ea4220ea..a6c1d6f0 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_intervals.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_intervals.h
@@ -185,7 +185,7 @@ class Persistence_intervals {
 
     out.close();
 
-    std::cout << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
+    std::clog << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
               << gnuplot_script.str().c_str() << "\'\"" << std::endl;
   }
 
@@ -293,7 +293,7 @@ std::vector<std::pair<double, double> > Persistence_intervals::dominant_interval
   for (size_t i = 0; i != std::min(where_to_cut, position_length_vector.size()); ++i) {
     result.push_back(this->intervals[position_length_vector[i].first]);
     if (dbg)
-      std::cerr << "Position : " << position_length_vector[i].first << " length : " << position_length_vector[i].second
+      std::clog << "Position : " << position_length_vector[i].first << " length : " << position_length_vector[i].second
                 << std::endl;
   }
 
@@ -303,7 +303,7 @@ std::vector<std::pair<double, double> > Persistence_intervals::dominant_interval
 std::vector<size_t> Persistence_intervals::histogram_of_lengths(size_t number_of_bins) const {
   bool dbg = false;
 
-  if (dbg) std::cerr << "this->intervals.size() : " << this->intervals.size() << std::endl;
+  if (dbg) std::clog << "this->intervals.size() : " << this->intervals.size() << std::endl;
   // first find the length of the longest interval:
   double lengthOfLongest = 0;
   for (size_t i = 0; i != this->intervals.size(); ++i) {
@@ -313,7 +313,7 @@ std::vector<size_t> Persistence_intervals::histogram_of_lengths(size_t number_of
   }
 
   if (dbg) {
-    std::cerr << "lengthOfLongest : " << lengthOfLongest << std::endl;
+    std::clog << "lengthOfLongest : " << lengthOfLongest << std::endl;
   }
 
   // this is a container we will use to store the resulting histogram
@@ -330,10 +330,10 @@ std::vector<size_t> Persistence_intervals::histogram_of_lengths(size_t number_of
     ++result[position];
 
     if (dbg) {
-      std::cerr << "i : " << i << std::endl;
-      std::cerr << "Interval : [" << this->intervals[i].first << " , " << this->intervals[i].second << " ] \n";
-      std::cerr << "relative_length_of_this_interval : " << relative_length_of_this_interval << std::endl;
-      std::cerr << "position : " << position << std::endl;
+      std::clog << "i : " << i << std::endl;
+      std::clog << "Interval : [" << this->intervals[i].first << " , " << this->intervals[i].second << " ] \n";
+      std::clog << "relative_length_of_this_interval : " << relative_length_of_this_interval << std::endl;
+      std::clog << "position : " << position << std::endl;
       getchar();
     }
   }
@@ -342,7 +342,7 @@ std::vector<size_t> Persistence_intervals::histogram_of_lengths(size_t number_of
   result.resize(number_of_bins);
 
   if (dbg) {
-    for (size_t i = 0; i != result.size(); ++i) std::cerr << result[i] << std::endl;
+    for (size_t i = 0; i != result.size(); ++i) std::clog << result[i] << std::endl;
   }
   return result;
 }
@@ -368,7 +368,7 @@ std::vector<double> Persistence_intervals::characteristic_function_of_diagram(do
 
   for (size_t i = 0; i != this->intervals.size(); ++i) {
     if (dbg) {
-      std::cerr << "Interval : " << this->intervals[i].first << " , " << this->intervals[i].second << std::endl;
+      std::clog << "Interval : " << this->intervals[i].first << " , " << this->intervals[i].second << std::endl;
     }
 
     size_t beginIt = 0;
@@ -390,8 +390,8 @@ std::vector<double> Persistence_intervals::characteristic_function_of_diagram(do
     }
 
     if (dbg) {
-      std::cerr << "beginIt : " << beginIt << std::endl;
-      std::cerr << "endIt : " << endIt << std::endl;
+      std::clog << "beginIt : " << beginIt << std::endl;
+      std::clog << "endIt : " << endIt << std::endl;
     }
 
     for (size_t pos = beginIt; pos != endIt; ++pos) {
@@ -399,11 +399,11 @@ std::vector<double> Persistence_intervals::characteristic_function_of_diagram(do
                      (this->intervals[i].second - this->intervals[i].first);
     }
     if (dbg) {
-      std::cerr << "Result at this stage \n";
+      std::clog << "Result at this stage \n";
       for (size_t aa = 0; aa != result.size(); ++aa) {
-        std::cerr << result[aa] << " ";
+        std::clog << result[aa] << " ";
       }
-      std::cerr << std::endl;
+      std::clog << std::endl;
     }
   }
   return result;
@@ -455,9 +455,9 @@ inline double compute_euclidean_distance(const std::pair<double, double>& f, con
 std::vector<double> Persistence_intervals::k_n_n(size_t k, size_t where_to_cut) const {
   bool dbg = false;
   if (dbg) {
-    std::cerr << "Here are the intervals : \n";
+    std::clog << "Here are the intervals : \n";
     for (size_t i = 0; i != this->intervals.size(); ++i) {
-      std::cerr << "[ " << this->intervals[i].first << " , " << this->intervals[i].second << "] \n";
+      std::clog << "[ " << this->intervals[i].first << " , " << this->intervals[i].second << "] \n";
     }
     getchar();
   }
@@ -486,12 +486,12 @@ std::vector<double> Persistence_intervals::k_n_n(size_t k, size_t where_to_cut)
     distances_from_diagonal[i] = distanceToDiagonal;
 
     if (dbg) {
-      std::cerr << "Here are the distances form the point : [" << this->intervals[i].first << " , "
+      std::clog << "Here are the distances form the point : [" << this->intervals[i].first << " , "
                 << this->intervals[i].second << "] in the diagram \n";
       for (size_t aa = 0; aa != distancesFromI.size(); ++aa) {
-        std::cerr << "To : " << i + aa << " : " << distancesFromI[aa] << " ";
+        std::clog << "To : " << i + aa << " : " << distancesFromI[aa] << " ";
       }
-      std::cerr << std::endl;
+      std::clog << std::endl;
       getchar();
     }
 
@@ -502,18 +502,18 @@ std::vector<double> Persistence_intervals::k_n_n(size_t k, size_t where_to_cut)
     }
   }
   if (dbg) {
-    std::cerr << "Here is the distance matrix : \n";
+    std::clog << "Here is the distance matrix : \n";
     for (size_t i = 0; i != distances.size(); ++i) {
       for (size_t j = 0; j != distances.size(); ++j) {
-        std::cerr << distances[i][j] << " ";
+        std::clog << distances[i][j] << " ";
       }
-      std::cerr << std::endl;
+      std::clog << std::endl;
     }
-    std::cerr << std::endl << std::endl << "And here are the distances to the diagonal : " << std::endl;
+    std::clog << std::endl << std::endl << "And here are the distances to the diagonal : " << std::endl;
     for (size_t i = 0; i != distances_from_diagonal.size(); ++i) {
-      std::cerr << distances_from_diagonal[i] << " ";
+      std::clog << distances_from_diagonal[i] << " ";
     }
-    std::cerr << std::endl << std::endl;
+    std::clog << std::endl << std::endl;
     getchar();
   }
 
@@ -526,13 +526,13 @@ std::vector<double> Persistence_intervals::k_n_n(size_t k, size_t where_to_cut)
 
     if (k > distancesFromI.size()) {
       if (dbg) {
-        std::cerr << "There are not enough neighbors in your set. We set the result to plus infty \n";
+        std::clog << "There are not enough neighbors in your set. We set the result to plus infty \n";
       }
       result.push_back(std::numeric_limits<double>::max());
     } else {
       if (distances_from_diagonal[i] > distancesFromI[k]) {
         if (dbg) {
-          std::cerr << "The k-th n.n. is on a diagonal. Therefore we set up a distance to diagonal \n";
+          std::clog << "The k-th n.n. is on a diagonal. Therefore we set up a distance to diagonal \n";
         }
         result.push_back(distances_from_diagonal[i]);
       } else {
diff --git a/src/Persistence_representations/include/gudhi/Persistence_landscape.h b/src/Persistence_representations/include/gudhi/Persistence_landscape.h
index b819ccb6..ce4065b8 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_landscape.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_landscape.h
@@ -343,7 +343,7 @@ class Persistence_landscape {
     bool dbg = false;
 
     if (dbg) {
-      std::cerr << "to_average.size() : " << to_average.size() << std::endl;
+      std::clog << "to_average.size() : " << to_average.size() << std::endl;
     }
 
     std::vector<Persistence_landscape*> nextLevelMerge(to_average.size());
@@ -357,13 +357,13 @@ class Persistence_landscape {
 
     while (nextLevelMerge.size() != 1) {
       if (dbg) {
-        std::cerr << "nextLevelMerge.size() : " << nextLevelMerge.size() << std::endl;
+        std::clog << "nextLevelMerge.size() : " << nextLevelMerge.size() << std::endl;
       }
       std::vector<Persistence_landscape*> nextNextLevelMerge;
       nextNextLevelMerge.reserve(to_average.size());
       for (size_t i = 0; i < nextLevelMerge.size(); i = i + 2) {
         if (dbg) {
-          std::cerr << "i : " << i << std::endl;
+          std::clog << "i : " << i << std::endl;
         }
         Persistence_landscape* l = new Persistence_landscape;
         if (i + 1 != nextLevelMerge.size()) {
@@ -374,7 +374,7 @@ class Persistence_landscape {
         nextNextLevelMerge.push_back(l);
       }
       if (dbg) {
-        std::cerr << "After this iteration \n";
+        std::clog << "After this iteration \n";
         getchar();
       }
 
@@ -471,25 +471,25 @@ Persistence_landscape::Persistence_landscape(const char* filename, size_t dimens
 bool operatorEqualDbg = false;
 bool Persistence_landscape::operator==(const Persistence_landscape& rhs) const {
   if (this->land.size() != rhs.land.size()) {
-    if (operatorEqualDbg) std::cerr << "1\n";
+    if (operatorEqualDbg) std::clog << "1\n";
     return false;
   }
   for (size_t level = 0; level != this->land.size(); ++level) {
     if (this->land[level].size() != rhs.land[level].size()) {
-      if (operatorEqualDbg) std::cerr << "this->land[level].size() : " << this->land[level].size() << "\n";
-      if (operatorEqualDbg) std::cerr << "rhs.land[level].size() : " << rhs.land[level].size() << "\n";
-      if (operatorEqualDbg) std::cerr << "2\n";
+      if (operatorEqualDbg) std::clog << "this->land[level].size() : " << this->land[level].size() << "\n";
+      if (operatorEqualDbg) std::clog << "rhs.land[level].size() : " << rhs.land[level].size() << "\n";
+      if (operatorEqualDbg) std::clog << "2\n";
       return false;
     }
     for (size_t i = 0; i != this->land[level].size(); ++i) {
       if (!(almost_equal(this->land[level][i].first, rhs.land[level][i].first) &&
             almost_equal(this->land[level][i].second, rhs.land[level][i].second))) {
         if (operatorEqualDbg)
-          std::cerr << "this->land[level][i] : " << this->land[level][i].first << " " << this->land[level][i].second
+          std::clog << "this->land[level][i] : " << this->land[level][i].first << " " << this->land[level][i].second
                     << "\n";
         if (operatorEqualDbg)
-          std::cerr << "rhs.land[level][i] : " << rhs.land[level][i].first << " " << rhs.land[level][i].second << "\n";
-        if (operatorEqualDbg) std::cerr << "3\n";
+          std::clog << "rhs.land[level][i] : " << rhs.land[level][i].first << " " << rhs.land[level][i].second << "\n";
+        if (operatorEqualDbg) std::clog << "3\n";
         return false;
       }
     }
@@ -507,7 +507,7 @@ void Persistence_landscape::construct_persistence_landscape_from_barcode(
     const std::vector<std::pair<double, double> >& p, size_t number_of_levels) {
   bool dbg = false;
   if (dbg) {
-    std::cerr << "Persistence_landscape::Persistence_landscape( const std::vector< std::pair< double , double > >& p )"
+    std::clog << "Persistence_landscape::Persistence_landscape( const std::vector< std::pair< double , double > >& p )"
               << std::endl;
   }
 
@@ -517,9 +517,9 @@ void Persistence_landscape::construct_persistence_landscape_from_barcode(
   std::sort(bars.begin(), bars.end(), compare_points_sorting);
 
   if (dbg) {
-    std::cerr << "Bars : \n";
+    std::clog << "Bars : \n";
     for (size_t i = 0; i != bars.size(); ++i) {
-      std::cerr << bars[i].first << " " << bars[i].second << "\n";
+      std::clog << bars[i].first << " " << bars[i].second << "\n";
     }
     getchar();
   }
@@ -534,7 +534,7 @@ void Persistence_landscape::construct_persistence_landscape_from_barcode(
   while (!characteristicPoints.empty()) {
     if (dbg) {
       for (size_t i = 0; i != characteristicPoints.size(); ++i) {
-        std::cout << "(" << characteristicPoints[i].first << " " << characteristicPoints[i].second << ")\n";
+        std::clog << "(" << characteristicPoints[i].first << " " << characteristicPoints[i].second << ")\n";
       }
       std::cin.ignore();
     }
@@ -545,7 +545,7 @@ void Persistence_landscape::construct_persistence_landscape_from_barcode(
     lambda_n.push_back(characteristicPoints[0]);
 
     if (dbg) {
-      std::cerr << "1 Adding to lambda_n : (" << -std::numeric_limits<int>::max() << " " << 0 << ") , ("
+      std::clog << "1 Adding to lambda_n : (" << -std::numeric_limits<int>::max() << " " << 0 << ") , ("
                 << minus_length(characteristicPoints[0]) << " " << 0 << ") , (" << characteristicPoints[0].first << " "
                 << characteristicPoints[0].second << ") \n";
     }
@@ -562,13 +562,13 @@ void Persistence_landscape::construct_persistence_landscape_from_barcode(
               (birth_plus_deaths(lambda_n[lambda_n.size() - 1]) - minus_length(characteristicPoints[i])) / 2);
           lambda_n.push_back(point);
           if (dbg) {
-            std::cerr << "2 Adding to lambda_n : (" << point.first << " " << point.second << ")\n";
+            std::clog << "2 Adding to lambda_n : (" << point.first << " " << point.second << ")\n";
           }
 
           if (dbg) {
-            std::cerr << "characteristicPoints[i+p] : " << characteristicPoints[i + p].first << " "
+            std::clog << "characteristicPoints[i+p] : " << characteristicPoints[i + p].first << " "
                       << characteristicPoints[i + p].second << "\n";
-            std::cerr << "point : " << point.first << " " << point.second << "\n";
+            std::clog << "point : " << point.first << " " << point.second << "\n";
             getchar();
           }
 
@@ -577,7 +577,7 @@ void Persistence_landscape::construct_persistence_landscape_from_barcode(
                  (birth_plus_deaths(point) <= birth_plus_deaths(characteristicPoints[i + p]))) {
             newCharacteristicPoints.push_back(characteristicPoints[i + p]);
             if (dbg) {
-              std::cerr << "3.5 Adding to newCharacteristicPoints : (" << characteristicPoints[i + p].first << " "
+              std::clog << "3.5 Adding to newCharacteristicPoints : (" << characteristicPoints[i + p].first << " "
                         << characteristicPoints[i + p].second << ")\n";
               getchar();
             }
@@ -586,7 +586,7 @@ void Persistence_landscape::construct_persistence_landscape_from_barcode(
 
           newCharacteristicPoints.push_back(point);
           if (dbg) {
-            std::cerr << "4 Adding to newCharacteristicPoints : (" << point.first << " " << point.second << ")\n";
+            std::clog << "4 Adding to newCharacteristicPoints : (" << point.first << " " << point.second << ")\n";
           }
 
           while ((i + p < characteristicPoints.size()) &&
@@ -594,15 +594,15 @@ void Persistence_landscape::construct_persistence_landscape_from_barcode(
                  (birth_plus_deaths(point) >= birth_plus_deaths(characteristicPoints[i + p]))) {
             newCharacteristicPoints.push_back(characteristicPoints[i + p]);
             if (dbg) {
-              std::cerr << "characteristicPoints[i+p] : " << characteristicPoints[i + p].first << " "
+              std::clog << "characteristicPoints[i+p] : " << characteristicPoints[i + p].first << " "
                         << characteristicPoints[i + p].second << "\n";
-              std::cerr << "point : " << point.first << " " << point.second << "\n";
-              std::cerr << "characteristicPoints[i+p] birth and death : " << minus_length(characteristicPoints[i + p])
+              std::clog << "point : " << point.first << " " << point.second << "\n";
+              std::clog << "characteristicPoints[i+p] birth and death : " << minus_length(characteristicPoints[i + p])
                         << " , " << birth_plus_deaths(characteristicPoints[i + p]) << "\n";
-              std::cerr << "point birth and death : " << minus_length(point) << " , " << birth_plus_deaths(point)
+              std::clog << "point birth and death : " << minus_length(point) << " , " << birth_plus_deaths(point)
                         << "\n";
 
-              std::cerr << "3 Adding to newCharacteristicPoints : (" << characteristicPoints[i + p].first << " "
+              std::clog << "3 Adding to newCharacteristicPoints : (" << characteristicPoints[i + p].first << " "
                         << characteristicPoints[i + p].second << ")\n";
               getchar();
             }
@@ -613,20 +613,20 @@ void Persistence_landscape::construct_persistence_landscape_from_barcode(
           lambda_n.push_back(std::make_pair(birth_plus_deaths(lambda_n[lambda_n.size() - 1]), 0));
           lambda_n.push_back(std::make_pair(minus_length(characteristicPoints[i]), 0));
           if (dbg) {
-            std::cerr << "5 Adding to lambda_n : (" << birth_plus_deaths(lambda_n[lambda_n.size() - 1]) << " " << 0
+            std::clog << "5 Adding to lambda_n : (" << birth_plus_deaths(lambda_n[lambda_n.size() - 1]) << " " << 0
                       << ")\n";
-            std::cerr << "5 Adding to lambda_n : (" << minus_length(characteristicPoints[i]) << " " << 0 << ")\n";
+            std::clog << "5 Adding to lambda_n : (" << minus_length(characteristicPoints[i]) << " " << 0 << ")\n";
           }
         }
         lambda_n.push_back(characteristicPoints[i]);
         if (dbg) {
-          std::cerr << "6 Adding to lambda_n : (" << characteristicPoints[i].first << " "
+          std::clog << "6 Adding to lambda_n : (" << characteristicPoints[i].first << " "
                     << characteristicPoints[i].second << ")\n";
         }
       } else {
         newCharacteristicPoints.push_back(characteristicPoints[i]);
         if (dbg) {
-          std::cerr << "7 Adding to newCharacteristicPoints : (" << characteristicPoints[i].first << " "
+          std::clog << "7 Adding to newCharacteristicPoints : (" << characteristicPoints[i].first << " "
                     << characteristicPoints[i].second << ")\n";
         }
       }
@@ -692,7 +692,7 @@ double Persistence_landscape::compute_integral_of_landscape(double p) const {
   double result = 0;
   for (size_t i = 0; i != this->land.size(); ++i) {
     for (size_t nr = 2; nr != this->land[i].size() - 1; ++nr) {
-      if (dbg) std::cout << "nr : " << nr << "\n";
+      if (dbg) std::clog << "nr : " << nr << "\n";
       // In this interval, the landscape has a form f(x) = ax+b. We want to compute integral of (ax+b)^p = 1/a *
       // (ax+b)^{p+1}/(p+1)
       std::pair<double, double> coef = compute_parameters_of_a_line(this->land[i][nr], this->land[i][nr - 1]);
@@ -700,7 +700,7 @@ double Persistence_landscape::compute_integral_of_landscape(double p) const {
       double b = coef.second;
 
       if (dbg)
-        std::cout << "(" << this->land[i][nr].first << "," << this->land[i][nr].second << ") , "
+        std::clog << "(" << this->land[i][nr].first << "," << this->land[i][nr].second << ") , "
                   << this->land[i][nr - 1].first << "," << this->land[i][nr].second << ")" << std::endl;
       if (this->land[i][nr].first == this->land[i][nr - 1].first) continue;
       if (a != 0) {
@@ -710,8 +710,8 @@ double Persistence_landscape::compute_integral_of_landscape(double p) const {
         result += (this->land[i][nr].first - this->land[i][nr - 1].first) * (pow(this->land[i][nr].second, p));
       }
       if (dbg) {
-        std::cout << "a : " << a << " , b : " << b << std::endl;
-        std::cout << "result : " << result << std::endl;
+        std::clog << "a : " << a << " , b : " << b << std::endl;
+        std::clog << "result : " << result << std::endl;
       }
     }
   }
@@ -730,31 +730,31 @@ double Persistence_landscape::compute_value_at_a_given_point(unsigned level, dou
   unsigned coordEnd = this->land[level].size() - 2;
 
   if (compute_value_at_a_given_pointDbg) {
-    std::cerr << "Here \n";
-    std::cerr << "x : " << x << "\n";
-    std::cerr << "this->land[level][coordBegin].first : " << this->land[level][coordBegin].first << "\n";
-    std::cerr << "this->land[level][coordEnd].first : " << this->land[level][coordEnd].first << "\n";
+    std::clog << "Here \n";
+    std::clog << "x : " << x << "\n";
+    std::clog << "this->land[level][coordBegin].first : " << this->land[level][coordBegin].first << "\n";
+    std::clog << "this->land[level][coordEnd].first : " << this->land[level][coordEnd].first << "\n";
   }
 
   // in this case x is outside the support of the landscape, therefore the value of the landscape is 0.
   if (x <= this->land[level][coordBegin].first) return 0;
   if (x >= this->land[level][coordEnd].first) return 0;
 
-  if (compute_value_at_a_given_pointDbg) std::cerr << "Entering to the while loop \n";
+  if (compute_value_at_a_given_pointDbg) std::clog << "Entering to the while loop \n";
 
   while (coordBegin + 1 != coordEnd) {
     if (compute_value_at_a_given_pointDbg) {
-      std::cerr << "coordBegin : " << coordBegin << "\n";
-      std::cerr << "coordEnd : " << coordEnd << "\n";
-      std::cerr << "this->land[level][coordBegin].first : " << this->land[level][coordBegin].first << "\n";
-      std::cerr << "this->land[level][coordEnd].first : " << this->land[level][coordEnd].first << "\n";
+      std::clog << "coordBegin : " << coordBegin << "\n";
+      std::clog << "coordEnd : " << coordEnd << "\n";
+      std::clog << "this->land[level][coordBegin].first : " << this->land[level][coordBegin].first << "\n";
+      std::clog << "this->land[level][coordEnd].first : " << this->land[level][coordEnd].first << "\n";
     }
 
     unsigned newCord = (unsigned)floor((coordEnd + coordBegin) / 2.0);
 
     if (compute_value_at_a_given_pointDbg) {
-      std::cerr << "newCord : " << newCord << "\n";
-      std::cerr << "this->land[level][newCord].first : " << this->land[level][newCord].first << "\n";
+      std::clog << "newCord : " << newCord << "\n";
+      std::clog << "this->land[level][newCord].first : " << this->land[level][newCord].first << "\n";
       std::cin.ignore();
     }
 
@@ -767,12 +767,12 @@ double Persistence_landscape::compute_value_at_a_given_point(unsigned level, dou
   }
 
   if (compute_value_at_a_given_pointDbg) {
-    std::cout << "x : " << x << " is between : " << this->land[level][coordBegin].first << " a  "
+    std::clog << "x : " << x << " is between : " << this->land[level][coordBegin].first << " a  "
               << this->land[level][coordEnd].first << "\n";
-    std::cout << "the y coords are : " << this->land[level][coordBegin].second << " a  "
+    std::clog << "the y coords are : " << this->land[level][coordBegin].second << " a  "
               << this->land[level][coordEnd].second << "\n";
-    std::cerr << "coordBegin : " << coordBegin << "\n";
-    std::cerr << "coordEnd : " << coordEnd << "\n";
+    std::clog << "coordBegin : " << coordBegin << "\n";
+    std::clog << "coordEnd : " << coordEnd << "\n";
     std::cin.ignore();
   }
   return function_value(this->land[level][coordBegin], this->land[level][coordEnd], x);
@@ -810,13 +810,13 @@ Persistence_landscape Persistence_landscape::abs() {
   Persistence_landscape result;
   for (size_t level = 0; level != this->land.size(); ++level) {
     if (AbsDbg) {
-      std::cout << "level: " << level << std::endl;
+      std::clog << "level: " << level << std::endl;
     }
     std::vector<std::pair<double, double> > lambda_n;
     lambda_n.push_back(std::make_pair(-std::numeric_limits<int>::max(), 0));
     for (size_t i = 1; i != this->land[level].size(); ++i) {
       if (AbsDbg) {
-        std::cout << "this->land[" << level << "][" << i << "] : " << this->land[level][i].first << " "
+        std::clog << "this->land[" << level << "][" << i << "] : " << this->land[level][i].first << " "
                   << this->land[level][i].second << std::endl;
       }
       // if a line segment between this->land[level][i-1] and this->land[level][i] crosses the x-axis, then we have to
@@ -828,15 +828,15 @@ Persistence_landscape Persistence_landscape::abs() {
         lambda_n.push_back(std::make_pair(zero, 0));
         lambda_n.push_back(std::make_pair(this->land[level][i].first, fabs(this->land[level][i].second)));
         if (AbsDbg) {
-          std::cout << "Adding pair : (" << zero << ",0)" << std::endl;
-          std::cout << "In the same step adding pair : (" << this->land[level][i].first << ","
+          std::clog << "Adding pair : (" << zero << ",0)" << std::endl;
+          std::clog << "In the same step adding pair : (" << this->land[level][i].first << ","
                     << fabs(this->land[level][i].second) << ") " << std::endl;
           std::cin.ignore();
         }
       } else {
         lambda_n.push_back(std::make_pair(this->land[level][i].first, fabs(this->land[level][i].second)));
         if (AbsDbg) {
-          std::cout << "Adding pair : (" << this->land[level][i].first << "," << fabs(this->land[level][i].second)
+          std::clog << "Adding pair : (" << this->land[level][i].first << "," << fabs(this->land[level][i].second)
                     << ") " << std::endl;
           std::cin.ignore();
         }
@@ -851,13 +851,13 @@ Persistence_landscape* Persistence_landscape::new_abs() {
   Persistence_landscape* result = new Persistence_landscape(*this);
   for (size_t level = 0; level != this->land.size(); ++level) {
     if (AbsDbg) {
-      std::cout << "level: " << level << std::endl;
+      std::clog << "level: " << level << std::endl;
     }
     std::vector<std::pair<double, double> > lambda_n;
     lambda_n.push_back(std::make_pair(-std::numeric_limits<int>::max(), 0));
     for (size_t i = 1; i != this->land[level].size(); ++i) {
       if (AbsDbg) {
-        std::cout << "this->land[" << level << "][" << i << "] : " << this->land[level][i].first << " "
+        std::clog << "this->land[" << level << "][" << i << "] : " << this->land[level][i].first << " "
                   << this->land[level][i].second << std::endl;
       }
       // if a line segment between this->land[level][i-1] and this->land[level][i] crosses the x-axis, then we have to
@@ -869,15 +869,15 @@ Persistence_landscape* Persistence_landscape::new_abs() {
         lambda_n.push_back(std::make_pair(zero, 0));
         lambda_n.push_back(std::make_pair(this->land[level][i].first, fabs(this->land[level][i].second)));
         if (AbsDbg) {
-          std::cout << "Adding pair : (" << zero << ",0)" << std::endl;
-          std::cout << "In the same step adding pair : (" << this->land[level][i].first << ","
+          std::clog << "Adding pair : (" << zero << ",0)" << std::endl;
+          std::clog << "In the same step adding pair : (" << this->land[level][i].first << ","
                     << fabs(this->land[level][i].second) << ") " << std::endl;
           std::cin.ignore();
         }
       } else {
         lambda_n.push_back(std::make_pair(this->land[level][i].first, fabs(this->land[level][i].second)));
         if (AbsDbg) {
-          std::cout << "Adding pair : (" << this->land[level][i].first << "," << fabs(this->land[level][i].second)
+          std::clog << "Adding pair : (" << this->land[level][i].first << "," << fabs(this->land[level][i].second)
                     << ") " << std::endl;
           std::cin.ignore();
         }
@@ -943,11 +943,11 @@ void Persistence_landscape::load_landscape_from_file(const char* filename) {
       lineSS >> endd;
       landscapeAtThisLevel.push_back(std::make_pair(beginn, endd));
       if (dbg) {
-        std::cerr << "Reading a point : " << beginn << " , " << endd << std::endl;
+        std::clog << "Reading a point : " << beginn << " , " << endd << std::endl;
       }
     } else {
       if (dbg) {
-        std::cout << "IGNORE LINE\n";
+        std::clog << "IGNORE LINE\n";
         getchar();
       }
       if (!isThisAFirsLine) {
@@ -975,7 +975,7 @@ Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscap
                                                       const Persistence_landscape& land2) {
   bool operation_on_pair_of_landscapesDBG = false;
   if (operation_on_pair_of_landscapesDBG) {
-    std::cout << "operation_on_pair_of_landscapes\n";
+    std::clog << "operation_on_pair_of_landscapes\n";
     std::cin.ignore();
   }
   Persistence_landscape result;
@@ -985,8 +985,8 @@ Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscap
 
   if (operation_on_pair_of_landscapesDBG) {
     for (size_t i = 0; i != std::min(land1.land.size(), land2.land.size()); ++i) {
-      std::cerr << "land1.land[" << i << "].size() : " << land1.land[i].size() << std::endl;
-      std::cerr << "land2.land[" << i << "].size() : " << land2.land[i].size() << std::endl;
+      std::clog << "land1.land[" << i << "].size() : " << land1.land[i].size() << std::endl;
+      std::clog << "land2.land[" << i << "].size() : " << land2.land[i].size() << std::endl;
     }
     getchar();
   }
@@ -997,20 +997,20 @@ Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscap
     size_t q = 0;
     while ((p + 1 < land1.land[i].size()) && (q + 1 < land2.land[i].size())) {
       if (operation_on_pair_of_landscapesDBG) {
-        std::cerr << "p : " << p << "\n";
-        std::cerr << "q : " << q << "\n";
-        std::cerr << "land1.land.size() : " << land1.land.size() << std::endl;
-        std::cerr << "land2.land.size() : " << land2.land.size() << std::endl;
-        std::cerr << "land1.land[" << i << "].size() : " << land1.land[i].size() << std::endl;
-        std::cerr << "land2.land[" << i << "].size() : " << land2.land[i].size() << std::endl;
-        std::cout << "land1.land[i][p].first : " << land1.land[i][p].first << "\n";
-        std::cout << "land2.land[i][q].first : " << land2.land[i][q].first << "\n";
+        std::clog << "p : " << p << "\n";
+        std::clog << "q : " << q << "\n";
+        std::clog << "land1.land.size() : " << land1.land.size() << std::endl;
+        std::clog << "land2.land.size() : " << land2.land.size() << std::endl;
+        std::clog << "land1.land[" << i << "].size() : " << land1.land[i].size() << std::endl;
+        std::clog << "land2.land[" << i << "].size() : " << land2.land[i].size() << std::endl;
+        std::clog << "land1.land[i][p].first : " << land1.land[i][p].first << "\n";
+        std::clog << "land2.land[i][q].first : " << land2.land[i][q].first << "\n";
       }
 
       if (land1.land[i][p].first < land2.land[i][q].first) {
         if (operation_on_pair_of_landscapesDBG) {
-          std::cout << "first \n";
-          std::cout << " function_value(land2.land[i][q-1],land2.land[i][q],land1.land[i][p].first) : "
+          std::clog << "first \n";
+          std::clog << " function_value(land2.land[i][q-1],land2.land[i][q],land1.land[i][p].first) : "
                     << function_value(land2.land[i][q - 1], land2.land[i][q], land1.land[i][p].first) << "\n";
         }
         lambda_n.push_back(
@@ -1022,12 +1022,12 @@ Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscap
       }
       if (land1.land[i][p].first > land2.land[i][q].first) {
         if (operation_on_pair_of_landscapesDBG) {
-          std::cout << "Second \n";
-          std::cout << "function_value(" << land1.land[i][p - 1].first << " " << land1.land[i][p - 1].second << " ,"
+          std::clog << "Second \n";
+          std::clog << "function_value(" << land1.land[i][p - 1].first << " " << land1.land[i][p - 1].second << " ,"
                     << land1.land[i][p].first << " " << land1.land[i][p].second << ", " << land2.land[i][q].first
                     << " ) : " << function_value(land1.land[i][p - 1], land1.land[i][p - 1], land2.land[i][q].first)
                     << "\n";
-          std::cout << "oper( " << function_value(land1.land[i][p], land1.land[i][p - 1], land2.land[i][q].first) << ","
+          std::clog << "oper( " << function_value(land1.land[i][p], land1.land[i][p - 1], land2.land[i][q].first) << ","
                     << land2.land[i][q].second << " : "
                     << oper(land2.land[i][q].second,
                             function_value(land1.land[i][p], land1.land[i][p - 1], land2.land[i][q].first))
@@ -1040,19 +1040,19 @@ Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscap
         continue;
       }
       if (land1.land[i][p].first == land2.land[i][q].first) {
-        if (operation_on_pair_of_landscapesDBG) std::cout << "Third \n";
+        if (operation_on_pair_of_landscapesDBG) std::clog << "Third \n";
         lambda_n.push_back(
             std::make_pair(land2.land[i][q].first, oper(land1.land[i][p].second, land2.land[i][q].second)));
         ++p;
         ++q;
       }
       if (operation_on_pair_of_landscapesDBG) {
-        std::cout << "Next iteration \n";
+        std::clog << "Next iteration \n";
       }
     }
     while ((p + 1 < land1.land[i].size()) && (q + 1 >= land2.land[i].size())) {
       if (operation_on_pair_of_landscapesDBG) {
-        std::cout << "New point : " << land1.land[i][p].first
+        std::clog << "New point : " << land1.land[i][p].first
                   << "  oper(land1.land[i][p].second,0) : " << oper(land1.land[i][p].second, 0) << std::endl;
       }
       lambda_n.push_back(std::make_pair(land1.land[i][p].first, oper(land1.land[i][p].second, 0)));
@@ -1060,7 +1060,7 @@ Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscap
     }
     while ((p + 1 >= land1.land[i].size()) && (q + 1 < land2.land[i].size())) {
       if (operation_on_pair_of_landscapesDBG) {
-        std::cout << "New point : " << land2.land[i][q].first
+        std::clog << "New point : " << land2.land[i][q].first
                   << " oper(0,land2.land[i][q].second) : " << oper(0, land2.land[i][q].second) << std::endl;
       }
       lambda_n.push_back(std::make_pair(land2.land[i][q].first, oper(0, land2.land[i][q].second)));
@@ -1073,7 +1073,7 @@ Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscap
   }
   if (land1.land.size() > std::min(land1.land.size(), land2.land.size())) {
     if (operation_on_pair_of_landscapesDBG) {
-      std::cout << "land1.land.size() > std::min( land1.land.size() , land2.land.size() )" << std::endl;
+      std::clog << "land1.land.size() > std::min( land1.land.size() , land2.land.size() )" << std::endl;
     }
     for (size_t i = std::min(land1.land.size(), land2.land.size()); i != std::max(land1.land.size(), land2.land.size());
          ++i) {
@@ -1088,7 +1088,7 @@ Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscap
   }
   if (land2.land.size() > std::min(land1.land.size(), land2.land.size())) {
     if (operation_on_pair_of_landscapesDBG) {
-      std::cout << "( land2.land.size() > std::min( land1.land.size() , land2.land.size() ) ) " << std::endl;
+      std::clog << "( land2.land.size() > std::min( land1.land.size() , land2.land.size() ) ) " << std::endl;
     }
     for (size_t i = std::min(land1.land.size(), land2.land.size()); i != std::max(land1.land.size(), land2.land.size());
          ++i) {
@@ -1102,7 +1102,7 @@ Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscap
     }
   }
   if (operation_on_pair_of_landscapesDBG) {
-    std::cout << "operation_on_pair_of_landscapes END\n";
+    std::clog << "operation_on_pair_of_landscapes END\n";
     std::cin.ignore();
   }
   return result;
@@ -1110,20 +1110,20 @@ Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscap
 
 double compute_maximal_distance_non_symmetric(const Persistence_landscape& pl1, const Persistence_landscape& pl2) {
   bool dbg = false;
-  if (dbg) std::cerr << " compute_maximal_distance_non_symmetric \n";
+  if (dbg) std::clog << " compute_maximal_distance_non_symmetric \n";
   // this distance is not symmetric. It compute ONLY distance between inflection points of pl1 and pl2.
   double maxDist = 0;
   size_t minimalNumberOfLevels = std::min(pl1.land.size(), pl2.land.size());
   for (size_t level = 0; level != minimalNumberOfLevels; ++level) {
     if (dbg) {
-      std::cerr << "Level : " << level << std::endl;
-      std::cerr << "PL1 : \n";
+      std::clog << "Level : " << level << std::endl;
+      std::clog << "PL1 : \n";
       for (size_t i = 0; i != pl1.land[level].size(); ++i) {
-        std::cerr << "(" << pl1.land[level][i].first << "," << pl1.land[level][i].second << ") \n";
+        std::clog << "(" << pl1.land[level][i].first << "," << pl1.land[level][i].second << ") \n";
       }
-      std::cerr << "PL2 : \n";
+      std::clog << "PL2 : \n";
       for (size_t i = 0; i != pl2.land[level].size(); ++i) {
-        std::cerr << "(" << pl2.land[level][i].first << "," << pl2.land[level][i].second << ") \n";
+        std::clog << "(" << pl2.land[level][i].first << "," << pl2.land[level][i].second << ") \n";
       }
       std::cin.ignore();
     }
@@ -1143,24 +1143,24 @@ double compute_maximal_distance_non_symmetric(const Persistence_landscape& pl1,
       if (maxDist <= val) maxDist = val;
 
       if (dbg) {
-        std::cerr << pl1.land[level][i].first << "in [" << pl2.land[level][p2Count].first << ","
+        std::clog << pl1.land[level][i].first << "in [" << pl2.land[level][p2Count].first << ","
                   << pl2.land[level][p2Count + 1].first << "] \n";
-        std::cerr << "pl1[level][i].second : " << pl1.land[level][i].second << std::endl;
-        std::cerr << "function_value( pl2[level][p2Count] , pl2[level][p2Count+1] , pl1[level][i].first ) : "
+        std::clog << "pl1[level][i].second : " << pl1.land[level][i].second << std::endl;
+        std::clog << "function_value( pl2[level][p2Count] , pl2[level][p2Count+1] , pl1[level][i].first ) : "
                   << function_value(pl2.land[level][p2Count], pl2.land[level][p2Count + 1], pl1.land[level][i].first)
                   << std::endl;
-        std::cerr << "val : " << val << std::endl;
+        std::clog << "val : " << val << std::endl;
         std::cin.ignore();
       }
     }
   }
 
-  if (dbg) std::cerr << "minimalNumberOfLevels : " << minimalNumberOfLevels << std::endl;
+  if (dbg) std::clog << "minimalNumberOfLevels : " << minimalNumberOfLevels << std::endl;
 
   if (minimalNumberOfLevels < pl1.land.size()) {
     for (size_t level = minimalNumberOfLevels; level != pl1.land.size(); ++level) {
       for (size_t i = 0; i != pl1.land[level].size(); ++i) {
-        if (dbg) std::cerr << "pl1[level][i].second  : " << pl1.land[level][i].second << std::endl;
+        if (dbg) std::clog << "pl1[level][i].second  : " << pl1.land[level][i].second << std::endl;
         if (maxDist < pl1.land[level][i].second) maxDist = pl1.land[level][i].second;
       }
     }
@@ -1181,7 +1181,7 @@ double compute_distance_of_landscapes(const Persistence_landscape& first, const
   lan = lan.abs();
 
   if (dbg) {
-    std::cerr << "Abs of difference ; " << lan << std::endl;
+    std::clog << "Abs of difference ; " << lan << std::endl;
     getchar();
   }
 
@@ -1189,17 +1189,17 @@ double compute_distance_of_landscapes(const Persistence_landscape& first, const
     // \int_{- \infty}^{+\infty}| first-second |^p
     double result;
     if (p != 1) {
-      if (dbg) std::cerr << "Power != 1, compute integral to the power p\n";
+      if (dbg) std::clog << "Power != 1, compute integral to the power p\n";
       result = lan.compute_integral_of_landscape(p);
     } else {
-      if (dbg) std::cerr << "Power = 1, compute integral \n";
+      if (dbg) std::clog << "Power = 1, compute integral \n";
       result = lan.compute_integral_of_landscape();
     }
     // (\int_{- \infty}^{+\infty}| first-second |^p)^(1/p)
     return pow(result, 1.0 / p);
   } else {
     // p == infty
-    if (dbg) std::cerr << "Power = infty, compute maximum \n";
+    if (dbg) std::clog << "Power = infty, compute maximum \n";
     return lan.compute_maximum();
   }
 }
@@ -1220,7 +1220,7 @@ double compute_inner_product(const Persistence_landscape& l1, const Persistence_
 
   for (size_t level = 0; level != std::min(l1.size(), l2.size()); ++level) {
     if (dbg) {
-      std::cerr << "Computing inner product for a level : " << level << std::endl;
+      std::clog << "Computing inner product for a level : " << level << std::endl;
       getchar();
     }
     auto&& l1_land_level = l1.land[level];
@@ -1267,14 +1267,14 @@ double compute_inner_product(const Persistence_landscape& l1, const Persistence_
       result += contributionFromThisPart;
 
       if (dbg) {
-        std::cerr << "[l1_land_level[l1It].first,l1_land_level[l1It+1].first] : " << l1_land_level[l1It].first
+        std::clog << "[l1_land_level[l1It].first,l1_land_level[l1It+1].first] : " << l1_land_level[l1It].first
                   << " , " << l1_land_level[l1It + 1].first << std::endl;
-        std::cerr << "[l2_land_level[l2It].first,l2_land_level[l2It+1].first] : " << l2_land_level[l2It].first
+        std::clog << "[l2_land_level[l2It].first,l2_land_level[l2It+1].first] : " << l2_land_level[l2It].first
                   << " , " << l2_land_level[l2It + 1].first << std::endl;
-        std::cerr << "a : " << a << ", b : " << b << " , c: " << c << ", d : " << d << std::endl;
-        std::cerr << "x1 : " << x1 << " , x2 : " << x2 << std::endl;
-        std::cerr << "contributionFromThisPart : " << contributionFromThisPart << std::endl;
-        std::cerr << "result : " << result << std::endl;
+        std::clog << "a : " << a << ", b : " << b << " , c: " << c << ", d : " << d << std::endl;
+        std::clog << "x1 : " << x1 << " , x2 : " << x2 << std::endl;
+        std::clog << "contributionFromThisPart : " << contributionFromThisPart << std::endl;
+        std::clog << "result : " << result << std::endl;
         getchar();
       }
 
@@ -1290,11 +1290,11 @@ double compute_inner_product(const Persistence_landscape& l1, const Persistence_
           // in this case, we increment both:
           ++l2It;
           if (dbg) {
-            std::cerr << "Incrementing both \n";
+            std::clog << "Incrementing both \n";
           }
         } else {
           if (dbg) {
-            std::cerr << "Incrementing first \n";
+            std::clog << "Incrementing first \n";
           }
         }
         ++l1It;
@@ -1302,7 +1302,7 @@ double compute_inner_product(const Persistence_landscape& l1, const Persistence_
         // in this case we increment l2It
         ++l2It;
         if (dbg) {
-          std::cerr << "Incrementing second \n";
+          std::clog << "Incrementing second \n";
         }
       }
 
@@ -1361,7 +1361,7 @@ void Persistence_landscape::plot(const char* filename, double xRangeBegin, doubl
     }
     out << "EOF" << std::endl;
   }
-  std::cout << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
+  std::clog << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
             << gnuplot_script.str().c_str() << "\'\"" << std::endl;
 }
 
diff --git a/src/Persistence_representations/include/gudhi/Persistence_landscape_on_grid.h b/src/Persistence_representations/include/gudhi/Persistence_landscape_on_grid.h
index 68bce336..537131da 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_landscape_on_grid.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_landscape_on_grid.h
@@ -155,9 +155,9 @@ class Persistence_landscape_on_grid {
     double dx = (this->grid_max - this->grid_min) / static_cast<double>(this->values_of_landscapes.size() - 1);
 
     if (dbg) {
-      std::cerr << "this->grid_max : " << this->grid_max << std::endl;
-      std::cerr << "this->grid_min : " << this->grid_min << std::endl;
-      std::cerr << "this->values_of_landscapes.size() : " << this->values_of_landscapes.size() << std::endl;
+      std::clog << "this->grid_max : " << this->grid_max << std::endl;
+      std::clog << "this->grid_min : " << this->grid_min << std::endl;
+      std::clog << "this->values_of_landscapes.size() : " << this->values_of_landscapes.size() << std::endl;
       getchar();
     }
 
@@ -169,14 +169,14 @@ class Persistence_landscape_on_grid {
       if (this->values_of_landscapes[i].size() > level) current_y = this->values_of_landscapes[i][level];
 
       if (dbg) {
-        std::cerr << "this->values_of_landscapes[i].size() : " << this->values_of_landscapes[i].size()
+        std::clog << "this->values_of_landscapes[i].size() : " << this->values_of_landscapes[i].size()
                   << " , level : " << level << std::endl;
         if (this->values_of_landscapes[i].size() > level)
-          std::cerr << "this->values_of_landscapes[i][level] : " << this->values_of_landscapes[i][level] << std::endl;
-        std::cerr << "previous_y : " << previous_y << std::endl;
-        std::cerr << "current_y : " << current_y << std::endl;
-        std::cerr << "dx : " << dx << std::endl;
-        std::cerr << "0.5*dx*( previous_y + current_y ); " << 0.5 * dx * (previous_y + current_y) << std::endl;
+          std::clog << "this->values_of_landscapes[i][level] : " << this->values_of_landscapes[i][level] << std::endl;
+        std::clog << "previous_y : " << previous_y << std::endl;
+        std::clog << "current_y : " << current_y << std::endl;
+        std::clog << "dx : " << dx << std::endl;
+        std::clog << "0.5*dx*( previous_y + current_y ); " << 0.5 * dx * (previous_y + current_y) << std::endl;
       }
 
       result += 0.5 * dx * (previous_y + current_y);
@@ -213,10 +213,10 @@ class Persistence_landscape_on_grid {
     if (this->values_of_landscapes[0].size() > level) previous_y = this->values_of_landscapes[0][level];
 
     if (dbg) {
-      std::cerr << "dx : " << dx << std::endl;
-      std::cerr << "previous_x : " << previous_x << std::endl;
-      std::cerr << "previous_y : " << previous_y << std::endl;
-      std::cerr << "power : " << p << std::endl;
+      std::clog << "dx : " << dx << std::endl;
+      std::clog << "previous_x : " << previous_x << std::endl;
+      std::clog << "previous_y : " << previous_y << std::endl;
+      std::clog << "power : " << p << std::endl;
       getchar();
     }
 
@@ -225,7 +225,7 @@ class Persistence_landscape_on_grid {
       double current_y = 0;
       if (this->values_of_landscapes[i].size() > level) current_y = this->values_of_landscapes[i][level];
 
-      if (dbg) std::cerr << "current_y : " << current_y << std::endl;
+      if (dbg) std::clog << "current_y : " << current_y << std::endl;
 
       if (current_y == previous_y) continue;
 
@@ -235,7 +235,7 @@ class Persistence_landscape_on_grid {
       double b = coef.second;
 
       if (dbg) {
-        std::cerr << "A line passing through points : (" << previous_x << "," << previous_y << ") and (" << current_x
+        std::clog << "A line passing through points : (" << previous_x << "," << previous_y << ") and (" << current_x
                   << "," << current_y << ") is : " << a << "x+" << b << std::endl;
       }
 
@@ -249,14 +249,14 @@ class Persistence_landscape_on_grid {
       }
       result += value_to_add;
       if (dbg) {
-        std::cerr << "Increasing result by : " << value_to_add << std::endl;
-        std::cerr << "result : " << result << std::endl;
+        std::clog << "Increasing result by : " << value_to_add << std::endl;
+        std::clog << "result : " << result << std::endl;
         getchar();
       }
       previous_x = current_x;
       previous_y = current_y;
     }
-    if (dbg) std::cerr << "The total result is : " << result << std::endl;
+    if (dbg) std::clog << "The total result is : " << result << std::endl;
     return result;
   }
 
@@ -297,10 +297,10 @@ class Persistence_landscape_on_grid {
     size_t position = size_t((x - this->grid_min) / dx);
 
     if (dbg) {
-      std::cerr << "This is a procedure compute_value_at_a_given_point \n";
-      std::cerr << "level : " << level << std::endl;
-      std::cerr << "x : " << x << std::endl;
-      std::cerr << "position : " << position << std::endl;
+      std::clog << "This is a procedure compute_value_at_a_given_point \n";
+      std::clog << "level : " << level << std::endl;
+      std::clog << "x : " << x << std::endl;
+      std::clog << "position : " << position << std::endl;
     }
     // check if we are not exactly in the grid point:
     if (almost_equal(position * dx + this->grid_min, x)) {
@@ -432,23 +432,23 @@ class Persistence_landscape_on_grid {
   bool operator==(const Persistence_landscape_on_grid& rhs) const {
     bool dbg = true;
     if (this->values_of_landscapes.size() != rhs.values_of_landscapes.size()) {
-      if (dbg) std::cerr << "values_of_landscapes of incompatible sizes\n";
+      if (dbg) std::clog << "values_of_landscapes of incompatible sizes\n";
       return false;
     }
     if (!almost_equal(this->grid_min, rhs.grid_min)) {
-      if (dbg) std::cerr << "grid_min not equal\n";
+      if (dbg) std::clog << "grid_min not equal\n";
       return false;
     }
     if (!almost_equal(this->grid_max, rhs.grid_max)) {
-      if (dbg) std::cerr << "grid_max not equal\n";
+      if (dbg) std::clog << "grid_max not equal\n";
       return false;
     }
     for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
       for (size_t aa = 0; aa != this->values_of_landscapes[i].size(); ++aa) {
         if (!almost_equal(this->values_of_landscapes[i][aa], rhs.values_of_landscapes[i][aa])) {
           if (dbg) {
-            std::cerr << "Problem in the position : " << i << " of values_of_landscapes. \n";
-            std::cerr << this->values_of_landscapes[i][aa] << " " << rhs.values_of_landscapes[i][aa] << std::endl;
+            std::clog << "Problem in the position : " << i << " of values_of_landscapes. \n";
+            std::clog << this->values_of_landscapes[i][aa] << " " << rhs.values_of_landscapes[i][aa] << std::endl;
           }
           return false;
         }
@@ -615,7 +615,7 @@ class Persistence_landscape_on_grid {
     double previous_y_l1 = 0;
     double previous_y_l2 = 0;
     for (size_t i = 0; i != l1.values_of_landscapes.size(); ++i) {
-      if (dbg) std::cerr << "i : " << i << std::endl;
+      if (dbg) std::clog << "i : " << i << std::endl;
 
       double current_x = previous_x + dx;
       double current_y_l1 = 0;
@@ -625,11 +625,11 @@ class Persistence_landscape_on_grid {
       if (l2.values_of_landscapes[i].size() > level) current_y_l2 = l2.values_of_landscapes[i][level];
 
       if (dbg) {
-        std::cerr << "previous_x  : " << previous_x << std::endl;
-        std::cerr << "previous_y_l1 : " << previous_y_l1 << std::endl;
-        std::cerr << "current_y_l1 : " << current_y_l1 << std::endl;
-        std::cerr << "previous_y_l2 : " << previous_y_l2 << std::endl;
-        std::cerr << "current_y_l2 : " << current_y_l2 << std::endl;
+        std::clog << "previous_x  : " << previous_x << std::endl;
+        std::clog << "previous_y_l1 : " << previous_y_l1 << std::endl;
+        std::clog << "current_y_l1 : " << current_y_l1 << std::endl;
+        std::clog << "previous_y_l2 : " << previous_y_l2 << std::endl;
+        std::clog << "current_y_l2 : " << current_y_l2 << std::endl;
       }
 
       std::pair<double, double> l1_coords = compute_parameters_of_a_line(std::make_pair(previous_x, previous_y_l1),
@@ -646,11 +646,11 @@ class Persistence_landscape_on_grid {
       double d = l2_coords.second;
 
       if (dbg) {
-        std::cerr << "Here are the formulas for a line: \n";
-        std::cerr << "a : " << a << std::endl;
-        std::cerr << "b : " << b << std::endl;
-        std::cerr << "c : " << c << std::endl;
-        std::cerr << "d : " << d << std::endl;
+        std::clog << "Here are the formulas for a line: \n";
+        std::clog << "a : " << a << std::endl;
+        std::clog << "b : " << b << std::endl;
+        std::clog << "c : " << c << std::endl;
+        std::clog << "d : " << d << std::endl;
       }
 
       // now, to compute the inner product in this interval we need to compute the integral of (ax+b)(cx+d) = acx^2 +
@@ -663,11 +663,11 @@ class Persistence_landscape_on_grid {
                             (a * d + b * c) / 2 * previous_x * previous_x + b * d * previous_x);
 
       if (dbg) {
-        std::cerr << "Value of the integral on the left end i.e. : " << previous_x << " is : "
+        std::clog << "Value of the integral on the left end i.e. : " << previous_x << " is : "
                   << a * c / 3 * previous_x * previous_x * previous_x + (a * d + b * c) / 2 * previous_x * previous_x +
                          b * d * previous_x
                   << std::endl;
-        std::cerr << "Value of the integral on the right end i.e. : " << current_x << " is "
+        std::clog << "Value of the integral on the right end i.e. : " << current_x << " is "
                   << a * c / 3 * current_x * current_x * current_x + (a * d + b * c) / 2 * current_x * current_x +
                          b * d * current_x
                   << std::endl;
@@ -676,8 +676,8 @@ class Persistence_landscape_on_grid {
       result += added_value;
 
       if (dbg) {
-        std::cerr << "added_value : " << added_value << std::endl;
-        std::cerr << "result : " << result << std::endl;
+        std::clog << "added_value : " << added_value << std::endl;
+        std::clog << "result : " << result << std::endl;
         getchar();
       }
 
@@ -703,8 +703,8 @@ class Persistence_landscape_on_grid {
     // time:
 
     if (dbg) {
-      std::cerr << "first : " << first << std::endl;
-      std::cerr << "second : " << second << std::endl;
+      std::clog << "first : " << first << std::endl;
+      std::clog << "second : " << second << std::endl;
       getchar();
     }
 
@@ -712,14 +712,14 @@ class Persistence_landscape_on_grid {
     Persistence_landscape_on_grid lan = first - second;
 
     if (dbg) {
-      std::cerr << "Difference : " << lan << std::endl;
+      std::clog << "Difference : " << lan << std::endl;
     }
 
     //| first-second |:
     lan.abs();
 
     if (dbg) {
-      std::cerr << "Abs : " << lan << std::endl;
+      std::clog << "Abs : " << lan << std::endl;
     }
 
     if (p < std::numeric_limits<double>::max()) {
@@ -727,18 +727,18 @@ class Persistence_landscape_on_grid {
       double result;
       if (p != 1) {
         if (dbg) {
-          std::cerr << "p : " << p << std::endl;
+          std::clog << "p : " << p << std::endl;
           getchar();
         }
         result = lan.compute_integral_of_landscape(p);
         if (dbg) {
-          std::cerr << "integral : " << result << std::endl;
+          std::clog << "integral : " << result << std::endl;
           getchar();
         }
       } else {
         result = lan.compute_integral_of_landscape();
         if (dbg) {
-          std::cerr << "integral, without power : " << result << std::endl;
+          std::clog << "integral, without power : " << result << std::endl;
           getchar();
         }
       }
@@ -820,7 +820,7 @@ class Persistence_landscape_on_grid {
     this->grid_max = (to_average[0])->grid_max;
 
     if (dbg) {
-      std::cerr << "Computations of average. The data from the current landscape have been cleared. We are ready to do "
+      std::clog << "Computations of average. The data from the current landscape have been cleared. We are ready to do "
                    "the computations. \n";
     }
 
@@ -835,7 +835,7 @@ class Persistence_landscape_on_grid {
       this->values_of_landscapes[grid_point] = std::vector<double>(maximal_size_of_vector);
 
       if (dbg) {
-        std::cerr << "We are considering the point : " << grid_point
+        std::clog << "We are considering the point : " << grid_point
                   << " of the grid. In this point, there are at most : " << maximal_size_of_vector
                   << " nonzero landscape functions \n";
       }
@@ -931,12 +931,12 @@ void Persistence_landscape_on_grid::set_up_values_of_landscapes(const std::vecto
                                                                 size_t number_of_points_, unsigned number_of_levels) {
   bool dbg = false;
   if (dbg) {
-    std::cerr << "Here is the procedure : set_up_values_of_landscapes. The parameters are : grid_min_ : " << grid_min_
+    std::clog << "Here is the procedure : set_up_values_of_landscapes. The parameters are : grid_min_ : " << grid_min_
               << ", grid_max_ : " << grid_max_ << ", number_of_points_ : " << number_of_points_
               << ", number_of_levels: " << number_of_levels << std::endl;
-    std::cerr << "Here are the intervals at our disposal : \n";
+    std::clog << "Here are the intervals at our disposal : \n";
     for (size_t i = 0; i != p.size(); ++i) {
-      std::cerr << p[i].first << " , " << p[i].second << std::endl;
+      std::clog << p[i].first << " , " << p[i].second << std::endl;
     }
   }
 
@@ -976,17 +976,17 @@ void Persistence_landscape_on_grid::set_up_values_of_landscapes(const std::vecto
     size_t grid_interval_midpoint = (size_t)(0.5 * (grid_interval_begin + grid_interval_end));
 
     if (dbg) {
-      std::cerr << "Considering an interval : " << p[int_no].first << "," << p[int_no].second << std::endl;
+      std::clog << "Considering an interval : " << p[int_no].first << "," << p[int_no].second << std::endl;
 
-      std::cerr << "grid_interval_begin : " << grid_interval_begin << std::endl;
-      std::cerr << "grid_interval_end : " << grid_interval_end << std::endl;
-      std::cerr << "grid_interval_midpoint : " << grid_interval_midpoint << std::endl;
+      std::clog << "grid_interval_begin : " << grid_interval_begin << std::endl;
+      std::clog << "grid_interval_end : " << grid_interval_end << std::endl;
+      std::clog << "grid_interval_midpoint : " << grid_interval_midpoint << std::endl;
     }
 
     double landscape_value = dx;
     for (size_t i = grid_interval_begin + 1; i < grid_interval_midpoint; ++i) {
       if (dbg) {
-        std::cerr << "Adding landscape value (going up) for a point : " << i << " equal : " << landscape_value
+        std::clog << "Adding landscape value (going up) for a point : " << i << " equal : " << landscape_value
                   << std::endl;
       }
       if (number_of_levels != std::numeric_limits<unsigned>::max()) {
@@ -1044,7 +1044,7 @@ void Persistence_landscape_on_grid::set_up_values_of_landscapes(const std::vecto
         }
 
         if (dbg) {
-          std::cerr << "Adding landscape value (going down) for a point : " << i << " equal : " << landscape_value
+          std::clog << "Adding landscape value (going down) for a point : " << i << " equal : " << landscape_value
                     << std::endl;
         }
       }
@@ -1246,7 +1246,7 @@ void Persistence_landscape_on_grid::plot(const char* filename, double min_x, dou
     }
     out << "EOF" << std::endl;
   }
-  std::cout << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
+  std::clog << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
             << gnuplot_script.str().c_str() << "\'\"" << std::endl;
 }
 
diff --git a/src/Persistence_representations/include/gudhi/Persistence_vectors.h b/src/Persistence_representations/include/gudhi/Persistence_vectors.h
index 6776f4a3..fab96900 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_vectors.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_vectors.h
@@ -189,7 +189,7 @@ class Vector_distances_in_diagram {
     }
     out << std::endl;
     out.close();
-    std::cout << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
+    std::clog << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
               << gnuplot_script.str().c_str() << "\'\"" << std::endl;
   }
 
@@ -360,9 +360,9 @@ template <typename F>
 void Vector_distances_in_diagram<F>::compute_sorted_vector_of_distances_via_heap(size_t where_to_cut) {
   bool dbg = false;
   if (dbg) {
-    std::cerr << "Here are the intervals : \n";
+    std::clog << "Here are the intervals : \n";
     for (size_t i = 0; i != this->intervals.size(); ++i) {
-      std::cerr << this->intervals[i].first << " , " << this->intervals[i].second << std::endl;
+      std::clog << this->intervals[i].first << " , " << this->intervals[i].second << std::endl;
     }
   }
   where_to_cut = std::min(
@@ -385,14 +385,14 @@ void Vector_distances_in_diagram<F>::compute_sorted_vector_of_distances_via_heap
                                                    0.5 * (this->intervals[j].first + this->intervals[j].second)))));
 
       if (dbg) {
-        std::cerr << "Value : " << value << std::endl;
-        std::cerr << "heap.front() : " << heap.front() << std::endl;
+        std::clog << "Value : " << value << std::endl;
+        std::clog << "heap.front() : " << heap.front() << std::endl;
         getchar();
       }
 
       if (-value < heap.front()) {
         if (dbg) {
-          std::cerr << "Replacing : " << heap.front() << " with : " << -value << std::endl;
+          std::clog << "Replacing : " << heap.front() << " with : " << -value << std::endl;
           getchar();
         }
         // remove the first element from the heap
@@ -431,11 +431,11 @@ void Vector_distances_in_diagram<F>::compute_sorted_vector_of_distances_via_heap
   }
 
   if (dbg) {
-    std::cerr << "This is the heap after all the operations :\n";
+    std::clog << "This is the heap after all the operations :\n";
     for (size_t i = 0; i != heap.size(); ++i) {
-      std::cout << heap[i] << " ";
+      std::clog << heap[i] << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   this->sorted_vector_of_distances = heap;
@@ -519,11 +519,11 @@ double Vector_distances_in_diagram<F>::distance(const Vector_distances_in_diagra
   bool dbg = false;
 
   if (dbg) {
-    std::cerr << "Entering double Vector_distances_in_diagram<F>::distance( const Abs_Topological_data_with_distances* "
+    std::clog << "Entering double Vector_distances_in_diagram<F>::distance( const Abs_Topological_data_with_distances* "
                  "second , double power ) procedure \n";
-    std::cerr << "Power : " << power << std::endl;
-    std::cerr << "This : " << *this << std::endl;
-    std::cerr << "second : " << second_ << std::endl;
+    std::clog << "Power : " << power << std::endl;
+    std::clog << "This : " << *this << std::endl;
+    std::clog << "second : " << second_ << std::endl;
   }
 
   double result = 0;
@@ -531,7 +531,7 @@ double Vector_distances_in_diagram<F>::distance(const Vector_distances_in_diagra
        ++i) {
     if (power == 1) {
       if (dbg) {
-        std::cerr << "|" << this->sorted_vector_of_distances[i] << " -  " << second_.sorted_vector_of_distances[i]
+        std::clog << "|" << this->sorted_vector_of_distances[i] << " -  " << second_.sorted_vector_of_distances[i]
                   << " |  : " << fabs(this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i])
                   << std::endl;
       }
@@ -545,7 +545,7 @@ double Vector_distances_in_diagram<F>::distance(const Vector_distances_in_diagra
           result = fabs(this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i]);
       }
       if (dbg) {
-        std::cerr << "| " << this->sorted_vector_of_distances[i] << " - " << second_.sorted_vector_of_distances[i]
+        std::clog << "| " << this->sorted_vector_of_distances[i] << " - " << second_.sorted_vector_of_distances[i]
                   << " : " << fabs(this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i])
                   << std::endl;
       }
diff --git a/src/Persistence_representations/include/gudhi/read_persistence_from_file.h b/src/Persistence_representations/include/gudhi/read_persistence_from_file.h
index 5c2d2038..a5bc1bca 100644
--- a/src/Persistence_representations/include/gudhi/read_persistence_from_file.h
+++ b/src/Persistence_representations/include/gudhi/read_persistence_from_file.h
@@ -50,28 +50,28 @@ std::vector<std::pair<double, double> > read_persistence_intervals_in_one_dimens
   final_barcode.reserve(barcode_initial.size());
 
   if (dbg) {
-    std::cerr << "Here are the intervals that we read from the file : \n";
+    std::clog << "Here are the intervals that we read from the file : \n";
     for (size_t i = 0; i != barcode_initial.size(); ++i) {
-      std::cout << barcode_initial[i].first << " " << barcode_initial[i].second << std::endl;
+      std::clog << barcode_initial[i].first << " " << barcode_initial[i].second << std::endl;
     }
     getchar();
   }
 
   for (size_t i = 0; i != barcode_initial.size(); ++i) {
     if (dbg) {
-      std::cout << "COnsidering interval : " << barcode_initial[i].first << " " << barcode_initial[i].second
+      std::clog << "Considering interval : " << barcode_initial[i].first << " " << barcode_initial[i].second
                 << std::endl;
     }
 
     if (barcode_initial[i].first > barcode_initial[i].second) {
       // note that in this case barcode_initial[i].second != std::numeric_limits<double>::infinity()
-      if (dbg) std::cout << "Swap and enter \n";
+      if (dbg) std::clog << "Swap and enter \n";
       // swap them to make sure that birth < death
       final_barcode.push_back(std::pair<double, double>(barcode_initial[i].second, barcode_initial[i].first));
       continue;
     } else {
       if (barcode_initial[i].second != std::numeric_limits<double>::infinity()) {
-        if (dbg) std::cout << "Simply enters\n";
+        if (dbg) std::clog << "Simply enters\n";
         // in this case, due to the previous conditions we know that barcode_initial[i].first <
         // barcode_initial[i].second, so we put them as they are
         final_barcode.push_back(std::pair<double, double>(barcode_initial[i].first, barcode_initial[i].second));
@@ -91,11 +91,11 @@ std::vector<std::pair<double, double> > read_persistence_intervals_in_one_dimens
   }
 
   if (dbg) {
-    std::cerr << "Here are the final bars that we are sending further : \n";
+    std::clog << "Here are the final bars that we are sending further : \n";
     for (size_t i = 0; i != final_barcode.size(); ++i) {
-      std::cout << final_barcode[i].first << " " << final_barcode[i].second << std::endl;
+      std::clog << final_barcode[i].first << " " << final_barcode[i].second << std::endl;
     }
-    std::cerr << "final_barcode.size() : " << final_barcode.size() << std::endl;
+    std::clog << "final_barcode.size() : " << final_barcode.size() << std::endl;
     getchar();
   }
 
diff --git a/src/Persistence_representations/utilities/CMakeLists.txt b/src/Persistence_representations/utilities/CMakeLists.txt
index fc51b1d6..85633b7b 100644
--- a/src/Persistence_representations/utilities/CMakeLists.txt
+++ b/src/Persistence_representations/utilities/CMakeLists.txt
@@ -14,7 +14,7 @@ function(add_persistence_representation_creation_utility creation_utility)
     install(TARGETS ${creation_utility} DESTINATION bin)
 endfunction(add_persistence_representation_creation_utility)
 
-function(add_persistence_representation_plot_utility plot_utility tool_extension)
+function(add_persistence_representation_plot_utility creation_utility plot_utility tool_extension)
     add_executable ( ${plot_utility} ${plot_utility}.cpp )
 
     # as the function is called in a subdirectory level, need to '../' to find persistence heat maps files
@@ -22,17 +22,21 @@ function(add_persistence_representation_plot_utility plot_utility tool_extension
         "${CMAKE_CURRENT_BINARY_DIR}/../first.pers${tool_extension}")
     #add_test(NAME Persistence_representation_utilities_${plot_utility}_second COMMAND $<TARGET_FILE:${plot_utility}>
     #    "${CMAKE_CURRENT_BINARY_DIR}/../second.pers${tool_extension}")
+    set_tests_properties(Persistence_representation_utilities_${plot_utility}_first PROPERTIES DEPENDS
+                         Persistence_representation_utilities_${creation_utility})
     if(GNUPLOT_PATH)
         add_test(NAME Persistence_representation_utilities_${plot_utility}_first_gnuplot COMMAND ${GNUPLOT_PATH}
             "-e" "load '${CMAKE_CURRENT_BINARY_DIR}/../first.pers${tool_extension}_GnuplotScript'")
         #add_test(NAME Persistence_representation_utilities_${plot_utility}_second_gnuplot COMMAND ${GNUPLOT_PATH}
         #    "-e" "load '${CMAKE_CURRENT_BINARY_DIR}/../second.pers${tool_extension}_GnuplotScript'")
+        set_tests_properties(Persistence_representation_utilities_${plot_utility}_first_gnuplot PROPERTIES DEPENDS
+                             Persistence_representation_utilities_${plot_utility}_first)
     endif()
 
     install(TARGETS ${plot_utility} DESTINATION bin)
 endfunction(add_persistence_representation_plot_utility)
 
-function(add_persistence_representation_function_utility function_utility tool_extension)
+function(add_persistence_representation_function_utility creation_utility function_utility tool_extension)
     add_executable ( ${function_utility} ${function_utility}.cpp )
 
     # ARGV2 is an optional argument
@@ -48,6 +52,8 @@ function(add_persistence_representation_function_utility function_utility tool_e
             "${CMAKE_CURRENT_BINARY_DIR}/../first.pers${tool_extension}"
             "${CMAKE_CURRENT_BINARY_DIR}/../second.pers${tool_extension}")
     endif()
+    set_tests_properties(Persistence_representation_utilities_${function_utility} PROPERTIES DEPENDS
+                         Persistence_representation_utilities_${creation_utility})
 
     install(TARGETS ${function_utility} DESTINATION bin)
 endfunction(add_persistence_representation_function_utility)
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/CMakeLists.txt b/src/Persistence_representations/utilities/persistence_heat_maps/CMakeLists.txt
index 89ef232f..e4c471c2 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/CMakeLists.txt
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/CMakeLists.txt
@@ -2,13 +2,24 @@ project(Persistence_representations_heat_maps_utilities)
 
 add_persistence_representation_creation_utility(create_pssk  "10" "-1" "-1" "4" "-1")
 add_persistence_representation_creation_utility(create_p_h_m_weighted_by_arctan_of_their_persistence "10" "-1" "-1" "4" "-1")
+
 add_persistence_representation_creation_utility(create_p_h_m_weighted_by_distance_from_diagonal "10" "-1" "-1" "4" "-1")
+# Tests output the same file
+set_tests_properties(Persistence_representation_utilities_create_p_h_m_weighted_by_distance_from_diagonal PROPERTIES DEPENDS
+                     Persistence_representation_utilities_create_p_h_m_weighted_by_arctan_of_their_persistence)
+
 add_persistence_representation_creation_utility(create_p_h_m_weighted_by_squared_diag_distance "10" "-1" "-1" "4" "-1")
+# Tests output the same file
+set_tests_properties(Persistence_representation_utilities_create_p_h_m_weighted_by_squared_diag_distance PROPERTIES DEPENDS
+                     Persistence_representation_utilities_create_p_h_m_weighted_by_distance_from_diagonal)
+
 # Need to set grid min and max for further average, distance and scalar_product
 add_persistence_representation_creation_utility(create_persistence_heat_maps "10" "0" "35" "10" "-1")
+set_tests_properties(Persistence_representation_utilities_create_persistence_heat_maps PROPERTIES DEPENDS
+                     Persistence_representation_utilities_create_p_h_m_weighted_by_squared_diag_distance)
 
-add_persistence_representation_plot_utility(plot_persistence_heat_map ".mps")
+add_persistence_representation_plot_utility(create_persistence_heat_maps plot_persistence_heat_map ".mps")
 
-add_persistence_representation_function_utility(average_persistence_heat_maps ".mps")
-add_persistence_representation_function_utility(compute_distance_of_persistence_heat_maps ".mps" "1")
-add_persistence_representation_function_utility(compute_scalar_product_of_persistence_heat_maps ".mps")
+add_persistence_representation_function_utility(create_persistence_heat_maps average_persistence_heat_maps ".mps")
+add_persistence_representation_function_utility(create_persistence_heat_maps compute_distance_of_persistence_heat_maps ".mps" "1")
+add_persistence_representation_function_utility(create_persistence_heat_maps compute_scalar_product_of_persistence_heat_maps ".mps")
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp
index 3d088b58..54b1f77d 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp
@@ -17,12 +17,12 @@ using constant_scaling_function = Gudhi::Persistence_representations::constant_s
 using Persistence_heat_maps = Gudhi::Persistence_representations::Persistence_heat_maps<constant_scaling_function>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes average of persistence heat maps stored in files (the files needs to be "
+  std::clog << "This program computes average of persistence heat maps stored in files (the files needs to be "
             << "created beforehand).\n"
             << "The parameters of this programs are names of files with persistence heat maps.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -46,6 +46,6 @@ int main(int argc, char** argv) {
     delete maps[i];
   }
 
-  std::cout << "Average can be found in 'average.mps' file\n";
+  std::clog << "Average can be found in 'average.mps' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp
index 48000bb1..757a97fc 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp
@@ -19,14 +19,14 @@ using constant_scaling_function = Gudhi::Persistence_representations::constant_s
 using Persistence_heat_maps = Gudhi::Persistence_representations::Persistence_heat_maps<constant_scaling_function>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes distance of persistence heat maps stored in files (the files needs to be "
+  std::clog << "This program computes distance of persistence heat maps stored in files (the files needs to be "
             << "created beforehand).\n"
             << "The first parameter of a program is an integer p. The program compute L^p distance of the two heat "
             << "maps. For L^infty distance choose p = -1. \n"
             << "The remaining parameters of this program are names of files with persistence heat maps.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -69,14 +69,14 @@ int main(int argc, char** argv) {
   out.open("distance.mps");
   for (size_t i = 0; i != distance.size(); ++i) {
     for (size_t j = 0; j != distance.size(); ++j) {
-      std::cout << distance[i][j] << " ";
+      std::clog << distance[i][j] << " ";
       out << distance[i][j] << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     out << std::endl;
   }
   out.close();
 
-  std::cout << "Distance can be found in 'distance.mps' file\n";
+  std::clog << "Distance can be found in 'distance.mps' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp
index 8a96f1b0..e7f18ce1 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp
@@ -18,12 +18,12 @@ using constant_scaling_function = Gudhi::Persistence_representations::constant_s
 using Persistence_heat_maps = Gudhi::Persistence_representations::Persistence_heat_maps<constant_scaling_function>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes scalar product of persistence heat maps stored in a file (the file needs to be "
+  std::clog << "This program computes scalar product of persistence heat maps stored in a file (the file needs to be "
             << "created beforehand). \n"
             << "The parameters of this programs are names of files with persistence heat maps.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -60,14 +60,14 @@ int main(int argc, char** argv) {
   out.open("scalar_product.mps");
   for (size_t i = 0; i != scalar_product.size(); ++i) {
     for (size_t j = 0; j != scalar_product.size(); ++j) {
-      std::cout << scalar_product[i][j] << " ";
+      std::clog << scalar_product[i][j] << " ";
       out << scalar_product[i][j] << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     out << std::endl;
   }
   out.close();
 
-  std::cout << "Distance can be found in 'scalar_product.mps' file\n";
+  std::clog << "Distance can be found in 'scalar_product.mps' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp
index f82a39b0..6b38b930 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp
@@ -20,7 +20,7 @@ using Persistence_heat_maps =
     Gudhi::Persistence_representations::Persistence_heat_maps<arc_tan_of_persistence_of_point>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates persistence heat map files (*.mps) of persistence diagrams files (*.pers) "
+  std::clog << "This program creates persistence heat map files (*.mps) of persistence diagrams files (*.pers) "
             << "provided as an input.The Gaussian kernels are weighted by the arc tangential of their persistence.\n"
             << "The first parameter of a program is an integer, a size of a grid.\n"
             << "The second and third parameters are min and max of the grid. If you want those numbers to be computed "
@@ -36,7 +36,7 @@ int main(int argc, char** argv) {
             << "The remaining parameters are the names of files with persistence diagrams. \n";
 
   if (argc < 7) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
 
@@ -58,7 +58,7 @@ int main(int argc, char** argv) {
 
   std::vector<std::vector<double> > filter = Gudhi::Persistence_representations::create_Gaussian_filter(stdiv, 1);
   for (size_t i = 0; i != filenames.size(); ++i) {
-    std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
+    std::clog << "Creating a heat map based on a file : " << filenames[i] << std::endl;
     Persistence_heat_maps l(filenames[i], filter, false, size_of_grid, min_, max_, dimension);
 
     std::stringstream ss;
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp
index 5a657b13..fece2e36 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp
@@ -19,7 +19,7 @@ using distance_from_diagonal_scaling = Gudhi::Persistence_representations::dista
 using Persistence_heat_maps = Gudhi::Persistence_representations::Persistence_heat_maps<distance_from_diagonal_scaling>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates persistence heat map files (*.mps) of persistence diagrams files (*.pers) "
+  std::clog << "This program creates persistence heat map files (*.mps) of persistence diagrams files (*.pers) "
             << "provided as an input.The Gaussian kernels are weighted by the distance of a center from the "
             << "diagonal.\n"
             << "The first parameter of a program is an integer, a size of a grid.\n"
@@ -36,7 +36,7 @@ int main(int argc, char** argv) {
             << "The remaining parameters are the names of files with persistence diagrams. \n";
 
   if (argc < 7) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
 
@@ -58,7 +58,7 @@ int main(int argc, char** argv) {
 
   std::vector<std::vector<double> > filter = Gudhi::Persistence_representations::create_Gaussian_filter(stdiv, 1);
   for (size_t i = 0; i != filenames.size(); ++i) {
-    std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
+    std::clog << "Creating a heat map based on a file : " << filenames[i] << std::endl;
     Persistence_heat_maps l(filenames[i], filter, false, size_of_grid, min_, max_, dimension);
 
     std::stringstream ss;
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp
index 8d67a54d..86e6fc19 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp
@@ -21,7 +21,7 @@ using Persistence_heat_maps =
     Gudhi::Persistence_representations::Persistence_heat_maps<squared_distance_from_diagonal_scaling>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates persistence heat map files (*.mps) of persistence diagrams files (*.pers) "
+  std::clog << "This program creates persistence heat map files (*.mps) of persistence diagrams files (*.pers) "
             << "provided as an input.The Gaussian kernels are weighted by the square of distance of a center from the "
             << "diagonal.\n"
             << "The first parameter of a program is an integer, a size of a grid.\n"
@@ -38,7 +38,7 @@ int main(int argc, char** argv) {
             << "The remaining parameters are the names of files with persistence diagrams. \n";
 
   if (argc < 7) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
 
@@ -60,7 +60,7 @@ int main(int argc, char** argv) {
 
   std::vector<std::vector<double> > filter = Gudhi::Persistence_representations::create_Gaussian_filter(stdiv, 1);
   for (size_t i = 0; i != filenames.size(); ++i) {
-    std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
+    std::clog << "Creating a heat map based on a file : " << filenames[i] << std::endl;
     Persistence_heat_maps l(filenames[i], filter, false, size_of_grid, min_, max_, dimension);
 
     std::stringstream ss;
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp
index 29170c32..ca27f8e3 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp
@@ -19,7 +19,7 @@ using constant_scaling_function = Gudhi::Persistence_representations::constant_s
 using Persistence_heat_maps = Gudhi::Persistence_representations::Persistence_heat_maps<constant_scaling_function>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates persistence heat map files (*.mps) of persistence diagrams files (*.pers) "
+  std::clog << "This program creates persistence heat map files (*.mps) of persistence diagrams files (*.pers) "
             << "provided as an input.\n"
             << "The first parameter of a program is an integer, a size of a grid.\n"
             << "The second and third parameters are min and max of the grid. If you want those numbers to be computed "
@@ -35,7 +35,7 @@ int main(int argc, char** argv) {
             << "The remaining parameters are the names of files with persistence diagrams. \n";
 
   if (argc < 7) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
   size_t size_of_grid = (size_t)atoi(argv[1]);
@@ -55,7 +55,7 @@ int main(int argc, char** argv) {
 
   std::vector<std::vector<double> > filter = Gudhi::Persistence_representations::create_Gaussian_filter(stdiv, 1);
   for (size_t i = 0; i != filenames.size(); ++i) {
-    std::cout << "Creating a heat map based on file : " << filenames[i] << std::endl;
+    std::clog << "Creating a heat map based on file : " << filenames[i] << std::endl;
     Persistence_heat_maps l(filenames[i], filter, false, size_of_grid, min_, max_, dimension);
 
     std::stringstream ss;
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp
index 995771b9..d2ebcc7e 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp
@@ -18,7 +18,7 @@
 using PSSK = Gudhi::Persistence_representations::PSSK;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates PSSK files (*.pssk) of persistence diagrams files (*.pers) "
+  std::clog << "This program creates PSSK files (*.pssk) of persistence diagrams files (*.pers) "
             << "provided as an input.\n"
             << "The first parameter of a program is an integer, a size of a grid.\n"
             << "The second and third parameters are min and max of the grid. If you want those numbers to be computed "
@@ -34,7 +34,7 @@ int main(int argc, char** argv) {
             << "The remaining parameters are the names of files with persistence diagrams. \n";
 
   if (argc < 7) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
 
@@ -56,7 +56,7 @@ int main(int argc, char** argv) {
 
   std::vector<std::vector<double> > filter = Gudhi::Persistence_representations::create_Gaussian_filter(stdiv, 1);
   for (size_t i = 0; i != filenames.size(); ++i) {
-    std::cout << "Creating a PSSK based on a file : " << filenames[i] << std::endl;
+    std::clog << "Creating a PSSK based on a file : " << filenames[i] << std::endl;
     PSSK l(filenames[i], filter, size_of_grid, min_, max_, dimension);
 
     std::stringstream ss;
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp
index cf6e07cb..87cc97d1 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp
@@ -17,10 +17,10 @@ using constant_scaling_function = Gudhi::Persistence_representations::constant_s
 using Persistence_heat_maps = Gudhi::Persistence_representations::Persistence_heat_maps<constant_scaling_function>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates a gnuplot script from a persistence heat maps stored in a file (the file needs "
+  std::clog << "This program creates a gnuplot script from a persistence heat maps stored in a file (the file needs "
             << "to be created beforehand). Please call the code with the name of a single heat maps file \n";
   if (argc != 2) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
   Persistence_heat_maps l;
diff --git a/src/Persistence_representations/utilities/persistence_intervals/CMakeLists.txt b/src/Persistence_representations/utilities/persistence_intervals/CMakeLists.txt
index a025183e..118c1e9b 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/CMakeLists.txt
+++ b/src/Persistence_representations/utilities/persistence_intervals/CMakeLists.txt
@@ -3,17 +3,16 @@ project(Persistence_representations_intervals_utilities)
 
 add_executable ( plot_histogram_of_intervals_lengths plot_histogram_of_intervals_lengths.cpp )
 
-add_test(NAME plot_histogram_of_intervals_lengths COMMAND $<TARGET_FILE:plot_histogram_of_intervals_lengths>
+add_test(NAME Persistence_representation_utilities_plot_histogram_of_intervals_lengths COMMAND $<TARGET_FILE:plot_histogram_of_intervals_lengths>
     "${CMAKE_CURRENT_BINARY_DIR}/../first.pers" "-1")
 
 install(TARGETS plot_histogram_of_intervals_lengths DESTINATION bin)
 
-add_persistence_representation_plot_utility(plot_persistence_intervals "")
-add_persistence_representation_plot_utility(plot_persistence_Betti_numbers "")
+add_persistence_representation_plot_utility(plot_histogram_of_intervals_lengths plot_persistence_intervals "")
+add_persistence_representation_plot_utility(plot_histogram_of_intervals_lengths plot_persistence_Betti_numbers "")
 
 add_persistence_representation_creation_utility(compute_birth_death_range_in_persistence_diagram "-1")
 
-
 add_executable ( compute_number_of_dominant_intervals compute_number_of_dominant_intervals.cpp )
 add_test(NAME Persistence_representation_utilities_compute_number_of_dominant_intervals
     COMMAND $<TARGET_FILE:compute_number_of_dominant_intervals>
diff --git a/src/Persistence_representations/utilities/persistence_intervals/compute_birth_death_range_in_persistence_diagram.cpp b/src/Persistence_representations/utilities/persistence_intervals/compute_birth_death_range_in_persistence_diagram.cpp
index 519cc47d..72325cad 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/compute_birth_death_range_in_persistence_diagram.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/compute_birth_death_range_in_persistence_diagram.cpp
@@ -18,7 +18,7 @@
 using Persistence_intervals = Gudhi::Persistence_representations::Persistence_intervals;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes the range of birth and death times of persistence pairs in diagrams provided as "
+  std::clog << "This program computes the range of birth and death times of persistence pairs in diagrams provided as "
             << "an input.\n"
             << "The first parameter is the dimension of persistence to be used to create persistence intervals. "
             << "If your file contains the information about dimension of persistence pairs, please provide here the "
@@ -27,7 +27,7 @@ int main(int argc, char** argv) {
             << "The remaining parameters of the program are the names of files with persistence diagrams.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
 
@@ -45,12 +45,12 @@ int main(int argc, char** argv) {
   double max_ = -std::numeric_limits<double>::max();
 
   for (size_t file_no = 0; file_no != filenames.size(); ++file_no) {
-    std::cout << "Creating diagram based on a file : " << filenames[file_no] << std::endl;
+    std::clog << "Creating diagram based on a file : " << filenames[file_no] << std::endl;
     Persistence_intervals p(filenames[file_no], dimension);
     std::pair<double, double> min_max_ = p.get_x_range();
     if (min_max_.first < min_) min_ = min_max_.first;
     if (min_max_.second > max_) max_ = min_max_.second;
   }
-  std::cout << "Birth-death range : min: " << min_ << ", max: " << max_ << std::endl;
+  std::clog << "Birth-death range : min: " << min_ << ", max: " << max_ << std::endl;
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_intervals/compute_bottleneck_distance.cpp b/src/Persistence_representations/utilities/persistence_intervals/compute_bottleneck_distance.cpp
index 6155727a..465bf72e 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/compute_bottleneck_distance.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/compute_bottleneck_distance.cpp
@@ -18,7 +18,7 @@
 using Persistence_intervals_with_distances = Gudhi::Persistence_representations::Persistence_intervals_with_distances;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes the bottleneck distance of persistence pairs in diagrams provided as "
+  std::clog << "This program computes the bottleneck distance of persistence pairs in diagrams provided as "
             << "an input.\n"
             << "The first parameter is the dimension of persistence to be used to create persistence intervals. "
             << "If your file contains the information about dimension of persistence pairs, please provide here the "
@@ -27,7 +27,7 @@ int main(int argc, char** argv) {
             << "The remaining parameters of the program are the names of files with persistence diagrams.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -70,14 +70,14 @@ int main(int argc, char** argv) {
   out.open("distance.itv");
   for (size_t i = 0; i != distance.size(); ++i) {
     for (size_t j = 0; j != distance.size(); ++j) {
-      std::cout << distance[i][j] << " ";
+      std::clog << distance[i][j] << " ";
       out << distance[i][j] << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     out << std::endl;
   }
   out.close();
 
-  std::cout << "Distance can be found in 'distance.itv' file\n";
+  std::clog << "Distance can be found in 'distance.itv' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_intervals/compute_number_of_dominant_intervals.cpp b/src/Persistence_representations/utilities/persistence_intervals/compute_number_of_dominant_intervals.cpp
index dd6e1a5b..ea1fe717 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/compute_number_of_dominant_intervals.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/compute_number_of_dominant_intervals.cpp
@@ -18,10 +18,10 @@
 using Persistence_intervals = Gudhi::Persistence_representations::Persistence_intervals;
 
 int main(int argc, char** argv) {
-  std::cout << "This program compute the dominant intervals. A number of intervals to be displayed is a parameter of "
+  std::clog << "This program compute the dominant intervals. A number of intervals to be displayed is a parameter of "
                "this program. \n";
   if (argc != 4) {
-    std::cout << "To run this program, please provide the name of a file with persistence diagram, dimension of "
+    std::clog << "To run this program, please provide the name of a file with persistence diagram, dimension of "
                  "intervals that should be taken into account (if your file contains only persistence pairs in a "
                  "single dimension, set it up to -1) and number of dominant intervals you would like to get \n";
     return 1;
@@ -33,9 +33,9 @@ int main(int argc, char** argv) {
   }
   Persistence_intervals p(argv[1], dimension);
   std::vector<std::pair<double, double> > dominant_intervals = p.dominant_intervals(atoi(argv[3]));
-  std::cout << "Here are the dominant intervals : " << std::endl;
+  std::clog << "Here are the dominant intervals : " << std::endl;
   for (size_t i = 0; i != dominant_intervals.size(); ++i) {
-    std::cout << " " << dominant_intervals[i].first << "," << dominant_intervals[i].second << " " << std::endl;
+    std::clog << " " << dominant_intervals[i].first << "," << dominant_intervals[i].second << " " << std::endl;
   }
 
   return 0;
diff --git a/src/Persistence_representations/utilities/persistence_intervals/plot_histogram_of_intervals_lengths.cpp b/src/Persistence_representations/utilities/persistence_intervals/plot_histogram_of_intervals_lengths.cpp
index 13d2133f..e5eec3f5 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/plot_histogram_of_intervals_lengths.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/plot_histogram_of_intervals_lengths.cpp
@@ -18,10 +18,10 @@
 using Persistence_intervals = Gudhi::Persistence_representations::Persistence_intervals;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes a histogram of barcode's length. A number of bins in the histogram is a "
+  std::clog << "This program computes a histogram of barcode's length. A number of bins in the histogram is a "
             << "parameter of this program. \n";
   if ((argc != 3) && (argc != 4)) {
-    std::cout << "To run this program, please provide the name of a file with persistence diagram and number of "
+    std::clog << "To run this program, please provide the name of a file with persistence diagram and number of "
               << "dominant intervals you would like to get. Set a negative number dominant intervals value "
               << "If your file contains only birth-death pairs.\n"
               << "The third parameter is the dimension of the persistence that is to be used. If your "
@@ -59,7 +59,7 @@ int main(int argc, char** argv) {
   out << std::endl;
   out.close();
 
-  std::cout << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
+  std::clog << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
             << gnuplot_script.str().c_str() << "\'\"" << std::endl;
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_Betti_numbers.cpp b/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_Betti_numbers.cpp
index 451be77f..27c69e07 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_Betti_numbers.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_Betti_numbers.cpp
@@ -19,7 +19,7 @@ using Persistence_intervals = Gudhi::Persistence_representations::Persistence_in
 
 int main(int argc, char** argv) {
   if ((argc != 3) && (argc != 2)) {
-    std::cout << "This program creates a gnuplot script of Betti numbers from a single persistence diagram file"
+    std::clog << "This program creates a gnuplot script of Betti numbers from a single persistence diagram file"
               << "(*.pers).\n"
               << "To run this program, please provide the name of a file with persistence diagram.\n"
               << "The second optional parameter of a program is the dimension of the persistence that is to be used. "
@@ -68,7 +68,7 @@ int main(int argc, char** argv) {
   out << std::endl;
   out.close();
 
-  std::cout << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
+  std::clog << "To visualize, install gnuplot and type the command: gnuplot -persist -e \"load \'"
             << gnuplot_script.str().c_str() << "\'\"" << std::endl;
 
   return 0;
diff --git a/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_intervals.cpp b/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_intervals.cpp
index 09a56869..199a3266 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_intervals.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_intervals.cpp
@@ -19,7 +19,7 @@ using Persistence_intervals = Gudhi::Persistence_representations::Persistence_in
 
 int main(int argc, char** argv) {
   if ((argc != 3) && (argc != 2)) {
-    std::cout << "This program creates a gnuplot script from a single persistence diagram file (*.pers).\n"
+    std::clog << "This program creates a gnuplot script from a single persistence diagram file (*.pers).\n"
               << "To run this program, please provide the name of a file with persistence diagram.\n"
               << "The second optional parameter of a program is the dimension of the persistence that is to be used. "
               << "If your file contains only birth-death pairs, you can skip this parameter.\n";
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/CMakeLists.txt b/src/Persistence_representations/utilities/persistence_landscapes/CMakeLists.txt
index 6b24d032..4df84d36 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/CMakeLists.txt
+++ b/src/Persistence_representations/utilities/persistence_landscapes/CMakeLists.txt
@@ -2,8 +2,8 @@ project(Persistence_representations_landscapes_utilities)
 
 add_persistence_representation_creation_utility(create_landscapes "-1")
 
-add_persistence_representation_plot_utility(plot_landscapes ".land")
+add_persistence_representation_plot_utility(create_landscapes plot_landscapes ".land")
 
-add_persistence_representation_function_utility(average_landscapes ".land")
-add_persistence_representation_function_utility(compute_distance_of_landscapes ".land" "1")
-add_persistence_representation_function_utility(compute_scalar_product_of_landscapes ".land")
+add_persistence_representation_function_utility(create_landscapes average_landscapes ".land")
+add_persistence_representation_function_utility(create_landscapes compute_distance_of_landscapes ".land" "1")
+add_persistence_representation_function_utility(create_landscapes compute_scalar_product_of_landscapes ".land")
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/average_landscapes.cpp b/src/Persistence_representations/utilities/persistence_landscapes/average_landscapes.cpp
index 04a0ada4..612e9700 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/average_landscapes.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes/average_landscapes.cpp
@@ -16,13 +16,13 @@
 using Persistence_landscape = Gudhi::Persistence_representations::Persistence_landscape;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes average of persistence landscapes stored in files (the files needs to be "
+  std::clog << "This program computes average of persistence landscapes stored in files (the files needs to be "
             << "created beforehand).\n"
             << "The parameters of this programs are names of files with persistence landscapes.\n";
   std::vector<const char*> filenames;
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -46,6 +46,6 @@ int main(int argc, char** argv) {
     delete lands[i];
   }
 
-  std::cout << "Average can be found in 'average.land' file\n";
+  std::clog << "Average can be found in 'average.land' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/compute_distance_of_landscapes.cpp b/src/Persistence_representations/utilities/persistence_landscapes/compute_distance_of_landscapes.cpp
index 1093c1aa..2246a37d 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/compute_distance_of_landscapes.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes/compute_distance_of_landscapes.cpp
@@ -18,14 +18,14 @@
 using Persistence_landscape = Gudhi::Persistence_representations::Persistence_landscape;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes distance of persistence landscapes stored in files (the files needs to be "
+  std::clog << "This program computes distance of persistence landscapes stored in files (the files needs to be "
             << "created beforehand).\n"
             << "The first parameter of a program is an integer p. The program compute L^p distance of the two heat "
             << "maps. For L^infty distance choose p = -1. \n"
             << "The remaining parameters of this program are names of files with persistence landscapes.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -68,14 +68,14 @@ int main(int argc, char** argv) {
   out.open("distance.land");
   for (size_t i = 0; i != distance.size(); ++i) {
     for (size_t j = 0; j != distance.size(); ++j) {
-      std::cout << distance[i][j] << " ";
+      std::clog << distance[i][j] << " ";
       out << distance[i][j] << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     out << std::endl;
   }
   out.close();
 
-  std::cout << "Distance can be found in 'distance.land' file\n";
+  std::clog << "Distance can be found in 'distance.land' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/compute_scalar_product_of_landscapes.cpp b/src/Persistence_representations/utilities/persistence_landscapes/compute_scalar_product_of_landscapes.cpp
index 16b76497..44f50543 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/compute_scalar_product_of_landscapes.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes/compute_scalar_product_of_landscapes.cpp
@@ -17,12 +17,12 @@
 using Persistence_landscape = Gudhi::Persistence_representations::Persistence_landscape;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes scalar product of persistence landscapes stored in a file (the file needs to be "
+  std::clog << "This program computes scalar product of persistence landscapes stored in a file (the file needs to be "
             << "created beforehand). \n"
             << "The parameters of this programs are names of files with persistence landscapes.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -59,14 +59,14 @@ int main(int argc, char** argv) {
   out.open("scalar_product.land");
   for (size_t i = 0; i != scalar_product.size(); ++i) {
     for (size_t j = 0; j != scalar_product.size(); ++j) {
-      std::cout << scalar_product[i][j] << " ";
+      std::clog << scalar_product[i][j] << " ";
       out << scalar_product[i][j] << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     out << std::endl;
   }
   out.close();
 
-  std::cout << "Distance can be found in 'scalar_product.land' file\n";
+  std::clog << "Distance can be found in 'scalar_product.land' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/create_landscapes.cpp b/src/Persistence_representations/utilities/persistence_landscapes/create_landscapes.cpp
index 4d772086..fab5c75f 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/create_landscapes.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes/create_landscapes.cpp
@@ -18,7 +18,7 @@
 using Persistence_landscape = Gudhi::Persistence_representations::Persistence_landscape;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates persistence landscapes files (*.land) of persistence diagrams files (*.pers) "
+  std::clog << "This program creates persistence landscapes files (*.land) of persistence diagrams files (*.pers) "
             << "provided as an input.\n"
             << "The first parameter of this program is a dimension of persistence that will be used in creation of "
             << "the persistence heat maps."
@@ -29,7 +29,7 @@ int main(int argc, char** argv) {
             << "The remaining parameters are the names of files with persistence diagrams. \n";
 
   if (argc < 3) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
   std::vector<const char*> filenames;
@@ -43,7 +43,7 @@ int main(int argc, char** argv) {
   }
 
   for (size_t i = 0; i != filenames.size(); ++i) {
-    std::cout << "Creating a landscape based on file : " << filenames[i] << std::endl;
+    std::clog << "Creating a landscape based on file : " << filenames[i] << std::endl;
     Persistence_landscape l(filenames[i], dimension);
     std::stringstream ss;
     ss << filenames[i] << ".land";
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/plot_landscapes.cpp b/src/Persistence_representations/utilities/persistence_landscapes/plot_landscapes.cpp
index 1fe03640..da9b9bba 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/plot_landscapes.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes/plot_landscapes.cpp
@@ -16,10 +16,10 @@
 using Persistence_landscape = Gudhi::Persistence_representations::Persistence_landscape;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates a gnuplot script from a persistence landscape stored in a file (the file needs "
+  std::clog << "This program creates a gnuplot script from a persistence landscape stored in a file (the file needs "
             << "to be created beforehand). Please call the code with the name of a single landscape file.\n";
   if (argc != 2) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
 
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/CMakeLists.txt b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/CMakeLists.txt
index 36f3196b..8cd965f1 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/CMakeLists.txt
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/CMakeLists.txt
@@ -3,8 +3,8 @@ project(Persistence_representations_lanscapes_on_grid_utilities)
 # Need to set grid min and max for further average, distance and scalar_product
 add_persistence_representation_creation_utility(create_landscapes_on_grid "100" "0" "35" "-1")
 
-add_persistence_representation_plot_utility(plot_landscapes_on_grid ".g_land")
+add_persistence_representation_plot_utility(create_landscapes_on_grid plot_landscapes_on_grid ".g_land")
 
-add_persistence_representation_function_utility(average_landscapes_on_grid ".g_land")
-add_persistence_representation_function_utility(compute_distance_of_landscapes_on_grid ".g_land" "1")
-add_persistence_representation_function_utility(compute_scalar_product_of_landscapes_on_grid ".g_land")
+add_persistence_representation_function_utility(create_landscapes_on_grid average_landscapes_on_grid ".g_land")
+add_persistence_representation_function_utility(create_landscapes_on_grid compute_distance_of_landscapes_on_grid ".g_land" "1")
+add_persistence_representation_function_utility(create_landscapes_on_grid compute_scalar_product_of_landscapes_on_grid ".g_land")
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/average_landscapes_on_grid.cpp b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/average_landscapes_on_grid.cpp
index f92cde72..39f7a67f 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/average_landscapes_on_grid.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/average_landscapes_on_grid.cpp
@@ -16,12 +16,12 @@
 using Persistence_landscape_on_grid = Gudhi::Persistence_representations::Persistence_landscape_on_grid;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes average of persistence landscapes on grid stored in files (the files needs to "
+  std::clog << "This program computes average of persistence landscapes on grid stored in files (the files needs to "
             << "be created beforehand).\n"
             << "The parameters of this programs are names of files with persistence landscapes on grid.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -46,6 +46,6 @@ int main(int argc, char** argv) {
     delete lands[i];
   }
 
-  std::cout << "Average can be found in 'average.g_land' file\n";
+  std::clog << "Average can be found in 'average.g_land' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_distance_of_landscapes_on_grid.cpp b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_distance_of_landscapes_on_grid.cpp
index baec6aeb..01fd09d8 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_distance_of_landscapes_on_grid.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_distance_of_landscapes_on_grid.cpp
@@ -18,14 +18,14 @@
 using Persistence_landscape_on_grid = Gudhi::Persistence_representations::Persistence_landscape_on_grid;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes distance of persistence landscapes on grid stored in files (the files needs to "
+  std::clog << "This program computes distance of persistence landscapes on grid stored in files (the files needs to "
             << "be created beforehand).\n"
             << "The first parameter of a program is an integer p. The program compute L^p distance of the two heat "
             << "maps. For L^infty distance choose p = -1. \n"
             << "The remaining parameters of this program are names of files with persistence landscapes on grid.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -68,14 +68,14 @@ int main(int argc, char** argv) {
   out.open("distance.g_land");
   for (size_t i = 0; i != distance.size(); ++i) {
     for (size_t j = 0; j != distance.size(); ++j) {
-      std::cout << distance[i][j] << " ";
+      std::clog << distance[i][j] << " ";
       out << distance[i][j] << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     out << std::endl;
   }
   out.close();
 
-  std::cout << "Distance can be found in 'distance.g_land' file\n";
+  std::clog << "Distance can be found in 'distance.g_land' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_scalar_product_of_landscapes_on_grid.cpp b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_scalar_product_of_landscapes_on_grid.cpp
index e94dacdb..71c2f419 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_scalar_product_of_landscapes_on_grid.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_scalar_product_of_landscapes_on_grid.cpp
@@ -17,13 +17,13 @@
 using Persistence_landscape_on_grid = Gudhi::Persistence_representations::Persistence_landscape_on_grid;
 
 int main(int argc, char** argv) {
-  std::cout
+  std::clog
       << "This program computes scalar product of persistence landscapes on grid stored in a file (the file needs to "
       << "be created beforehand). \n"
       << "The parameters of this programs are names of files with persistence landscapes on grid.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -60,14 +60,14 @@ int main(int argc, char** argv) {
   out.open("scalar_product.g_land");
   for (size_t i = 0; i != scalar_product.size(); ++i) {
     for (size_t j = 0; j != scalar_product.size(); ++j) {
-      std::cout << scalar_product[i][j] << " ";
+      std::clog << scalar_product[i][j] << " ";
       out << scalar_product[i][j] << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     out << std::endl;
   }
   out.close();
 
-  std::cout << "Distance can be found in 'scalar_product.g_land' file\n";
+  std::clog << "Distance can be found in 'scalar_product.g_land' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/create_landscapes_on_grid.cpp b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/create_landscapes_on_grid.cpp
index d510c3df..788313c4 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/create_landscapes_on_grid.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/create_landscapes_on_grid.cpp
@@ -18,7 +18,7 @@
 using Persistence_landscape_on_grid = Gudhi::Persistence_representations::Persistence_landscape_on_grid;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates persistence landscapes on grid files (*.g_land) of persistence diagrams files "
+  std::clog << "This program creates persistence landscapes on grid files (*.g_land) of persistence diagrams files "
             << "(*.pers) provided as an input.\n"
             << "The first parameter of a program is an integer, a size of a grid.\n"
             << "The second and third parameters are min and max of the grid. If you want those numbers to be computed "
@@ -32,7 +32,7 @@ int main(int argc, char** argv) {
             << "The remaining parameters are the names of files with persistence diagrams. \n";
 
   if (argc < 6) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
 
@@ -51,7 +51,7 @@ int main(int argc, char** argv) {
   }
 
   for (size_t i = 0; i != filenames.size(); ++i) {
-    std::cout << "Creating persistence landscape on a grid based on a file : " << filenames[i] << std::endl;
+    std::clog << "Creating persistence landscape on a grid based on a file : " << filenames[i] << std::endl;
     Persistence_landscape_on_grid l;
     if ((min_ != -1) || (max_ != -1)) {
       l = Persistence_landscape_on_grid(filenames[i], min_, max_, size_of_grid, dimension);
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/plot_landscapes_on_grid.cpp b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/plot_landscapes_on_grid.cpp
index 4e20f37f..ec6112b5 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/plot_landscapes_on_grid.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/plot_landscapes_on_grid.cpp
@@ -16,11 +16,11 @@
 using Persistence_landscape_on_grid = Gudhi::Persistence_representations::Persistence_landscape_on_grid;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates a gnuplot script from a persistence landscape on grid stored in a file (the file "
+  std::clog << "This program creates a gnuplot script from a persistence landscape on grid stored in a file (the file "
             << "needs to be created beforehand). Please call the code with the name of a single landscape on grid file"
             << ".\n";
   if (argc != 2) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
 
diff --git a/src/Persistence_representations/utilities/persistence_vectors/CMakeLists.txt b/src/Persistence_representations/utilities/persistence_vectors/CMakeLists.txt
index bc982094..5b22ca84 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/CMakeLists.txt
+++ b/src/Persistence_representations/utilities/persistence_vectors/CMakeLists.txt
@@ -2,8 +2,8 @@ project(Persistence_vectors_utilities)
 
 add_persistence_representation_creation_utility(create_persistence_vectors "-1")
 
-add_persistence_representation_plot_utility(plot_persistence_vectors ".vect")
+add_persistence_representation_plot_utility(create_persistence_vectors plot_persistence_vectors ".vect")
 
-add_persistence_representation_function_utility(average_persistence_vectors ".vect")
-add_persistence_representation_function_utility(compute_distance_of_persistence_vectors ".vect" "1")
-add_persistence_representation_function_utility(compute_scalar_product_of_persistence_vectors ".vect")
+add_persistence_representation_function_utility(create_persistence_vectors average_persistence_vectors ".vect")
+add_persistence_representation_function_utility(create_persistence_vectors compute_distance_of_persistence_vectors ".vect" "1")
+add_persistence_representation_function_utility(create_persistence_vectors compute_scalar_product_of_persistence_vectors ".vect")
diff --git a/src/Persistence_representations/utilities/persistence_vectors/average_persistence_vectors.cpp b/src/Persistence_representations/utilities/persistence_vectors/average_persistence_vectors.cpp
index 89e42f0f..4eb32eb3 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/average_persistence_vectors.cpp
+++ b/src/Persistence_representations/utilities/persistence_vectors/average_persistence_vectors.cpp
@@ -17,12 +17,12 @@ using Euclidean_distance = Gudhi::Euclidean_distance;
 using Vector_distances_in_diagram = Gudhi::Persistence_representations::Vector_distances_in_diagram<Euclidean_distance>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes average of persistence vectors stored in files (the files needs to "
+  std::clog << "This program computes average of persistence vectors stored in files (the files needs to "
             << "be created beforehand).\n"
             << "The parameters of this programs are names of files with persistence vectors.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -47,7 +47,7 @@ int main(int argc, char** argv) {
     delete lands[i];
   }
 
-  std::cout << "Done \n";
+  std::clog << "Done \n";
 
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_vectors/compute_distance_of_persistence_vectors.cpp b/src/Persistence_representations/utilities/persistence_vectors/compute_distance_of_persistence_vectors.cpp
index 541dd25f..236981a3 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/compute_distance_of_persistence_vectors.cpp
+++ b/src/Persistence_representations/utilities/persistence_vectors/compute_distance_of_persistence_vectors.cpp
@@ -19,14 +19,14 @@ using Euclidean_distance = Gudhi::Euclidean_distance;
 using Vector_distances_in_diagram = Gudhi::Persistence_representations::Vector_distances_in_diagram<Euclidean_distance>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program compute distance of persistence vectors stored in a file (the file needs to be created "
+  std::clog << "This program compute distance of persistence vectors stored in a file (the file needs to be created "
                "beforehand). \n";
-  std::cout << "The first parameter of a program is an integer p. The program compute l^p distance of the vectors. For "
+  std::clog << "The first parameter of a program is an integer p. The program compute l^p distance of the vectors. For "
                "l^infty distance choose p = -1. \n";
-  std::cout << "The remaining parameters of this programs are names of files with persistence vectors.\n";
+  std::clog << "The remaining parameters of this programs are names of files with persistence vectors.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -69,14 +69,14 @@ int main(int argc, char** argv) {
   out.open("distance.vect");
   for (size_t i = 0; i != distance.size(); ++i) {
     for (size_t j = 0; j != distance.size(); ++j) {
-      std::cout << distance[i][j] << " ";
+      std::clog << distance[i][j] << " ";
       out << distance[i][j] << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     out << std::endl;
   }
   out.close();
 
-  std::cout << "Distance can be found in 'distance.vect' file\n";
+  std::clog << "Distance can be found in 'distance.vect' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_vectors/compute_scalar_product_of_persistence_vectors.cpp b/src/Persistence_representations/utilities/persistence_vectors/compute_scalar_product_of_persistence_vectors.cpp
index bbc50c98..c6ea0e1c 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/compute_scalar_product_of_persistence_vectors.cpp
+++ b/src/Persistence_representations/utilities/persistence_vectors/compute_scalar_product_of_persistence_vectors.cpp
@@ -19,12 +19,12 @@ using Euclidean_distance = Gudhi::Euclidean_distance;
 using Vector_distances_in_diagram = Gudhi::Persistence_representations::Vector_distances_in_diagram<Euclidean_distance>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program computes scalar product of persistence vectors stored in a file (the file needs to "
+  std::clog << "This program computes scalar product of persistence vectors stored in a file (the file needs to "
             << "be created beforehand). \n"
             << "The parameters of this programs are names of files with persistence vectors.\n";
 
   if (argc < 3) {
-    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    std::clog << "Wrong number of parameters, the program will now terminate \n";
     return 1;
   }
 
@@ -61,14 +61,14 @@ int main(int argc, char** argv) {
   out.open("scalar_product.vect");
   for (size_t i = 0; i != scalar_product.size(); ++i) {
     for (size_t j = 0; j != scalar_product.size(); ++j) {
-      std::cout << scalar_product[i][j] << " ";
+      std::clog << scalar_product[i][j] << " ";
       out << scalar_product[i][j] << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     out << std::endl;
   }
   out.close();
 
-  std::cout << "Distance can be found in 'scalar_product.vect' file\n";
+  std::clog << "Distance can be found in 'scalar_product.vect' file\n";
   return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_vectors/create_persistence_vectors.cpp b/src/Persistence_representations/utilities/persistence_vectors/create_persistence_vectors.cpp
index f974c3d3..608e04e5 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/create_persistence_vectors.cpp
+++ b/src/Persistence_representations/utilities/persistence_vectors/create_persistence_vectors.cpp
@@ -19,7 +19,7 @@ using Euclidean_distance = Gudhi::Euclidean_distance;
 using Vector_distances_in_diagram = Gudhi::Persistence_representations::Vector_distances_in_diagram<Euclidean_distance>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program creates persistence vectors files (*.vect) of persistence diagrams files (*.pers) "
+  std::clog << "This program creates persistence vectors files (*.vect) of persistence diagrams files (*.pers) "
             << "provided as an input.\n"
             << "The first parameter of this program is a dimension of persistence that will be used in creation of "
             << "the persistence heat maps."
@@ -30,11 +30,11 @@ int main(int argc, char** argv) {
             << "The remaining parameters are the names of files with persistence diagrams. \n";
 
   if (argc < 3) {
-    std::cout << "Wrong parameter list, the program will now terminate \n";
+    std::clog << "Wrong parameter list, the program will now terminate \n";
     return 1;
   }
 
-  std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+  std::clog << "The remaining parameters are the names of files with persistence diagrams. \n";
   int dim = atoi(argv[1]);
   unsigned dimension = std::numeric_limits<unsigned>::max();
   if (dim >= 0) {
diff --git a/src/Persistence_representations/utilities/persistence_vectors/plot_persistence_vectors.cpp b/src/Persistence_representations/utilities/persistence_vectors/plot_persistence_vectors.cpp
index de08fcfe..2decb134 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/plot_persistence_vectors.cpp
+++ b/src/Persistence_representations/utilities/persistence_vectors/plot_persistence_vectors.cpp
@@ -17,10 +17,10 @@ using Euclidean_distance = Gudhi::Euclidean_distance;
 using Vector_distances_in_diagram = Gudhi::Persistence_representations::Vector_distances_in_diagram<Euclidean_distance>;
 
 int main(int argc, char** argv) {
-  std::cout << "This program create a Gnuplot script to plot persistence vector. Please call this program with the "
+  std::clog << "This program create a Gnuplot script to plot persistence vector. Please call this program with the "
                "name of file with persistence vector. \n";
   if (argc != 2) {
-    std::cout << "Wrong number of parameters, the program will now terminate. \n";
+    std::clog << "Wrong number of parameters, the program will now terminate. \n";
     return 1;
   }
   Vector_distances_in_diagram l;
diff --git a/src/Persistent_cohomology/benchmark/performance_rips_persistence.cpp b/src/Persistent_cohomology/benchmark/performance_rips_persistence.cpp
index 45757002..030b072a 100644
--- a/src/Persistent_cohomology/benchmark/performance_rips_persistence.cpp
+++ b/src/Persistent_cohomology/benchmark/performance_rips_persistence.cpp
@@ -74,7 +74,7 @@ int main(int argc, char * argv[]) {
   Rips_complex rips_complex_from_file(off_reader.get_point_cloud(), threshold, Gudhi::Euclidean_distance());
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "Compute Rips graph in " << elapsed_sec << " ms.\n";
+  std::clog << "Compute Rips graph in " << elapsed_sec << " ms.\n";
 
   // Construct the Rips complex in a Simplex Tree
   Simplex_tree st;
@@ -86,16 +86,16 @@ int main(int argc, char * argv[]) {
 
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "Compute Rips complex in " << elapsed_sec << " ms.\n";
-  std::cout << "  - dimension           = " << st.dimension() << std::endl;
-  std::cout << "  - number of simplices = " << st.num_simplices() << std::endl;
+  std::clog << "Compute Rips complex in " << elapsed_sec << " ms.\n";
+  std::clog << "  - dimension           = " << st.dimension() << std::endl;
+  std::clog << "  - number of simplices = " << st.num_simplices() << std::endl;
 
   // Sort the simplices in the order of the filtration
   start = std::chrono::system_clock::now();
   st.initialize_filtration();
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "Order the simplices of the filtration in " << elapsed_sec << " ms.\n";
+  std::clog << "Order the simplices of the filtration in " << elapsed_sec << " ms.\n";
 
   // Copy the keys inside the simplices
   start = std::chrono::system_clock::now();
@@ -106,22 +106,22 @@ int main(int argc, char * argv[]) {
   }
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "Copied the keys inside the simplices in " << elapsed_sec << " ms.\n";
+  std::clog << "Copied the keys inside the simplices in " << elapsed_sec << " ms.\n";
 
   // Convert the simplex tree into a hasse diagram
   start = std::chrono::system_clock::now();
   Gudhi::Hasse_complex<> hcpx(st);
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "Convert the simplex tree into a Hasse diagram in " << elapsed_sec << " ms.\n";
+  std::clog << "Convert the simplex tree into a Hasse diagram in " << elapsed_sec << " ms.\n";
 
 
-  std::cout << "Timings when using a simplex tree: \n";
+  std::clog << "Timings when using a simplex tree: \n";
   timing_persistence(st, p);
   timing_persistence(st, q);
   timing_persistence(st, p, q);
 
-  std::cout << "Timings when using a Hasse complex: \n";
+  std::clog << "Timings when using a Hasse complex: \n";
   timing_persistence(hcpx, p);
   timing_persistence(hcpx, q);
   timing_persistence(hcpx, p, q);
@@ -130,7 +130,7 @@ int main(int argc, char * argv[]) {
   }
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "Running the complex destructors in " << elapsed_sec << " ms.\n";
+  std::clog << "Running the complex destructors in " << elapsed_sec << " ms.\n";
   return 0;
 }
 
@@ -145,13 +145,13 @@ timing_persistence(FilteredComplex & cpx
   Gudhi::persistent_cohomology::Persistent_cohomology< FilteredComplex, Field_Zp > pcoh(cpx);
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "  Initialize pcoh in " << elapsed_sec << " ms.\n";
+  std::clog << "  Initialize pcoh in " << elapsed_sec << " ms.\n";
   // initializes the coefficient field for homology
   start = std::chrono::system_clock::now();
   pcoh.init_coefficients(p);
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "  Initialize the coefficient field in " << elapsed_sec << " ms.\n";
+  std::clog << "  Initialize the coefficient field in " << elapsed_sec << " ms.\n";
 
   start = std::chrono::system_clock::now();
 
@@ -159,12 +159,12 @@ timing_persistence(FilteredComplex & cpx
 
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "  Compute persistent homology in Z/" << p << "Z in " << elapsed_sec << " ms.\n";
+  std::clog << "  Compute persistent homology in Z/" << p << "Z in " << elapsed_sec << " ms.\n";
   start = std::chrono::system_clock::now();
   }
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "  Run the persistence destructors in " << elapsed_sec << " ms.\n";
+  std::clog << "  Run the persistence destructors in " << elapsed_sec << " ms.\n";
 }
 
 template< typename FilteredComplex>
@@ -179,13 +179,13 @@ timing_persistence(FilteredComplex & cpx
   Gudhi::persistent_cohomology::Persistent_cohomology< FilteredComplex, Multi_field > pcoh(cpx);
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "  Initialize pcoh in " << elapsed_sec << " ms.\n";
+  std::clog << "  Initialize pcoh in " << elapsed_sec << " ms.\n";
   // initializes the coefficient field for homology
   start = std::chrono::system_clock::now();
   pcoh.init_coefficients(p, q);
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "  Initialize the coefficient field in " << elapsed_sec << " ms.\n";
+  std::clog << "  Initialize the coefficient field in " << elapsed_sec << " ms.\n";
   // compute persistent homology, disgarding persistent features of life shorter than min_persistence
 
   start = std::chrono::system_clock::now();
@@ -194,11 +194,11 @@ timing_persistence(FilteredComplex & cpx
 
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "  Compute multi-field persistent homology in all coefficient fields Z/pZ "
+  std::clog << "  Compute multi-field persistent homology in all coefficient fields Z/pZ "
       << "with p in [" << p << ";" << q << "] in " << elapsed_sec << " ms.\n";
   start = std::chrono::system_clock::now();
   }
   end = std::chrono::system_clock::now();
   elapsed_sec = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  std::cout << "  Run the persistence destructors in " << elapsed_sec << " ms.\n";
+  std::clog << "  Run the persistence destructors in " << elapsed_sec << " ms.\n";
 }
diff --git a/src/Persistent_cohomology/example/custom_persistence_sort.cpp b/src/Persistent_cohomology/example/custom_persistence_sort.cpp
index be74cf50..87e9c207 100644
--- a/src/Persistent_cohomology/example/custom_persistence_sort.cpp
+++ b/src/Persistent_cohomology/example/custom_persistence_sort.cpp
@@ -70,26 +70,26 @@ struct cmp_intervals_by_dim_then_length {
 int main(int argc, char **argv) {
   std::vector<Point> points = random_points();
 
-  std::cout << "Points size=" << points.size() << std::endl;
+  std::clog << "Points size=" << points.size() << std::endl;
   // Alpha complex persistence computation from generated points
   Alpha_complex alpha_complex_from_points(points);
-  std::cout << "alpha_complex_from_points" << std::endl;
+  std::clog << "alpha_complex_from_points" << std::endl;
 
   Simplex_tree simplex;
-  std::cout << "simplex" << std::endl;
+  std::clog << "simplex" << std::endl;
   if (alpha_complex_from_points.create_complex(simplex, 0.6)) {
-    std::cout << "simplex" << std::endl;
+    std::clog << "simplex" << std::endl;
     // ----------------------------------------------------------------------------
     // Display information about the alpha complex
     // ----------------------------------------------------------------------------
-    std::cout << "Simplicial complex is of dimension " << simplex.dimension() <<
+    std::clog << "Simplicial complex is of dimension " << simplex.dimension() <<
         " - " << simplex.num_simplices() << " simplices - " <<
         simplex.num_vertices() << " vertices." << std::endl;
 
     // Sort the simplices in the order of the filtration
     simplex.initialize_filtration();
 
-    std::cout << "Simplex_tree dim: " << simplex.dimension() << std::endl;
+    std::clog << "Simplex_tree dim: " << simplex.dimension() << std::endl;
 
     Persistent_cohomology pcoh(simplex);
 
@@ -102,23 +102,23 @@ int main(int argc, char **argv) {
     auto persistent_pairs = pcoh.get_persistent_pairs();
     std::sort(std::begin(persistent_pairs), std::end(persistent_pairs), cmp);
     for (auto pair : persistent_pairs) {
-      std::cout << simplex.dimension(get<0>(pair)) << " "
+      std::clog << simplex.dimension(get<0>(pair)) << " "
             << simplex.filtration(get<0>(pair)) << " "
             << simplex.filtration(get<1>(pair)) << std::endl;
     }
 
     // Persistent Betti numbers
-    std::cout << "The persistent Betti numbers in interval [0.40, 0.41] are : ";
+    std::clog << "The persistent Betti numbers in interval [0.40, 0.41] are : ";
     for (int dim = 0; dim < simplex.dimension(); dim++)
-      std::cout << "b" << dim << " = " << pcoh.persistent_betti_number(dim, 0.40, 0.41) << " ; ";
-    std::cout << std::endl;
+      std::clog << "b" << dim << " = " << pcoh.persistent_betti_number(dim, 0.40, 0.41) << " ; ";
+    std::clog << std::endl;
 
     // Betti numbers
     std::vector<int> betti_numbers = pcoh.betti_numbers();
-    std::cout << "The Betti numbers are : ";
+    std::clog << "The Betti numbers are : ";
     for (std::size_t i = 0; i < betti_numbers.size(); i++)
-      std::cout << "b" << i << " = " << betti_numbers[i] << " ; ";
-    std::cout << std::endl;
+      std::clog << "b" << i << " = " << betti_numbers[i] << " ; ";
+    std::clog << std::endl;
   }
   return 0;
 }
diff --git a/src/Persistent_cohomology/example/persistence_from_file.cpp b/src/Persistent_cohomology/example/persistence_from_file.cpp
index d169cc63..79108730 100644
--- a/src/Persistent_cohomology/example/persistence_from_file.cpp
+++ b/src/Persistent_cohomology/example/persistence_from_file.cpp
@@ -37,9 +37,9 @@ int main(int argc, char * argv[]) {
 
   program_options(argc, argv, simplex_tree_file, output_file, p, min_persistence);
 
-  std::cout << "Simplex_tree from file=" << simplex_tree_file.c_str() << " - output_file=" << output_file.c_str()
+  std::clog << "Simplex_tree from file=" << simplex_tree_file.c_str() << " - output_file=" << output_file.c_str()
       << std::endl;
-  std::cout << "     - p=" << p << " - min_persistence=" << min_persistence << std::endl;
+  std::clog << "     - p=" << p << " - min_persistence=" << min_persistence << std::endl;
 
   // Read the list of simplices from a file.
   Simplex_tree<> simplex_tree;
@@ -47,16 +47,16 @@ int main(int argc, char * argv[]) {
   std::ifstream simplex_tree_stream(simplex_tree_file);
   simplex_tree_stream >> simplex_tree;
 
-  std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices" << std::endl;
-  std::cout << "   - dimension " << simplex_tree.dimension() << std::endl;
+  std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices" << std::endl;
+  std::clog << "   - dimension " << simplex_tree.dimension() << std::endl;
 
   /*
-  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+  std::clog << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
   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::cout << std::endl;
+  { std::clog << vertex << " "; }
+  std::clog << std::endl;
   }*/
 
   // Sort the simplices in the order of the filtration
@@ -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>(&output_file)->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 std::clog")
       ("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),
@@ -114,17 +114,17 @@ void program_options(int argc, char * argv[]
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a Rips complex defined on a set of input points.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a Rips complex defined on a set of input points.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp b/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp
index 3c91662f..bffaabdd 100644
--- a/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp
+++ b/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp
@@ -51,62 +51,62 @@ int main(int argc, char * const argv[]) {
   }
 
   // TEST OF INSERTION
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF INSERTION" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF INSERTION" << std::endl;
   Simplex_tree st;
 
   // ++ FIRST
-  std::cout << "   - INSERT (0,1,2)" << std::endl;
+  std::clog << "   - INSERT (0,1,2)" << std::endl;
   typeVectorVertex SimplexVector = {0, 1, 2};
   st.insert_simplex_and_subfaces(SimplexVector, 0.3);
 
   // ++ SECOND
-  std::cout << "   - INSERT 3" << std::endl;
+  std::clog << "   - INSERT 3" << std::endl;
   SimplexVector = {3};
   st.insert_simplex_and_subfaces(SimplexVector, 0.1);
 
   // ++ THIRD
-  std::cout << "   - INSERT (0,3)" << std::endl;
+  std::clog << "   - INSERT (0,3)" << std::endl;
   SimplexVector = {0, 3};
   st.insert_simplex_and_subfaces(SimplexVector, 0.2);
 
   // ++ FOURTH
-  std::cout << "   - INSERT (0,1) (already inserted)" << std::endl;
+  std::clog << "   - INSERT (0,1) (already inserted)" << std::endl;
   SimplexVector = {0, 1};
   st.insert_simplex_and_subfaces(SimplexVector, 0.2);
 
   // ++ FIFTH
-  std::cout << "   - INSERT (3,4,5)" << std::endl;
+  std::clog << "   - INSERT (3,4,5)" << std::endl;
   SimplexVector = {3, 4, 5};
   st.insert_simplex_and_subfaces(SimplexVector, 0.3);
 
   // ++ SIXTH
-  std::cout << "   - INSERT (0,1,6,7)" << std::endl;
+  std::clog << "   - INSERT (0,1,6,7)" << std::endl;
   SimplexVector = {0, 1, 6, 7};
   st.insert_simplex_and_subfaces(SimplexVector, 0.4);
 
   // ++ SEVENTH
-  std::cout << "   - INSERT (4,5,8,9)" << std::endl;
+  std::clog << "   - INSERT (4,5,8,9)" << std::endl;
   SimplexVector = {4, 5, 8, 9};
   st.insert_simplex_and_subfaces(SimplexVector, 0.4);
 
   // ++ EIGHTH
-  std::cout << "   - INSERT (9,10,11)" << std::endl;
+  std::clog << "   - INSERT (9,10,11)" << std::endl;
   SimplexVector = {9, 10, 11};
   st.insert_simplex_and_subfaces(SimplexVector, 0.3);
 
   // ++ NINETH
-  std::cout << "   - INSERT (2,10,12)" << std::endl;
+  std::clog << "   - INSERT (2,10,12)" << std::endl;
   SimplexVector = {2, 10, 12};
   st.insert_simplex_and_subfaces(SimplexVector, 0.3);
 
   // ++ TENTH
-  std::cout << "   - INSERT (11,6)" << std::endl;
+  std::clog << "   - INSERT (11,6)" << std::endl;
   SimplexVector = {6, 11};
   st.insert_simplex_and_subfaces(SimplexVector, 0.2);
 
   // ++ ELEVENTH
-  std::cout << "   - INSERT (13,14,15)" << std::endl;
+  std::clog << "   - INSERT (13,14,15)" << std::endl;
   SimplexVector = {13, 14, 15};
   st.insert_simplex_and_subfaces(SimplexVector, 0.25);
 
@@ -131,24 +131,24 @@ int main(int argc, char * const argv[]) {
   /*   An edge [10,12,2]      */
 
 
-  std::cout << "The complex contains " << st.num_simplices() << " simplices - " << st.num_vertices() << " vertices "
+  std::clog << "The complex contains " << st.num_simplices() << " simplices - " << st.num_vertices() << " vertices "
       << std::endl;
-  std::cout << "   - dimension " << st.dimension() << std::endl;
-  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:"
+  std::clog << "   - dimension " << st.dimension() << std::endl;
+  std::clog << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:"
       << std::endl;
-  std::cout << "**************************************************************" << std::endl;
-  std::cout << "strict graph G { " << std::endl;
+  std::clog << "**************************************************************" << std::endl;
+  std::clog << "strict graph G { " << 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 << static_cast<int>(vertex) << " -- ";
+      std::clog << static_cast<int>(vertex) << " -- ";
     }
-    std::cout << ";" << std::endl;
+    std::clog << ";" << std::endl;
   }
 
-  std::cout << "}" << std::endl;
-  std::cout << "**************************************************************" << std::endl;
+  std::clog << "}" << std::endl;
+  std::clog << "**************************************************************" << std::endl;
 
   // Compute the persistence diagram of the complex
   Persistent_cohomology pcoh(st);
diff --git a/src/Persistent_cohomology/example/plain_homology.cpp b/src/Persistent_cohomology/example/plain_homology.cpp
index 84333e46..4d329020 100644
--- a/src/Persistent_cohomology/example/plain_homology.cpp
+++ b/src/Persistent_cohomology/example/plain_homology.cpp
@@ -83,9 +83,9 @@ int main() {
   pcoh.output_diagram();
 
   // Print the Betti numbers are b0=2 and b1=2.
-  std::cout << std::endl;
-  std::cout << "The Betti numbers are : ";
+  std::clog << std::endl;
+  std::clog << "The Betti numbers are : ";
   for (int i = 0; i < 3; i++)
-    std::cout << "b" << i << " = " << pcoh.betti_number(i) << " ; ";
-  std::cout << std::endl;
+    std::clog << "b" << i << " = " << pcoh.betti_number(i) << " ; ";
+  std::clog << std::endl;
 }
diff --git a/src/Persistent_cohomology/example/rips_multifield_persistence.cpp b/src/Persistent_cohomology/example/rips_multifield_persistence.cpp
index 9eb5ccfc..e2e2c0a5 100644
--- a/src/Persistent_cohomology/example/rips_multifield_persistence.cpp
+++ b/src/Persistent_cohomology/example/rips_multifield_persistence.cpp
@@ -56,8 +56,8 @@ int main(int argc, char * argv[]) {
   Simplex_tree simplex_tree;
 
   rips_complex_from_file.create_complex(simplex_tree, dim_max);
-  std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
-  std::cout << "   and has dimension " << simplex_tree.dimension() << " \n";
+  std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
+  std::clog << "   and has dimension " << simplex_tree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
   simplex_tree.initialize_filtration();
@@ -99,7 +99,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::cout")
+       "Name of file in which the persistence diagram is written. Default print in std::clog")
       ("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),
@@ -123,20 +123,20 @@ void program_options(int argc, char * argv[]
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with various coefficient fields \n";
-    std::cout << "of a Rips complex defined on a set of input points. The coefficient \n";
-    std::cout << "fields are all the Z/rZ for a prime number r contained in the \n";
-    std::cout << "specified range [p,q]\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p1*...*pr   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p1*...*pr is the product of prime numbers pi such that the homology \n";
-    std::cout << "feature exists in homology with Z/piZ coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with various coefficient fields \n";
+    std::clog << "of a Rips complex defined on a set of input points. The coefficient \n";
+    std::clog << "fields are all the Z/rZ for a prime number r contained in the \n";
+    std::clog << "specified range [p,q]\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p1*...*pr   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p1*...*pr is the product of prime numbers pi such that the homology \n";
+    std::clog << "feature exists in homology with Z/piZ coefficients." << std::endl << 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/Persistent_cohomology/example/rips_persistence_step_by_step.cpp b/src/Persistent_cohomology/example/rips_persistence_step_by_step.cpp
index 02db05ec..7da9f15d 100644
--- a/src/Persistent_cohomology/example/rips_persistence_step_by_step.cpp
+++ b/src/Persistent_cohomology/example/rips_persistence_step_by_step.cpp
@@ -73,8 +73,8 @@ int main(int argc, char * argv[]) {
   // expand the graph until dimension dim_max
   st.expansion(dim_max);
 
-  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();
@@ -115,7 +115,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::cout")
+       "Name of file in which the persistence diagram is written. Default print in std::clog")
       ("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.")
@@ -138,17 +138,17 @@ void program_options(int argc, char * argv[]
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a Rips complex defined on a set of input points.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a Rips complex defined on a set of input points.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Persistent_cohomology/example/rips_persistence_via_boundary_matrix.cpp b/src/Persistent_cohomology/example/rips_persistence_via_boundary_matrix.cpp
index 37fa5e93..db456f70 100644
--- a/src/Persistent_cohomology/example/rips_persistence_via_boundary_matrix.cpp
+++ b/src/Persistent_cohomology/example/rips_persistence_via_boundary_matrix.cpp
@@ -64,8 +64,8 @@ int main(int argc, char * argv[]) {
   Simplex_tree& st = *new Simplex_tree;
   rips_complex_from_file.create_complex(st, dim_max);
 
-  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";
 
 #ifdef GUDHI_USE_TBB
   // Unnecessary, but clarifies which operations are parallel.
@@ -122,7 +122,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::cout")
+       "Name of file in which the persistence diagram is written. Default print in std::clog")
       ("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),
@@ -144,17 +144,17 @@ void program_options(int argc, char * argv[]
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a Rips complex defined on a set of input points.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a Rips complex defined on a set of input points.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Persistent_cohomology/include/gudhi/Persistent_cohomology.h b/src/Persistent_cohomology/include/gudhi/Persistent_cohomology.h
index 0f1876d0..ca4bc10d 100644
--- a/src/Persistent_cohomology/include/gudhi/Persistent_cohomology.h
+++ b/src/Persistent_cohomology/include/gudhi/Persistent_cohomology.h
@@ -288,10 +288,7 @@ class Persistent_cohomology {
     // with multiplicity. We used to sum the coefficients directly in
     // annotations_in_boundary by using a map, we now do it later.
     typedef std::pair<Column *, int> annotation_t;
-#ifdef GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    thread_local
-#endif  // GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    std::vector<annotation_t> annotations_in_boundary;
+    thread_local std::vector<annotation_t> annotations_in_boundary;
     annotations_in_boundary.clear();
     int sign = 1 - 2 * (dim_sigma % 2);  // \in {-1,1} provides the sign in the
                                          // alternate sum in the boundary.
@@ -566,15 +563,9 @@ class Persistent_cohomology {
     std::sort(std::begin(persistent_pairs_), std::end(persistent_pairs_), cmp);
     bool has_infinity = std::numeric_limits<Filtration_value>::has_infinity;
     for (auto pair : persistent_pairs_) {
-      // Special case on windows, inf is "1.#INF" (cf. unitary tests and R package TDA)
-      if (has_infinity && cpx_->filtration(get<1>(pair)) == std::numeric_limits<Filtration_value>::infinity()) {
-        ostream << get<2>(pair) << "  " << cpx_->dimension(get<0>(pair)) << " "
-          << cpx_->filtration(get<0>(pair)) << " inf " << std::endl;
-      } else {
-        ostream << get<2>(pair) << "  " << cpx_->dimension(get<0>(pair)) << " "
-          << cpx_->filtration(get<0>(pair)) << " "
-          << cpx_->filtration(get<1>(pair)) << " " << std::endl;
-      }
+      ostream << get<2>(pair) << "  " << cpx_->dimension(get<0>(pair)) << " "
+        << cpx_->filtration(get<0>(pair)) << " "
+        << cpx_->filtration(get<1>(pair)) << " " << std::endl;
     }
   }
 
@@ -584,15 +575,9 @@ class Persistent_cohomology {
     std::sort(std::begin(persistent_pairs_), std::end(persistent_pairs_), cmp);
     bool has_infinity = std::numeric_limits<Filtration_value>::has_infinity;
     for (auto pair : persistent_pairs_) {
-      // Special case on windows, inf is "1.#INF"
-      if (has_infinity && cpx_->filtration(get<1>(pair)) == std::numeric_limits<Filtration_value>::infinity()) {
-        diagram_out << cpx_->dimension(get<0>(pair)) << " "
-              << cpx_->filtration(get<0>(pair)) << " inf" << std::endl;
-      } else {
-        diagram_out << cpx_->dimension(get<0>(pair)) << " "
-              << cpx_->filtration(get<0>(pair)) << " "
-              << cpx_->filtration(get<1>(pair)) << std::endl;
-      }
+      diagram_out << cpx_->dimension(get<0>(pair)) << " "
+            << cpx_->filtration(get<0>(pair)) << " "
+            << cpx_->filtration(get<1>(pair)) << std::endl;
     }
   }
 
diff --git a/src/Persistent_cohomology/test/betti_numbers_unit_test.cpp b/src/Persistent_cohomology/test/betti_numbers_unit_test.cpp
index b9f11607..7a2feeff 100644
--- a/src/Persistent_cohomology/test/betti_numbers_unit_test.cpp
+++ b/src/Persistent_cohomology/test/betti_numbers_unit_test.cpp
@@ -82,7 +82,7 @@ BOOST_AUTO_TEST_CASE( plain_homology_betti_numbers )
   // 2  1 0 inf 
   // means that in Z/2Z-homology, the Betti numbers are b0=2 and b1=1.
   
-  std::cout << "BETTI NUMBERS" << std::endl;
+  std::clog << "BETTI NUMBERS" << std::endl;
 
   BOOST_CHECK(pcoh.betti_number(0) == 2);
   BOOST_CHECK(pcoh.betti_number(1) == 1);
@@ -94,7 +94,7 @@ BOOST_AUTO_TEST_CASE( plain_homology_betti_numbers )
   BOOST_CHECK(bns[1] == 1);
   BOOST_CHECK(bns[2] == 0);
 
-  std::cout << "GET PERSISTENT PAIRS" << std::endl;
+  std::clog << "GET PERSISTENT PAIRS" << std::endl;
   
   // Custom sort and output persistence
   cmp_intervals_by_dim_then_length<Mini_simplex_tree> cmp(&st);
@@ -118,12 +118,12 @@ BOOST_AUTO_TEST_CASE( plain_homology_betti_numbers )
   BOOST_CHECK(st.filtration(get<0>(persistent_pairs[2])) == 0);
   BOOST_CHECK(get<1>(persistent_pairs[2]) == st.null_simplex());
 
-  std::cout << "INTERVALS IN DIMENSION" << std::endl;
+  std::clog << "INTERVALS IN DIMENSION" << std::endl;
 
   auto intervals_in_dimension_0 = pcoh.intervals_in_dimension(0);
-  std::cout << "intervals_in_dimension_0.size() = " << intervals_in_dimension_0.size() << std::endl;
+  std::clog << "intervals_in_dimension_0.size() = " << intervals_in_dimension_0.size() << std::endl;
   for (std::size_t i = 0; i < intervals_in_dimension_0.size(); i++)
-    std::cout << "intervals_in_dimension_0[" << i << "] = [" << intervals_in_dimension_0[i].first << "," <<
+    std::clog << "intervals_in_dimension_0[" << i << "] = [" << intervals_in_dimension_0[i].first << "," <<
                  intervals_in_dimension_0[i].second << "]" << std::endl;
   BOOST_CHECK(intervals_in_dimension_0.size() == 2);
   BOOST_CHECK(intervals_in_dimension_0[0].first == 0);
@@ -133,16 +133,16 @@ BOOST_AUTO_TEST_CASE( plain_homology_betti_numbers )
 
 
   auto intervals_in_dimension_1 = pcoh.intervals_in_dimension(1);
-  std::cout << "intervals_in_dimension_1.size() = " << intervals_in_dimension_1.size() << std::endl;
+  std::clog << "intervals_in_dimension_1.size() = " << intervals_in_dimension_1.size() << std::endl;
   for (std::size_t i = 0; i < intervals_in_dimension_1.size(); i++)
-    std::cout << "intervals_in_dimension_1[" << i << "] = [" << intervals_in_dimension_1[i].first << "," <<
+    std::clog << "intervals_in_dimension_1[" << i << "] = [" << intervals_in_dimension_1[i].first << "," <<
                  intervals_in_dimension_1[i].second << "]" << std::endl;
   BOOST_CHECK(intervals_in_dimension_1.size() == 1);
   BOOST_CHECK(intervals_in_dimension_1[0].first == 0);
   BOOST_CHECK(intervals_in_dimension_1[0].second == std::numeric_limits<Mini_simplex_tree::Filtration_value>::infinity());
 
   auto intervals_in_dimension_2 = pcoh.intervals_in_dimension(2);
-  std::cout << "intervals_in_dimension_2.size() = " << intervals_in_dimension_2.size() << std::endl;
+  std::clog << "intervals_in_dimension_2.size() = " << intervals_in_dimension_2.size() << std::endl;
   BOOST_CHECK(intervals_in_dimension_2.size() == 0);
 }
 
@@ -259,12 +259,12 @@ BOOST_AUTO_TEST_CASE( betti_numbers )
   BOOST_CHECK(st.filtration(get<0>(persistent_pairs[2])) == 1);
   BOOST_CHECK(get<1>(persistent_pairs[2]) == st.null_simplex());
 
-  std::cout << "INTERVALS IN DIMENSION" << std::endl;
+  std::clog << "INTERVALS IN DIMENSION" << std::endl;
 
   auto intervals_in_dimension_0 = pcoh.intervals_in_dimension(0);
-  std::cout << "intervals_in_dimension_0.size() = " << intervals_in_dimension_0.size() << std::endl;
+  std::clog << "intervals_in_dimension_0.size() = " << intervals_in_dimension_0.size() << std::endl;
   for (std::size_t i = 0; i < intervals_in_dimension_0.size(); i++)
-    std::cout << "intervals_in_dimension_0[" << i << "] = [" << intervals_in_dimension_0[i].first << "," <<
+    std::clog << "intervals_in_dimension_0[" << i << "] = [" << intervals_in_dimension_0[i].first << "," <<
                  intervals_in_dimension_0[i].second << "]" << std::endl;
   BOOST_CHECK(intervals_in_dimension_0.size() == 2);
   BOOST_CHECK(intervals_in_dimension_0[0].first == 2);
@@ -273,19 +273,19 @@ BOOST_AUTO_TEST_CASE( betti_numbers )
   BOOST_CHECK(intervals_in_dimension_0[1].second == std::numeric_limits<Mini_simplex_tree::Filtration_value>::infinity());
 
   auto intervals_in_dimension_1 = pcoh.intervals_in_dimension(1);
-  std::cout << "intervals_in_dimension_1.size() = " << intervals_in_dimension_1.size() << std::endl;
+  std::clog << "intervals_in_dimension_1.size() = " << intervals_in_dimension_1.size() << std::endl;
   for (std::size_t i = 0; i < intervals_in_dimension_1.size(); i++)
-    std::cout << "intervals_in_dimension_1[" << i << "] = [" << intervals_in_dimension_1[i].first << "," <<
+    std::clog << "intervals_in_dimension_1[" << i << "] = [" << intervals_in_dimension_1[i].first << "," <<
                  intervals_in_dimension_1[i].second << "]" << std::endl;
   BOOST_CHECK(intervals_in_dimension_1.size() == 1);
   BOOST_CHECK(intervals_in_dimension_1[0].first == 4);
   BOOST_CHECK(intervals_in_dimension_1[0].second == std::numeric_limits<Mini_simplex_tree::Filtration_value>::infinity());
 
   auto intervals_in_dimension_2 = pcoh.intervals_in_dimension(2);
-  std::cout << "intervals_in_dimension_2.size() = " << intervals_in_dimension_2.size() << std::endl;
+  std::clog << "intervals_in_dimension_2.size() = " << intervals_in_dimension_2.size() << std::endl;
   BOOST_CHECK(intervals_in_dimension_2.size() == 0);
 
-  std::cout << "EMPTY COMPLEX" << std::endl;
+  std::clog << "EMPTY COMPLEX" << std::endl;
   Simplex_tree empty;
   empty.initialize_filtration();
   St_persistence pcoh_empty(empty, false);
diff --git a/src/Persistent_cohomology/test/persistent_cohomology_unit_test.cpp b/src/Persistent_cohomology/test/persistent_cohomology_unit_test.cpp
index a1c106d5..fe3f8517 100644
--- a/src/Persistent_cohomology/test/persistent_cohomology_unit_test.cpp
+++ b/src/Persistent_cohomology/test/persistent_cohomology_unit_test.cpp
@@ -30,7 +30,7 @@ std::string test_rips_persistence(int coefficient, int min_persistence) {
   simplex_tree_stream.close();
 
   // Display the Simplex_tree
-  std::cout << "The complex contains " << st.num_simplices() << " simplices" << " - dimension= " << st.dimension()
+  std::clog << "The complex contains " << st.num_simplices() << " simplices" << " - dimension= " << st.dimension()
       << std::endl;
 
   // Check
@@ -76,11 +76,11 @@ void test_rips_persistence_in_dimension(int dimension) {
   value8.insert(0,std::to_string(dimension));
   value9.insert(0,std::to_string(dimension));
 
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF RIPS_PERSISTENT_COHOMOLOGY_SINGLE_FIELD DIM=" << dimension << " MIN_PERS=0" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF RIPS_PERSISTENT_COHOMOLOGY_SINGLE_FIELD DIM=" << dimension << " MIN_PERS=0" << std::endl;
 
   std::string str_rips_persistence = test_rips_persistence(dimension, 0);
-  std::cout << str_rips_persistence << std::endl;
+  std::clog << str_rips_persistence << std::endl;
   
   BOOST_CHECK(str_rips_persistence.find(value0) != std::string::npos); // Check found
   BOOST_CHECK(str_rips_persistence.find(value1) != std::string::npos); // Check found
@@ -92,10 +92,10 @@ void test_rips_persistence_in_dimension(int dimension) {
   BOOST_CHECK(str_rips_persistence.find(value7) != std::string::npos); // Check found
   BOOST_CHECK(str_rips_persistence.find(value8) != std::string::npos); // Check found
   BOOST_CHECK(str_rips_persistence.find(value9) != std::string::npos); // Check found
-  std::cout << "str_rips_persistence=" << str_rips_persistence << std::endl;
+  std::clog << "str_rips_persistence=" << str_rips_persistence << std::endl;
 
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF RIPS_PERSISTENT_COHOMOLOGY_SINGLE_FIELD DIM=" << dimension << " MIN_PERS=1" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF RIPS_PERSISTENT_COHOMOLOGY_SINGLE_FIELD DIM=" << dimension << " MIN_PERS=1" << std::endl;
 
   str_rips_persistence = test_rips_persistence(dimension, 1);
 
@@ -109,10 +109,10 @@ void test_rips_persistence_in_dimension(int dimension) {
   BOOST_CHECK(str_rips_persistence.find(value7) != std::string::npos); // Check found
   BOOST_CHECK(str_rips_persistence.find(value8) != std::string::npos); // Check found
   BOOST_CHECK(str_rips_persistence.find(value9) != std::string::npos); // Check found
-  std::cout << "str_rips_persistence=" << str_rips_persistence << std::endl;
+  std::clog << "str_rips_persistence=" << str_rips_persistence << std::endl;
 
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF RIPS_PERSISTENT_COHOMOLOGY_SINGLE_FIELD DIM=" << dimension << " MIN_PERS=2" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF RIPS_PERSISTENT_COHOMOLOGY_SINGLE_FIELD DIM=" << dimension << " MIN_PERS=2" << std::endl;
 
   str_rips_persistence = test_rips_persistence(dimension, 2);
 
@@ -126,10 +126,10 @@ void test_rips_persistence_in_dimension(int dimension) {
   BOOST_CHECK(str_rips_persistence.find(value7) == std::string::npos); // Check not found
   BOOST_CHECK(str_rips_persistence.find(value8) != std::string::npos); // Check found
   BOOST_CHECK(str_rips_persistence.find(value9) != std::string::npos); // Check found
-  std::cout << "str_rips_persistence=" << str_rips_persistence << std::endl;
+  std::clog << "str_rips_persistence=" << str_rips_persistence << std::endl;
 
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF RIPS_PERSISTENT_COHOMOLOGY_SINGLE_FIELD DIM=" << dimension << " MIN_PERS=Inf" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF RIPS_PERSISTENT_COHOMOLOGY_SINGLE_FIELD DIM=" << dimension << " MIN_PERS=Inf" << std::endl;
 
   str_rips_persistence = test_rips_persistence(dimension, (std::numeric_limits<int>::max)());
 
@@ -143,7 +143,7 @@ void test_rips_persistence_in_dimension(int dimension) {
   BOOST_CHECK(str_rips_persistence.find(value7) == std::string::npos); // Check not found
   BOOST_CHECK(str_rips_persistence.find(value8) != std::string::npos); // Check found
   BOOST_CHECK(str_rips_persistence.find(value9) != std::string::npos); // Check found
-  std::cout << "str_rips_persistence=" << str_rips_persistence << std::endl;
+  std::clog << "str_rips_persistence=" << str_rips_persistence << std::endl;
 }
 
 BOOST_AUTO_TEST_CASE( rips_persistent_cohomology_single_field_dim_1 )
diff --git a/src/Persistent_cohomology/test/persistent_cohomology_unit_test_multi_field.cpp b/src/Persistent_cohomology/test/persistent_cohomology_unit_test_multi_field.cpp
index 9e767943..3602aa09 100644
--- a/src/Persistent_cohomology/test/persistent_cohomology_unit_test_multi_field.cpp
+++ b/src/Persistent_cohomology/test/persistent_cohomology_unit_test_multi_field.cpp
@@ -30,7 +30,7 @@ std::string test_rips_persistence(int min_coefficient, int max_coefficient, doub
   simplex_tree_stream.close();
 
   // Display the Simplex_tree
-  std::cout << "The complex contains " << st.num_simplices() << " simplices" << " - dimension= " << st.dimension()
+  std::clog << "The complex contains " << st.num_simplices() << " simplices" << " - dimension= " << st.dimension()
       << std::endl;
 
   // Check
@@ -68,11 +68,11 @@ void test_rips_persistence_in_dimension(int min_dimension, int max_dimension) {
   std::string value6("  2 0.3 inf");
   std::string value7("  2 0.4 inf");
 
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF RIPS_PERSISTENT_COHOMOLOGY_MULTI_FIELD MIN_DIM=" << min_dimension << " MAX_DIM=" << max_dimension << " MIN_PERS=0" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF RIPS_PERSISTENT_COHOMOLOGY_MULTI_FIELD MIN_DIM=" << min_dimension << " MAX_DIM=" << max_dimension << " MIN_PERS=0" << std::endl;
 
   std::string str_rips_persistence = test_rips_persistence(min_dimension, max_dimension, 0.0);
-  std::cout << "str_rips_persistence=" << str_rips_persistence << std::endl;
+  std::clog << "str_rips_persistence=" << str_rips_persistence << std::endl;
 
   BOOST_CHECK(str_rips_persistence.find(value0) != std::string::npos); // Check found
   BOOST_CHECK(str_rips_persistence.find(value1) != std::string::npos); // Check found
diff --git a/src/Rips_complex/example/CMakeLists.txt b/src/Rips_complex/example/CMakeLists.txt
index e7772bdb..244a93ec 100644
--- a/src/Rips_complex/example/CMakeLists.txt
+++ b/src/Rips_complex/example/CMakeLists.txt
@@ -53,15 +53,23 @@ if (DIFF_PATH)
   add_test(Rips_complex_example_from_off_doc_12_1_diff_files ${DIFF_PATH}
       ${CMAKE_CURRENT_BINARY_DIR}/ripsoffreader_result_12_1.txt
       ${CMAKE_CURRENT_BINARY_DIR}/one_skeleton_rips_for_doc.txt)
+  set_tests_properties(Rips_complex_example_from_off_doc_12_1_diff_files PROPERTIES DEPENDS Rips_complex_example_from_off_doc_12_1) 
+
   add_test(Rips_complex_example_from_off_doc_12_3_diff_files ${DIFF_PATH}
       ${CMAKE_CURRENT_BINARY_DIR}/ripsoffreader_result_12_3.txt
       ${CMAKE_CURRENT_BINARY_DIR}/full_skeleton_rips_for_doc.txt)
+  set_tests_properties(Rips_complex_example_from_off_doc_12_3_diff_files PROPERTIES DEPENDS Rips_complex_example_from_off_doc_12_3) 
+
   add_test(Rips_complex_example_from_csv_distance_matrix_doc_12_1_diff_files ${DIFF_PATH}
       ${CMAKE_CURRENT_BINARY_DIR}/ripscsvreader_result_12_1.txt
       ${CMAKE_CURRENT_BINARY_DIR}/one_skeleton_rips_for_doc.txt)
+  set_tests_properties(Rips_complex_example_from_csv_distance_matrix_doc_12_1_diff_files PROPERTIES DEPENDS Rips_complex_example_from_csv_distance_matrix_doc_12_1) 
+
   add_test(Rips_complex_example_from_csv_distance_matrix_doc_12_3_diff_files ${DIFF_PATH}
       ${CMAKE_CURRENT_BINARY_DIR}/ripscsvreader_result_12_3.txt
       ${CMAKE_CURRENT_BINARY_DIR}/full_skeleton_rips_for_doc.txt)
+  set_tests_properties(Rips_complex_example_from_csv_distance_matrix_doc_12_3_diff_files PROPERTIES DEPENDS Rips_complex_example_from_csv_distance_matrix_doc_12_3) 
+
 endif()
 
 install(TARGETS Rips_complex_example_from_off DESTINATION bin)
diff --git a/src/Rips_complex/example/example_one_skeleton_rips_from_correlation_matrix.cpp b/src/Rips_complex/example/example_one_skeleton_rips_from_correlation_matrix.cpp
index 05bacb9f..3d2ba54f 100644
--- a/src/Rips_complex/example/example_one_skeleton_rips_from_correlation_matrix.cpp
+++ b/src/Rips_complex/example/example_one_skeleton_rips_from_correlation_matrix.cpp
@@ -63,18 +63,18 @@ int main() {
   // have a reverse filtration (i.e. filtration of boundary of each simplex S
   // is greater or equal to the filtration of S).
   // ----------------------------------------------------------------------------
-  std::cout << "Rips complex is of dimension " << stree.dimension() << " - " << stree.num_simplices() << " simplices - "
+  std::clog << "Rips complex is of dimension " << stree.dimension() << " - " << stree.num_simplices() << " simplices - "
             << stree.num_vertices() << " vertices." << std::endl;
 
-  std::cout << "Iterator on Rips complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  std::clog << "Iterator on Rips complex simplices in the filtration order, with [filtration value]:" << std::endl;
   for (auto f_simplex : stree.filtration_simplex_range()) {
-    std::cout << "   ( ";
+    std::clog << "   ( ";
     for (auto vertex : stree.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> "
+    std::clog << ") -> "
               << "[" << stree.filtration(f_simplex) << "] ";
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   return 0;
diff --git a/src/Rips_complex/example/example_one_skeleton_rips_from_distance_matrix.cpp b/src/Rips_complex/example/example_one_skeleton_rips_from_distance_matrix.cpp
index bbc3c755..25f93b03 100644
--- a/src/Rips_complex/example/example_one_skeleton_rips_from_distance_matrix.cpp
+++ b/src/Rips_complex/example/example_one_skeleton_rips_from_distance_matrix.cpp
@@ -39,19 +39,19 @@ int main() {
   // ----------------------------------------------------------------------------
   // Display information about the one skeleton Rips complex
   // ----------------------------------------------------------------------------
-  std::cout << "Rips complex is of dimension " << stree.dimension() <<
+  std::clog << "Rips complex is of dimension " << stree.dimension() <<
                " - " << stree.num_simplices() << " simplices - " <<
                stree.num_vertices() << " vertices." << std::endl;
 
-  std::cout << "Iterator on Rips complex simplices in the filtration order, with [filtration value]:" <<
+  std::clog << "Iterator on Rips complex simplices in the filtration order, with [filtration value]:" <<
                std::endl;
   for (auto f_simplex : stree.filtration_simplex_range()) {
-    std::cout << "   ( ";
+    std::clog << "   ( ";
     for (auto vertex : stree.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> " << "[" << stree.filtration(f_simplex) << "] ";
-    std::cout << std::endl;
+    std::clog << ") -> " << "[" << stree.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
   }
 
   return 0;
diff --git a/src/Rips_complex/example/example_one_skeleton_rips_from_points.cpp b/src/Rips_complex/example/example_one_skeleton_rips_from_points.cpp
index a1db8910..d9df245b 100644
--- a/src/Rips_complex/example/example_one_skeleton_rips_from_points.cpp
+++ b/src/Rips_complex/example/example_one_skeleton_rips_from_points.cpp
@@ -34,19 +34,19 @@ int main() {
   // ----------------------------------------------------------------------------
   // Display information about the one skeleton Rips complex
   // ----------------------------------------------------------------------------
-  std::cout << "Rips complex is of dimension " << stree.dimension() <<
+  std::clog << "Rips complex is of dimension " << stree.dimension() <<
                " - " << stree.num_simplices() << " simplices - " <<
                stree.num_vertices() << " vertices." << std::endl;
 
-  std::cout << "Iterator on Rips complex simplices in the filtration order, with [filtration value]:" <<
+  std::clog << "Iterator on Rips complex simplices in the filtration order, with [filtration value]:" <<
                std::endl;
   for (auto f_simplex : stree.filtration_simplex_range()) {
-    std::cout << "   ( ";
+    std::clog << "   ( ";
     for (auto vertex : stree.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> " << "[" << stree.filtration(f_simplex) << "] ";
-    std::cout << std::endl;
+    std::clog << ") -> " << "[" << stree.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
   }
   return 0;
 }
diff --git a/src/Rips_complex/example/example_rips_complex_from_csv_distance_matrix_file.cpp b/src/Rips_complex/example/example_rips_complex_from_csv_distance_matrix_file.cpp
index b7040453..c0c57e7b 100644
--- a/src/Rips_complex/example/example_rips_complex_from_csv_distance_matrix_file.cpp
+++ b/src/Rips_complex/example/example_rips_complex_from_csv_distance_matrix_file.cpp
@@ -42,7 +42,7 @@ int main(int argc, char **argv) {
     ouput_file_stream.open(std::string(argv[4]));
     streambuffer = ouput_file_stream.rdbuf();
   } else {
-    streambuffer = std::cout.rdbuf();
+    streambuffer = std::clog.rdbuf();
   }
 
   Simplex_tree stree;
diff --git a/src/Rips_complex/example/example_rips_complex_from_off_file.cpp b/src/Rips_complex/example/example_rips_complex_from_off_file.cpp
index 36b468a7..9aa7a657 100644
--- a/src/Rips_complex/example/example_rips_complex_from_off_file.cpp
+++ b/src/Rips_complex/example/example_rips_complex_from_off_file.cpp
@@ -41,7 +41,7 @@ int main(int argc, char **argv) {
     ouput_file_stream.open(std::string(argv[4]));
     streambuffer = ouput_file_stream.rdbuf();
   } else {
-    streambuffer = std::cout.rdbuf();
+    streambuffer = std::clog.rdbuf();
   }
 
   Simplex_tree stree;
diff --git a/src/Rips_complex/example/example_sparse_rips.cpp b/src/Rips_complex/example/example_sparse_rips.cpp
index 1c95b48c..4bd31103 100644
--- a/src/Rips_complex/example/example_sparse_rips.cpp
+++ b/src/Rips_complex/example/example_sparse_rips.cpp
@@ -25,6 +25,6 @@ int main() {
   // ----------------------------------------------------------------------------
   // Display information about the complex
   // ----------------------------------------------------------------------------
-  std::cout << "Sparse Rips complex is of dimension " << stree.dimension() << " - " << stree.num_simplices()
+  std::clog << "Sparse Rips complex is of dimension " << stree.dimension() << " - " << stree.num_simplices()
             << " simplices - " << stree.num_vertices() << " vertices." << std::endl;
 }
diff --git a/src/Rips_complex/test/test_rips_complex.cpp b/src/Rips_complex/test/test_rips_complex.cpp
index 1225f8df..19dcd283 100644
--- a/src/Rips_complex/test/test_rips_complex.cpp
+++ b/src/Rips_complex/test/test_rips_complex.cpp
@@ -43,7 +43,7 @@ BOOST_AUTO_TEST_CASE(RIPS_DOC_OFF_file) {
   // ----------------------------------------------------------------------------
   std::string off_file_name("alphacomplexdoc.off");
   double rips_threshold = 12.0;
-  std::cout << "========== OFF FILE NAME = " << off_file_name << " - Rips threshold=" <<
+  std::clog << "========== OFF FILE NAME = " << off_file_name << " - Rips threshold=" <<
       rips_threshold << "==========" << std::endl;
 
   Gudhi::Points_off_reader<Point> off_reader(off_file_name);
@@ -52,14 +52,14 @@ BOOST_AUTO_TEST_CASE(RIPS_DOC_OFF_file) {
   const int DIMENSION_1 = 1;
   Simplex_tree st;
   rips_complex_from_file.create_complex(st, DIMENSION_1);
-  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+  std::clog << "st.dimension()=" << st.dimension() << std::endl;
   BOOST_CHECK(st.dimension() == DIMENSION_1);
 
   const int NUMBER_OF_VERTICES = 7;
-  std::cout << "st.num_vertices()=" << st.num_vertices() << std::endl;
+  std::clog << "st.num_vertices()=" << st.num_vertices() << std::endl;
   BOOST_CHECK(st.num_vertices() == NUMBER_OF_VERTICES);
 
-  std::cout << "st.num_simplices()=" << st.num_simplices() << std::endl;
+  std::clog << "st.num_simplices()=" << st.num_simplices() << std::endl;
   BOOST_CHECK(st.num_simplices() == 18);
 
   // Check filtration values of vertices is 0.0
@@ -71,12 +71,12 @@ BOOST_AUTO_TEST_CASE(RIPS_DOC_OFF_file) {
   for (auto f_simplex : st.skeleton_simplex_range(DIMENSION_1)) {
     if (DIMENSION_1 == st.dimension(f_simplex)) {
       std::vector<Point> vp;
-      std::cout << "vertex = (";
+      std::clog << "vertex = (";
       for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-        std::cout << vertex << ",";
+        std::clog << vertex << ",";
         vp.push_back(off_reader.get_point_cloud().at(vertex));
       }
-      std::cout << ") - distance =" << Gudhi::Euclidean_distance()(vp.at(0), vp.at(1)) <<
+      std::clog << ") - distance =" << Gudhi::Euclidean_distance()(vp.at(0), vp.at(1)) <<
           " - filtration =" << st.filtration(f_simplex) << std::endl;
       BOOST_CHECK(vp.size() == 2);
       GUDHI_TEST_FLOAT_EQUALITY_CHECK(st.filtration(f_simplex), Gudhi::Euclidean_distance()(vp.at(0), vp.at(1)));
@@ -86,46 +86,46 @@ BOOST_AUTO_TEST_CASE(RIPS_DOC_OFF_file) {
   const int DIMENSION_2 = 2;
   Simplex_tree st2;
   rips_complex_from_file.create_complex(st2, DIMENSION_2);
-  std::cout << "st2.dimension()=" << st2.dimension() << std::endl;
+  std::clog << "st2.dimension()=" << st2.dimension() << std::endl;
   BOOST_CHECK(st2.dimension() == DIMENSION_2);
   
-  std::cout << "st2.num_vertices()=" << st2.num_vertices() << std::endl;
+  std::clog << "st2.num_vertices()=" << st2.num_vertices() << std::endl;
   BOOST_CHECK(st2.num_vertices() == NUMBER_OF_VERTICES);
 
-  std::cout << "st2.num_simplices()=" << st2.num_simplices() << std::endl;
+  std::clog << "st2.num_simplices()=" << st2.num_simplices() << std::endl;
   BOOST_CHECK(st2.num_simplices() == 23);
 
   Simplex_tree::Filtration_value f01 = st2.filtration(st2.find({0, 1}));
   Simplex_tree::Filtration_value f02 = st2.filtration(st2.find({0, 2}));
   Simplex_tree::Filtration_value f12 = st2.filtration(st2.find({1, 2}));
   Simplex_tree::Filtration_value f012 = st2.filtration(st2.find({0, 1, 2}));
-  std::cout << "f012= " << f012 << " | f01= " << f01 << " - f02= " << f02 << " - f12= " << f12 << std::endl;
+  std::clog << "f012= " << f012 << " | f01= " << f01 << " - f02= " << f02 << " - f12= " << f12 << std::endl;
   GUDHI_TEST_FLOAT_EQUALITY_CHECK(f012, std::max(f01, std::max(f02,f12)));
   
   Simplex_tree::Filtration_value f45 = st2.filtration(st2.find({4, 5}));
   Simplex_tree::Filtration_value f56 = st2.filtration(st2.find({5, 6}));
   Simplex_tree::Filtration_value f46 = st2.filtration(st2.find({4, 6}));
   Simplex_tree::Filtration_value f456 = st2.filtration(st2.find({4, 5, 6}));
-  std::cout << "f456= " << f456 << " | f45= " << f45 << " - f56= " << f56 << " - f46= " << f46 << std::endl;
+  std::clog << "f456= " << f456 << " | f45= " << f45 << " - f56= " << f56 << " - f46= " << f46 << std::endl;
   GUDHI_TEST_FLOAT_EQUALITY_CHECK(f456, std::max(f45, std::max(f56,f46)));
 
   const int DIMENSION_3 = 3;
   Simplex_tree st3;
   rips_complex_from_file.create_complex(st3, DIMENSION_3);
-  std::cout << "st3.dimension()=" << st3.dimension() << std::endl;
+  std::clog << "st3.dimension()=" << st3.dimension() << std::endl;
   BOOST_CHECK(st3.dimension() == DIMENSION_3);
   
-  std::cout << "st3.num_vertices()=" << st3.num_vertices() << std::endl;
+  std::clog << "st3.num_vertices()=" << st3.num_vertices() << std::endl;
   BOOST_CHECK(st3.num_vertices() == NUMBER_OF_VERTICES);
 
-  std::cout << "st3.num_simplices()=" << st3.num_simplices() << std::endl;
+  std::clog << "st3.num_simplices()=" << st3.num_simplices() << std::endl;
   BOOST_CHECK(st3.num_simplices() == 24);
 
   Simplex_tree::Filtration_value f123 = st3.filtration(st3.find({1, 2, 3}));
   Simplex_tree::Filtration_value f013 = st3.filtration(st3.find({0, 1, 3}));
   Simplex_tree::Filtration_value f023 = st3.filtration(st3.find({0, 2, 3}));
   Simplex_tree::Filtration_value f0123 = st3.filtration(st3.find({0, 1, 2, 3}));
-  std::cout << "f0123= " << f0123 << " | f012= " << f012 << " - f123= " << f123 << " - f013= " << f013 <<
+  std::clog << "f0123= " << f0123 << " | f012= " << f012 << " - f123= " << f123 << " - f013= " << f013 <<
       " - f023= " << f023 << std::endl;
   GUDHI_TEST_FLOAT_EQUALITY_CHECK(f0123, std::max(f012, std::max(f123, std::max(f013, f023))));
 
@@ -176,34 +176,34 @@ BOOST_AUTO_TEST_CASE(Rips_complex_from_points) {
   // ----------------------------------------------------------------------------
   Rips_complex rips_complex_from_points(points, 2.0, Custom_square_euclidean_distance());
 
-  std::cout << "========== Rips_complex_from_points ==========" << std::endl;
+  std::clog << "========== Rips_complex_from_points ==========" << std::endl;
   Simplex_tree st;
   const int DIMENSION = 3;
   rips_complex_from_points.create_complex(st, DIMENSION);
 
   // Another way to check num_simplices
-  std::cout << "Iterator on Rips complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  std::clog << "Iterator on Rips complex simplices in the filtration order, with [filtration value]:" << std::endl;
   int num_simplices = 0;
   for (auto f_simplex : st.filtration_simplex_range()) {
     num_simplices++;
-    std::cout << "   ( ";
+    std::clog << "   ( ";
     for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> " << "[" << st.filtration(f_simplex) << "] ";
-    std::cout << std::endl;
+    std::clog << ") -> " << "[" << st.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
   }
   BOOST_CHECK(num_simplices == 15);
-  std::cout << "st.num_simplices()=" << st.num_simplices() << std::endl;
+  std::clog << "st.num_simplices()=" << st.num_simplices() << std::endl;
   BOOST_CHECK(st.num_simplices() == 15);
 
-  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+  std::clog << "st.dimension()=" << st.dimension() << std::endl;
   BOOST_CHECK(st.dimension() == DIMENSION);
-  std::cout << "st.num_vertices()=" << st.num_vertices() << std::endl;
+  std::clog << "st.num_vertices()=" << st.num_vertices() << std::endl;
   BOOST_CHECK(st.num_vertices() == 4);
 
   for (auto f_simplex : st.filtration_simplex_range()) {
-    std::cout << "dimension(" << st.dimension(f_simplex) << ") - f = " << st.filtration(f_simplex) << std::endl;
+    std::clog << "dimension(" << st.dimension(f_simplex) << ") - f = " << st.filtration(f_simplex) << std::endl;
     switch (st.dimension(f_simplex)) {
       case 0:
         GUDHI_TEST_FLOAT_EQUALITY_CHECK(st.filtration(f_simplex), 0.0);
@@ -241,34 +241,34 @@ BOOST_AUTO_TEST_CASE(Sparse_rips_complex_from_points) {
   // .001 is small enough that we get a deterministic result matching the exact Rips
   Sparse_rips_complex sparse_rips(points, Custom_square_euclidean_distance(), .001);
 
-  std::cout << "========== Sparse_rips_complex_from_points ==========" << std::endl;
+  std::clog << "========== Sparse_rips_complex_from_points ==========" << std::endl;
   Simplex_tree st;
   const int DIMENSION = 3;
   sparse_rips.create_complex(st, DIMENSION);
 
   // Another way to check num_simplices
-  std::cout << "Iterator on Rips complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  std::clog << "Iterator on Rips complex simplices in the filtration order, with [filtration value]:" << std::endl;
   int num_simplices = 0;
   for (auto f_simplex : st.filtration_simplex_range()) {
     num_simplices++;
-    std::cout << "   ( ";
+    std::clog << "   ( ";
     for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-      std::cout << vertex << " ";
+      std::clog << vertex << " ";
     }
-    std::cout << ") -> " << "[" << st.filtration(f_simplex) << "] ";
-    std::cout << std::endl;
+    std::clog << ") -> " << "[" << st.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
   }
   BOOST_CHECK(num_simplices == 15);
-  std::cout << "st.num_simplices()=" << st.num_simplices() << std::endl;
+  std::clog << "st.num_simplices()=" << st.num_simplices() << std::endl;
   BOOST_CHECK(st.num_simplices() == 15);
 
-  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+  std::clog << "st.dimension()=" << st.dimension() << std::endl;
   BOOST_CHECK(st.dimension() == DIMENSION);
-  std::cout << "st.num_vertices()=" << st.num_vertices() << std::endl;
+  std::clog << "st.num_vertices()=" << st.num_vertices() << std::endl;
   BOOST_CHECK(st.num_vertices() == 4);
 
   for (auto f_simplex : st.filtration_simplex_range()) {
-    std::cout << "dimension(" << st.dimension(f_simplex) << ") - f = " << st.filtration(f_simplex) << std::endl;
+    std::clog << "dimension(" << st.dimension(f_simplex) << ") - f = " << st.filtration(f_simplex) << std::endl;
     switch (st.dimension(f_simplex)) {
       case 0:
         GUDHI_TEST_FLOAT_EQUALITY_CHECK(st.filtration(f_simplex), 0.0);
@@ -293,7 +293,7 @@ BOOST_AUTO_TEST_CASE(Rips_doc_csv_file) {
   // ----------------------------------------------------------------------------
   std::string csv_file_name("full_square_distance_matrix.csv");
   double rips_threshold = 12.0;
-  std::cout << "========== CSV FILE NAME = " << csv_file_name << " - Rips threshold=" <<
+  std::clog << "========== CSV FILE NAME = " << csv_file_name << " - Rips threshold=" <<
       rips_threshold << "==========" << std::endl;
 
   Distance_matrix distances = Gudhi::read_lower_triangular_matrix_from_csv_file<Filtration_value>(csv_file_name);
@@ -302,14 +302,14 @@ BOOST_AUTO_TEST_CASE(Rips_doc_csv_file) {
   const int DIMENSION_1 = 1;
   Simplex_tree st;
   rips_complex_from_file.create_complex(st, DIMENSION_1);
-  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+  std::clog << "st.dimension()=" << st.dimension() << std::endl;
   BOOST_CHECK(st.dimension() == DIMENSION_1);
 
   const int NUMBER_OF_VERTICES = 7;
-  std::cout << "st.num_vertices()=" << st.num_vertices() << std::endl;
+  std::clog << "st.num_vertices()=" << st.num_vertices() << std::endl;
   BOOST_CHECK(st.num_vertices() == NUMBER_OF_VERTICES);
 
-  std::cout << "st.num_simplices()=" << st.num_simplices() << std::endl;
+  std::clog << "st.num_simplices()=" << st.num_simplices() << std::endl;
   BOOST_CHECK(st.num_simplices() == 18);
 
   // Check filtration values of vertices is 0.0
@@ -321,12 +321,12 @@ BOOST_AUTO_TEST_CASE(Rips_doc_csv_file) {
   for (auto f_simplex : st.skeleton_simplex_range(DIMENSION_1)) {
     if (DIMENSION_1 == st.dimension(f_simplex)) {
       std::vector<Simplex_tree::Vertex_handle> vvh;
-      std::cout << "vertex = (";
+      std::clog << "vertex = (";
       for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-        std::cout << vertex << ",";
+        std::clog << vertex << ",";
         vvh.push_back(vertex);
       }
-      std::cout << ") - filtration =" << st.filtration(f_simplex) << std::endl;
+      std::clog << ") - filtration =" << st.filtration(f_simplex) << std::endl;
       BOOST_CHECK(vvh.size() == 2);
       GUDHI_TEST_FLOAT_EQUALITY_CHECK(st.filtration(f_simplex), distances[vvh.at(0)][vvh.at(1)]);
     }
@@ -335,46 +335,46 @@ BOOST_AUTO_TEST_CASE(Rips_doc_csv_file) {
   const int DIMENSION_2 = 2;
   Simplex_tree st2;
   rips_complex_from_file.create_complex(st2, DIMENSION_2);
-  std::cout << "st2.dimension()=" << st2.dimension() << std::endl;
+  std::clog << "st2.dimension()=" << st2.dimension() << std::endl;
   BOOST_CHECK(st2.dimension() == DIMENSION_2);
   
-  std::cout << "st2.num_vertices()=" << st2.num_vertices() << std::endl;
+  std::clog << "st2.num_vertices()=" << st2.num_vertices() << std::endl;
   BOOST_CHECK(st2.num_vertices() == NUMBER_OF_VERTICES);
 
-  std::cout << "st2.num_simplices()=" << st2.num_simplices() << std::endl;
+  std::clog << "st2.num_simplices()=" << st2.num_simplices() << std::endl;
   BOOST_CHECK(st2.num_simplices() == 23);
 
   Simplex_tree::Filtration_value f01 = st2.filtration(st2.find({0, 1}));
   Simplex_tree::Filtration_value f02 = st2.filtration(st2.find({0, 2}));
   Simplex_tree::Filtration_value f12 = st2.filtration(st2.find({1, 2}));
   Simplex_tree::Filtration_value f012 = st2.filtration(st2.find({0, 1, 2}));
-  std::cout << "f012= " << f012 << " | f01= " << f01 << " - f02= " << f02 << " - f12= " << f12 << std::endl;
+  std::clog << "f012= " << f012 << " | f01= " << f01 << " - f02= " << f02 << " - f12= " << f12 << std::endl;
   GUDHI_TEST_FLOAT_EQUALITY_CHECK(f012, std::max(f01, std::max(f02,f12)));
   
   Simplex_tree::Filtration_value f45 = st2.filtration(st2.find({4, 5}));
   Simplex_tree::Filtration_value f56 = st2.filtration(st2.find({5, 6}));
   Simplex_tree::Filtration_value f46 = st2.filtration(st2.find({4, 6}));
   Simplex_tree::Filtration_value f456 = st2.filtration(st2.find({4, 5, 6}));
-  std::cout << "f456= " << f456 << " | f45= " << f45 << " - f56= " << f56 << " - f46= " << f46 << std::endl;
+  std::clog << "f456= " << f456 << " | f45= " << f45 << " - f56= " << f56 << " - f46= " << f46 << std::endl;
   GUDHI_TEST_FLOAT_EQUALITY_CHECK(f456, std::max(f45, std::max(f56,f46)));
 
   const int DIMENSION_3 = 3;
   Simplex_tree st3;
   rips_complex_from_file.create_complex(st3, DIMENSION_3);
-  std::cout << "st3.dimension()=" << st3.dimension() << std::endl;
+  std::clog << "st3.dimension()=" << st3.dimension() << std::endl;
   BOOST_CHECK(st3.dimension() == DIMENSION_3);
   
-  std::cout << "st3.num_vertices()=" << st3.num_vertices() << std::endl;
+  std::clog << "st3.num_vertices()=" << st3.num_vertices() << std::endl;
   BOOST_CHECK(st3.num_vertices() == NUMBER_OF_VERTICES);
 
-  std::cout << "st3.num_simplices()=" << st3.num_simplices() << std::endl;
+  std::clog << "st3.num_simplices()=" << st3.num_simplices() << std::endl;
   BOOST_CHECK(st3.num_simplices() == 24);
 
   Simplex_tree::Filtration_value f123 = st3.filtration(st3.find({1, 2, 3}));
   Simplex_tree::Filtration_value f013 = st3.filtration(st3.find({0, 1, 3}));
   Simplex_tree::Filtration_value f023 = st3.filtration(st3.find({0, 2, 3}));
   Simplex_tree::Filtration_value f0123 = st3.filtration(st3.find({0, 1, 2, 3}));
-  std::cout << "f0123= " << f0123 << " | f012= " << f012 << " - f123= " << f123 << " - f013= " << f013 <<
+  std::clog << "f0123= " << f0123 << " | f012= " << f012 << " - f123= " << f123 << " - f013= " << f013 <<
       " - f023= " << f023 << std::endl;
   GUDHI_TEST_FLOAT_EQUALITY_CHECK(f0123, std::max(f012, std::max(f123, std::max(f013, f023))));
 
@@ -389,7 +389,7 @@ BOOST_AUTO_TEST_CASE(Rips_create_complex_throw) {
   // ----------------------------------------------------------------------------
   std::string off_file_name("alphacomplexdoc.off");
   double rips_threshold = 12.0;
-  std::cout << "========== OFF FILE NAME = " << off_file_name << " - Rips threshold=" <<
+  std::clog << "========== OFF FILE NAME = " << off_file_name << " - Rips threshold=" <<
       rips_threshold << "==========" << std::endl;
 
   Gudhi::Points_off_reader<Point> off_reader(off_file_name);
@@ -398,7 +398,7 @@ BOOST_AUTO_TEST_CASE(Rips_create_complex_throw) {
   Simplex_tree stree;
   std::vector<int> simplex = {0, 1, 2};
   stree.insert_simplex_and_subfaces(simplex);
-  std::cout << "Check exception throw in debug mode" << std::endl;
+  std::clog << "Check exception throw in debug mode" << std::endl;
   // throw excpt because stree is not empty
   BOOST_CHECK_THROW (rips_complex_from_file.create_complex(stree, 1), std::invalid_argument);
 }
diff --git a/src/Rips_complex/utilities/rips_correlation_matrix_persistence.cpp b/src/Rips_complex/utilities/rips_correlation_matrix_persistence.cpp
index 585de4a0..67f921a6 100644
--- a/src/Rips_complex/utilities/rips_correlation_matrix_persistence.cpp
+++ b/src/Rips_complex/utilities/rips_correlation_matrix_persistence.cpp
@@ -68,8 +68,8 @@ int main(int argc, char* argv[]) {
   Simplex_tree simplex_tree;
 
   rips_complex_from_file.create_complex(simplex_tree, dim_max);
-  std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
-  std::cout << "   and has dimension " << simplex_tree.dimension() << " \n";
+  std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
+  std::clog << "   and has dimension " << simplex_tree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
   simplex_tree.initialize_filtration();
@@ -121,7 +121,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 std::clog")(
       "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),
@@ -143,17 +143,17 @@ void program_options(int argc, char* argv[], std::string& csv_matrix_file, std::
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a Rips complex defined on a corelation matrix.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a Rips complex defined on a corelation matrix.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Rips_complex/utilities/rips_distance_matrix_persistence.cpp b/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp
index ad429e11..4ad19675 100644
--- a/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp
+++ b/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp
@@ -47,8 +47,8 @@ int main(int argc, char* argv[]) {
   Simplex_tree simplex_tree;
 
   rips_complex_from_file.create_complex(simplex_tree, dim_max);
-  std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
-  std::cout << "   and has dimension " << simplex_tree.dimension() << " \n";
+  std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
+  std::clog << "   and has dimension " << simplex_tree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
   simplex_tree.initialize_filtration();
@@ -82,7 +82,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 std::clog")(
       "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.")(
@@ -105,17 +105,17 @@ void program_options(int argc, char* argv[], std::string& csv_matrix_file, std::
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a Rips complex defined on a set of distance matrix.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a Rips complex defined on a set of distance matrix.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Rips_complex/utilities/rips_persistence.cpp b/src/Rips_complex/utilities/rips_persistence.cpp
index daa7e1db..4cc63d3c 100644
--- a/src/Rips_complex/utilities/rips_persistence.cpp
+++ b/src/Rips_complex/utilities/rips_persistence.cpp
@@ -49,8 +49,8 @@ int main(int argc, char* argv[]) {
   Simplex_tree simplex_tree;
 
   rips_complex_from_file.create_complex(simplex_tree, dim_max);
-  std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
-  std::cout << "   and has dimension " << simplex_tree.dimension() << " \n";
+  std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
+  std::clog << "   and has dimension " << simplex_tree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
   simplex_tree.initialize_filtration();
@@ -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::cout")(
+      "Name of file in which the persistence diagram is written. Default print in std::clog")(
       "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.")(
@@ -107,17 +107,17 @@ void program_options(int argc, char* argv[], std::string& off_file_points, std::
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a Rips complex defined on a set of input points.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a Rips complex defined on a set of input points.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Rips_complex/utilities/sparse_rips_persistence.cpp b/src/Rips_complex/utilities/sparse_rips_persistence.cpp
index cefd8a67..40606158 100644
--- a/src/Rips_complex/utilities/sparse_rips_persistence.cpp
+++ b/src/Rips_complex/utilities/sparse_rips_persistence.cpp
@@ -51,8 +51,8 @@ int main(int argc, char* argv[]) {
   Simplex_tree simplex_tree;
 
   sparse_rips.create_complex(simplex_tree, dim_max);
-  std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
-  std::cout << "   and has dimension " << simplex_tree.dimension() << " \n";
+  std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
+  std::clog << "   and has dimension " << simplex_tree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
   simplex_tree.initialize_filtration();
@@ -87,7 +87,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 std::clog")(
       "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.")(
@@ -112,17 +112,17 @@ void program_options(int argc, char* argv[], std::string& off_file_points, std::
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a sparse 1/(1-epsilon)-approximation of the Rips complex \ndefined on a set of input points.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a sparse 1/(1-epsilon)-approximation of the Rips complex \ndefined on a set of input points.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/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;
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h
index 76608008..430d1ac4 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h
@@ -24,6 +24,7 @@
 #include <boost/iterator/transform_iterator.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/range/adaptor/reversed.hpp>
+#include <boost/container/static_vector.hpp>
 
 #ifdef GUDHI_USE_TBB
 #include <tbb/parallel_sort.h>
@@ -246,8 +247,8 @@ class Simplex_tree {
    * which is consequenlty
    * equal to \f$(-1)^{\text{dim} \sigma}\f$ the canonical orientation on the simplex.
    */
-  Simplex_vertex_range simplex_vertex_range(Simplex_handle sh) {
-    assert(sh != null_simplex());  // Empty simplex
+  Simplex_vertex_range simplex_vertex_range(Simplex_handle sh) const {
+    GUDHI_CHECK(sh != null_simplex(), "empty simplex");
     return Simplex_vertex_range(Simplex_vertex_iterator(this, sh),
                                 Simplex_vertex_iterator(this));
   }
@@ -286,7 +287,7 @@ class Simplex_tree {
   /** \brief User-defined copy constructor reproduces the whole tree structure. */
   Simplex_tree(const Simplex_tree& complex_source) {
 #ifdef DEBUG_TRACES
-    std::cout << "Simplex_tree copy constructor" << std::endl;
+    std::clog << "Simplex_tree copy constructor" << std::endl;
 #endif  // DEBUG_TRACES
     copy_from(complex_source);
   }
@@ -296,7 +297,7 @@ class Simplex_tree {
    */
   Simplex_tree(Simplex_tree && complex_source) {
 #ifdef DEBUG_TRACES
-    std::cout << "Simplex_tree move constructor" << std::endl;
+    std::clog << "Simplex_tree move constructor" << std::endl;
 #endif  // DEBUG_TRACES
     move_from(complex_source);
 
@@ -313,7 +314,7 @@ class Simplex_tree {
   /** \brief User-defined copy assignment reproduces the whole tree structure. */
   Simplex_tree& operator= (const Simplex_tree& complex_source) {
 #ifdef DEBUG_TRACES
-    std::cout << "Simplex_tree copy assignment" << std::endl;
+    std::clog << "Simplex_tree copy assignment" << std::endl;
 #endif  // DEBUG_TRACES
     // Self-assignment detection
     if (&complex_source != this) {
@@ -330,7 +331,7 @@ class Simplex_tree {
    */
   Simplex_tree& operator=(Simplex_tree&& complex_source) {
 #ifdef DEBUG_TRACES
-    std::cout << "Simplex_tree move assignment" << std::endl;
+    std::clog << "Simplex_tree move assignment" << std::endl;
 #endif  // DEBUG_TRACES
     // Self-assignment detection
     if (&complex_source != this) {
@@ -450,6 +451,15 @@ class Simplex_tree {
     return true;
   }
 
+  /** \brief Returns the filtration value of a simplex.
+   *
+   * Same as `filtration()`, but does not handle `null_simplex()`.
+   */
+  static Filtration_value filtration_(Simplex_handle sh) {
+    GUDHI_CHECK (sh != null_simplex(), "null simplex");
+    return sh->second.filtration();
+  }
+
  public:
   /** \brief Returns the key associated to a simplex.
    *
@@ -755,12 +765,7 @@ class Simplex_tree {
     if (first == last)
       return { null_simplex(), true }; // FIXME: false would make more sense to me.
 
-    // Copy before sorting
-    // Thread local is not available on XCode version < V.8 - It will slow down computation
-#ifdef GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    thread_local
-#endif  // GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    std::vector<Vertex_handle> copy;
+    thread_local std::vector<Vertex_handle> copy;
     copy.clear();
     copy.insert(copy.end(), first, last);
     std::sort(copy.begin(), copy.end());
@@ -827,7 +832,7 @@ class Simplex_tree {
 
   /** Returns the Siblings containing a simplex.*/
   template<class SimplexHandle>
-  Siblings* self_siblings(SimplexHandle sh) {
+  static Siblings* self_siblings(SimplexHandle sh) {
     if (sh->second.children()->parent() == sh->first)
       return sh->second.children()->oncles();
     else
@@ -1123,10 +1128,7 @@ class Simplex_tree {
     Dictionary_it next = siblings->members().begin();
     ++next;
 
-#ifdef GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    thread_local
-#endif  // GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    std::vector<std::pair<Vertex_handle, Node> > inter;
+    thread_local std::vector<std::pair<Vertex_handle, Node> > inter;
     for (Dictionary_it s_h = siblings->members().begin();
          s_h != siblings->members().end(); ++s_h, ++next) {
       Simplex_handle root_sh = find_vertex(s_h->first);
@@ -1317,6 +1319,8 @@ class Simplex_tree {
    * \post Some simplex tree functions require the filtration to be valid. `make_filtration_non_decreasing()`
    * function is not launching `initialize_filtration()` but returns the filtration modification information. If the
    * complex has changed , please call `initialize_filtration()` to recompute it.
+   * 
+   * If a simplex has a `NaN` filtration value, it is considered lower than any other defined filtration value.
    */
   bool make_filtration_non_decreasing() {
     bool modified = false;
@@ -1347,7 +1351,9 @@ class Simplex_tree {
                                                               });
 
       Filtration_value max_filt_border_value = filtration(*max_border);
-      if (simplex.second.filtration() < max_filt_border_value) {
+      // Replacing if(f<max) with if(!(f>=max)) would mean that if f is NaN, we replace it with the max of the children.
+      // That seems more useful than keeping NaN.
+      if (!(simplex.second.filtration() >= max_filt_border_value)) {
         // Store the filtration modification information
         modified = true;
         simplex.second.assign_filtration(max_filt_border_value);
@@ -1418,9 +1424,9 @@ class Simplex_tree {
     for (Simplex_handle sh : complex_simplex_range()) {
 #ifdef DEBUG_TRACES
       for (auto vertex : simplex_vertex_range(sh)) {
-        std::cout << " " << vertex;
+        std::clog << " " << vertex;
       }
-      std::cout << std::endl;
+      std::clog << std::endl;
 #endif  // DEBUG_TRACES
 
       int sh_dimension = dimension(sh);
@@ -1465,6 +1471,66 @@ class Simplex_tree {
     }
   }
 
+  /** \brief Returns a vertex of `sh` that has the same filtration value as `sh` if it exists, and `null_vertex()` otherwise.
+   *
+   * For a lower-star filtration built with `make_filtration_non_decreasing()`, this is a way to invert the process and find out which vertex had its filtration value propagated to `sh`.
+   * If several vertices have the same filtration value, the one it returns is arbitrary. */
+  Vertex_handle vertex_with_same_filtration(Simplex_handle sh) {
+    auto filt = filtration_(sh);
+    for(auto v : simplex_vertex_range(sh))
+      if(filtration_(find_vertex(v)) == filt)
+        return v;
+    return null_vertex();
+  }
+
+  /** \brief Returns an edge of `sh` that has the same filtration value as `sh` if it exists, and `null_simplex()` otherwise.
+   *
+   * For a flag-complex built with `expansion()`, this is a way to invert the process and find out which edge had its filtration value propagated to `sh`.
+   * If several edges have the same filtration value, the one it returns is arbitrary.
+   *
+   * \pre `sh` must have dimension at least 1. */
+  Simplex_handle edge_with_same_filtration(Simplex_handle sh) {
+    // See issue #251 for potential speed improvements.
+    auto&& vertices = simplex_vertex_range(sh); // vertices in decreasing order
+    auto end = std::end(vertices);
+    auto vi = std::begin(vertices);
+    GUDHI_CHECK(vi != end, "empty simplex");
+    auto v0 = *vi;
+    ++vi;
+    GUDHI_CHECK(vi != end, "simplex of dimension 0");
+    if(std::next(vi) == end) return sh; // shortcut for dimension 1
+    boost::container::static_vector<Vertex_handle, 40> suffix;
+    suffix.push_back(v0);
+    auto filt = filtration_(sh);
+    do
+    {
+      Vertex_handle v = *vi;
+      auto&& children1 = find_vertex(v)->second.children()->members_;
+      for(auto w : suffix){
+        // Can we take advantage of the fact that suffix is ordered?
+        Simplex_handle s = children1.find(w);
+        if(filtration_(s) == filt)
+          return s;
+      }
+      suffix.push_back(v);
+    }
+    while(++vi != end);
+    return null_simplex();
+  }
+
+  /** \brief Returns a minimal face of `sh` that has the same filtration value as `sh`.
+   *
+   * For a filtration built with `make_filtration_non_decreasing()`, this is a way to invert the process and find out which simplex had its filtration value propagated to `sh`.
+   * If several minimal (for inclusion) simplices have the same filtration value, the one it returns is arbitrary, and it is not guaranteed to be the one with smallest dimension. */
+  Simplex_handle minimal_simplex_with_same_filtration(Simplex_handle sh) {
+    auto filt = filtration_(sh);
+    // Naive implementation, it can be sped up.
+    for(auto b : boundary_simplex_range(sh))
+      if(filtration_(b) == filt)
+        return minimal_simplex_with_same_filtration(b);
+    return sh; // None of its faces has the same filtration.
+  }
+
  private:
   Vertex_handle null_vertex_;
   /** \brief Total number of simplices in the complex, without the empty simplex.*/
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h
index efccf2f2..9007b6bd 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h
@@ -15,9 +15,7 @@
 
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/version.hpp>
-#if BOOST_VERSION >= 105600
-# include <boost/container/static_vector.hpp>
-#endif
+#include <boost/container/static_vector.hpp>
 
 #include <vector>
 
@@ -42,13 +40,13 @@ class Simplex_tree_simplex_vertex_iterator : public boost::iterator_facade<
   typedef typename SimplexTree::Siblings Siblings;
   typedef typename SimplexTree::Vertex_handle Vertex_handle;
 
-  explicit Simplex_tree_simplex_vertex_iterator(SimplexTree * st)
+  explicit Simplex_tree_simplex_vertex_iterator(SimplexTree const* st)
       :  // any end() iterator
         sib_(nullptr),
         v_(st->null_vertex()) {
   }
 
-  Simplex_tree_simplex_vertex_iterator(SimplexTree * st, Simplex_handle sh)
+  Simplex_tree_simplex_vertex_iterator(SimplexTree const* st, Simplex_handle sh)
       : sib_(st->self_siblings(sh)),
         v_(sh->first) {
   }
@@ -166,15 +164,11 @@ class Simplex_tree_boundary_simplex_iterator : public boost::iterator_facade<
   // Most of the storage should be moved to the range, iterators should be light.
   Vertex_handle last_;  // last vertex of the simplex
   Vertex_handle next_;  // next vertex to push in suffix_
-#if BOOST_VERSION >= 105600
   // 40 seems a conservative bound on the dimension of a Simplex_tree for now,
   // as it would not fit on the biggest hard-drive.
   boost::container::static_vector<Vertex_handle, 40> suffix_;
   // static_vector still has some overhead compared to a trivial hand-made
   // version using std::aligned_storage, or compared to making suffix_ static.
-#else
-  std::vector<Vertex_handle> suffix_;
-#endif
   Siblings * sib_;  // where the next search will start from
   Simplex_handle sh_;  // current Simplex_handle in the boundary
   SimplexTree * st_;  // simplex containing the simplicial complex
diff --git a/src/Simplex_tree/test/CMakeLists.txt b/src/Simplex_tree/test/CMakeLists.txt
index 8b9163f5..cf2b0153 100644
--- a/src/Simplex_tree/test/CMakeLists.txt
+++ b/src/Simplex_tree/test/CMakeLists.txt
@@ -28,3 +28,9 @@ if (TBB_FOUND)
   target_link_libraries(Simplex_tree_ctor_and_move_test_unit ${TBB_LIBRARIES})
 endif()
 gudhi_add_boost_test(Simplex_tree_ctor_and_move_test_unit)
+
+add_executable ( Simplex_tree_make_filtration_non_decreasing_test_unit simplex_tree_make_filtration_non_decreasing_unit_test.cpp )
+if (TBB_FOUND)
+  target_link_libraries(Simplex_tree_make_filtration_non_decreasing_test_unit ${TBB_LIBRARIES})
+endif()
+gudhi_add_boost_test(Simplex_tree_make_filtration_non_decreasing_test_unit)
diff --git a/src/Simplex_tree/test/simplex_tree_ctor_and_move_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_ctor_and_move_unit_test.cpp
index c0615b12..229ae46f 100644
--- a/src/Simplex_tree/test/simplex_tree_ctor_and_move_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_ctor_and_move_unit_test.cpp
@@ -30,16 +30,16 @@ void print_simplex_filtration(Simplex_tree& st, const std::string& msg) {
   // Required before browsing through filtration values
   st.initialize_filtration();
 
-  std::cout << "********************************************************************\n";
-  std::cout << "* " << msg << "\n";
-  std::cout << "* The complex contains " << st.num_simplices() << " simplices";
-  std::cout << "   - dimension " << st.dimension() << "\n";
-  std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "* " << msg << "\n";
+  std::clog << "* The complex contains " << st.num_simplices() << " simplices";
+  std::clog << "   - 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 << "(" << vertex << ")";
-    std::cout << std::endl;
+    for (auto vertex : st.simplex_vertex_range(f_simplex)) std::clog << "(" << vertex << ")";
+    std::clog << std::endl;
   }
 
 }
@@ -70,8 +70,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_copy_constructor, Simplex_tree, list_of_te
 
   print_simplex_filtration(st, "Default Simplex_tree is initialized");
 
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF COPY CONSTRUCTOR" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF COPY CONSTRUCTOR" << std::endl;
 
   Simplex_tree st1(st);
   Simplex_tree st2(st);
@@ -82,8 +82,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_copy_constructor, Simplex_tree, list_of_te
   BOOST_CHECK(st == st2);
   BOOST_CHECK(st1 == st);
 
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF COPY ASSIGNMENT" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF COPY ASSIGNMENT" << std::endl;
   Simplex_tree st3;
   // To check there is no memory leak
   st3.insert_simplex_and_subfaces({9, 10, 11}, 200.0);
@@ -103,8 +103,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_copy_constructor, Simplex_tree, list_of_te
 
   BOOST_CHECK(st3 == st);
 
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF MOVE CONSTRUCTOR" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF MOVE CONSTRUCTOR" << std::endl;
   Simplex_tree st5(std::move(st1));
   print_simplex_filtration(st5, "First move constructor from the default Simplex_tree");
   print_simplex_filtration(st1, "First moved Simplex_tree shall be empty");
@@ -122,8 +122,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_copy_constructor, Simplex_tree, list_of_te
   BOOST_CHECK(empty_st == st2);
   BOOST_CHECK(st1 == empty_st);
 
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF MOVE ASSIGNMENT" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF MOVE ASSIGNMENT" << std::endl;
 
   Simplex_tree st7;
   // To check there is no memory leak
diff --git a/src/Simplex_tree/test/simplex_tree_graph_expansion_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_graph_expansion_unit_test.cpp
index fab25eb8..881a06ae 100644
--- a/src/Simplex_tree/test/simplex_tree_graph_expansion_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_graph_expansion_unit_test.cpp
@@ -55,34 +55,34 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_expansion_with_blockers_3, typeST, li
 
   simplex_tree.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 : simplex_tree.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 << "] ( " << simplex_tree.filtration(sh);
+      std::clog << "] ( " << simplex_tree.filtration(sh);
       // User can re-assign a new filtration value directly in the blocker (default is the maximal value of boudaries)
       simplex_tree.assign_filtration(sh, simplex_tree.filtration(sh) + 1.);
 
-      std::cout << " + 1. ) = " << result << std::endl;
+      std::clog << " + 1. ) = " << result << std::endl;
 
       return result;
     });
 
-  std::cout << "********************************************************************\n";
-  std::cout << "simplex_tree_expansion_with_blockers_3\n";
-  std::cout << "********************************************************************\n";
-  std::cout << "* The complex contains " << simplex_tree.num_simplices() << " simplices";
-  std::cout << " - dimension " << simplex_tree.dimension() << "\n";
-  std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "simplex_tree_expansion_with_blockers_3\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "* The complex contains " << simplex_tree.num_simplices() << " simplices";
+  std::clog << " - dimension " << simplex_tree.dimension() << "\n";
+  std::clog << "* 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::cout << std::endl;
+      std::clog << "(" << vertex << ")";
+    std::clog << std::endl;
   }
 
   BOOST_CHECK(simplex_tree.num_simplices() == 23);
@@ -117,34 +117,34 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_expansion_with_blockers_2, typeST, li
 
   simplex_tree.expansion_with_blockers(2, [&](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 : simplex_tree.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 << "] ( " << simplex_tree.filtration(sh);
+      std::clog << "] ( " << simplex_tree.filtration(sh);
       // User can re-assign a new filtration value directly in the blocker (default is the maximal value of boudaries)
       simplex_tree.assign_filtration(sh, simplex_tree.filtration(sh) + 1.);
 
-      std::cout << " + 1. ) = " << result << std::endl;
+      std::clog << " + 1. ) = " << result << std::endl;
 
       return result;
     });
 
-  std::cout << "********************************************************************\n";
-  std::cout << "simplex_tree_expansion_with_blockers_2\n";
-  std::cout << "********************************************************************\n";
-  std::cout << "* The complex contains " << simplex_tree.num_simplices() << " simplices";
-  std::cout << " - dimension " << simplex_tree.dimension() << "\n";
-  std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "simplex_tree_expansion_with_blockers_2\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "* The complex contains " << simplex_tree.num_simplices() << " simplices";
+  std::clog << " - dimension " << simplex_tree.dimension() << "\n";
+  std::clog << "* 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::cout << std::endl;
+      std::clog << "(" << vertex << ")";
+    std::clog << std::endl;
   }
 
   BOOST_CHECK(simplex_tree.num_simplices() == 22);
@@ -176,17 +176,17 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_expansion, typeST, list_of_tested_var
   simplex_tree.insert_simplex({6}, 10.);
 
   simplex_tree.expansion(3);
-  std::cout << "********************************************************************\n";
-  std::cout << "simplex_tree_expansion_3\n";
-  std::cout << "********************************************************************\n";
-  std::cout << "* The complex contains " << simplex_tree.num_simplices() << " simplices";
-  std::cout << " - dimension " << simplex_tree.dimension() << "\n";
-  std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "simplex_tree_expansion_3\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "* The complex contains " << simplex_tree.num_simplices() << " simplices";
+  std::clog << " - dimension " << simplex_tree.dimension() << "\n";
+  std::clog << "* 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::cout << std::endl;
+      std::clog << "(" << vertex << ")";
+    std::clog << std::endl;
   }
 
   BOOST_CHECK(simplex_tree.num_simplices() == 24);
@@ -220,17 +220,17 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_expansion_2, typeST, list_of_tested_v
 
   simplex_tree.expansion(2);
 
-  std::cout << "********************************************************************\n";
-  std::cout << "simplex_tree_expansion_2\n";
-  std::cout << "********************************************************************\n";
-  std::cout << "* The complex contains " << simplex_tree.num_simplices() << " simplices";
-  std::cout << " - dimension " << simplex_tree.dimension() << "\n";
-  std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "simplex_tree_expansion_2\n";
+  std::clog << "********************************************************************\n";
+  std::clog << "* The complex contains " << simplex_tree.num_simplices() << " simplices";
+  std::clog << " - dimension " << simplex_tree.dimension() << "\n";
+  std::clog << "* 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::cout << std::endl;
+      std::clog << "(" << vertex << ")";
+    std::clog << std::endl;
   }
 
   BOOST_CHECK(simplex_tree.num_simplices() == 23);
diff --git a/src/Simplex_tree/test/simplex_tree_iostream_operator_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_iostream_operator_unit_test.cpp
index 28c29489..20007488 100644
--- a/src/Simplex_tree/test/simplex_tree_iostream_operator_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_iostream_operator_unit_test.cpp
@@ -34,8 +34,8 @@ typedef boost::mpl::list<Simplex_tree<>,
                         > list_of_tested_variants;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(iostream_operator, Stree_type, list_of_tested_variants) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "SIMPLEX TREE IOSTREAM OPERATOR" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "SIMPLEX TREE IOSTREAM OPERATOR" << std::endl;
 
   Stree_type st;
 
@@ -46,15 +46,15 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(iostream_operator, Stree_type, list_of_tested_vari
 
   st.initialize_filtration();
   // Display the Simplex_tree
-  std::cout << "The ORIGINAL complex contains " << st.num_simplices() << " simplices - dimension = "
+  std::clog << "The ORIGINAL complex contains " << st.num_simplices() << " simplices - dimension = "
             << st.dimension() << std::endl;
-  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+  std::clog << std::endl << std::endl << "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 << (int) vertex << " ";
+      std::clog << (int) vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   // st:
@@ -75,15 +75,15 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(iostream_operator, Stree_type, list_of_tested_vari
   simplex_tree_istream >> read_st;
 
   // Display the Simplex_tree
-  std::cout << "The READ complex contains " << read_st.num_simplices() << " simplices - dimension = "
+  std::clog << "The READ complex contains " << read_st.num_simplices() << " simplices - dimension = "
             << read_st.dimension() << std::endl;
-  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+  std::clog << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
   for (auto f_simplex : read_st.filtration_simplex_range()) {
-    std::cout << "   " << "[" << read_st.filtration(f_simplex) << "] ";
+    std::clog << "   " << "[" << read_st.filtration(f_simplex) << "] ";
     for (auto vertex : read_st.simplex_vertex_range(f_simplex)) {
-      std::cout << (int) vertex << " ";
+      std::clog << (int) vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   BOOST_CHECK(st == read_st);
@@ -91,8 +91,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(iostream_operator, Stree_type, list_of_tested_vari
 
 
 BOOST_AUTO_TEST_CASE(mini_iostream_operator) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "MINI SIMPLEX TREE IOSTREAM OPERATOR" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "MINI SIMPLEX TREE IOSTREAM OPERATOR" << std::endl;
 
   Simplex_tree<MyOptions> st;
 
@@ -103,14 +103,14 @@ BOOST_AUTO_TEST_CASE(mini_iostream_operator) {
 
   st.initialize_filtration();
   // Display the Simplex_tree
-  std::cout << "The ORIGINAL complex contains " << st.num_simplices() << " simplices - dimension = "
+  std::clog << "The ORIGINAL complex contains " << st.num_simplices() << " simplices - dimension = "
             << st.dimension() << 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 << (int) vertex << " ";
+      std::clog << (int) vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   // st:
@@ -131,15 +131,15 @@ BOOST_AUTO_TEST_CASE(mini_iostream_operator) {
   simplex_tree_istream >> read_st;
 
   // Display the Simplex_tree
-  std::cout << "The READ complex contains " << read_st.num_simplices() << " simplices - dimension = "
+  std::clog << "The READ complex contains " << read_st.num_simplices() << " simplices - dimension = "
             << read_st.dimension() << std::endl;
-  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+  std::clog << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
   for (auto f_simplex : read_st.filtration_simplex_range()) {
-    std::cout << "   " << "[" << read_st.filtration(f_simplex) << "] ";
+    std::clog << "   " << "[" << read_st.filtration(f_simplex) << "] ";
     for (auto vertex : read_st.simplex_vertex_range(f_simplex)) {
-      std::cout << (int) vertex << " ";
+      std::clog << (int) vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   BOOST_CHECK(st == read_st);
diff --git a/src/Simplex_tree/test/simplex_tree_make_filtration_non_decreasing_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_make_filtration_non_decreasing_unit_test.cpp
new file mode 100644
index 00000000..e0e7cadf
--- /dev/null
+++ b/src/Simplex_tree/test/simplex_tree_make_filtration_non_decreasing_unit_test.cpp
@@ -0,0 +1,148 @@
+/*    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
+ */
+
+#include <iostream>
+#include <limits>  // for NaN
+#include <cmath>  // for isNaN
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "simplex_tree_make_filtration_non_decreasing"
+#include <boost/test/unit_test.hpp>
+#include <boost/mpl/list.hpp>
+
+//  ^
+// /!\ Nothing else from Simplex_tree shall be included to test includes are well defined.
+#include "gudhi/Simplex_tree.h"
+
+using namespace Gudhi;
+
+typedef boost::mpl::list<Simplex_tree<>, Simplex_tree<Simplex_tree_options_fast_persistence>> list_of_tested_variants;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(make_filtration_non_decreasing, typeST, list_of_tested_variants) {
+  typeST st;
+
+  st.insert_simplex_and_subfaces({2, 1, 0}, 2.0);
+  st.insert_simplex_and_subfaces({3, 0}, 2.0);
+  st.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
+  
+  /* Inserted simplex:     */
+  /*    1                  */
+  /*    o                  */
+  /*   /X\                 */
+  /*  o---o---o---o        */
+  /*  2   0   3\X/4        */
+  /*            o          */
+  /*            5          */
+
+  std::clog << "Check default insertion ensures the filtration values are non decreasing" << std::endl;
+  BOOST_CHECK(!st.make_filtration_non_decreasing());
+
+  // Because of non decreasing property of simplex tree, { 0 } , { 1 } and { 0, 1 } are going to be set from value 2.0
+  // to 1.0
+  st.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
+  
+  // Inserted simplex:
+  //    1   6
+  //    o---o
+  //   /X\7/
+  //  o---o---o---o
+  //  2   0   3\X/4
+  //            o
+  //            5
+  
+  std::clog << "Check default second insertion ensures the filtration values are non decreasing" << std::endl;
+  BOOST_CHECK(!st.make_filtration_non_decreasing());
+  
+  // Copy original simplex tree
+  typeST st_copy = st;
+
+  // Modify specific values for st to become like st_copy thanks to make_filtration_non_decreasing
+  st.assign_filtration(st.find({0,1,6,7}), 0.8);
+  st.assign_filtration(st.find({0,1,6}), 0.9);
+  st.assign_filtration(st.find({0,6}), 0.6);
+  st.assign_filtration(st.find({3,4,5}), 1.2);
+  st.assign_filtration(st.find({3,4}), 1.1);
+  st.assign_filtration(st.find({4,5}), 1.99);
+  
+  std::clog << "Check the simplex_tree is rolled back in case of decreasing filtration values" << std::endl;
+  BOOST_CHECK(st.make_filtration_non_decreasing());
+  BOOST_CHECK(st == st_copy);
+
+  // Other simplex tree
+  typeST st_other;
+  st_other.insert_simplex_and_subfaces({2, 1, 0}, 3.0);  // This one is different from st
+  st_other.insert_simplex_and_subfaces({3, 0}, 2.0);
+  st_other.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
+  st_other.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
+
+  // Modify specific values for st to become like st_other thanks to make_filtration_non_decreasing
+  st.assign_filtration(st.find({2}), 3.0);
+  // By modifying just the simplex {2}
+  // {0,1,2}, {1,2} and {0,2} will be modified
+  
+  std::clog << "Check the simplex_tree is repaired in case of decreasing filtration values" << std::endl;
+  BOOST_CHECK(st.make_filtration_non_decreasing());
+  BOOST_CHECK(st == st_other);
+
+  // Modify specific values for st still to be non-decreasing
+  st.assign_filtration(st.find({0,1,2}), 10.0);
+  st.assign_filtration(st.find({0,2}), 9.0);
+  st.assign_filtration(st.find({0,1,6,7}), 50.0);
+  st.assign_filtration(st.find({0,1,6}), 49.0);
+  st.assign_filtration(st.find({0,1,7}), 48.0);
+  // Other copy simplex tree
+  typeST st_other_copy = st;
+  
+  std::clog << "Check the simplex_tree is not modified in case of non-decreasing filtration values" << std::endl;
+  BOOST_CHECK(!st.make_filtration_non_decreasing());
+  BOOST_CHECK(st == st_other_copy);
+  
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(make_filtration_non_decreasing_on_nan_values, typeST, list_of_tested_variants) {
+  typeST st;
+
+  st.insert_simplex_and_subfaces({2, 1, 0}, std::numeric_limits<double>::quiet_NaN());
+  st.insert_simplex_and_subfaces({3, 0},    std::numeric_limits<double>::quiet_NaN());
+  st.insert_simplex_and_subfaces({3, 4, 5}, std::numeric_limits<double>::quiet_NaN());
+  
+  /* Inserted simplex:     */
+  /*    1                  */
+  /*    o                  */
+  /*   /X\                 */
+  /*  o---o---o---o        */
+  /*  2   0   3\X/4        */
+  /*            o          */
+  /*            5          */
+
+  std::clog << "SPECIFIC CASE:" << std::endl;
+  std::clog << "Insertion with NaN values does not ensure the filtration values are non decreasing" << std::endl;
+  st.make_filtration_non_decreasing();
+
+  std::clog << "Check all filtration values are NaN" << std::endl;
+  for (auto f_simplex : st.complex_simplex_range()) {
+    BOOST_CHECK(std::isnan(st.filtration(f_simplex)));
+  }
+
+  st.assign_filtration(st.find({0}), 0.);
+  st.assign_filtration(st.find({1}), 0.);
+  st.assign_filtration(st.find({2}), 0.);
+  st.assign_filtration(st.find({3}), 0.);
+  st.assign_filtration(st.find({4}), 0.);
+  st.assign_filtration(st.find({5}), 0.);
+
+  std::clog << "Check make_filtration_non_decreasing is modifying the simplicial complex" << std::endl;
+  BOOST_CHECK(st.make_filtration_non_decreasing());
+  
+  std::clog << "Check all filtration values are now defined" << std::endl;
+  for (auto f_simplex : st.complex_simplex_range()) {
+    BOOST_CHECK(!std::isnan(st.filtration(f_simplex)));
+  }
+}
diff --git a/src/Simplex_tree/test/simplex_tree_remove_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_remove_unit_test.cpp
index 97347992..36b8b3c6 100644
--- a/src/Simplex_tree/test/simplex_tree_remove_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_remove_unit_test.cpp
@@ -32,8 +32,8 @@ using Mini_stree = Simplex_tree<MyOptions>;
 using Stree = Simplex_tree<>;
 
 BOOST_AUTO_TEST_CASE(remove_maximal_simplex) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "REMOVE MAXIMAL SIMPLEX" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "REMOVE MAXIMAL SIMPLEX" << std::endl;
 
   Mini_stree st;
 
@@ -66,21 +66,21 @@ BOOST_AUTO_TEST_CASE(remove_maximal_simplex) {
   //            5
 
 #ifdef GUDHI_DEBUG
-  std::cout << "Check exception throw in debug mode" << std::endl;
+  std::clog << "Check exception throw in debug mode" << std::endl;
   // throw excpt because sh has children
   BOOST_CHECK_THROW (st.remove_maximal_simplex(st.find({0, 1, 6})), std::invalid_argument);
   BOOST_CHECK_THROW (st.remove_maximal_simplex(st.find({3})), std::invalid_argument);
   BOOST_CHECK(st == st_complete);
 #endif
-  std::cout << "st.remove_maximal_simplex({0, 2})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({0, 2})" << std::endl;
   st.remove_maximal_simplex(st.find({0, 2}));
-  std::cout << "st.remove_maximal_simplex({0, 1, 2})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({0, 1, 2})" << std::endl;
   st.remove_maximal_simplex(st.find({0, 1, 2}));
-  std::cout << "st.remove_maximal_simplex({1, 2})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({1, 2})" << std::endl;
   st.remove_maximal_simplex(st.find({1, 2}));
-  std::cout << "st.remove_maximal_simplex({2})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({2})" << std::endl;
   st.remove_maximal_simplex(st.find({2}));
-  std::cout << "st.remove_maximal_simplex({3})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({3})" << std::endl;
   st.remove_maximal_simplex(st.find({0, 3}));
   
   BOOST_CHECK(st == st_pruned);
@@ -102,39 +102,39 @@ BOOST_AUTO_TEST_CASE(remove_maximal_simplex) {
   //            5
 
   // Remove all 7 to test the both remove_maximal_simplex cases (when _members is empty or not)
-  std::cout << "st.remove_maximal_simplex({0, 1, 6, 7})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({0, 1, 6, 7})" << std::endl;
   st.remove_maximal_simplex(st.find({0, 1, 6, 7}));
-  std::cout << "st.remove_maximal_simplex({0, 1, 7})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({0, 1, 7})" << std::endl;
   st.remove_maximal_simplex(st.find({0, 1, 7}));
-  std::cout << "st.remove_maximal_simplex({0, 6, 7})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({0, 6, 7})" << std::endl;
   st.remove_maximal_simplex(st.find({0, 6, 7}));
-  std::cout << "st.remove_maximal_simplex({0, 7})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({0, 7})" << std::endl;
   st.remove_maximal_simplex(st.find({0, 7}));
-  std::cout << "st.remove_maximal_simplex({1, 6, 7})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({1, 6, 7})" << std::endl;
   st.remove_maximal_simplex(st.find({1, 6, 7}));
-  std::cout << "st.remove_maximal_simplex({1, 7})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({1, 7})" << std::endl;
   st.remove_maximal_simplex(st.find({1, 7}));
-  std::cout << "st.remove_maximal_simplex({6, 7})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({6, 7})" << std::endl;
   st.remove_maximal_simplex(st.find({6, 7}));
-  std::cout << "st.remove_maximal_simplex({7})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({7})" << std::endl;
   st.remove_maximal_simplex(st.find({7}));
 
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
 
   // Check dimension calls lower_upper_bound_dimension to recompute dimension
   BOOST_CHECK(st.dimension() == 2);
   BOOST_CHECK(st.upper_bound_dimension() == 2);
 
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension()
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension()
             << " | st_wo_seven.upper_bound_dimension()=" << st_wo_seven.upper_bound_dimension() << std::endl;
-  std::cout << "st.dimension()=" << st.dimension() << " | st_wo_seven.dimension()=" << st_wo_seven.dimension() << std::endl;
+  std::clog << "st.dimension()=" << st.dimension() << " | st_wo_seven.dimension()=" << st_wo_seven.dimension() << std::endl;
   BOOST_CHECK(st == st_wo_seven);
 }
 
 BOOST_AUTO_TEST_CASE(auto_dimension_set) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "DIMENSION ON REMOVE MAXIMAL SIMPLEX" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "DIMENSION ON REMOVE MAXIMAL SIMPLEX" << std::endl;
 
   Mini_stree st;
 
@@ -148,80 +148,80 @@ BOOST_AUTO_TEST_CASE(auto_dimension_set) {
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
-  std::cout << "st.remove_maximal_simplex({6, 7, 8, 10})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({6, 7, 8, 10})" << std::endl;
   st.remove_maximal_simplex(st.find({6, 7, 8, 10}));
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
-  std::cout << "st.remove_maximal_simplex({6, 7, 8, 9})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({6, 7, 8, 9})" << std::endl;
   st.remove_maximal_simplex(st.find({6, 7, 8, 9}));
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
-  std::cout << "st.remove_maximal_simplex({1, 2, 3, 4})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({1, 2, 3, 4})" << std::endl;
   st.remove_maximal_simplex(st.find({1, 2, 3, 4}));
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
-  std::cout << "st.remove_maximal_simplex({1, 2, 3, 5})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({1, 2, 3, 5})" << std::endl;
   st.remove_maximal_simplex(st.find({1, 2, 3, 5}));
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 2);
-  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+  std::clog << "st.dimension()=" << st.dimension() << std::endl;
 
-  std::cout << "st.insert_simplex_and_subfaces({1, 2, 3, 5})" << std::endl;
+  std::clog << "st.insert_simplex_and_subfaces({1, 2, 3, 5})" << std::endl;
   st.insert_simplex_and_subfaces({1, 2, 3, 5});
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
-  std::cout << "st.insert_simplex_and_subfaces({1, 2, 3, 4})" << std::endl;
+  std::clog << "st.insert_simplex_and_subfaces({1, 2, 3, 4})" << std::endl;
   st.insert_simplex_and_subfaces({1, 2, 3, 4});
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
 
-  std::cout << "st.remove_maximal_simplex({1, 2, 3, 5})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({1, 2, 3, 5})" << std::endl;
   st.remove_maximal_simplex(st.find({1, 2, 3, 5}));
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
 
-  std::cout << "st.remove_maximal_simplex({1, 2, 3, 4})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({1, 2, 3, 4})" << std::endl;
   st.remove_maximal_simplex(st.find({1, 2, 3, 4}));
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 2);
-  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+  std::clog << "st.dimension()=" << st.dimension() << std::endl;
 
-  std::cout << "st.insert_simplex_and_subfaces({0, 1, 3, 4})" << std::endl;
+  std::clog << "st.insert_simplex_and_subfaces({0, 1, 3, 4})" << std::endl;
   st.insert_simplex_and_subfaces({0, 1, 3, 4});
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
-  std::cout << "st.remove_maximal_simplex({0, 1, 3, 4})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({0, 1, 3, 4})" << std::endl;
   st.remove_maximal_simplex(st.find({0, 1, 3, 4}));
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 2);
-  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+  std::clog << "st.dimension()=" << st.dimension() << std::endl;
 
-  std::cout << "st.insert_simplex_and_subfaces({1, 2, 3, 5})" << std::endl;
+  std::clog << "st.insert_simplex_and_subfaces({1, 2, 3, 5})" << std::endl;
   st.insert_simplex_and_subfaces({1, 2, 3, 5});
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
-  std::cout << "st.insert_simplex_and_subfaces({1, 2, 3, 4})" << std::endl;
+  std::clog << "st.insert_simplex_and_subfaces({1, 2, 3, 4})" << std::endl;
   st.insert_simplex_and_subfaces({1, 2, 3, 4});
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
@@ -229,7 +229,7 @@ BOOST_AUTO_TEST_CASE(auto_dimension_set) {
   // Check you can override the dimension
   // This is a limit test case - shall not happen
   st.set_dimension(1);
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 1);
   // check dimension() and lower_upper_bound_dimension() is not giving the right answer because dimension is too low
   BOOST_CHECK(st.dimension() == 1);
@@ -238,7 +238,7 @@ BOOST_AUTO_TEST_CASE(auto_dimension_set) {
   // Check you can override the dimension
   // This is a limit test case - shall not happen
   st.set_dimension(6);
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 6);
   // check dimension() do not launch lower_upper_bound_dimension()
   BOOST_CHECK(st.dimension() == 6);
@@ -246,27 +246,27 @@ BOOST_AUTO_TEST_CASE(auto_dimension_set) {
 
   // Reset with the correct value
   st.set_dimension(3);
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
   BOOST_CHECK(st.dimension() == 3);
 
-  std::cout << "st.insert_simplex_and_subfaces({0, 1, 2, 3, 4, 5, 6})" << std::endl;
+  std::clog << "st.insert_simplex_and_subfaces({0, 1, 2, 3, 4, 5, 6})" << std::endl;
   st.insert_simplex_and_subfaces({0, 1, 2, 3, 4, 5, 6});
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 6);
   BOOST_CHECK(st.dimension() == 6);
 
-  std::cout << "st.remove_maximal_simplex({0, 1, 2, 3, 4, 5, 6})" << std::endl;
+  std::clog << "st.remove_maximal_simplex({0, 1, 2, 3, 4, 5, 6})" << std::endl;
   st.remove_maximal_simplex(st.find({0, 1, 2, 3, 4, 5, 6}));
-  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 6);
   BOOST_CHECK(st.dimension() == 5);
 
 }
 
 BOOST_AUTO_TEST_CASE(prune_above_filtration) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "PRUNE ABOVE FILTRATION" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "PRUNE ABOVE FILTRATION" << std::endl;
 
   Stree st;
 
@@ -321,15 +321,15 @@ BOOST_AUTO_TEST_CASE(prune_above_filtration) {
   BOOST_CHECK(!simplex_is_changed);
 
   // Display the Simplex_tree
-  std::cout << "The complex contains " << st.num_simplices() << " simplices";
-  std::cout << " - dimension " << st.dimension() << std::endl;
-  std::cout << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+  std::clog << "The complex contains " << st.num_simplices() << " simplices";
+  std::clog << " - dimension " << st.dimension() << 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 << (int) vertex << " ";
+      std::clog << (int) vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   // Check the pruned cases
@@ -340,15 +340,15 @@ BOOST_AUTO_TEST_CASE(prune_above_filtration) {
   BOOST_CHECK(simplex_is_changed);
 
   // Display the Simplex_tree
-  std::cout << "The complex pruned at 2.5 contains " << st.num_simplices() << " simplices";
-  std::cout << " - dimension " << st.dimension() << std::endl;
+  std::clog << "The complex pruned at 2.5 contains " << st.num_simplices() << " simplices";
+  std::clog << " - dimension " << st.dimension() << std::endl;
 
   simplex_is_changed = st.prune_above_filtration(2.0);
   if (simplex_is_changed)
     st.initialize_filtration();
   
-  std::cout << "The complex pruned at 2.0 contains " << st.num_simplices() << " simplices";
-  std::cout << " - dimension " << st.dimension() << std::endl;
+  std::clog << "The complex pruned at 2.0 contains " << st.num_simplices() << " simplices";
+  std::clog << " - dimension " << st.dimension() << std::endl;
 
   BOOST_CHECK(st == st_pruned);
   BOOST_CHECK(!simplex_is_changed);
@@ -360,12 +360,12 @@ BOOST_AUTO_TEST_CASE(prune_above_filtration) {
     st.initialize_filtration();
 
   // Display the Simplex_tree
-  std::cout << "The complex pruned at 0.0 contains " << st.num_simplices() << " simplices";
-  std::cout << " - upper_bound_dimension " << st.upper_bound_dimension() << std::endl;
+  std::clog << "The complex pruned at 0.0 contains " << st.num_simplices() << " simplices";
+  std::clog << " - upper_bound_dimension " << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == 3);
 
   BOOST_CHECK(st.dimension() == -1);
-  std::cout << "upper_bound_dimension=" << st.upper_bound_dimension() << std::endl;
+  std::clog << "upper_bound_dimension=" << st.upper_bound_dimension() << std::endl;
   BOOST_CHECK(st.upper_bound_dimension() == -1);
 
   BOOST_CHECK(st == st_empty);
@@ -380,8 +380,8 @@ BOOST_AUTO_TEST_CASE(prune_above_filtration) {
 }
 
 BOOST_AUTO_TEST_CASE(mini_prune_above_filtration) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "MINI PRUNE ABOVE FILTRATION" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "MINI PRUNE ABOVE FILTRATION" << std::endl;
 
   Mini_stree st;
 
@@ -402,7 +402,7 @@ BOOST_AUTO_TEST_CASE(mini_prune_above_filtration) {
   st.initialize_filtration();
   
   // Display the Simplex_tree
-  std::cout << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
+  std::clog << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
   BOOST_CHECK(st.num_simplices() == 27);
 
   // Test case to the limit - With these options, there is no filtration, which means filtration is 0
@@ -410,7 +410,7 @@ BOOST_AUTO_TEST_CASE(mini_prune_above_filtration) {
   if (simplex_is_changed)
     st.initialize_filtration();
   // Display the Simplex_tree
-  std::cout << "The complex pruned at 1.0 contains " << st.num_simplices() << " simplices" << std::endl;
+  std::clog << "The complex pruned at 1.0 contains " << st.num_simplices() << " simplices" << std::endl;
   BOOST_CHECK(!simplex_is_changed);
   BOOST_CHECK(st.num_simplices() == 27);
 
@@ -418,7 +418,7 @@ BOOST_AUTO_TEST_CASE(mini_prune_above_filtration) {
   if (simplex_is_changed)
     st.initialize_filtration();
   // Display the Simplex_tree
-  std::cout << "The complex pruned at 0.0 contains " << st.num_simplices() << " simplices" << std::endl;
+  std::clog << "The complex pruned at 0.0 contains " << st.num_simplices() << " simplices" << std::endl;
   BOOST_CHECK(!simplex_is_changed);
   BOOST_CHECK(st.num_simplices() == 27);
 
@@ -427,11 +427,11 @@ BOOST_AUTO_TEST_CASE(mini_prune_above_filtration) {
   if (simplex_is_changed)
     st.initialize_filtration();
   // Display the Simplex_tree
-  std::cout << "The complex pruned at -1.0 contains " << st.num_simplices() << " simplices" << std::endl;
+  std::clog << "The complex pruned at -1.0 contains " << st.num_simplices() << " simplices" << std::endl;
   BOOST_CHECK(simplex_is_changed);
   BOOST_CHECK(st.num_simplices() == 0);
 
   // Display the Simplex_tree
-  std::cout << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
+  std::clog << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
 
 }
diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
index 58bfa8db..9b5fa8fe 100644
--- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
@@ -48,22 +48,22 @@ void test_empty_simplex_tree(typeST& tst) {
 
 template<class typeST>
 void test_iterators_on_empty_simplex_tree(typeST& tst) {
-  std::cout << "Iterator on vertices: " << std::endl;
+  std::clog << "Iterator on vertices: " << std::endl;
   for (auto vertex : tst.complex_vertex_range()) {
-    std::cout << "vertice:" << vertex << std::endl;
+    std::clog << "vertice:" << vertex << std::endl;
     BOOST_CHECK(false); // shall be empty
   }
-  std::cout << "Iterator on simplices: " << std::endl;
+  std::clog << "Iterator on simplices: " << std::endl;
   for (auto simplex : tst.complex_simplex_range()) {
     BOOST_CHECK(simplex != simplex); // shall be empty - to remove warning of non-used simplex
   }
 
-  std::cout
+  std::clog
       << "Iterator on Simplices in the filtration, with [filtration value]:"
       << std::endl;
   for (auto f_simplex : tst.filtration_simplex_range()) {
     BOOST_CHECK(false); // shall be empty
-    std::cout << "test_iterators_on_empty_simplex_tree - filtration="
+    std::clog << "test_iterators_on_empty_simplex_tree - filtration="
         << tst.filtration(f_simplex) << std::endl;
   }
 }
@@ -72,15 +72,15 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_when_empty, typeST, list_of_tested_va
   typedef std::pair<typename typeST::Simplex_handle, bool> typePairSimplexBool;
   typedef std::vector<typename typeST::Vertex_handle> typeVectorVertex;
 
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF DEFAULT CONSTRUCTOR" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF DEFAULT CONSTRUCTOR" << std::endl;
   typeST st;
 
   test_empty_simplex_tree(st);
 
   test_iterators_on_empty_simplex_tree(st);
   // TEST OF EMPTY INSERTION
-  std::cout << "TEST OF EMPTY INSERTION" << std::endl;
+  std::clog << "TEST OF EMPTY INSERTION" << std::endl;
   typeVectorVertex simplexVectorEmpty;
   BOOST_CHECK(simplexVectorEmpty.empty() == true);
   typePairSimplexBool returnEmptyValue = st.insert_simplex(simplexVectorEmpty, 0.0);
@@ -98,8 +98,8 @@ bool AreAlmostTheSame(float a, float b) {
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_from_file, typeST, list_of_tested_variants) {
   // TEST OF INSERTION
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF SIMPLEX TREE FROM A FILE" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF SIMPLEX TREE FROM A FILE" << std::endl;
   typeST st;
 
   std::string inputFile("simplex_tree_for_unit_test.txt");
@@ -107,8 +107,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_from_file, typeST, list_of_tested_var
   simplex_tree_stream >> st;
 
   // Display the Simplex_tree
-  std::cout << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
-  std::cout << "   - dimension " << st.dimension() << std::endl;
+  std::clog << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
+  std::clog << "   - dimension " << st.dimension() << std::endl;
 
   // Check
   BOOST_CHECK(st.num_simplices() == 143353);
@@ -134,13 +134,13 @@ template<class typeST, class typeSimplex>
 void test_simplex_tree_contains(typeST& simplexTree, typeSimplex& simplex, int pos) {
   auto f_simplex = simplexTree.filtration_simplex_range().begin() + pos;
 
-  std::cout << "test_simplex_tree_contains - filtration=" << simplexTree.filtration(*f_simplex) << "||" << simplex.second << std::endl;
+  std::clog << "test_simplex_tree_contains - filtration=" << simplexTree.filtration(*f_simplex) << "||" << simplex.second << std::endl;
   BOOST_CHECK(AreAlmostTheSame(simplexTree.filtration(*f_simplex), simplex.second));
 
   int simplexIndex = simplex.first.size() - 1;
   std::sort(simplex.first.begin(), simplex.first.end()); // if the simplex wasn't sorted, the next test could fail
   for (auto vertex : simplexTree.simplex_vertex_range(*f_simplex)) {
-    std::cout << "test_simplex_tree_contains - vertex=" << vertex << "||" << simplex.first.at(simplexIndex) << std::endl;
+    std::clog << "test_simplex_tree_contains - vertex=" << vertex << "||" << simplex.first.at(simplexIndex) << std::endl;
     BOOST_CHECK(vertex == simplex.first.at(simplexIndex));
     BOOST_CHECK(simplexIndex >= 0);
     simplexIndex--;
@@ -163,7 +163,7 @@ void set_and_test_simplex_tree_dim_fil(typeST& simplexTree, int vectorSize, cons
   if (vectorSize > dim_max + 1) {
     dim_max = vectorSize - 1;
     simplexTree.set_dimension(dim_max);
-    std::cout << "   set_and_test_simplex_tree_dim_fil - dim_max=" << dim_max
+    std::clog << "   set_and_test_simplex_tree_dim_fil - dim_max=" << dim_max
         << std::endl;
   }
 
@@ -193,12 +193,12 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   dim_max = -1;
 
   // TEST OF INSERTION
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF INSERTION" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF INSERTION" << std::endl;
   typeST st;
 
   // ++ FIRST
-  std::cout << "   - INSERT 0" << std::endl;
+  std::clog << "   - INSERT 0" << std::endl;
   typeVectorVertex firstSimplexVector{0};
   BOOST_CHECK(firstSimplexVector.size() == 1);
   typeSimplex firstSimplex = std::make_pair(firstSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
@@ -209,7 +209,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   BOOST_CHECK(st.num_vertices() == (size_t) 1);
 
   // ++ SECOND
-  std::cout << "   - INSERT 1" << std::endl;
+  std::clog << "   - INSERT 1" << std::endl;
   typeVectorVertex secondSimplexVector{1};
   BOOST_CHECK(secondSimplexVector.size() == 1);
   typeSimplex secondSimplex = std::make_pair(secondSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
@@ -220,7 +220,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   BOOST_CHECK(st.num_vertices() == (size_t) 2);
 
   // ++ THIRD
-  std::cout << "   - INSERT (0,1)" << std::endl;
+  std::clog << "   - INSERT (0,1)" << std::endl;
   typeVectorVertex thirdSimplexVector{0, 1};
   BOOST_CHECK(thirdSimplexVector.size() == 2);
   typeSimplex thirdSimplex = std::make_pair(thirdSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
@@ -231,7 +231,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   BOOST_CHECK(st.num_vertices() == (size_t) 2); // Not incremented !!
 
   // ++ FOURTH
-  std::cout << "   - INSERT 2" << std::endl;
+  std::clog << "   - INSERT 2" << std::endl;
   typeVectorVertex fourthSimplexVector{2};
   BOOST_CHECK(fourthSimplexVector.size() == 1);
   typeSimplex fourthSimplex = std::make_pair(fourthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
@@ -242,7 +242,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   BOOST_CHECK(st.num_vertices() == (size_t) 3);
 
   // ++ FIFTH
-  std::cout << "   - INSERT (2,0)" << std::endl;
+  std::clog << "   - INSERT (2,0)" << std::endl;
   typeVectorVertex fifthSimplexVector{2, 0};
   BOOST_CHECK(fifthSimplexVector.size() == 2);
   typeSimplex fifthSimplex = std::make_pair(fifthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
@@ -253,7 +253,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   BOOST_CHECK(st.num_vertices() == (size_t) 3); // Not incremented !!
 
   // ++ SIXTH
-  std::cout << "   - INSERT (2,1)" << std::endl;
+  std::clog << "   - INSERT (2,1)" << std::endl;
   typeVectorVertex sixthSimplexVector{2, 1};
   BOOST_CHECK(sixthSimplexVector.size() == 2);
   typeSimplex sixthSimplex = std::make_pair(sixthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
@@ -264,7 +264,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   BOOST_CHECK(st.num_vertices() == (size_t) 3); // Not incremented !!
 
   // ++ SEVENTH
-  std::cout << "   - INSERT (2,1,0)" << std::endl;
+  std::clog << "   - INSERT (2,1,0)" << std::endl;
   typeVectorVertex seventhSimplexVector{2, 1, 0};
   BOOST_CHECK(seventhSimplexVector.size() == 3);
   typeSimplex seventhSimplex = std::make_pair(seventhSimplexVector, Filtration_value(THIRD_FILTRATION_VALUE));
@@ -275,7 +275,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   BOOST_CHECK(st.num_vertices() == (size_t) 3); // Not incremented !!
 
   // ++ EIGHTH
-  std::cout << "   - INSERT 3" << std::endl;
+  std::clog << "   - INSERT 3" << std::endl;
   typeVectorVertex eighthSimplexVector{3};
   BOOST_CHECK(eighthSimplexVector.size() == 1);
   typeSimplex eighthSimplex = std::make_pair(eighthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
@@ -286,7 +286,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   BOOST_CHECK(st.num_vertices() == (size_t) 4);
 
   // ++ NINETH
-  std::cout << "   - INSERT (3,0)" << std::endl;
+  std::clog << "   - INSERT (3,0)" << std::endl;
   typeVectorVertex ninethSimplexVector{3, 0};
   BOOST_CHECK(ninethSimplexVector.size() == 2);
   typeSimplex ninethSimplex = std::make_pair(ninethSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
@@ -297,7 +297,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   BOOST_CHECK(st.num_vertices() == (size_t) 4); // Not incremented !!
 
   // ++ TENTH
-  std::cout << "   - INSERT 0 (already inserted)" << std::endl;
+  std::clog << "   - INSERT 0 (already inserted)" << std::endl;
   typeVectorVertex tenthSimplexVector{0};
   BOOST_CHECK(tenthSimplexVector.size() == 1);
   // With a different filtration value
@@ -308,12 +308,12 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   // Simplex_handle = boost::container::flat_map< typeST::Vertex_handle, Node >::iterator
   typename typeST::Simplex_handle shReturned = returnValue.first;
   BOOST_CHECK(shReturned == typename typeST::Simplex_handle(nullptr));
-  std::cout << "st.num_vertices()=" << st.num_vertices() << std::endl;
+  std::clog << "st.num_vertices()=" << st.num_vertices() << std::endl;
   BOOST_CHECK(st.num_vertices() == (size_t) 4); // Not incremented !!
   BOOST_CHECK(st.dimension() == dim_max);
 
   // ++ 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};
   BOOST_CHECK(eleventhSimplexVector.size() == 3);
   typeSimplex eleventhSimplex = std::make_pair(eleventhSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
@@ -343,35 +343,35 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   //   [0.2] 3 0
   //   [0.3] 2 1 0
   //  !! Be careful, simplex are sorted by filtration value on insertion !!
-  std::cout << "simplex_tree_insertion - first - 0" << std::endl;
+  std::clog << "simplex_tree_insertion - first - 0" << std::endl;
   test_simplex_tree_contains(st, firstSimplex, 0); // (0) -> 0
-  std::cout << "simplex_tree_insertion - second - 1" << std::endl;
+  std::clog << "simplex_tree_insertion - second - 1" << std::endl;
   test_simplex_tree_contains(st, secondSimplex, 1); // (1) -> 1
-  std::cout << "simplex_tree_insertion - third - 4" << std::endl;
+  std::clog << "simplex_tree_insertion - third - 4" << std::endl;
   test_simplex_tree_contains(st, thirdSimplex, 4); // (0,1) -> 4
-  std::cout << "simplex_tree_insertion - fourth - 2" << std::endl;
+  std::clog << "simplex_tree_insertion - fourth - 2" << std::endl;
   test_simplex_tree_contains(st, fourthSimplex, 2); // (2) -> 2
-  std::cout << "simplex_tree_insertion - fifth - 5" << std::endl;
+  std::clog << "simplex_tree_insertion - fifth - 5" << std::endl;
   test_simplex_tree_contains(st, fifthSimplex, 5); // (2,0) -> 5
-  std::cout << "simplex_tree_insertion - sixth - 6" << std::endl;
+  std::clog << "simplex_tree_insertion - sixth - 6" << std::endl;
   test_simplex_tree_contains(st, sixthSimplex, 6); //(2,1) -> 6
-  std::cout << "simplex_tree_insertion - seventh - 8" << std::endl;
+  std::clog << "simplex_tree_insertion - seventh - 8" << std::endl;
   test_simplex_tree_contains(st, seventhSimplex, 8); // (2,1,0) -> 8
-  std::cout << "simplex_tree_insertion - eighth - 3" << std::endl;
+  std::clog << "simplex_tree_insertion - eighth - 3" << std::endl;
   test_simplex_tree_contains(st, eighthSimplex, 3); // (3) -> 3
-  std::cout << "simplex_tree_insertion - nineth - 7" << std::endl;
+  std::clog << "simplex_tree_insertion - nineth - 7" << std::endl;
   test_simplex_tree_contains(st, ninethSimplex, 7); // (3,0) -> 7
 
   // Display the Simplex_tree - Can not be done in the middle of 2 inserts
-  std::cout << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
-  std::cout << "   - dimension " << st.dimension() << std::endl;
-  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+  std::clog << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
+  std::clog << "   - dimension " << st.dimension() << std::endl;
+  std::clog << std::endl << std::endl << "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 << (int) vertex << " ";
+      std::clog << (int) vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
 }
@@ -380,14 +380,14 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(NSimplexAndSubfaces_tree_insertion, typeST, list_o
   typedef std::pair<typename typeST::Simplex_handle, bool> typePairSimplexBool;
   typedef std::vector<typename typeST::Vertex_handle> typeVectorVertex;
   typedef std::pair<typeVectorVertex, typename typeST::Filtration_value> typeSimplex;
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF RECURSIVE INSERTION" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST OF RECURSIVE INSERTION" << std::endl;
   typeST st;
   typePairSimplexBool returnValue;
   int position = 0;
 
   // ++ FIRST
-  std::cout << "   - INSERT (2,1,0)" << std::endl;
+  std::clog << "   - INSERT (2,1,0)" << std::endl;
   typeVectorVertex SimplexVector1{2, 1, 0};
   BOOST_CHECK(SimplexVector1.size() == 3);
   returnValue = st.insert_simplex_and_subfaces(SimplexVector1);
@@ -400,13 +400,13 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(NSimplexAndSubfaces_tree_insertion, typeST, list_o
   std::sort(SimplexVector1.begin(), SimplexVector1.end(), std::greater<typename typeST::Vertex_handle>());
   for (auto vertex : st.simplex_vertex_range(returnValue.first)) {
     // Check returned Simplex_handle
-    std::cout << "vertex = " << vertex << " | vector[" << position << "] = " << SimplexVector1[position] << std::endl;
+    std::clog << "vertex = " << vertex << " | vector[" << position << "] = " << SimplexVector1[position] << std::endl;
     BOOST_CHECK(vertex == SimplexVector1[position]);
     position++;
   }
 
   // ++ SECOND
-  std::cout << "   - INSERT 3" << std::endl;
+  std::clog << "   - INSERT 3" << std::endl;
   typeVectorVertex SimplexVector2{3};
   BOOST_CHECK(SimplexVector2.size() == 1);
   returnValue = st.insert_simplex_and_subfaces(SimplexVector2);
@@ -419,13 +419,13 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(NSimplexAndSubfaces_tree_insertion, typeST, list_o
   std::sort(SimplexVector2.begin(), SimplexVector2.end(), std::greater<typename typeST::Vertex_handle>());
   for (auto vertex : st.simplex_vertex_range(returnValue.first)) {
     // Check returned Simplex_handle
-    std::cout << "vertex = " << vertex << " | vector[" << position << "] = " << SimplexVector2[position] << std::endl;
+    std::clog << "vertex = " << vertex << " | vector[" << position << "] = " << SimplexVector2[position] << std::endl;
     BOOST_CHECK(vertex == SimplexVector2[position]);
     position++;
   }
 
   // ++ THIRD
-  std::cout << "   - INSERT (0,3)" << std::endl;
+  std::clog << "   - INSERT (0,3)" << std::endl;
   typeVectorVertex SimplexVector3{3, 0};
   BOOST_CHECK(SimplexVector3.size() == 2);
   returnValue = st.insert_simplex_and_subfaces(SimplexVector3);
@@ -438,13 +438,13 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(NSimplexAndSubfaces_tree_insertion, typeST, list_o
   std::sort(SimplexVector3.begin(), SimplexVector3.end(), std::greater<typename typeST::Vertex_handle>());
   for (auto vertex : st.simplex_vertex_range(returnValue.first)) {
     // Check returned Simplex_handle
-    std::cout << "vertex = " << vertex << " | vector[" << position << "] = " << SimplexVector3[position] << std::endl;
+    std::clog << "vertex = " << vertex << " | vector[" << position << "] = " << SimplexVector3[position] << std::endl;
     BOOST_CHECK(vertex == SimplexVector3[position]);
     position++;
   }
 
   // ++ FOURTH
-  std::cout << "   - INSERT (1,0) (already inserted)" << std::endl;
+  std::clog << "   - INSERT (1,0) (already inserted)" << std::endl;
   typeVectorVertex SimplexVector4{1, 0};
   BOOST_CHECK(SimplexVector4.size() == 2);
   returnValue = st.insert_simplex_and_subfaces(SimplexVector4);
@@ -455,7 +455,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(NSimplexAndSubfaces_tree_insertion, typeST, list_o
   BOOST_CHECK(false == returnValue.second);
 
   // ++ FIFTH
-  std::cout << "   - INSERT (3,4,5)" << std::endl;
+  std::clog << "   - INSERT (3,4,5)" << std::endl;
   typeVectorVertex SimplexVector5{3, 4, 5};
   BOOST_CHECK(SimplexVector5.size() == 3);
   returnValue = st.insert_simplex_and_subfaces(SimplexVector5);
@@ -468,13 +468,13 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(NSimplexAndSubfaces_tree_insertion, typeST, list_o
   std::sort(SimplexVector5.begin(), SimplexVector5.end(), std::greater<typename typeST::Vertex_handle>());
   for (auto vertex : st.simplex_vertex_range(returnValue.first)) {
     // Check returned Simplex_handle
-    std::cout << "vertex = " << vertex << " | vector[" << position << "] = " << SimplexVector5[position] << std::endl;
+    std::clog << "vertex = " << vertex << " | vector[" << position << "] = " << SimplexVector5[position] << std::endl;
     BOOST_CHECK(vertex == SimplexVector5[position]);
     position++;
   }
 
   // ++ SIXTH
-  std::cout << "   - INSERT (0,1,6,7)" << std::endl;
+  std::clog << "   - INSERT (0,1,6,7)" << std::endl;
   typeVectorVertex SimplexVector6{0, 1, 6, 7};
   BOOST_CHECK(SimplexVector6.size() == 4);
   returnValue = st.insert_simplex_and_subfaces(SimplexVector6);
@@ -487,7 +487,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(NSimplexAndSubfaces_tree_insertion, typeST, list_o
   std::sort(SimplexVector6.begin(), SimplexVector6.end(), std::greater<typename typeST::Vertex_handle>());
   for (auto vertex : st.simplex_vertex_range(returnValue.first)) {
     // Check returned Simplex_handle
-    std::cout << "vertex = " << vertex << " | vector[" << position << "] = " << SimplexVector6[position] << std::endl;
+    std::clog << "vertex = " << vertex << " | vector[" << position << "] = " << SimplexVector6[position] << std::endl;
     BOOST_CHECK(vertex == SimplexVector6[position]);
     position++;
   }
@@ -525,63 +525,63 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(NSimplexAndSubfaces_tree_insertion, typeST, list_o
   // ------------------------------------------------------------------------------------------------------------------
   typeVectorVertex simpleSimplexVector{1};
   typename typeST::Simplex_handle simplexFound = st.find(simpleSimplexVector);
-  std::cout << "**************IS THE SIMPLEX {1} IN THE SIMPLEX TREE ?\n";
+  std::clog << "**************IS THE SIMPLEX {1} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != st.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";
   // Check it is found
   BOOST_CHECK(simplexFound != st.null_simplex());
 
   typeVectorVertex unknownSimplexVector{15};
   simplexFound = st.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 != st.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";
   // Check it is NOT found
   BOOST_CHECK(simplexFound == st.null_simplex());
 
   simplexFound = st.find(SimplexVector6);
-  std::cout << "**************IS THE SIMPLEX {0,1,6,7} IN THE SIMPLEX TREE ?\n";
+  std::clog << "**************IS THE SIMPLEX {0,1,6,7} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != st.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";
   // Check it is found
   BOOST_CHECK(simplexFound != st.null_simplex());
 
   typeVectorVertex otherSimplexVector{1, 15};
   simplexFound = st.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 != st.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";
   // Check it is NOT found
   BOOST_CHECK(simplexFound == st.null_simplex());
 
   typeVectorVertex invSimplexVector{1, 2, 0};
   simplexFound = st.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 != st.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";
   // Check it is found
   BOOST_CHECK(simplexFound != st.null_simplex());
 
   // Display the Simplex_tree - Can not be done in the middle of 2 inserts
-  std::cout << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
-  std::cout << "   - dimension " << st.dimension() << std::endl;
-  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+  std::clog << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
+  std::clog << "   - dimension " << st.dimension() << std::endl;
+  std::clog << std::endl << std::endl << "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 << (int) vertex << " ";
+      std::clog << (int) vertex << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 }
 
@@ -595,17 +595,17 @@ void test_cofaces(typeST& st, const std::vector<Vertex_handle>& expected, int di
   for (auto simplex = cofaces.begin(); simplex != cofaces.end(); ++simplex) {
     typename typeST::Simplex_vertex_range rg = st.simplex_vertex_range(*simplex);
     for (auto vertex = rg.begin(); vertex != rg.end(); ++vertex) {
-      std::cout << "(" << *vertex << ")";
+      std::clog << "(" << *vertex << ")";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     BOOST_CHECK(std::find(res.begin(), res.end(), *simplex) != res.end());
   }
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(coface_on_simplex_tree, typeST, list_of_tested_variants) {
   typedef std::vector<typename typeST::Vertex_handle> typeVectorVertex;
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST COFACE ALGORITHM" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST COFACE ALGORITHM" << std::endl;
   typeST st;
 
   typeVectorVertex SimplexVector{2, 1, 0};
@@ -631,7 +631,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(coface_on_simplex_tree, typeST, list_of_tested_var
 
   std::vector<typename typeST::Vertex_handle> simplex_result;
   std::vector<typename typeST::Simplex_handle> result;
-  std::cout << "First test - Star of (3):" << std::endl;
+  std::clog << "First test - Star of (3):" << std::endl;
 
   simplex_result = {3};
   result.push_back(st.find(simplex_result));
@@ -656,7 +656,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(coface_on_simplex_tree, typeST, list_of_tested_var
 
   vertex.push_back(1);
   vertex.push_back(7);
-  std::cout << "Second test - Star of (1,7): " << std::endl;
+  std::clog << "Second test - Star of (1,7): " << std::endl;
 
   simplex_result = {7, 1};
   result.push_back(st.find(simplex_result));
@@ -673,7 +673,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(coface_on_simplex_tree, typeST, list_of_tested_var
   test_cofaces(st, vertex, 0, result);
   result.clear();
 
-  std::cout << "Third test - 2-dimension Cofaces of simplex(1,7) : " << std::endl;
+  std::clog << "Third test - 2-dimension Cofaces of simplex(1,7) : " << std::endl;
 
   simplex_result = {7, 1, 0};
   result.push_back(st.find(simplex_result));
@@ -684,15 +684,15 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(coface_on_simplex_tree, typeST, list_of_tested_var
   test_cofaces(st, vertex, 1, result);
   result.clear();
 
-  std::cout << "Cofaces with a codimension too high (codimension + vetices > tree.dimension) :" << std::endl;
+  std::clog << "Cofaces with a codimension too high (codimension + vetices > tree.dimension) :" << std::endl;
   test_cofaces(st, vertex, 5, result);
 
-  //std::cout << "Cofaces with an empty codimension" << std::endl;
+  //std::clog << "Cofaces with an empty codimension" << std::endl;
   //test_cofaces(st, vertex, -1, result);
-  //    std::cout << "Cofaces in an empty simplex tree" << std::endl;
+  //    std::clog << "Cofaces in an empty simplex tree" << std::endl;
   //   typeST empty_tree;
   //    test_cofaces(empty_tree, vertex, 1, result);
-  //std::cout << "Cofaces of an empty simplex" << std::endl;
+  //std::clog << "Cofaces of an empty simplex" << std::endl;
   //vertex.clear();
   // test_cofaces(st, vertex, 1, result);
 
@@ -700,8 +700,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(coface_on_simplex_tree, typeST, list_of_tested_var
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(copy_move_on_simplex_tree, typeST, list_of_tested_variants) {
   typedef std::vector<typename typeST::Vertex_handle> typeVectorVertex;
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST COPY MOVE CONSTRUCTORS" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST COPY MOVE CONSTRUCTORS" << std::endl;
   typeST st;
 
   typeVectorVertex SimplexVector{2, 1, 0};
@@ -725,11 +725,11 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(copy_move_on_simplex_tree, typeST, list_of_tested_
   /*            o             */
   /*            5             */
 
-  std::cout << "Printing st - address = " << &st << std::endl;
+  std::clog << "Printing st - address = " << &st << std::endl;
 
   // Copy constructor  
   typeST st_copy = st;
-  std::cout << "Printing a copy of st - address = " << &st_copy << std::endl;
+  std::clog << "Printing a copy of st - address = " << &st_copy << std::endl;
 
   // Check the data are the same
   BOOST_CHECK(st == st_copy);
@@ -738,7 +738,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(copy_move_on_simplex_tree, typeST, list_of_tested_
 
   // Move constructor  
   typeST st_move = std::move(st);
-  std::cout << "Printing a move of st - address = " << &st_move << std::endl;
+  std::clog << "Printing a move of st - address = " << &st_move << std::endl;
 
   // Check the data are the same
   BOOST_CHECK(st_move == st_copy);
@@ -753,7 +753,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(copy_move_on_simplex_tree, typeST, list_of_tested_
   BOOST_CHECK(st.num_simplices() == 0);
   BOOST_CHECK(st.num_vertices() == (size_t)0);
   
-  std::cout << "Printing st once again- address = " << &st << std::endl;
+  std::clog << "Printing st once again- address = " << &st << std::endl;
 }
 
 template<class typeST>
@@ -768,22 +768,22 @@ void test_simplex_is_vertex(typeST& st, typename typeST::Simplex_handle sh, type
 BOOST_AUTO_TEST_CASE(non_contiguous) {
   typedef Simplex_tree<> typeST;
   typedef typeST::Simplex_handle Simplex_handle;
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST NON-CONTIGUOUS VERTICES" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST NON-CONTIGUOUS VERTICES" << std::endl;
   typeST st;
   typeST::Vertex_handle e[] = {3,-7};
-  std::cout << "Insert" << std::endl;
+  std::clog << "Insert" << std::endl;
   st.insert_simplex_and_subfaces(e);
   BOOST_CHECK(st.num_vertices() == 2);
   BOOST_CHECK(st.num_simplices() == 3);
-  std::cout << "Find" << std::endl;
+  std::clog << "Find" << std::endl;
   Simplex_handle sh = st.find(e);
   BOOST_CHECK(sh != st.null_simplex());
-  std::cout << "Endpoints" << std::endl;
+  std::clog << "Endpoints" << std::endl;
   auto p = st.endpoints(sh);
   test_simplex_is_vertex(st, p.first, 3);
   test_simplex_is_vertex(st, p.second, -7);
-  std::cout << "Boundary" << std::endl;
+  std::clog << "Boundary" << std::endl;
   auto&& b = st.boundary_simplex_range(sh);
   auto i = std::begin(b);
   test_simplex_is_vertex(st, *i, -7);
@@ -791,90 +791,6 @@ BOOST_AUTO_TEST_CASE(non_contiguous) {
   BOOST_CHECK(++i == std::end(b));
 }
 
-BOOST_AUTO_TEST_CASE(make_filtration_non_decreasing) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "MAKE FILTRATION NON DECREASING" << std::endl;
-  typedef Simplex_tree<> typeST;
-  typeST st;
-
-  st.insert_simplex_and_subfaces({2, 1, 0}, 2.0);
-  st.insert_simplex_and_subfaces({3, 0}, 2.0);
-  st.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
-  
-  /* Inserted simplex:     */
-  /*    1                  */
-  /*    o                  */
-  /*   /X\                 */
-  /*  o---o---o---o        */
-  /*  2   0   3\X/4        */
-  /*            o          */
-  /*            5          */
-
-  std::cout << "Check default insertion ensures the filtration values are non decreasing" << std::endl;
-  BOOST_CHECK(!st.make_filtration_non_decreasing());
-
-  // Because of non decreasing property of simplex tree, { 0 } , { 1 } and { 0, 1 } are going to be set from value 2.0
-  // to 1.0
-  st.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
-  
-  // Inserted simplex:
-  //    1   6
-  //    o---o
-  //   /X\7/
-  //  o---o---o---o
-  //  2   0   3\X/4
-  //            o
-  //            5
-  
-  std::cout << "Check default second insertion ensures the filtration values are non decreasing" << std::endl;
-  BOOST_CHECK(!st.make_filtration_non_decreasing());
-  
-  // Copy original simplex tree
-  typeST st_copy = st;
-
-  // Modify specific values for st to become like st_copy thanks to make_filtration_non_decreasing
-  st.assign_filtration(st.find({0,1,6,7}), 0.8);
-  st.assign_filtration(st.find({0,1,6}), 0.9);
-  st.assign_filtration(st.find({0,6}), 0.6);
-  st.assign_filtration(st.find({3,4,5}), 1.2);
-  st.assign_filtration(st.find({3,4}), 1.1);
-  st.assign_filtration(st.find({4,5}), 1.99);
-  
-  std::cout << "Check the simplex_tree is rolled back in case of decreasing filtration values" << std::endl;
-  BOOST_CHECK(st.make_filtration_non_decreasing());
-  BOOST_CHECK(st == st_copy);
-
-  // Other simplex tree
-  typeST st_other;
-  st_other.insert_simplex_and_subfaces({2, 1, 0}, 3.0);  // This one is different from st
-  st_other.insert_simplex_and_subfaces({3, 0}, 2.0);
-  st_other.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
-  st_other.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
-
-  // Modify specific values for st to become like st_other thanks to make_filtration_non_decreasing
-  st.assign_filtration(st.find({2}), 3.0);
-  // By modifying just the simplex {2}
-  // {0,1,2}, {1,2} and {0,2} will be modified
-  
-  std::cout << "Check the simplex_tree is repaired in case of decreasing filtration values" << std::endl;
-  BOOST_CHECK(st.make_filtration_non_decreasing());
-  BOOST_CHECK(st == st_other);
-
-  // Modify specific values for st still to be non-decreasing
-  st.assign_filtration(st.find({0,1,2}), 10.0);
-  st.assign_filtration(st.find({0,2}), 9.0);
-  st.assign_filtration(st.find({0,1,6,7}), 50.0);
-  st.assign_filtration(st.find({0,1,6}), 49.0);
-  st.assign_filtration(st.find({0,1,7}), 48.0);
-  // Other copy simplex tree
-  typeST st_other_copy = st;
-  
-  std::cout << "Check the simplex_tree is not modified in case of non-decreasing filtration values" << std::endl;
-  BOOST_CHECK(!st.make_filtration_non_decreasing());
-  BOOST_CHECK(st == st_other_copy);
-  
-}
-
 
 typedef boost::mpl::list<boost::adjacency_list<boost::setS, boost::vecS, boost::directedS,
                                                boost::property<vertex_filtration_t, double>,
@@ -896,8 +812,8 @@ typedef boost::mpl::list<boost::adjacency_list<boost::setS, boost::vecS, boost::
                                                boost::property<edge_filtration_t, double>>> list_of_graph_variants;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insert_graph, Graph, list_of_graph_variants) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "INSERT GRAPH" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "INSERT GRAPH" << std::endl;
 
   Graph g(3);
   // filtration value 0 everywhere
@@ -924,18 +840,18 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insert_graph, Graph, list_of_graph_va
   st2.insert_graph(g);
   BOOST_CHECK(st2.num_simplices() == 6);
 
-  std::cout << "st1 is" << std::endl;
-  std::cout << st1 << std::endl;
+  std::clog << "st1 is" << std::endl;
+  std::clog << st1 << std::endl;
 
-  std::cout << "st2 is" << std::endl;
-  std::cout << st2 << std::endl;
+  std::clog << "st2 is" << std::endl;
+  std::clog << st2 << std::endl;
 
   BOOST_CHECK(st1 == st2);
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(insert_duplicated_vertices, typeST, list_of_tested_variants) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST INSERT DUPLICATED VERTICES" << std::endl;
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST INSERT DUPLICATED VERTICES" << std::endl;
   typeST st;
 
   typename typeST::Simplex_handle sh;
@@ -943,25 +859,25 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(insert_duplicated_vertices, typeST, list_of_tested
   std::tie(sh, success) = st.insert_simplex_and_subfaces({1});
   BOOST_CHECK(success);
   BOOST_CHECK(sh != st.null_simplex());
-  std::cout << "st.dimension(sh)= " << st.dimension(sh) << std::endl;
+  std::clog << "st.dimension(sh)= " << st.dimension(sh) << std::endl;
   BOOST_CHECK(st.dimension(sh) == 0);
   std::tie(sh, success) = st.insert_simplex_and_subfaces({2, 2});
   BOOST_CHECK(success);
   BOOST_CHECK(sh != st.null_simplex());
-  std::cout << "st.dimension(sh)= " << st.dimension(sh) << std::endl;
+  std::clog << "st.dimension(sh)= " << st.dimension(sh) << std::endl;
   BOOST_CHECK(st.dimension(sh) == 0);
   std::tie(sh, success) = st.insert_simplex_and_subfaces({3, 3, 3});
   BOOST_CHECK(success);
   BOOST_CHECK(sh != st.null_simplex());
-  std::cout << "st.dimension(sh)= " << st.dimension(sh) << std::endl;
+  std::clog << "st.dimension(sh)= " << st.dimension(sh) << std::endl;
   BOOST_CHECK(st.dimension(sh) == 0);
   std::tie(sh, success) = st.insert_simplex_and_subfaces({4, 4, 4, 4});
   BOOST_CHECK(success);
   BOOST_CHECK(sh != st.null_simplex());
-  std::cout << "st.dimension(sh)= " << st.dimension(sh) << std::endl;
+  std::clog << "st.dimension(sh)= " << st.dimension(sh) << std::endl;
   BOOST_CHECK(st.dimension(sh) == 0);
 
-  std::cout << "dimension =" << st.dimension() << " - num_vertices = " << st.num_vertices()
+  std::clog << "dimension =" << st.dimension() << " - num_vertices = " << st.num_vertices()
             << " - num_simplices = " << st.num_simplices() << std::endl;
   BOOST_CHECK(st.dimension() == 0);
   BOOST_CHECK(st.num_simplices() == st.num_vertices());
@@ -969,10 +885,10 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(insert_duplicated_vertices, typeST, list_of_tested
   std::tie(sh, success) = st.insert_simplex_and_subfaces({2, 1, 1, 2});
   BOOST_CHECK(success);
   BOOST_CHECK(sh != st.null_simplex());
-  std::cout << "st.dimension(sh)= " << st.dimension(sh) << std::endl;
+  std::clog << "st.dimension(sh)= " << st.dimension(sh) << std::endl;
   BOOST_CHECK(st.dimension(sh) == 1);
 
-  std::cout << "dimension =" << st.dimension() << " - num_vertices = " << st.num_vertices()
+  std::clog << "dimension =" << st.dimension() << " - num_vertices = " << st.num_vertices()
             << " - num_simplices = " << st.num_simplices() << std::endl;
   BOOST_CHECK(st.dimension() == 1);
   BOOST_CHECK(st.num_simplices() == st.num_vertices() + 1);
@@ -982,9 +898,45 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(insert_duplicated_vertices, typeST, list_of_tested
   BOOST_CHECK(!success);
   BOOST_CHECK(sh == st.null_simplex());
 
-  std::cout << "dimension =" << st.dimension() << " - num_vertices = " << st.num_vertices()
+  std::clog << "dimension =" << st.dimension() << " - num_vertices = " << st.num_vertices()
             << " - num_simplices = " << st.num_simplices() << std::endl;
   BOOST_CHECK(st.dimension() == 1);
   BOOST_CHECK(st.num_simplices() == st.num_vertices() + 1);
+}
 
+BOOST_AUTO_TEST_CASE_TEMPLATE(generators, typeST, list_of_tested_variants) {
+  std::cout << "********************************************************************" << std::endl;
+  std::cout << "TEST FIND GENERATORS" << std::endl;
+  {
+    typeST st;
+    st.insert_simplex_and_subfaces({0,1,2,3,4,5,6},0);
+    st.assign_filtration(st.find({0,2,4}), 10);
+    st.assign_filtration(st.find({1,5}), 20);
+    st.assign_filtration(st.find({1,2,4}), 30);
+    st.assign_filtration(st.find({3}), 5);
+    st.make_filtration_non_decreasing();
+    BOOST_CHECK(st.filtration(st.find({1,2}))==0);
+    BOOST_CHECK(st.filtration(st.find({0,1,2,3,4}))==30);
+    BOOST_CHECK(st.minimal_simplex_with_same_filtration(st.find({0,1,2,3,4,5}))==st.find({1,2,4}));
+    BOOST_CHECK(st.minimal_simplex_with_same_filtration(st.find({0,2,3}))==st.find({3}));
+    auto s=st.minimal_simplex_with_same_filtration(st.find({0,2,6}));
+    BOOST_CHECK(s==st.find({0})||s==st.find({2})||s==st.find({6}));
+    BOOST_CHECK(st.vertex_with_same_filtration(st.find({2}))==2);
+    BOOST_CHECK(st.vertex_with_same_filtration(st.find({1,5}))==st.null_vertex());
+    BOOST_CHECK(st.vertex_with_same_filtration(st.find({5,6}))>=5);
+  }
+  {
+    typeST st;
+    st.insert_simplex_and_subfaces({0,1}, 8);
+    st.insert_simplex_and_subfaces({0,2}, 10);
+    st.insert_simplex_and_subfaces({3,4}, 6);
+    st.insert_simplex_and_subfaces({1,2}, 5);
+    st.insert_simplex_and_subfaces({1,5}, 4);
+    st.insert_simplex_and_subfaces({0,5}, 3);
+    st.insert_simplex_and_subfaces({2,5}, 2);
+    st.insert_simplex_and_subfaces({1,3}, 9);
+    st.expansion(50);
+    BOOST_CHECK(st.edge_with_same_filtration(st.find({0,1,2,5}))==st.find({0,2}));
+    BOOST_CHECK(st.edge_with_same_filtration(st.find({1,5}))==st.find({1,5}));
+  }
 }
diff --git a/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp b/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp
index 486827eb..d04ca289 100644
--- a/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp
+++ b/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp
@@ -35,13 +35,13 @@ int main(int argc, char *argv[]) {
   Complex complex(Gudhi::skeleton_blocker::make_complex_from_top_faces<Complex>(simplices.begin(), simplices.end()));
 
 
-  std::cout << "Simplices:" << std::endl;
+  std::clog << "Simplices:" << std::endl;
   for (const Simplex & s : complex.complex_simplex_range())
-    std::cout << s << " ";
-  std::cout << std::endl;
+    std::clog << s << " ";
+  std::clog << std::endl;
 
   // One blocker as simplex 0123 is not in the complex but all its proper faces are.
-  std::cout << "Blockers: " << complex.blockers_to_string() << std::endl;
+  std::clog << "Blockers: " << complex.blockers_to_string() << std::endl;
 
   // now build a complex from its full list of simplices
   simplices.clear();
@@ -53,13 +53,13 @@ int main(int argc, char *argv[]) {
   simplices.push_back(Simplex(Vertex_handle(2), Vertex_handle(0)));
   complex = Complex(simplices.begin(), simplices.end());
 
-  std::cout << "Simplices:" << std::endl;
+  std::clog << "Simplices:" << std::endl;
   for (const Simplex & s : complex.complex_simplex_range())
-    std::cout << s << " ";
-  std::cout << std::endl;
+    std::clog << s << " ";
+  std::clog << std::endl;
 
   // One blocker as simplex 012 is not in the complex but all its proper faces are.
-  std::cout << "Blockers: " << complex.blockers_to_string() << std::endl;
+  std::clog << "Blockers: " << complex.blockers_to_string() << std::endl;
 
   return EXIT_SUCCESS;
 }
diff --git a/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp b/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp
index 7f301047..62084692 100644
--- a/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp
+++ b/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp
@@ -45,7 +45,7 @@ int main(int argc, char *argv[]) {
   // more appropriated!
   unsigned num_vertices = 0;
   for (auto v : complex.vertex_range()) {
-    std::cout << "Vertex " << v << std::endl;
+    std::clog << "Vertex " << v << std::endl;
     ++num_vertices;
   }
 
@@ -65,9 +65,9 @@ int main(int argc, char *argv[]) {
     else
       euler -= 1;
   }
-  std::cout << "Saw " << num_vertices << " vertices, " << num_edges << " edges and " << num_simplices << " simplices"
+  std::clog << "Saw " << num_vertices << " vertices, " << num_edges << " edges and " << num_simplices << " simplices"
       << std::endl;
-  std::cout << "The Euler Characteristic is " << euler << std::endl;
-  std::cout << skbl_chrono;
+  std::clog << "The Euler Characteristic is " << euler << std::endl;
+  std::clog << skbl_chrono;
   return EXIT_SUCCESS;
 }
diff --git a/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp b/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp
index e634b656..ba7ce43c 100644
--- a/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp
+++ b/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp
@@ -32,25 +32,25 @@ int main(int argc, char *argv[]) {
   Simplex tetrahedron(Vertex_handle(0), Vertex_handle(1), Vertex_handle(2), Vertex_handle(3));
   complex.add_simplex(tetrahedron);
 
-  std::cout << "complex:" << complex.to_string() << std::endl;
+  std::clog << "complex:" << complex.to_string() << std::endl;
 
   // build the link of vertex 1, eg a triangle {0,2,3}
   auto link = complex.link(Vertex_handle(1));
-  std::cout << "link:" << link.to_string() << std::endl;
+  std::clog << "link:" << link.to_string() << std::endl;
 
   // Internally link is a subcomplex of 'complex' and its vertices are stored in a vector.
   // They can be accessed via Vertex_handle(x) where x is an index of the vector.
   // In that example, link has three vertices and thus it contains only
   // Vertex_handle(0),Vertex_handle(1) and Vertex_handle(2) are).
   for (int i = 0; i < 5; ++i)
-    std::cout << "link.contains_vertex(Vertex_handle(" << i << ")):" << link.contains_vertex(Vertex_handle(i)) <<
+    std::clog << "link.contains_vertex(Vertex_handle(" << i << ")):" << link.contains_vertex(Vertex_handle(i)) <<
         std::endl;
-  std::cout << std::endl;
+  std::clog << std::endl;
 
   // To access to the initial vertices eg (0,1,2,3,4),  Root_vertex_handle must be used.
   // For instance, to test if the link contains the vertex that was labeled i:
   for (int i = 0; i < 5; ++i)
-    std::cout << "link.contains_vertex(Root_vertex_handle(" << i << ")):" <<
+    std::clog << "link.contains_vertex(Root_vertex_handle(" << i << ")):" <<
       link.contains_vertex(Root_vertex_handle(i)) << std::endl;
 
   return EXIT_SUCCESS;
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
index bcca851f..653a63fd 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
@@ -154,8 +154,8 @@ of a simplicial complex.
                 else 
                         euler -= 1;
         }
-        std::cout << "Saw "<<num_vertices<<" vertices, "<<num_edges<<" edges and "<<num_simplices<<" simplices"<<std::endl;
-        std::cout << "The Euler Characteristic is "<<euler<<std::endl;
+        std::clog << "Saw "<<num_vertices<<" vertices, "<<num_edges<<" edges and "<<num_simplices<<" simplices"<<std::endl;
+        std::clog << "The Euler Characteristic is "<<euler<<std::endl;
   \endcode
 
 
@@ -182,13 +182,13 @@ The Euler Characteristic is 1
         //get complex from top faces
         make_complex_from_top_faces(complex,simplices.begin(),simplices.end());
 
-        std::cout << "Simplices:"<<std::endl;
+        std::clog << "Simplices:"<<std::endl;
         for(const Simplex & s : complex.star_simplex_range())
-                std::cout << s << " ";
-        std::cout << std::endl;
+                std::clog << s << " ";
+        std::clog << std::endl;
 
         //One blocker as simplex 0123 is not in the complex but all its proper faces are.
-        std::cout << "Blockers: "<<complex.blockers_to_string()<<std::endl;
+        std::clog << "Blockers: "<<complex.blockers_to_string()<<std::endl;
 
         //now build a complex from its full list of simplices
         simplices.clear();
@@ -200,13 +200,13 @@ The Euler Characteristic is 1
         simplices.push_back(Simplex(Vertex_handle(2),Vertex_handle(0)));
         complex = Complex(simplices.begin(),simplices.end());
 
-        std::cout << "Simplices:"<<std::endl;
+        std::clog << "Simplices:"<<std::endl;
         for(const Simplex & s : complex.star_simplex_range())
-                std::cout << s << " ";
-        std::cout << std::endl;
+                std::clog << s << " ";
+        std::clog << std::endl;
 
         //One blocker as simplex 012 is not in the complex but all its proper faces are.
-        std::cout << "Blockers: "<<complex.blockers_to_string()<<std::endl;
+        std::clog << "Blockers: "<<complex.blockers_to_string()<<std::endl;
  \endcode
 \verbatim
 ./SkeletonBlockerFromSimplices
diff --git a/src/Skeleton_blocker/test/test_skeleton_blocker_complex.cpp b/src/Skeleton_blocker/test/test_skeleton_blocker_complex.cpp
index 4336e33b..96438acf 100644
--- a/src/Skeleton_blocker/test/test_skeleton_blocker_complex.cpp
+++ b/src/Skeleton_blocker/test/test_skeleton_blocker_complex.cpp
@@ -91,10 +91,10 @@ BOOST_AUTO_TEST_CASE(test_skeleton_num_simplices) {
 BOOST_AUTO_TEST_CASE(test_skeleton_iterator_vertices1) {
   int n = 10;
   Complex complex(10);
-  std::cout << "complex.num_vertices():" << complex.num_vertices() << std::endl;
+  std::clog << "complex.num_vertices():" << complex.num_vertices() << std::endl;
   int num_vertex_seen = 0;
   for (auto vi : complex.vertex_range()) {
-    std::cout << "vertex:" << vi << std::endl;
+    std::clog << "vertex:" << vi << std::endl;
     ++num_vertex_seen;
   }
   BOOST_CHECK(num_vertex_seen == n);
@@ -104,14 +104,14 @@ BOOST_AUTO_TEST_CASE(test_skeleton_iterator_vertices2) {
   int n = 10;
   Complex complex;
   build_complete(10, complex);
-  std::cout << "complex.num_vertices():" << complex.num_vertices() << std::endl;
-  std::cout << "complex.num_edges():" << complex.num_edges() << std::endl;
+  std::clog << "complex.num_vertices():" << complex.num_vertices() << std::endl;
+  std::clog << "complex.num_edges():" << complex.num_edges() << std::endl;
   int num_vertex_seen = 0;
   for (auto vi : complex.vertex_range(Vertex_handle(2))) {
-    std::cout << "vertex:" << vi << std::endl;
+    std::clog << "vertex:" << vi << std::endl;
     ++num_vertex_seen;
   }
-  std::cout << "num_vertex_seen:" << num_vertex_seen << std::endl;
+  std::clog << "num_vertex_seen:" << num_vertex_seen << std::endl;
   BOOST_CHECK(num_vertex_seen == (n -1));
 }
 
@@ -123,10 +123,10 @@ BOOST_AUTO_TEST_CASE(test_skeleton_iterator_edge) {
       complex.add_edge_without_blockers(Vertex_handle(i), Vertex_handle(j));
   complex.remove_edge(Vertex_handle(2), Vertex_handle(3));
   complex.remove_edge(Vertex_handle(3), Vertex_handle(5));
-  std::cout << "complex.num_edges():" << complex.num_edges() << std::endl;
+  std::clog << "complex.num_edges():" << complex.num_edges() << std::endl;
   int num_edges_seen = 0;
   for (auto edge : complex.edge_range()) {
-    std::cout << "edge :" << complex[edge] << std::endl;
+    std::clog << "edge :" << complex[edge] << std::endl;
     ++num_edges_seen;
   }
 
@@ -141,10 +141,10 @@ BOOST_AUTO_TEST_CASE(test_skeleton_iterator_edge2) {
       complex.add_edge_without_blockers(Vertex_handle(i), Vertex_handle(j));
   complex.remove_edge(Vertex_handle(2), Vertex_handle(3));
   complex.remove_edge(Vertex_handle(3), Vertex_handle(5));
-  std::cout << "complex.num_edges():" << complex.num_edges() << std::endl;
+  std::clog << "complex.num_edges():" << complex.num_edges() << std::endl;
   int num_neigbors_seen = 0;
   for (auto neighbor : complex.vertex_range(Vertex_handle(2))) {
-    std::cout << "neighbor" << neighbor << std::endl;
+    std::clog << "neighbor" << neighbor << std::endl;
     ++num_neigbors_seen;
   }
   BOOST_CHECK(num_neigbors_seen == 8);
@@ -160,7 +160,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_iterator_triangles) {
     complex.add_edge_without_blockers(Vertex_handle(i), Vertex_handle(i + 1));
   complex.add_edge_without_blockers(Vertex_handle(1), Vertex_handle(6));
 
-  std::cout << complex.to_string() << std::endl;
+  std::clog << complex.to_string() << std::endl;
 
   int num_triangles_seen = 0;
   //for (auto t : complex.triangle_range(5)){
@@ -214,19 +214,19 @@ BOOST_AUTO_TEST_CASE(test_skeleton_iterator_simplices) {
   expected_num_simplices[Vertex_handle(5)] = 7;
 
   for (auto pair : expected_num_simplices) {
-    std::cout << "found list: ";
+    std::clog << "found list: ";
     unsigned num_simplices_around = 0;
     for (const auto& simplex : complex.star_simplex_range(pair.first)) {
       simplex.dimension();
-      std::cout << simplex << " - ";
+      std::clog << simplex << " - ";
       ++num_simplices_around;
     }
 
     BOOST_CHECK(num_simplices_around == pair.second);
 
-    std::cout << std::endl << "current vertex:" << pair.first << " - ";
-    std::cout << "expected_num_simplices:" << pair.second << " - ";
-    std::cout << "found:" << num_simplices_around << std::endl;
+    std::clog << std::endl << "current vertex:" << pair.first << " - ";
+    std::clog << "expected_num_simplices:" << pair.second << " - ";
+    std::clog << "found:" << num_simplices_around << std::endl;
   }
 }
 
@@ -276,19 +276,19 @@ BOOST_AUTO_TEST_CASE(test_skeleton_iterator_simplices3) {
 BOOST_AUTO_TEST_CASE(test_skeleton_iterator_simplices4) {
   Complex empty_complex;
   for (auto v : empty_complex.vertex_range()) {
-    std::cout << v;
+    std::clog << v;
     BOOST_CHECK(false);
   }
   for (auto e : empty_complex.edge_range()) {
-    std::cout << e;
+    std::clog << e;
     BOOST_CHECK(false);
   }
   for (auto t : empty_complex.triangle_range()) {
-    std::cout << t;
+    std::clog << t;
     BOOST_CHECK(false);
   }
   for (auto s : empty_complex.complex_simplex_range()) {
-    std::cout << s;
+    std::clog << s;
     BOOST_CHECK(false);
   }
 }
@@ -297,7 +297,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_iterator_coboundary) {
   Complex c;
   build_complete(4, c);
   c.remove_edge(Vertex_handle(1), Vertex_handle(3));
-  std::cout << c.to_string();
+  std::clog << c.to_string();
   Simplex s02(Vertex_handle(0), Vertex_handle(2));
   int n = 0;
   std::set<Simplex> expected;
@@ -373,7 +373,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_link0) {
   auto L2 = complex.link(alpha);
   BOOST_CHECK(L == L2);
 
-  std::cout << L.to_string();
+  std::clog << L.to_string();
 
   BOOST_CHECK(L.contains_vertex(*L.get_address(Root_vertex_handle(b))));
   BOOST_CHECK(L.contains_vertex(*L.get_address(Root_vertex_handle(d))));
@@ -432,9 +432,9 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_link2) {
   // Complexes built
 
   // Print result
-  std::cout << "complex complex" << complex.to_string();
-  std::cout << std::endl << std::endl;
-  std::cout << "L= Link_complex(" << alpha << ") : \n" << L.to_string();
+  std::clog << "complex complex" << complex.to_string();
+  std::clog << std::endl << std::endl;
+  std::clog << "L= Link_complex(" << alpha << ") : \n" << L.to_string();
 
   auto L2 = complex.link(alpha);
   BOOST_CHECK(L == L2);
@@ -472,9 +472,9 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_link3) {
   // Complexes built
 
   // Print result
-  std::cout << "complex complex" << complex.to_string();
-  std::cout << std::endl << std::endl;
-  std::cout << "L= Link_complex(" << alpha << ") : \n" << L.to_string();
+  std::clog << "complex complex" << complex.to_string();
+  std::clog << std::endl << std::endl;
+  std::clog << "L= Link_complex(" << alpha << ") : \n" << L.to_string();
 
   auto L2 = complex.link(alpha);
   BOOST_CHECK(L == L2);
@@ -529,8 +529,8 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_link5) {
   // Complexes built
 
   // Print result
-  std::cout << "Complex: " << complex.to_string()<< std::endl << std::endl;
-  std::cout << "Link: " << L.to_string() << std::endl;
+  std::clog << "Complex: " << complex.to_string()<< std::endl << std::endl;
+  std::clog << "Link: " << L.to_string() << std::endl;
 
   // verification
   BOOST_CHECK(L.num_vertices() == 0);
@@ -549,8 +549,8 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_link6) {
   build_link_of_blocker(complex, alpha, link_blocker_alpha);
 
   // Print result
-  std::cout << "Complex: " << complex.to_string()<< std::endl << std::endl;
-  std::cout << "Link: " << link_blocker_alpha.to_string() << std::endl;
+  std::clog << "Complex: " << complex.to_string()<< std::endl << std::endl;
+  std::clog << "Link: " << link_blocker_alpha.to_string() << std::endl;
 
   // verification
   BOOST_CHECK(link_blocker_alpha.num_vertices() == 1);
@@ -579,12 +579,12 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_link7) {
   //the result should be the edge {6,7} plus the blocker {0,1,2}
 
   // Print result
-  std::cout << "Complex: " << complex.to_string()<< std::endl << std::endl;
-  std::cout << "Link: " << link_blocker_alpha.to_string() << std::endl;
+  std::clog << "Complex: " << complex.to_string()<< std::endl << std::endl;
+  std::clog << "Link: " << link_blocker_alpha.to_string() << std::endl;
 
   Skeleton_blocker_link_complex link_blocker_alpha_cpy = link_blocker_alpha;
 
-  std::cout << "Link copy: " << link_blocker_alpha_cpy.to_string() << std::endl;
+  std::clog << "Link copy: " << link_blocker_alpha_cpy.to_string() << std::endl;
 
   BOOST_CHECK(link_blocker_alpha.num_vertices() == link_blocker_alpha_cpy.num_vertices());
   BOOST_CHECK(link_blocker_alpha.num_blockers() == link_blocker_alpha_cpy.num_blockers());
@@ -640,7 +640,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_constructor) {
 
   Complex complex(simplices.begin(), simplices.end());
 
-  std::cout << "Constructor 1:\n" << complex.to_string();
+  std::clog << "Constructor 1:\n" << complex.to_string();
 
   BOOST_CHECK(complex.num_vertices() == 6);
   BOOST_CHECK(complex.num_edges() == 10);
@@ -677,10 +677,10 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_constructor2) {
 
   Complex complex(simplices.begin(), simplices.end());
 
-  std::cout << "Constructor 2:\n" << complex.to_string();
+  std::clog << "Constructor 2:\n" << complex.to_string();
 
   for (auto b : complex.const_blocker_range()) {
-    std::cout << "b:" << b << std::endl;
+    std::clog << "b:" << b << std::endl;
   }
 
   BOOST_CHECK(complex.num_vertices() == 5);
@@ -698,7 +698,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_constructor3) {
 
   Complex complex(simplices.begin(), simplices.end());
 
-  std::cout << "Constructor 3:\n" << complex.to_string();
+  std::clog << "Constructor 3:\n" << complex.to_string();
 
   BOOST_CHECK(complex.num_blockers() == 1);
   Sh expected_blocker(Vh(0), Vh(1), Vh(2));
@@ -723,7 +723,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_constructor4) {
 
   Complex complex(simplices.begin(), simplices.end());
 
-  std::cout << "Constructor 4:\n" << complex.to_string();
+  std::clog << "Constructor 4:\n" << complex.to_string();
   BOOST_CHECK(complex.num_blockers() == 1);
   Sh expected_blocker(Vh(0), Vh(1), Vh(4));
   for (auto b : complex.const_blocker_range())
@@ -753,7 +753,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_constructor5) {
 
   Complex complex(simplices.begin(), simplices.end());
 
-  std::cout << "Constructor 5:\n" << complex.to_string();
+  std::clog << "Constructor 5:\n" << complex.to_string();
 
   BOOST_CHECK(complex.num_vertices() == 6);
   BOOST_CHECK(complex.num_blockers() == 3);
@@ -773,7 +773,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_constructor6) {
 
   Complex complex(simplices.begin(), simplices.end());
 
-  std::cout << "Constructor 6:\n" << complex.to_string();
+  std::clog << "Constructor 6:\n" << complex.to_string();
 
   BOOST_CHECK(complex.num_vertices() == 4);
   BOOST_CHECK(complex.num_blockers() == 1);
@@ -795,7 +795,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_constructor7) {
   //get complex from top faces
   Complex complex(Gudhi::skeleton_blocker::make_complex_from_top_faces<Complex>(simplices.begin(), simplices.end()));
 
-  std::cout << "Constructor 7:\n" << complex.to_string();
+  std::clog << "Constructor 7:\n" << complex.to_string();
 
   BOOST_CHECK(complex.num_vertices() == 4);
   BOOST_CHECK(complex.num_blockers() == 1);
@@ -818,7 +818,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_complex_constructor8) {
   //get complex from top faces
   Complex complex(Gudhi::skeleton_blocker::make_complex_from_top_faces<Complex>(simplices.begin(), simplices.end()));
 
-  std::cout << "Constructor 8:\n" << complex.to_string();
+  std::clog << "Constructor 8:\n" << complex.to_string();
 
   BOOST_CHECK(complex.num_vertices() == 4);
   BOOST_CHECK(complex.num_blockers() == 2);
diff --git a/src/Skeleton_blocker/test/test_skeleton_blocker_geometric_complex.cpp b/src/Skeleton_blocker/test/test_skeleton_blocker_geometric_complex.cpp
index 8cad97a1..9042ddcf 100644
--- a/src/Skeleton_blocker/test/test_skeleton_blocker_geometric_complex.cpp
+++ b/src/Skeleton_blocker/test/test_skeleton_blocker_geometric_complex.cpp
@@ -36,7 +36,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_off_reader_writer) {
   Gudhi::skeleton_blocker::Skeleton_blocker_off_reader<Complex> off_reader("test2.off", complex);
   BOOST_CHECK(off_reader.is_valid());
   
-  std::cout << "complex has " <<
+  std::clog << "complex has " <<
       complex.num_vertices() << " vertices, " <<
       complex.num_blockers() << " blockers, " <<
       complex.num_edges() << " edges and " <<
@@ -50,8 +50,8 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_off_reader_writer) {
   Complex same;
   Gudhi::skeleton_blocker::Skeleton_blocker_off_reader<Complex> off_reader2("tmp.off", same);
 
-  std::cout << "\ncomplex:" << complex.to_string() << std::endl;
-  std::cout << "\nsame:" << same.to_string() << std::endl;
+  std::clog << "\ncomplex:" << complex.to_string() << std::endl;
+  std::clog << "\nsame:" << same.to_string() << std::endl;
 
   BOOST_CHECK(complex == same);
 }
@@ -61,7 +61,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_abstract_link) {
   Gudhi::skeleton_blocker::Skeleton_blocker_off_reader<Complex> off_reader("test2.off", complex);
   BOOST_CHECK(off_reader.is_valid());
 
-  std::cout << "complex has " <<
+  std::clog << "complex has " <<
       complex.num_vertices() << " vertices, " <<
       complex.num_blockers() << " blockers, " <<
       complex.num_edges() << " edges and " <<
@@ -73,7 +73,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_abstract_link) {
 
   auto link_0 = complex.abstract_link(Vertex_handle(0));
 
-  std::cout << "\n link(0):" << link_0.to_string() << std::endl;
+  std::clog << "\n link(0):" << link_0.to_string() << std::endl;
 
   BOOST_CHECK(link_0.num_vertices() == 2);
   BOOST_CHECK(link_0.num_edges() == 1);
@@ -91,13 +91,13 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_abstract_link) {
   BOOST_CHECK(link_0[*(edge_handle)].second() == Root_vertex_handle(4));
 
   auto link_geometric_0 = complex.link(Vertex_handle(0));
-  std::cout << "\n link_geometric(0):" << link_geometric_0.to_string() << std::endl;
+  std::clog << "\n link_geometric(0):" << link_geometric_0.to_string() << std::endl;
 
   BOOST_CHECK(link_0 == link_geometric_0);
 
   auto print_point = [&](Vertex_handle v) {
-    for (auto x : link_geometric_0.point(v)) std::cout << x << " ";
-    std::cout << std::endl;
+    for (auto x : link_geometric_0.point(v)) std::clog << x << " ";
+    std::clog << std::endl;
   };
 
   std::for_each(link_geometric_0.vertex_range().begin(), link_geometric_0.vertex_range().end(), print_point);
diff --git a/src/Skeleton_blocker/test/test_skeleton_blocker_simplifiable.cpp b/src/Skeleton_blocker/test/test_skeleton_blocker_simplifiable.cpp
index b714753d..a85d4ff0 100644
--- a/src/Skeleton_blocker/test/test_skeleton_blocker_simplifiable.cpp
+++ b/src/Skeleton_blocker/test/test_skeleton_blocker_simplifiable.cpp
@@ -49,12 +49,12 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_contraction1) {
                               static_cast<Vertex_handle> (y)));
 
   // Print result
-  std::cout << "complex before complex" << complex.to_string() << std::endl;
+  std::clog << "complex before complex" << complex.to_string() << std::endl;
 
-  std::cout << std::endl << std::endl;
+  std::clog << std::endl << std::endl;
   complex.contract_edge(static_cast<Vertex_handle> (a), static_cast<Vertex_handle> (b));
   // Print result
-  std::cout << "ContractEdge(0,1)\n";
+  std::clog << "ContractEdge(0,1)\n";
   PRINT(complex.to_string());
 
   // verification
@@ -89,13 +89,13 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_contraction2) {
   complex.add_blocker(blocker);
 
   // Print result
-  std::cout << "complex complex" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "complex complex" << complex.to_string();
+  std::clog << std::endl << std::endl;
   complex.contract_edge(static_cast<Vertex_handle> (a), static_cast<Vertex_handle> (b));
 
-  std::cout << "complex.ContractEdge(a,b)" << complex.to_string();
+  std::clog << "complex.ContractEdge(a,b)" << complex.to_string();
 
-  std::cout << std::endl << std::endl;
+  std::clog << std::endl << std::endl;
 
   // there should be one blocker (a,c,d,e) in the complex
   BOOST_CHECK(complex.contains_blocker(Simplex(static_cast<Vertex_handle> (a), static_cast<Vertex_handle> (x),
@@ -110,8 +110,8 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_link_condition1) {
   complex.add_blocker(Simplex(static_cast<Vertex_handle> (0), static_cast<Vertex_handle> (1), static_cast<Vertex_handle> (2)));
 
   // Print result
-  std::cout << "complex complex" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "complex complex" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   BOOST_CHECK(complex.link_condition(Vertex_handle(1), Vertex_handle(2), true));
 
@@ -125,13 +125,13 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_collapse0) {
   complex.add_edge_without_blockers(static_cast<Vertex_handle> (2), static_cast<Vertex_handle> (4));
   complex.add_edge_without_blockers(static_cast<Vertex_handle> (3), static_cast<Vertex_handle> (4));
   // Print result
-  std::cout << "initial complex :\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "initial complex :\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   Simplex simplex_123(static_cast<Vertex_handle> (1), static_cast<Vertex_handle> (2), static_cast<Vertex_handle> (3));
   complex.remove_star(simplex_123);
-  std::cout << "complex.remove_star(1,2,3):\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "complex.remove_star(1,2,3):\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   // verification
   BOOST_CHECK(complex.contains_blocker(simplex_123));
@@ -142,13 +142,13 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_collapse1) {
   build_complete(4, complex);
   complex.add_blocker(Simplex(Vertex_handle(0), Vertex_handle(1), Vertex_handle(2), Vertex_handle(3)));
   // Print result
-  std::cout << "initial complex :\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "initial complex :\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   Simplex simplex_123(Vertex_handle(1), Vertex_handle(2), Vertex_handle(3));
   complex.remove_star(simplex_123);
-  std::cout << "complex.remove_star(1,2,3):\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "complex.remove_star(1,2,3):\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   // verification
   BOOST_CHECK(complex.contains_blocker(simplex_123));
@@ -164,13 +164,13 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_collapse2) {
   complex.add_edge_without_blockers(Vertex_handle(3), Vertex_handle(4));
   complex.add_blocker(Simplex(Vertex_handle(1), Vertex_handle(2), Vertex_handle(3), Vertex_handle(4)));
   // Print result
-  std::cout << "initial complex :\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "initial complex :\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   Simplex sigma(Vertex_handle(1), Vertex_handle(2), Vertex_handle(3));
   complex.remove_star(sigma);
-  std::cout << "complex.remove_star(1,2,3):\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "complex.remove_star(1,2,3):\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   // verification
   BOOST_CHECK(!complex.contains_blocker(Simplex(Vertex_handle(1), Vertex_handle(2),
@@ -187,11 +187,11 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_collapse3) {
   complex.add_edge_without_blockers(Vertex_handle(3), Vertex_handle(4));
   complex.add_blocker(Simplex(Vertex_handle(1), Vertex_handle(2), Vertex_handle(3), Vertex_handle(4)));
   // Print result
-  std::cout << "initial complex:\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "initial complex:\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   complex.remove_star(static_cast<Vertex_handle> (2));
-  std::cout << "complex after remove star of 2:\n" << complex.to_string();
+  std::clog << "complex after remove star of 2:\n" << complex.to_string();
 
   BOOST_CHECK(complex.contains_blocker(Simplex(Vertex_handle(1), Vertex_handle(3), Vertex_handle(4))));
   BOOST_CHECK(!complex.contains_blocker(Simplex(Vertex_handle(1), Vertex_handle(2),
@@ -202,11 +202,11 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_add_simplex) {
   Complex complex(4);
   build_complete(4, complex);
   complex.add_blocker(Simplex(Vertex_handle(0), Vertex_handle(1), Vertex_handle(3)));
-  std::cout << "initial complex:\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "initial complex:\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   complex.add_simplex(Simplex(Vertex_handle(0), Vertex_handle(1), Vertex_handle(3)));
-  std::cout << "complex after add_simplex:\n" << complex.to_string();
+  std::clog << "complex after add_simplex:\n" << complex.to_string();
   BOOST_CHECK(complex.num_blockers() == 1);
   BOOST_CHECK(complex.contains_blocker(Simplex(Vertex_handle(0), Vertex_handle(1),
                                                Vertex_handle(2), Vertex_handle(3))));
@@ -216,8 +216,8 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_add_simplex2) {
   Complex complex;
   build_complete(4, complex);
   // Print result
-  std::cout << "initial complex:\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "initial complex:\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   Complex copy(complex.num_vertices());
 
@@ -232,7 +232,7 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_add_simplex2) {
       copy.add_simplex(simplex);
   }
 
-  std::cout << "complex after add_simplex:\n" << copy.to_string();
+  std::clog << "complex after add_simplex:\n" << copy.to_string();
 
   BOOST_CHECK(complex.num_blockers() == copy.num_blockers());
   BOOST_CHECK(complex.num_edges() == copy.num_edges());
@@ -246,11 +246,11 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_add_simplex3) {
   Simplex sigma(Vertex_handle(0), Vertex_handle(1), Vertex_handle(2));
   complex.add_blocker(sigma);
   // Print result
-  std::cout << "initial complex:\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "initial complex:\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
   complex.add_simplex(sigma);
   //should create two blockers 0123 and 0124
-  std::cout << "complex after adding simplex 012:\n" << complex.to_string();
+  std::clog << "complex after adding simplex 012:\n" << complex.to_string();
   BOOST_CHECK(complex.num_blockers() == 2);
   BOOST_CHECK(complex.contains_blocker(Simplex(Vertex_handle(0), Vertex_handle(1),
                                                Vertex_handle(2), Vertex_handle(3))));
@@ -292,11 +292,11 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_add_edge) {
     complex.add_edge(Vertex_handle(i), Vertex_handle((i + 1) % 4));
 
   // Print result
-  std::cout << "initial complex:\n" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "initial complex:\n" << complex.to_string();
+  std::clog << std::endl << std::endl;
   complex.add_edge(Vertex_handle(1), Vertex_handle(3));
   //should create two blockers 013 and 012
-  std::cout << "complex after adding edge 13:\n" << complex.to_string();
+  std::clog << "complex after adding edge 13:\n" << complex.to_string();
   BOOST_CHECK(complex.num_blockers() == 2);
   BOOST_CHECK(complex.contains_blocker(Simplex(Vertex_handle(0), Vertex_handle(1), Vertex_handle(3))));
   BOOST_CHECK(complex.contains_blocker(Simplex(Vertex_handle(1), Vertex_handle(2), Vertex_handle(3))));
@@ -313,12 +313,12 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_remove_popable_blockers)
 
   complex.add_blocker(sigma1);
   complex.add_blocker(sigma2);
-  std::cout << "complex complex" << complex.to_string();
-  std::cout << std::endl << std::endl;
-  std::cout << "complex.RemovePopableBlockers();" << std::endl;
+  std::clog << "complex complex" << complex.to_string();
+  std::clog << std::endl << std::endl;
+  std::clog << "complex.RemovePopableBlockers();" << std::endl;
   complex.remove_popable_blockers();
-  std::cout << "complex complex" << complex.to_string();
-  std::cout << std::endl << std::endl;
+  std::clog << "complex complex" << complex.to_string();
+  std::clog << std::endl << std::endl;
 
   BOOST_CHECK(complex.num_blockers() == 1);
 
@@ -337,12 +337,12 @@ BOOST_AUTO_TEST_CASE(test_skeleton_blocker_simplifiable_remove_popable_blockers)
 
   complex.add_blocker(sigma1);
   complex.add_blocker(sigma2);
-  std::cout << "complex complex" << complex.to_string();
-  std::cout << std::endl << std::endl;
-  std::cout << "complex.RemovePopableBlockers();" << std::endl;
+  std::clog << "complex complex" << complex.to_string();
+  std::clog << std::endl << std::endl;
+  std::clog << "complex.RemovePopableBlockers();" << std::endl;
   complex.remove_popable_blockers();
-  std::cout << "complex complex" << complex.to_string();
+  std::clog << "complex complex" << complex.to_string();
 
-  std::cout << std::endl << std::endl;
+  std::clog << std::endl << std::endl;
   BOOST_CHECK(complex.num_blockers() == 0);
 }
diff --git a/src/Spatial_searching/example/example_spatial_searching.cpp b/src/Spatial_searching/example/example_spatial_searching.cpp
index 034ad24a..8f9151fc 100644
--- a/src/Spatial_searching/example/example_spatial_searching.cpp
+++ b/src/Spatial_searching/example/example_spatial_searching.cpp
@@ -23,38 +23,38 @@ int main(void) {
   Points_ds points_ds(points);
 
   // 10-nearest neighbor query
-  std::cout << "10 nearest neighbors from points[20]:\n";
+  std::clog << "10 nearest neighbors from points[20]:\n";
   auto knn_range = points_ds.k_nearest_neighbors(points[20], 10, true);
   for (auto const& nghb : knn_range)
-    std::cout << nghb.first << " (sq. dist. = " << nghb.second << ")\n";
+    std::clog << nghb.first << " (sq. dist. = " << nghb.second << ")\n";
 
   // Incremental nearest neighbor query
-  std::cout << "Incremental nearest neighbors:\n";
+  std::clog << "Incremental nearest neighbors:\n";
   auto inn_range = points_ds.incremental_nearest_neighbors(points[45]);
   // Get the neighbors in distance order until we hit the first point
   for (auto ins_iterator = inn_range.begin(); ins_iterator->first != 0; ++ins_iterator)
-    std::cout << ins_iterator->first << " (sq. dist. = " << ins_iterator->second << ")\n";
+    std::clog << ins_iterator->first << " (sq. dist. = " << ins_iterator->second << ")\n";
 
   // 10-furthest neighbor query
-  std::cout << "10 furthest neighbors from points[20]:\n";
+  std::clog << "10 furthest neighbors from points[20]:\n";
   auto kfn_range = points_ds.k_furthest_neighbors(points[20], 10, true);
   for (auto const& nghb : kfn_range)
-    std::cout << nghb.first << " (sq. dist. = " << nghb.second << ")\n";
+    std::clog << nghb.first << " (sq. dist. = " << nghb.second << ")\n";
 
   // Incremental furthest neighbor query
-  std::cout << "Incremental furthest neighbors:\n";
+  std::clog << "Incremental furthest neighbors:\n";
   auto ifn_range = points_ds.incremental_furthest_neighbors(points[45]);
   // Get the neighbors in distance reverse order until we hit the first point
   for (auto ifs_iterator = ifn_range.begin(); ifs_iterator->first != 0; ++ifs_iterator)
-    std::cout << ifs_iterator->first << " (sq. dist. = " << ifs_iterator->second << ")\n";
+    std::clog << ifs_iterator->first << " (sq. dist. = " << ifs_iterator->second << ")\n";
 
   // All-near-neighbors search
-  std::cout << "All-near-neighbors search:\n";
+  std::clog << "All-near-neighbors search:\n";
   std::vector<std::size_t> rs_result;
   points_ds.all_near_neighbors(points[45], 0.5, std::back_inserter(rs_result));
   K k;
   for (auto const& p_idx : rs_result)
-    std::cout << p_idx << " (sq. dist. = " << k.squared_distance_d_object()(points[p_idx], points[45]) << ")\n";
+    std::clog << p_idx << " (sq. dist. = " << k.squared_distance_d_object()(points[p_idx], points[45]) << ")\n";
 
   return 0;
 }
diff --git a/src/Subsampling/example/example_choose_n_farthest_points.cpp b/src/Subsampling/example/example_choose_n_farthest_points.cpp
index 5cfeb4d8..27cf5d4e 100644
--- a/src/Subsampling/example/example_choose_n_farthest_points.cpp
+++ b/src/Subsampling/example/example_choose_n_farthest_points.cpp
@@ -23,8 +23,8 @@ int main(void) {
   Gudhi::subsampling::choose_n_farthest_points(k, points, 100,
                                                Gudhi::subsampling::random_starting_point,
                                                std::back_inserter(results));
-  std::cout << "Before sparsification: " << points.size() << " points.\n";
-  std::cout << "After  sparsification: " << results.size() << " points.\n";
+  std::clog << "Before sparsification: " << points.size() << " points.\n";
+  std::clog << "After  sparsification: " << results.size() << " points.\n";
 
   return 0;
 }
diff --git a/src/Subsampling/example/example_custom_kernel.cpp b/src/Subsampling/example/example_custom_kernel.cpp
index f1eb757b..535bf42a 100644
--- a/src/Subsampling/example/example_custom_kernel.cpp
+++ b/src/Subsampling/example/example_custom_kernel.cpp
@@ -55,9 +55,9 @@ int main(void) {
   Gudhi::subsampling::choose_n_farthest_points(k, points, 2,
                                                Gudhi::subsampling::random_starting_point,
                                                std::back_inserter(results));
-  std::cout << "Before sparsification: " << points.size() << " points.\n";
-  std::cout << "After  sparsification: " << results.size() << " points.\n";
-  std::cout << "Result table: {" << results[0] << "," << results[1] << "}\n";
+  std::clog << "Before sparsification: " << points.size() << " points.\n";
+  std::clog << "After  sparsification: " << results.size() << " points.\n";
+  std::clog << "Result table: {" << results[0] << "," << results[1] << "}\n";
 
   return 0;
 }
diff --git a/src/Subsampling/example/example_pick_n_random_points.cpp b/src/Subsampling/example/example_pick_n_random_points.cpp
index 25266403..316feed1 100644
--- a/src/Subsampling/example/example_pick_n_random_points.cpp
+++ b/src/Subsampling/example/example_pick_n_random_points.cpp
@@ -21,8 +21,8 @@ int main(void) {
   K k;
   std::vector<Point_d> results;
   Gudhi::subsampling::pick_n_random_points(points, 100, std::back_inserter(results));
-  std::cout << "Before sparsification: " << points.size() << " points.\n";
-  std::cout << "After  sparsification: " << results.size() << " points.\n";
+  std::clog << "Before sparsification: " << points.size() << " points.\n";
+  std::clog << "After  sparsification: " << results.size() << " points.\n";
 
   return 0;
 }
diff --git a/src/Subsampling/example/example_sparsify_point_set.cpp b/src/Subsampling/example/example_sparsify_point_set.cpp
index a8caa720..1e2c38c1 100644
--- a/src/Subsampling/example/example_sparsify_point_set.cpp
+++ b/src/Subsampling/example/example_sparsify_point_set.cpp
@@ -21,8 +21,8 @@ int main(void) {
   K k;
   std::vector<Point_d> results;
   Gudhi::subsampling::sparsify_point_set(k, points, 0.4, std::back_inserter(results));
-  std::cout << "Before sparsification: " << points.size() << " points.\n";
-  std::cout << "After  sparsification: " << results.size() << " points.\n";
+  std::clog << "Before sparsification: " << points.size() << " points.\n";
+  std::clog << "After  sparsification: " << results.size() << " points.\n";
 
   return 0;
 }
diff --git a/src/Subsampling/test/test_pick_n_random_points.cpp b/src/Subsampling/test/test_pick_n_random_points.cpp
index 018fb8d2..fafae2af 100644
--- a/src/Subsampling/test/test_pick_n_random_points.cpp
+++ b/src/Subsampling/test/test_pick_n_random_points.cpp
@@ -49,9 +49,9 @@ BOOST_AUTO_TEST_CASE(test_pick_n_random_points)
 
   std::vector<Point_d> results;
   Gudhi::subsampling::pick_n_random_points(vect, 5, std::back_inserter(results));
-  std::cout << "landmark vector contains: ";
+  std::clog << "landmark vector contains: ";
   for (auto l: results)
-    std::cout << l << "\n";
+    std::clog << l << "\n";
   
   BOOST_CHECK(results.size() == 5);
 }
diff --git a/src/Subsampling/test/test_sparsify_point_set.cpp b/src/Subsampling/test/test_sparsify_point_set.cpp
index 587ab3ad..cdcfbff5 100644
--- a/src/Subsampling/test/test_sparsify_point_set.cpp
+++ b/src/Subsampling/test/test_sparsify_point_set.cpp
@@ -34,10 +34,10 @@ BOOST_AUTO_TEST_CASE(test_sparsify_point_set)
   K k;
   std::vector<Point_d> results;
   Gudhi::subsampling::sparsify_point_set(k, points, 0.5, std::back_inserter(results));
-  std::cout << "Before sparsification: " << points.size() << " points.\n";
-  std::cout << "After  sparsification: " << results.size() << " points.\n";
+  std::clog << "Before sparsification: " << points.size() << " points.\n";
+  std::clog << "After  sparsification: " << results.size() << " points.\n";
   //for (auto p : results)
-  //  std::cout << p << "\n";
+  //  std::clog << p << "\n";
 
   BOOST_CHECK(points.size() > results.size());
 }
diff --git a/src/Tangential_complex/test/test_tangential_complex.cpp b/src/Tangential_complex/test/test_tangential_complex.cpp
index 46caec54..023c1e1a 100644
--- a/src/Tangential_complex/test/test_tangential_complex.cpp
+++ b/src/Tangential_complex/test/test_tangential_complex.cpp
@@ -76,14 +76,14 @@ BOOST_AUTO_TEST_CASE(test_mini_tangential) {
   points.push_back(Point(point.size(), point.begin(), point.end()));
   point = {1.0, 1.0};
   points.push_back(Point(point.size(), point.begin(), point.end()));
-  std::cout << "points = " << points.size() << std::endl;
+  std::clog << "points = " << points.size() << std::endl;
   Kernel k;
 
   // Compute the TC
   TC tc(points, INTRINSIC_DIM, k);
   tc.compute_tangential_complex();
   TC::Num_inconsistencies num_inc = tc.number_of_inconsistent_simplices();
-  std::cout << "TC vertices = " << tc.number_of_vertices() << " - simplices = " << num_inc.num_simplices <<
+  std::clog << "TC vertices = " << tc.number_of_vertices() << " - simplices = " << num_inc.num_simplices <<
                " - inc simplices = " << num_inc.num_inconsistent_simplices <<
                " - inc stars = " << num_inc.num_inconsistent_stars << std::endl;
 
@@ -95,7 +95,7 @@ BOOST_AUTO_TEST_CASE(test_mini_tangential) {
   // Export the TC into a Simplex_tree
   Gudhi::Simplex_tree<> stree;
   tc.create_complex(stree);
-  std::cout << "ST vertices = " << stree.num_vertices() << " - simplices = " << stree.num_simplices() << std::endl;
+  std::clog << "ST vertices = " << stree.num_vertices() << " - simplices = " << stree.num_simplices() << std::endl;
 
   BOOST_CHECK(stree.num_vertices() == 4);
   BOOST_CHECK(stree.num_simplices() == 6);
@@ -109,7 +109,7 @@ BOOST_AUTO_TEST_CASE(test_mini_tangential) {
 
   // Export the TC into a Simplex_tree
   tc.create_complex(stree);
-  std::cout << "ST vertices = " << stree.num_vertices() << " - simplices = " << stree.num_simplices() << std::endl;
+  std::clog << "ST vertices = " << stree.num_vertices() << " - simplices = " << stree.num_simplices() << std::endl;
 
   BOOST_CHECK(stree.num_vertices() == 4);
   BOOST_CHECK(stree.num_simplices() == 6);
@@ -139,7 +139,7 @@ BOOST_AUTO_TEST_CASE(test_basic_example_throw) {
   // Compute the TC
   TC tc(points, INTRINSIC_DIM, k);
   tc.set_max_squared_edge_length(0.01);
-  std::cout << "test_basic_example_throw - set_max_squared_edge_length(0.01) to make GUDHI_CHECK fail" << std::endl;
+  std::clog << "test_basic_example_throw - set_max_squared_edge_length(0.01) to make GUDHI_CHECK fail" << std::endl;
   BOOST_CHECK_THROW(tc.compute_tangential_complex(), std::invalid_argument);
 
 }
diff --git a/src/Toplex_map/benchmark/benchmark_tm.cpp b/src/Toplex_map/benchmark/benchmark_tm.cpp
index feb5d01c..d078fcf8 100644
--- a/src/Toplex_map/benchmark/benchmark_tm.cpp
+++ b/src/Toplex_map/benchmark/benchmark_tm.cpp
@@ -25,10 +25,10 @@ typedef std::pair<Simplex_tree<>::Simplex_handle, bool> typePairSimplexBool;
 class ST_wrapper {
  public:
   void insert_simplex(const Simplex& tau) {
-    /*std::cout << "insert_simplex - " << simplexTree.num_simplices() << " - ";
+    /*std::clog << "insert_simplex - " << simplexTree.num_simplices() << " - ";
     for (auto v : tau)
-      std::cout << v << ", ";
-    std::cout << std::endl;
+      std::clog << v << ", ";
+    std::clog << std::endl;
     */
     simplexTree.insert_simplex_and_subfaces(tau);
   }
@@ -104,22 +104,22 @@ void chrono(int n, int d) {
   auto c2 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
 
   if (c3 > 0)
-    std::cout << c1 << "\t \t" << c2 << "\t \t" << c3 << "\t \t" << K.num_maximal_simplices() << std::endl;
+    std::clog << c1 << "\t \t" << c2 << "\t \t" << c3 << "\t \t" << K.num_maximal_simplices() << std::endl;
   else
-    std::cout << c1 << "\t \t" << c2 << "\t \tN/A\t \t" << K.num_maximal_simplices() << std::endl;
+    std::clog << c1 << "\t \t" << c2 << "\t \tN/A\t \t" << K.num_maximal_simplices() << std::endl;
 }
 
 int main() {
   for (int d = 5; d <= 40; d += 5) {
-    std::cout << "d=" << d << " \t  Insertions \t   Membership \t Contractions \t        Size" << std::endl;
-    std::cout << "T Map \t \t";
+    std::clog << "d=" << d << " \t  Insertions \t   Membership \t Contractions \t        Size" << std::endl;
+    std::clog << "T Map \t \t";
     chrono<Toplex_map>(n, d);
-    std::cout << "Lazy \t \t";
+    std::clog << "Lazy \t \t";
     chrono<Lazy_toplex_map>(n, d);
     if (d <= 15) {
-      std::cout << "ST \t \t";
+      std::clog << "ST \t \t";
       chrono<ST_wrapper>(n, d);
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 }
diff --git a/src/Toplex_map/example/simple_toplex_map.cpp b/src/Toplex_map/example/simple_toplex_map.cpp
index 7538c989..c432608e 100644
--- a/src/Toplex_map/example/simple_toplex_map.cpp
+++ b/src/Toplex_map/example/simple_toplex_map.cpp
@@ -31,72 +31,72 @@ int main(int argc, char* const argv[]) {
   /*  o---o        */
   /*  1   3        */
 
-  std::cout << "num max simplices = " << tm.num_maximal_simplices() << " - num vertices = " << tm.num_vertices()
+  std::clog << "num max simplices = " << tm.num_maximal_simplices() << " - num vertices = " << tm.num_vertices()
             << std::endl;
 
   // Browse maximal cofaces
   Simplex sigma3 = {2, 3};
-  std::cout << "Maximal cofaces of {2, 3} are :" << std::endl;
+  std::clog << "Maximal cofaces of {2, 3} are :" << std::endl;
   for (auto simplex_ptr : tm.maximal_cofaces(sigma3, 2)) {
     for (auto v : *simplex_ptr) {
-      std::cout << v << ", ";
+      std::clog << v << ", ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   // Browse maximal simplices
-  std::cout << "Maximal simplices are :" << std::endl;
+  std::clog << "Maximal simplices are :" << std::endl;
   for (auto simplex_ptr : tm.maximal_simplices()) {
     for (auto v : *simplex_ptr) {
-      std::cout << v << ", ";
+      std::clog << v << ", ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   Simplex sigma4 = {1, 3};
   assert(tm.membership(sigma4));
 
   Gudhi::Toplex_map::Vertex v = tm.contraction(1, 3);
-  std::cout << "After contraction(1, 3) - " << v << std::endl;
+  std::clog << "After contraction(1, 3) - " << v << std::endl;
   /* Simplex is:   */
   /*    2   4      */
   /*    o---o      */
   /*     \5/       */
   /*      o        */
   /*      3        */
-  std::cout << "num max simplices = " << tm.num_maximal_simplices() << " - num vertices = " << tm.num_vertices()
+  std::clog << "num max simplices = " << tm.num_maximal_simplices() << " - num vertices = " << tm.num_vertices()
             << std::endl;
 
   // Browse maximal simplices
-  std::cout << "Maximal simplices are :" << std::endl;
+  std::clog << "Maximal simplices are :" << std::endl;
   for (auto simplex_ptr : tm.maximal_simplices()) {
     for (auto v : *simplex_ptr) {
-      std::cout << v << ", ";
+      std::clog << v << ", ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   Simplex sigma5 = {3, 4};
   assert(tm.membership(sigma5));
 
   v = tm.contraction(3, 4);
-  std::cout << "After contraction(3, 4) - " << v << std::endl;
+  std::clog << "After contraction(3, 4) - " << v << std::endl;
   /* Simplex is:   */
   /*    2   4      */
   /*    o---o      */
   /*     \X/       */
   /*      o        */
   /*      5        */
-  std::cout << "num max simplices = " << tm.num_maximal_simplices() << " - num vertices = " << tm.num_vertices()
+  std::clog << "num max simplices = " << tm.num_maximal_simplices() << " - num vertices = " << tm.num_vertices()
             << std::endl;
 
   // Browse maximal simplices
-  std::cout << "Maximal simplices are :" << std::endl;
+  std::clog << "Maximal simplices are :" << std::endl;
   for (auto simplex_ptr : tm.maximal_simplices()) {
     for (auto v : *simplex_ptr) {
-      std::cout << v << ", ";
+      std::clog << v << ", ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   tm.insert_simplex(sigma1);
@@ -109,44 +109,44 @@ int main(int argc, char* const argv[]) {
   /*  1   3        */
   tm.remove_simplex(sigma1);
 
-  std::cout << "After remove_simplex(1, 2, 3)" << std::endl;
+  std::clog << "After remove_simplex(1, 2, 3)" << std::endl;
   /* Simplex is:   */
   /*    2   4      */
   /*    o---o      */
   /*   / \5/       */
   /*  o---o        */
   /*  1   3        */
-  std::cout << "num max simplices = " << tm.num_maximal_simplices() << " - num vertices = " << tm.num_vertices()
+  std::clog << "num max simplices = " << tm.num_maximal_simplices() << " - num vertices = " << tm.num_vertices()
             << std::endl;
 
   // Browse maximal simplices
-  std::cout << "Maximal simplices are :" << std::endl;
+  std::clog << "Maximal simplices are :" << std::endl;
   for (auto simplex_ptr : tm.maximal_simplices()) {
     for (auto v : *simplex_ptr) {
-      std::cout << v << ", ";
+      std::clog << v << ", ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   tm.remove_vertex(1);
 
-  std::cout << "After remove_vertex(1)" << std::endl;
+  std::clog << "After remove_vertex(1)" << std::endl;
   /* Simplex is:   */
   /*    2   4      */
   /*    o---o      */
   /*     \5/       */
   /*      o        */
   /*      3        */
-  std::cout << "num max simplices = " << tm.num_maximal_simplices() << " - num vertices = " << tm.num_vertices()
+  std::clog << "num max simplices = " << tm.num_maximal_simplices() << " - num vertices = " << tm.num_vertices()
             << std::endl;
 
   // Browse maximal simplices
-  std::cout << "Maximal simplices are :" << std::endl;
+  std::clog << "Maximal simplices are :" << std::endl;
   for (auto simplex_ptr : tm.maximal_simplices()) {
     for (auto v : *simplex_ptr) {
-      std::cout << v << ", ";
+      std::clog << v << ", ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
 
   return 0;
diff --git a/src/Toplex_map/test/lazy_toplex_map_unit_test.cpp b/src/Toplex_map/test/lazy_toplex_map_unit_test.cpp
index 639bf35a..994cee8e 100644
--- a/src/Toplex_map/test/lazy_toplex_map_unit_test.cpp
+++ b/src/Toplex_map/test/lazy_toplex_map_unit_test.cpp
@@ -20,43 +20,43 @@ BOOST_AUTO_TEST_CASE(toplex_map) {
   using Vertex = Gudhi::Lazy_toplex_map::Vertex;
 
   Gudhi::Lazy_toplex_map tm;
-  std::cout << "insert_simplex {1, 2, 3, 4}" << std::endl;
+  std::clog << "insert_simplex {1, 2, 3, 4}" << std::endl;
   std::vector<Vertex> sigma1 = {1, 2, 3, 4};
   tm.insert_simplex(sigma1);
-  std::cout << "insert_simplex {5, 2, 3, 6}" << std::endl;
+  std::clog << "insert_simplex {5, 2, 3, 6}" << std::endl;
   std::vector<Vertex> sigma2 = {5, 2, 3, 6};
   tm.insert_simplex(sigma2);
-  std::cout << "insert_simplex {5}" << std::endl;
+  std::clog << "insert_simplex {5}" << std::endl;
   std::vector<Vertex> sigma3 = {5};
   tm.insert_simplex(sigma3);
-  std::cout << "insert_simplex {4, 5, 3}" << std::endl;
+  std::clog << "insert_simplex {4, 5, 3}" << std::endl;
   std::vector<Vertex> sigma6 = {4, 5, 3};
   tm.insert_simplex(sigma6);
-  std::cout << "insert_simplex {4, 5, 9}" << std::endl;
+  std::clog << "insert_simplex {4, 5, 9}" << std::endl;
   std::vector<Vertex> sigma7 = {4, 5, 9};
   tm.insert_simplex(sigma7);
 
-  std::cout << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 5);
 
   std::vector<Vertex> sigma4 = {5, 2, 3};
   std::vector<Vertex> sigma5 = {5, 2, 7};
   BOOST_CHECK(tm.membership(sigma4));
   BOOST_CHECK(!tm.membership(sigma5));
-  std::cout << "insert_simplex {5, 2, 7}" << std::endl;
+  std::clog << "insert_simplex {5, 2, 7}" << std::endl;
   tm.insert_simplex(sigma5);
 
-  std::cout << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 6);
 
   BOOST_CHECK(tm.membership(sigma5));
 
-  std::cout << "contraction(4,5)" << std::endl;
+  std::clog << "contraction(4,5)" << std::endl;
   auto r = tm.contraction(4, 5);
-  std::cout << "r=" << r << std::endl;
+  std::clog << "r=" << r << std::endl;
   BOOST_CHECK(r == 5);
 
-  std::cout << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 6);
 
   std::vector<Vertex> sigma8 = {1, 2, 3};
@@ -68,11 +68,11 @@ BOOST_AUTO_TEST_CASE(toplex_map) {
   BOOST_CHECK(tm.membership(sigma8));
   BOOST_CHECK(tm.membership(sigma9));
 
-  std::cout << "remove_simplex({2, 7, r = 5})" << std::endl;
+  std::clog << "remove_simplex({2, 7, r = 5})" << std::endl;
   tm.remove_simplex(sigma9);
   BOOST_CHECK(!tm.membership(sigma9));
 
-  std::cout << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 8);
 
   // {2, 7, 5} is removed, but verify its edges are still there
@@ -88,71 +88,71 @@ BOOST_AUTO_TEST_CASE(toplex_map_empty_toplex) {
   using Vertex = Gudhi::Lazy_toplex_map::Vertex;
 
   Gudhi::Lazy_toplex_map tm;
-  std::cout << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 0);
-  std::cout << "num_vertices = " << tm.num_vertices() << std::endl;
+  std::clog << "num_vertices = " << tm.num_vertices() << std::endl;
   BOOST_CHECK(tm.num_vertices() == 0);
 
-  std::cout << "Check an empty simplex is a member." << std::endl;
+  std::clog << "Check an empty simplex is a member." << std::endl;
   std::vector<Vertex> empty_sigma = {};
   BOOST_CHECK(tm.membership(empty_sigma));
 
-  std::cout << "Check the edge 2,7 is not a member." << std::endl;
+  std::clog << "Check the edge 2,7 is not a member." << std::endl;
   std::vector<Vertex> edge = {2, 7};
   BOOST_CHECK(!tm.membership(edge));
 
-  std::cout << "Insert an empty simplex." << std::endl;
+  std::clog << "Insert an empty simplex." << std::endl;
   tm.insert_simplex(empty_sigma);
 
-  std::cout << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 0);
-  std::cout << "num_vertices = " << tm.num_vertices() << std::endl;
+  std::clog << "num_vertices = " << tm.num_vertices() << std::endl;
   BOOST_CHECK(tm.num_vertices() == 0);
 
-  std::cout << "Check an empty simplex is a member." << std::endl;
+  std::clog << "Check an empty simplex is a member." << std::endl;
   BOOST_CHECK(tm.membership(empty_sigma));
-  std::cout << "Check the edge 2,7 is not a member." << std::endl;
+  std::clog << "Check the edge 2,7 is not a member." << std::endl;
   BOOST_CHECK(!tm.membership(edge));
 
-  std::cout << "Insert edge 2,7." << std::endl;
+  std::clog << "Insert edge 2,7." << std::endl;
   tm.insert_simplex(edge);
 
-  std::cout << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 1);
-  std::cout << "num_vertices = " << tm.num_vertices() << std::endl;
+  std::clog << "num_vertices = " << tm.num_vertices() << std::endl;
   BOOST_CHECK(tm.num_vertices() == 2);
 
-  std::cout << "Check an empty simplex is a member." << std::endl;
+  std::clog << "Check an empty simplex is a member." << std::endl;
   BOOST_CHECK(tm.membership(empty_sigma));
-  std::cout << "Check the edge 2,7 is a member." << std::endl;
+  std::clog << "Check the edge 2,7 is a member." << std::endl;
   BOOST_CHECK(tm.membership(edge));
 
-  std::cout << "contraction(2,7)" << std::endl;
+  std::clog << "contraction(2,7)" << std::endl;
   auto r = tm.contraction(2, 7);
-  std::cout << "r=" << r << std::endl;
+  std::clog << "r=" << r << std::endl;
   BOOST_CHECK(r == 7);
 
-  std::cout << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 1);
-  std::cout << "num_vertices = " << tm.num_vertices() << std::endl;
+  std::clog << "num_vertices = " << tm.num_vertices() << std::endl;
   BOOST_CHECK(tm.num_vertices() == 1);
 
-  std::cout << "Check an empty simplex is a member." << std::endl;
+  std::clog << "Check an empty simplex is a member." << std::endl;
   BOOST_CHECK(tm.membership(empty_sigma));
-  std::cout << "Check the edge 2,7 is not a member." << std::endl;
+  std::clog << "Check the edge 2,7 is not a member." << std::endl;
   BOOST_CHECK(!tm.membership(edge));
 
-  std::cout << "Remove the vertex 7." << std::endl;
+  std::clog << "Remove the vertex 7." << std::endl;
   std::vector<Vertex> vertex = {7};
   tm.remove_simplex(vertex);
 
-  std::cout << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices = " << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 0);
-  std::cout << "num_vertices = " << tm.num_vertices() << std::endl;
+  std::clog << "num_vertices = " << tm.num_vertices() << std::endl;
   BOOST_CHECK(tm.num_vertices() == 0);
 
-  std::cout << "Check an empty simplex is a member." << std::endl;
+  std::clog << "Check an empty simplex is a member." << std::endl;
   BOOST_CHECK(tm.membership(empty_sigma));
-  std::cout << "Check the edge 2,7 is not a member." << std::endl;
+  std::clog << "Check the edge 2,7 is not a member." << std::endl;
   BOOST_CHECK(!tm.membership(edge));
 }
diff --git a/src/Toplex_map/test/toplex_map_unit_test.cpp b/src/Toplex_map/test/toplex_map_unit_test.cpp
index 24ec679b..0d0751ff 100644
--- a/src/Toplex_map/test/toplex_map_unit_test.cpp
+++ b/src/Toplex_map/test/toplex_map_unit_test.cpp
@@ -20,31 +20,31 @@ BOOST_AUTO_TEST_CASE(toplex_map) {
   using Vertex = Gudhi::Toplex_map::Vertex;
 
   Gudhi::Toplex_map tm;
-  std::cout << "insert_simplex {1, 2, 3, 4}" << std::endl;
+  std::clog << "insert_simplex {1, 2, 3, 4}" << std::endl;
   std::vector<Vertex> sigma1 = {1, 2, 3, 4};
   tm.insert_simplex(sigma1);
-  std::cout << "insert_simplex {5, 2, 3, 6}" << std::endl;
+  std::clog << "insert_simplex {5, 2, 3, 6}" << std::endl;
   std::vector<Vertex> sigma2 = {5, 2, 3, 6};
   tm.insert_simplex(sigma2);
-  std::cout << "insert_simplex {5}" << std::endl;
+  std::clog << "insert_simplex {5}" << std::endl;
   std::vector<Vertex> sigma3 = {5};
   tm.insert_simplex(sigma3);
-  std::cout << "insert_simplex {4, 5, 3}" << std::endl;
+  std::clog << "insert_simplex {4, 5, 3}" << std::endl;
   std::vector<Vertex> sigma6 = {4, 5, 3};
   tm.insert_simplex(sigma6);
-  std::cout << "insert_simplex {4, 5, 9}" << std::endl;
+  std::clog << "insert_simplex {4, 5, 9}" << std::endl;
   std::vector<Vertex> sigma7 = {4, 5, 9};
   tm.insert_simplex(sigma7);
 
-  std::cout << "num_maximal_simplices" << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices" << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 4);
   // Browse maximal simplices
-  std::cout << "Maximal simplices are :" << std::endl;
+  std::clog << "Maximal simplices are :" << std::endl;
   for (auto simplex_ptr : tm.maximal_simplices()) {
     for (auto v : *simplex_ptr) {
-      std::cout << v << ", ";
+      std::clog << v << ", ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     BOOST_CHECK(tm.maximality(*simplex_ptr));
   }
 
@@ -58,37 +58,37 @@ BOOST_AUTO_TEST_CASE(toplex_map) {
   std::vector<Vertex> sigma5 = {5, 2, 7};
   BOOST_CHECK(tm.membership(sigma4));
   BOOST_CHECK(!tm.membership(sigma5));
-  std::cout << "insert_simplex {5, 2, 7}" << std::endl;
+  std::clog << "insert_simplex {5, 2, 7}" << std::endl;
   tm.insert_simplex(sigma5);
 
-  std::cout << "num_maximal_simplices" << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices" << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 5);
   // Browse maximal simplices
-  std::cout << "Maximal simplices are :" << std::endl;
+  std::clog << "Maximal simplices are :" << std::endl;
   for (auto simplex_ptr : tm.maximal_simplices()) {
     for (auto v : *simplex_ptr) {
-      std::cout << v << ", ";
+      std::clog << v << ", ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     BOOST_CHECK(tm.maximality(*simplex_ptr));
   }
 
   BOOST_CHECK(tm.membership(sigma5));
 
-  std::cout << "contraction(4,5)" << std::endl;
+  std::clog << "contraction(4,5)" << std::endl;
   auto r = tm.contraction(4, 5);
-  std::cout << "r=" << r << std::endl;
+  std::clog << "r=" << r << std::endl;
   BOOST_CHECK(r == 5);
 
-  std::cout << "num_maximal_simplices" << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices" << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 4);
   // Browse maximal simplices
-  std::cout << "Maximal simplices are :" << std::endl;
+  std::clog << "Maximal simplices are :" << std::endl;
   for (auto simplex_ptr : tm.maximal_simplices()) {
     for (auto v : *simplex_ptr) {
-      std::cout << v << ", ";
+      std::clog << v << ", ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     BOOST_CHECK(tm.maximality(*simplex_ptr));
   }
 
@@ -101,19 +101,19 @@ BOOST_AUTO_TEST_CASE(toplex_map) {
   BOOST_CHECK(tm.membership(sigma8));
   BOOST_CHECK(tm.membership(sigma9));
 
-  std::cout << "remove_simplex({2, 7, r = 5})" << std::endl;
+  std::clog << "remove_simplex({2, 7, r = 5})" << std::endl;
   tm.remove_simplex(sigma9);
   BOOST_CHECK(!tm.membership(sigma9));
 
-  std::cout << "num_maximal_simplices" << tm.num_maximal_simplices() << std::endl;
+  std::clog << "num_maximal_simplices" << tm.num_maximal_simplices() << std::endl;
   BOOST_CHECK(tm.num_maximal_simplices() == 5);
   // Browse maximal simplices
-  std::cout << "Maximal simplices are :" << std::endl;
+  std::clog << "Maximal simplices are :" << std::endl;
   for (auto simplex_ptr : tm.maximal_simplices()) {
     for (auto v : *simplex_ptr) {
-      std::cout << v << ", ";
+      std::clog << v << ", ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
     BOOST_CHECK(tm.maximality(*simplex_ptr));
   }
   // {2, 7, 5} is removed, but verify its edges are still there
diff --git a/src/Witness_complex/example/example_nearest_landmark_table.cpp b/src/Witness_complex/example/example_nearest_landmark_table.cpp
index 441900c1..14101847 100644
--- a/src/Witness_complex/example/example_nearest_landmark_table.cpp
+++ b/src/Witness_complex/example/example_nearest_landmark_table.cpp
@@ -33,7 +33,7 @@ int main(int argc, char * const argv[]) {
   Witness_complex witness_complex(nlt);
   witness_complex.create_complex(simplex_tree, .41);
 
-  std::cout << "Number of simplices: " << simplex_tree.num_simplices() << std::endl;
+  std::clog << "Number of simplices: " << simplex_tree.num_simplices() << std::endl;
 
   Persistent_cohomology pcoh(simplex_tree);
   // initializes the coefficient field for homology
diff --git a/src/Witness_complex/example/example_strong_witness_complex_off.cpp b/src/Witness_complex/example/example_strong_witness_complex_off.cpp
index 19f73836..583a04ab 100644
--- a/src/Witness_complex/example/example_strong_witness_complex_off.cpp
+++ b/src/Witness_complex/example/example_strong_witness_complex_off.cpp
@@ -38,8 +38,8 @@ int main(int argc, char* const argv[]) {
   }
   point_vector = Point_vector(off_reader.get_point_cloud());
 
-  std::cout << "Successfully read " << point_vector.size() << " points.\n";
-  std::cout << "Ambient dimension is " << point_vector[0].dimension() << ".\n";
+  std::clog << "Successfully read " << point_vector.size() << " points.\n";
+  std::clog << "Ambient dimension is " << point_vector[0].dimension() << ".\n";
 
   // Choose landmarks (decomment one of the following two lines)
   // Gudhi::subsampling::pick_n_random_points(point_vector, nbL, std::back_inserter(landmarks));
@@ -52,6 +52,6 @@ int main(int argc, char* const argv[]) {
 
   witness_complex.create_complex(simplex_tree, alpha2, lim_dim);
   end = clock();
-  std::cout << "Strong witness complex took " << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
-  std::cout << "Number of simplices is: " << simplex_tree.num_simplices() << "\n";
+  std::clog << "Strong witness complex took " << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
+  std::clog << "Number of simplices is: " << simplex_tree.num_simplices() << "\n";
 }
diff --git a/src/Witness_complex/example/example_witness_complex_off.cpp b/src/Witness_complex/example/example_witness_complex_off.cpp
index be11c955..3635da78 100644
--- a/src/Witness_complex/example/example_witness_complex_off.cpp
+++ b/src/Witness_complex/example/example_witness_complex_off.cpp
@@ -42,8 +42,8 @@ int main(int argc, char * const argv[]) {
     }
   point_vector = Point_vector(off_reader.get_point_cloud());
 
-  std::cout << "Successfully read " << point_vector.size() << " points.\n";
-  std::cout << "Ambient dimension is " << point_vector[0].dimension() << ".\n";
+  std::clog << "Successfully read " << point_vector.size() << " points.\n";
+  std::clog << "Ambient dimension is " << point_vector[0].dimension() << ".\n";
 
   // Choose landmarks (decomment one of the following two lines)
   // Gudhi::subsampling::pick_n_random_points(point_vector, nbL, std::back_inserter(landmarks));
@@ -56,7 +56,7 @@ int main(int argc, char * const argv[]) {
 
   witness_complex.create_complex(simplex_tree, alpha2, lim_dim);
   end = clock();
-  std::cout << "Witness complex took "
+  std::clog << "Witness complex took "
       << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
-  std::cout << "Number of simplices is: " << simplex_tree.num_simplices() << "\n";
+  std::clog << "Number of simplices is: " << simplex_tree.num_simplices() << "\n";
 }
diff --git a/src/Witness_complex/example/example_witness_complex_sphere.cpp b/src/Witness_complex/example/example_witness_complex_sphere.cpp
index 9e3c972d..78d5db4f 100644
--- a/src/Witness_complex/example/example_witness_complex_sphere.cpp
+++ b/src/Witness_complex/example/example_witness_complex_sphere.cpp
@@ -47,8 +47,8 @@ int main(int argc, char* const argv[]) {
     Gudhi::Simplex_tree<> simplex_tree;
     Point_Vector point_vector, landmarks;
     generate_points_sphere(point_vector, nbP, 4);
-    std::cout << "Successfully generated " << point_vector.size() << " points.\n";
-    std::cout << "Ambient dimension is " << point_vector[0].size() << ".\n";
+    std::clog << "Successfully generated " << point_vector.size() << " points.\n";
+    std::clog << "Ambient dimension is " << point_vector[0].size() << ".\n";
 
     // Choose landmarks
     start = clock();
@@ -62,8 +62,8 @@ int main(int argc, char* const argv[]) {
     witness_complex.create_complex(simplex_tree, 0);
     end = clock();
     double time = static_cast<double>(end - start) / CLOCKS_PER_SEC;
-    std::cout << "Witness complex for " << number_of_landmarks << " landmarks took " << time << " s. \n";
-    std::cout << "Number of simplices is: " << simplex_tree.num_simplices() << "\n";
+    std::clog << "Witness complex for " << number_of_landmarks << " landmarks took " << time << " s. \n";
+    std::clog << "Number of simplices is: " << simplex_tree.num_simplices() << "\n";
     l_time.push_back(std::make_pair(nbP, time));
   }
   write_data(l_time, "w_time.dat");
diff --git a/src/Witness_complex/test/test_euclidean_simple_witness_complex.cpp b/src/Witness_complex/test/test_euclidean_simple_witness_complex.cpp
index 4f718203..9b19f6dc 100644
--- a/src/Witness_complex/test/test_euclidean_simple_witness_complex.cpp
+++ b/src/Witness_complex/test/test_euclidean_simple_witness_complex.cpp
@@ -82,12 +82,12 @@ BOOST_AUTO_TEST_CASE(simple_witness_complex) {
                                                witnesses);
   eucl_witness_complex.create_complex(complex, 0);
 
-  std::cout << "complex.num_simplices() = " << complex.num_simplices() << std::endl;
+  std::clog << "complex.num_simplices() = " << complex.num_simplices() << std::endl;
   BOOST_CHECK(complex.num_simplices() == 24);
 
   eucl_witness_complex.create_complex(relaxed_complex, 8.01);
 
-  std::cout << "relaxed_complex.num_simplices() = " << relaxed_complex.num_simplices() << std::endl;
+  std::clog << "relaxed_complex.num_simplices() = " << relaxed_complex.num_simplices() << std::endl;
   BOOST_CHECK(relaxed_complex.num_simplices() == 239);
   // The corner simplex {0,2,5,7} and its cofaces are missing.
 
@@ -95,12 +95,12 @@ BOOST_AUTO_TEST_CASE(simple_witness_complex) {
   WitnessComplex witness_complex(nearest_landmark_table);
   witness_complex.create_complex(complex_ne, 0);
 
-  std::cout << "complex.num_simplices() = " << complex_ne.num_simplices() << std::endl;
+  std::clog << "complex.num_simplices() = " << complex_ne.num_simplices() << std::endl;
   BOOST_CHECK(complex_ne.num_simplices() == 24);
 
   witness_complex.create_complex(relaxed_complex_ne, 8.01);
 
-  std::cout << "relaxed_complex.num_simplices() = " << relaxed_complex_ne.num_simplices() << std::endl;
+  std::clog << "relaxed_complex.num_simplices() = " << relaxed_complex_ne.num_simplices() << std::endl;
   BOOST_CHECK(relaxed_complex_ne.num_simplices() == 239);
 
 
@@ -111,10 +111,10 @@ BOOST_AUTO_TEST_CASE(simple_witness_complex) {
   eucl_strong_witness_complex.create_complex(strong_relaxed_complex, 9.1);
   eucl_strong_witness_complex.create_complex(strong_relaxed_complex2, 9.1, 2);
 
-  std::cout << "strong_relaxed_complex.num_simplices() = " << strong_relaxed_complex.num_simplices() << std::endl;
+  std::clog << "strong_relaxed_complex.num_simplices() = " << strong_relaxed_complex.num_simplices() << std::endl;
   BOOST_CHECK(strong_relaxed_complex.num_simplices() == 239);
 
-  std::cout << "strong_relaxed_complex2.num_simplices() = " << strong_relaxed_complex2.num_simplices() << std::endl;
+  std::clog << "strong_relaxed_complex2.num_simplices() = " << strong_relaxed_complex2.num_simplices() << std::endl;
   BOOST_CHECK(strong_relaxed_complex2.num_simplices() == 92);
 
 
@@ -124,10 +124,10 @@ BOOST_AUTO_TEST_CASE(simple_witness_complex) {
   strong_witness_complex.create_complex(strong_relaxed_complex_ne, 9.1);
   strong_witness_complex.create_complex(strong_relaxed_complex2_ne, 9.1, 2);
 
-  std::cout << "strong_relaxed_complex.num_simplices() = " << strong_relaxed_complex_ne.num_simplices() << std::endl;
+  std::clog << "strong_relaxed_complex.num_simplices() = " << strong_relaxed_complex_ne.num_simplices() << std::endl;
   BOOST_CHECK(strong_relaxed_complex_ne.num_simplices() == 239);
 
-  std::cout << "strong_relaxed_complex2.num_simplices() = " << strong_relaxed_complex2_ne.num_simplices() << std::endl;
+  std::clog << "strong_relaxed_complex2.num_simplices() = " << strong_relaxed_complex2_ne.num_simplices() << std::endl;
   BOOST_CHECK(strong_relaxed_complex2_ne.num_simplices() == 92);
 
 
diff --git a/src/Witness_complex/test/test_simple_witness_complex.cpp b/src/Witness_complex/test/test_simple_witness_complex.cpp
index 9e3509d3..7c48cc54 100644
--- a/src/Witness_complex/test/test_simple_witness_complex.cpp
+++ b/src/Witness_complex/test/test_simple_witness_complex.cpp
@@ -36,7 +36,7 @@ BOOST_AUTO_TEST_CASE(simple_witness_complex) {
   Witness_complex witness_complex(nlt);
   BOOST_CHECK(witness_complex.create_complex(stree, 4.1));
 
-  std::cout << "Number of simplices: " << stree.num_simplices() << std::endl;
+  std::clog << "Number of simplices: " << stree.num_simplices() << std::endl;
   BOOST_CHECK(stree.num_simplices() == 31);
 
   // Check when complex not empty
@@ -47,7 +47,7 @@ BOOST_AUTO_TEST_CASE(simple_witness_complex) {
   BOOST_CHECK(!witness_complex.create_complex(stree2, -0.02));
 
   witness_complex.create_complex(stree2, 4.1, 2);
-  std::cout << "Number of simplices: " << stree2.num_simplices() << std::endl;
+  std::clog << "Number of simplices: " << stree2.num_simplices() << std::endl;
   BOOST_CHECK(stree2.num_simplices() == 25);
 
 }
diff --git a/src/Witness_complex/utilities/strong_witness_persistence.cpp b/src/Witness_complex/utilities/strong_witness_persistence.cpp
index 75ba1f4b..1f61c77c 100644
--- a/src/Witness_complex/utilities/strong_witness_persistence.cpp
+++ b/src/Witness_complex/utilities/strong_witness_persistence.cpp
@@ -56,8 +56,8 @@ int main(int argc, char* argv[]) {
     exit(-1);  // ----- >>
   }
   witnesses = Point_vector(off_reader.get_point_cloud());
-  std::cout << "Successfully read " << witnesses.size() << " points.\n";
-  std::cout << "Ambient dimension is " << witnesses[0].dimension() << ".\n";
+  std::clog << "Successfully read " << witnesses.size() << " points.\n";
+  std::clog << "Ambient dimension is " << witnesses[0].dimension() << ".\n";
 
   // Choose landmarks (decomment one of the following two lines)
   // Gudhi::subsampling::pick_n_random_points(point_vector, nbL, std::back_inserter(landmarks));
@@ -69,8 +69,8 @@ int main(int argc, char* argv[]) {
 
   strong_witness_complex.create_complex(simplex_tree, max_squared_alpha, lim_d);
 
-  std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
-  std::cout << "   and has dimension " << simplex_tree.dimension() << " \n";
+  std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
+  std::clog << "   and has dimension " << simplex_tree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
   simplex_tree.initialize_filtration();
@@ -107,7 +107,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::cout")(
+      "Name of file in which the persistence diagram is written. Default print in std::clog")(
       "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),
@@ -128,17 +128,17 @@ void program_options(int argc, char* argv[], int& nbL, std::string& file_name, s
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a Strong witness complex defined on a set of input points.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a Strong witness complex defined on a set of input points.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Witness_complex/utilities/weak_witness_persistence.cpp b/src/Witness_complex/utilities/weak_witness_persistence.cpp
index 0e5b9cc1..93050af5 100644
--- a/src/Witness_complex/utilities/weak_witness_persistence.cpp
+++ b/src/Witness_complex/utilities/weak_witness_persistence.cpp
@@ -56,8 +56,8 @@ int main(int argc, char* argv[]) {
     exit(-1);  // ----- >>
   }
   witnesses = Point_vector(off_reader.get_point_cloud());
-  std::cout << "Successfully read " << witnesses.size() << " points.\n";
-  std::cout << "Ambient dimension is " << witnesses[0].dimension() << ".\n";
+  std::clog << "Successfully read " << witnesses.size() << " points.\n";
+  std::clog << "Ambient dimension is " << witnesses[0].dimension() << ".\n";
 
   // Choose landmarks (decomment one of the following two lines)
   // Gudhi::subsampling::pick_n_random_points(point_vector, nbL, std::back_inserter(landmarks));
@@ -69,8 +69,8 @@ int main(int argc, char* argv[]) {
 
   witness_complex.create_complex(simplex_tree, max_squared_alpha, lim_d);
 
-  std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
-  std::cout << "   and has dimension " << simplex_tree.dimension() << " \n";
+  std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
+  std::clog << "   and has dimension " << simplex_tree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
   simplex_tree.initialize_filtration();
@@ -107,7 +107,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::cout")(
+      "Name of file in which the persistence diagram is written. Default print in std::clog")(
       "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),
@@ -128,17 +128,17 @@ void program_options(int argc, char* argv[], int& nbL, std::string& file_name, s
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
-    std::cout << std::endl;
-    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-    std::cout << "of a Weak witness complex defined on a set of input points.\n \n";
-    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-    std::cout << "   p   dim b d \n";
-    std::cout << "where dim is the dimension of the homological feature,\n";
-    std::cout << "b and d are respectively the birth and death of the feature and \n";
-    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::cout << visible << std::endl;
+    std::clog << std::endl;
+    std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::clog << "of a Weak witness complex defined on a set of input points.\n \n";
+    std::clog << "The output diagram contains one bar per line, written with the convention: \n";
+    std::clog << "   p   dim b d \n";
+    std::clog << "where dim is the dimension of the homological feature,\n";
+    std::clog << "b and d are respectively the birth and death of the feature and \n";
+    std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << 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/Witness_complex/utilities/witnesscomplex.md b/src/Witness_complex/utilities/witnesscomplex.md
index 7ea397b9..3a3a7d83 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::cout.

+* `-o [ --output-file ]` Name of file in which the persistence diagram is written. By default, print in std::clog.

 * `-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::cout.

+* `-o [ --output-file ]` Name of file in which the persistence diagram is written. By default, print in std::clog.

 * `-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.

diff --git a/src/cmake/modules/GUDHI_compilation_flags.cmake b/src/cmake/modules/GUDHI_compilation_flags.cmake
index 34c2e065..567fbc40 100644
--- a/src/cmake/modules/GUDHI_compilation_flags.cmake
+++ b/src/cmake/modules/GUDHI_compilation_flags.cmake
@@ -1,7 +1,6 @@
 # This files manage compilation flags required by GUDHI
 
 include(TestCXXAcceptsFlag)
-include(CheckCXXSourceCompiles)
 
 # add a compiler flag only if it is accepted
 macro(add_cxx_compiler_flag _flag)
@@ -12,32 +11,6 @@ macro(add_cxx_compiler_flag _flag)
   endif()
 endmacro()
 
-function(can_cgal_use_cxx11_thread_local)
-  # This is because of https://github.com/CGAL/cgal/blob/master/Installation/include/CGAL/tss.h
-  # CGAL is using boost thread if thread_local is not ready (requires XCode 8 for Mac).
-  # The test in https://github.com/CGAL/cgal/blob/master/Installation/include/CGAL/config.h
-  #   #if __has_feature(cxx_thread_local) || \
-  #       ( (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L ) || \
-  #       ( _MSC_VER >= 1900 )
-  #   #define CGAL_CAN_USE_CXX11_THREAD_LOCAL
-  #   #endif
-  set(CGAL_CAN_USE_CXX11_THREAD_LOCAL "
-      int main() {
-      #ifndef __has_feature
-        #define __has_feature(x) 0  // Compatibility with non-clang compilers.
-      #endif
-      #if __has_feature(cxx_thread_local) || \
-          ( (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L ) || \
-          ( _MSC_VER >= 1900 )
-        bool has_feature_thread_local = true;
-      #else
-        // Explicit error of compilation for CMake test purpose - has_feature_thread_local is not defined
-      #endif
-        bool result = has_feature_thread_local;
-      }  ")
-  check_cxx_source_compiles("${CGAL_CAN_USE_CXX11_THREAD_LOCAL}" CGAL_CAN_USE_CXX11_THREAD_LOCAL_RESULT)
-endfunction()
-
 set (CMAKE_CXX_STANDARD 14)
 
 enable_testing()
@@ -58,16 +31,6 @@ if (DEBUG_TRACES)
   add_definitions(-DDEBUG_TRACES)
 endif()
 
-set(GUDHI_CAN_USE_CXX11_THREAD_LOCAL "
-    int main() {
-      thread_local int result = 0;
-      return result;
-    }  ")
-check_cxx_source_compiles("${GUDHI_CAN_USE_CXX11_THREAD_LOCAL}" GUDHI_CAN_USE_CXX11_THREAD_LOCAL_RESULT)
-if (GUDHI_CAN_USE_CXX11_THREAD_LOCAL_RESULT)
-  add_definitions(-DGUDHI_CAN_USE_CXX11_THREAD_LOCAL)
-endif()
-
 if(CMAKE_BUILD_TYPE MATCHES Debug)
   message("++ Debug compilation flags are: ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}")
 else()
diff --git a/src/cmake/modules/GUDHI_third_party_libraries.cmake b/src/cmake/modules/GUDHI_third_party_libraries.cmake
index 6db2c76b..2d010483 100644
--- a/src/cmake/modules/GUDHI_third_party_libraries.cmake
+++ b/src/cmake/modules/GUDHI_third_party_libraries.cmake
@@ -68,7 +68,7 @@ if(CGAL_FOUND)
 endif()
 
 # For those who dislike bundled dependencies, this indicates where to find a preinstalled Hera.
-set(HERA_WASSERSTEIN_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/ext/hera/geom_matching/wasserstein/include CACHE PATH "Directory where one can find Hera's wasserstein.h")
+set(HERA_WASSERSTEIN_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/ext/hera/wasserstein/include CACHE PATH "Directory where one can find Hera's wasserstein.h")
 
 option(WITH_GUDHI_USE_TBB "Build with Intel TBB parallelization" ON)
 
diff --git a/src/cmake/modules/GUDHI_user_version_target.cmake b/src/cmake/modules/GUDHI_user_version_target.cmake
index 5047252f..257d1939 100644
--- a/src/cmake/modules/GUDHI_user_version_target.cmake
+++ b/src/cmake/modules/GUDHI_user_version_target.cmake
@@ -55,7 +55,7 @@ add_custom_command(TARGET user_version PRE_BUILD COMMAND ${CMAKE_COMMAND} -E
                    copy_directory ${CMAKE_SOURCE_DIR}/src/GudhUI ${GUDHI_USER_VERSION_DIR}/GudhUI)
 
 add_custom_command(TARGET user_version PRE_BUILD COMMAND ${CMAKE_COMMAND} -E
-                   copy_directory ${CMAKE_SOURCE_DIR}/ext/hera/geom_matching/wasserstein/include ${GUDHI_USER_VERSION_DIR}/ext/hera/geom_matching/wasserstein/include)
+                   copy_directory ${CMAKE_SOURCE_DIR}/ext/hera/wasserstein/include ${GUDHI_USER_VERSION_DIR}/ext/hera/wasserstein/include)
 
 set(GUDHI_DIRECTORIES "doc;example;concept;utilities")
 
diff --git a/src/common/benchmark/Graph_simplicial_complex_benchmark.cpp b/src/common/benchmark/Graph_simplicial_complex_benchmark.cpp
index 0fc145fd..6fe7a887 100644
--- a/src/common/benchmark/Graph_simplicial_complex_benchmark.cpp
+++ b/src/common/benchmark/Graph_simplicial_complex_benchmark.cpp
@@ -66,7 +66,7 @@ void benchmark_proximity_graph(const std::string& msg, const std::string& off_fi
   Gudhi::Points_off_reader<std::vector<double>> off_reader(off_file_name);
   assert(off_reader.is_valid());
 
-  std::cout << "+ " << msg << std::endl;
+  std::clog << "+ " << msg << std::endl;
 
   results_csv << "\"nb_points\";"
               << "\"nb_simplices\";"
@@ -82,7 +82,7 @@ void benchmark_proximity_graph(const std::string& msg, const std::string& off_fi
                                                                                Gudhi::Euclidean_distance());
   // benchmark end
   pg_compute_proximity_graph.end();
-  std::cout << pg_compute_proximity_graph;
+  std::clog << pg_compute_proximity_graph;
 
   Gudhi::Simplex_tree<> complex;
   Gudhi::Clock st_create_clock("    benchmark_proximity_graph - complex creation");
@@ -91,13 +91,13 @@ void benchmark_proximity_graph(const std::string& msg, const std::string& off_fi
   complex.insert_graph(proximity_graph);
   // benchmark end
   st_create_clock.end();
-  std::cout << st_create_clock;
+  std::clog << st_create_clock;
 
   results_csv << off_reader.get_point_cloud().size() << ";" << complex.num_simplices() << ";"
               << pg_compute_proximity_graph.num_seconds() << ";"
               << st_create_clock.num_seconds() << ";" << std::endl;
 
-  std::cout << "    benchmark_proximity_graph - nb simplices = " << complex.num_simplices() << std::endl;
+  std::clog << "    benchmark_proximity_graph - nb simplices = " << complex.num_simplices() << std::endl;
 }
 
 int main(int argc, char * const argv[]) {
diff --git a/src/common/example/CMakeLists.txt b/src/common/example/CMakeLists.txt
index 583a0027..fa8eb98c 100644
--- a/src/common/example/CMakeLists.txt
+++ b/src/common/example/CMakeLists.txt
@@ -12,6 +12,7 @@ if (DIFF_PATH)
 
   add_test(Common_example_vector_double_off_reader_diff_files ${DIFF_PATH}
       ${CMAKE_CURRENT_BINARY_DIR}/vectordoubleoffreader_result.txt ${CMAKE_CURRENT_BINARY_DIR}/alphacomplexdoc.off.txt)
+  set_tests_properties(Common_example_vector_double_off_reader_diff_files PROPERTIES DEPENDS Common_example_vector_double_off_reader) 
 endif()
 
 if(NOT CGAL_VERSION VERSION_LESS 4.11.0)
diff --git a/src/common/example/example_CGAL_3D_points_off_reader.cpp b/src/common/example/example_CGAL_3D_points_off_reader.cpp
index 4658d8d5..7f4343f0 100644
--- a/src/common/example/example_CGAL_3D_points_off_reader.cpp
+++ b/src/common/example/example_CGAL_3D_points_off_reader.cpp
@@ -35,7 +35,7 @@ int main(int argc, char **argv) {
   int n {};
   for (auto point : point_cloud) {
     ++n;
-    std::cout << "Point[" << n << "] = (" << point[0] << ", " << point[1] << ", " << point[2] << ")\n";
+    std::clog << "Point[" << n << "] = (" << point[0] << ", " << point[1] << ", " << point[2] << ")\n";
   }
   return 0;
 }
diff --git a/src/common/example/example_CGAL_points_off_reader.cpp b/src/common/example/example_CGAL_points_off_reader.cpp
index f45683a5..b2bcdbcf 100644
--- a/src/common/example/example_CGAL_points_off_reader.cpp
+++ b/src/common/example/example_CGAL_points_off_reader.cpp
@@ -36,10 +36,10 @@ int main(int argc, char **argv) {
 
   int n {};
   for (auto point : point_cloud) {
-    std::cout << "Point[" << n << "] = ";
+    std::clog << "Point[" << n << "] = ";
     for (std::size_t i {0}; i < point.size(); i++)
-      std::cout << point[i] << " ";
-    std::cout << "\n";
+      std::clog << point[i] << " ";
+    std::clog << "\n";
     ++n;
   }
   return 0;
diff --git a/src/common/include/gudhi/Clock.h b/src/common/include/gudhi/Clock.h
index 00ab2f27..6966aaaa 100644
--- a/src/common/include/gudhi/Clock.h
+++ b/src/common/include/gudhi/Clock.h
@@ -41,9 +41,9 @@ class Clock {
     return msg;
   }
 
-  // Print current value to std::cout
+  // Print current value to std::clog
   void print() const {
-    std::cout << *this << std::endl;
+    std::clog << *this << std::endl;
   }
 
   friend std::ostream& operator<<(std::ostream& stream, const Clock& clock) {
diff --git a/src/common/include/gudhi/Debug_utils.h b/src/common/include/gudhi/Debug_utils.h
index 38abc06d..f8375b00 100644
--- a/src/common/include/gudhi/Debug_utils.h
+++ b/src/common/include/gudhi/Debug_utils.h
@@ -27,14 +27,14 @@
   #define GUDHI_CHECK_code(CODE)
 #endif
 
-#define PRINT(a) std::cerr << #a << ": " << (a) << " (DISP)" << std::endl
+#define PRINT(a) std::clog << #a << ": " << (a) << " (DISP)" << std::endl
 
 // #define DBG_VERBOSE
 #ifdef DBG_VERBOSE
-  #define DBG(a) std::cout << "DBG: " << (a) << std::endl
-  #define DBGMSG(a, b) std::cout << "DBG: " << a << b << std::endl
-  #define DBGVALUE(a) std::cout << "DBG: " <<  #a << ": " << a << std::endl
-  #define DBGCONT(a) std::cout << "DBG: container " << #a << " -> "; for (auto x : a) std::cout << x << ","; std::cout << std::endl
+  #define DBG(a) std::clog << "DBG: " << (a) << std::endl
+  #define DBGMSG(a, b) std::clog << "DBG: " << a << b << std::endl
+  #define DBGVALUE(a) std::clog << "DBG: " <<  #a << ": " << a << std::endl
+  #define DBGCONT(a) std::clog << "DBG: container " << #a << " -> "; for (auto x : a) std::clog << x << ","; std::clog << std::endl
 #else
   #define DBG(a) (void) 0
   #define DBGMSG(a, b) (void) 0
diff --git a/src/common/include/gudhi/Points_3D_off_io.h b/src/common/include/gudhi/Points_3D_off_io.h
index 2d110af3..39b79c96 100644
--- a/src/common/include/gudhi/Points_3D_off_io.h
+++ b/src/common/include/gudhi/Points_3D_off_io.h
@@ -41,7 +41,7 @@ class Points_3D_off_visitor_reader {
    */
   void init(int dim, int num_vertices, int num_faces, int num_edges) {
 #ifdef DEBUG_TRACES
-    std::cout << "Points_3D_off_visitor_reader::init - dim=" << dim << " - num_vertices=" <<
+    std::clog << "Points_3D_off_visitor_reader::init - dim=" << dim << " - num_vertices=" <<
         num_vertices << " - num_faces=" << num_faces << " - num_edges=" << num_edges << std::endl;
 #endif  // DEBUG_TRACES
     if (dim == 3) {
@@ -74,11 +74,11 @@ class Points_3D_off_visitor_reader {
   void point(const std::vector<double>& point) {
     if (valid_) {
 #ifdef DEBUG_TRACES
-      std::cout << "Points_3D_off_visitor_reader::point ";
+      std::clog << "Points_3D_off_visitor_reader::point ";
       for (auto coordinate : point) {
-        std::cout << coordinate << " | ";
+        std::clog << coordinate << " | ";
       }
-      std::cout << std::endl;
+      std::clog << std::endl;
 #endif  // DEBUG_TRACES
       // Fill the point cloud
       point_cloud_.push_back(Point_3(point[0], point[1], point[2]));
diff --git a/src/common/include/gudhi/Points_off_io.h b/src/common/include/gudhi/Points_off_io.h
index 99371d56..9dc40568 100644
--- a/src/common/include/gudhi/Points_off_io.h
+++ b/src/common/include/gudhi/Points_off_io.h
@@ -40,7 +40,7 @@ class Points_off_visitor_reader {
    */
   void init(int dim, int num_vertices, int num_faces, int num_edges) {
 #ifdef DEBUG_TRACES
-    std::cout << "Points_off_visitor_reader::init - dim=" << dim << " - num_vertices=" <<
+    std::clog << "Points_off_visitor_reader::init - dim=" << dim << " - num_vertices=" <<
         num_vertices << " - num_faces=" << num_faces << " - num_edges=" << num_edges << std::endl;
 #endif  // DEBUG_TRACES
     if (num_faces > 0) {
@@ -66,11 +66,11 @@ class Points_off_visitor_reader {
    */
   void point(const std::vector<double>& point) {
 #ifdef DEBUG_TRACES
-    std::cout << "Points_off_visitor_reader::point ";
+    std::clog << "Points_off_visitor_reader::point ";
     for (auto coordinate : point) {
-      std::cout << coordinate << " | ";
+      std::clog << coordinate << " | ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
 #endif  // DEBUG_TRACES
     // Fill the point cloud
     point_cloud.push_back(Point_d(point.begin(), point.end()));
diff --git a/src/common/include/gudhi/Unitary_tests_utils.h b/src/common/include/gudhi/Unitary_tests_utils.h
index 9b86460a..9f995d01 100644
--- a/src/common/include/gudhi/Unitary_tests_utils.h
+++ b/src/common/include/gudhi/Unitary_tests_utils.h
@@ -20,7 +20,7 @@ template<typename FloatingType >
 void GUDHI_TEST_FLOAT_EQUALITY_CHECK(FloatingType a, FloatingType b,
                                      FloatingType epsilon = std::numeric_limits<FloatingType>::epsilon()) {
 #ifdef DEBUG_TRACES
-  std::cout << "GUDHI_TEST_FLOAT_EQUALITY_CHECK - " << a << " versus " << b
+  std::clog << "GUDHI_TEST_FLOAT_EQUALITY_CHECK - " << a << " versus " << b
             << " | diff = " << std::fabs(a - b) << " - epsilon = " << epsilon << std::endl;
 #endif
   BOOST_CHECK(std::fabs(a - b) <= epsilon);
@@ -32,7 +32,7 @@ template<typename FloatingType >
 FloatingType GUDHI_PROTECT_FLOAT(FloatingType value) {
   volatile FloatingType protected_value = value;
 #ifdef DEBUG_TRACES
-  std::cout << "GUDHI_PROTECT_FLOAT - " << protected_value << std::endl;
+  std::clog << "GUDHI_PROTECT_FLOAT - " << protected_value << std::endl;
 #endif
   return protected_value;
 }
diff --git a/src/common/include/gudhi/distance_functions.h b/src/common/include/gudhi/distance_functions.h
index 94cf9ccc..9bbc62b7 100644
--- a/src/common/include/gudhi/distance_functions.h
+++ b/src/common/include/gudhi/distance_functions.h
@@ -97,7 +97,7 @@ class Minimal_enclosing_ball_radius {
 
     Min_sphere ms(boost::size(*point_cloud.begin()), point_cloud.begin(), point_cloud.end());
 #ifdef DEBUG_TRACES
-    std::cout << "Minimal_enclosing_ball_radius = " << std::sqrt(ms.squared_radius()) << " | nb points = "
+    std::clog << "Minimal_enclosing_ball_radius = " << std::sqrt(ms.squared_radius()) << " | nb points = "
               << boost::size(point_cloud) << " | dimension = "
               << boost::size(*point_cloud.begin()) << std::endl;
 #endif  // DEBUG_TRACES
diff --git a/src/common/include/gudhi/reader_utils.h b/src/common/include/gudhi/reader_utils.h
index db31bf5c..0938f5c1 100644
--- a/src/common/include/gudhi/reader_utils.h
+++ b/src/common/include/gudhi/reader_utils.h
@@ -220,7 +220,7 @@ template <typename Filtration_value>
 std::vector<std::vector<Filtration_value>> read_lower_triangular_matrix_from_csv_file(const std::string& filename,
                                                                                       const char separator = ';') {
 #ifdef DEBUG_TRACES
-  std::cout << "Using procedure read_lower_triangular_matrix_from_csv_file \n";
+  std::clog << "Using procedure read_lower_triangular_matrix_from_csv_file \n";
 #endif  // DEBUG_TRACES
   std::vector<std::vector<Filtration_value>> result;
   std::ifstream in;
@@ -272,12 +272,12 @@ std::vector<std::vector<Filtration_value>> read_lower_triangular_matrix_from_csv
   in.close();
 
 #ifdef DEBUG_TRACES
-  std::cerr << "Here is the matrix we read : \n";
+  std::clog << "Here is the matrix we read : \n";
   for (size_t i = 0; i != result.size(); ++i) {
     for (size_t j = 0; j != result[i].size(); ++j) {
-      std::cerr << result[i][j] << " ";
+      std::clog << result[i][j] << " ";
     }
-    std::cerr << std::endl;
+    std::clog << std::endl;
   }
 #endif  // DEBUG_TRACES
 
@@ -294,7 +294,7 @@ Note: the function does not check that birth <= death.
 template <typename OutputIterator>
 void read_persistence_intervals_and_dimension(std::string const& filename, OutputIterator out) {
 #ifdef DEBUG_TRACES
-  std::cout << "read_persistence_intervals_and_dimension - " << filename << std::endl;
+  std::clog << "read_persistence_intervals_and_dimension - " << filename << std::endl;
 #endif  // DEBUG_TRACES
   std::ifstream in(filename);
   if (!in.is_open()) {
@@ -311,11 +311,11 @@ void read_persistence_intervals_and_dimension(std::string const& filename, Outpu
       double numbers[4];
       int n = sscanf(line.c_str(), "%lf %lf %lf %lf", &numbers[0], &numbers[1], &numbers[2], &numbers[3]);
 #ifdef DEBUG_TRACES
-      std::cout << "[" << n << "] = ";
+      std::clog << "[" << n << "] = ";
       for (int i = 0; i < n; i++) {
-        std::cout << numbers[i] << ",";
+        std::clog << numbers[i] << ",";
       }
-      std::cout << std::endl;
+      std::clog << std::endl;
 #endif  // DEBUG_TRACES
       if (n >= 2) {
         int dim = (n >= 3 ? static_cast<int>(numbers[n - 3]) : -1);
diff --git a/src/common/test/test_distance_matrix_reader.cpp b/src/common/test/test_distance_matrix_reader.cpp
index bb619a29..73be8104 100644
--- a/src/common/test/test_distance_matrix_reader.cpp
+++ b/src/common/test/test_distance_matrix_reader.cpp
@@ -28,15 +28,15 @@ BOOST_AUTO_TEST_CASE( lower_triangular_distance_matrix )
                                                                              ',');
   for (auto& i : from_lower_triangular) {
     for (auto j : i) {
-      std::cout << j << " ";
+      std::clog << j << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
-  std::cout << "from_lower_triangular size = " << from_lower_triangular.size() << std::endl;
+  std::clog << "from_lower_triangular size = " << from_lower_triangular.size() << std::endl;
   BOOST_CHECK(from_lower_triangular.size() == 5);
 
   for (std::size_t i = 0; i < from_lower_triangular.size(); i++) {
-    std::cout << "from_lower_triangular[" << i << "] size = " << from_lower_triangular[i].size() << std::endl;
+    std::clog << "from_lower_triangular[" << i << "] size = " << from_lower_triangular[i].size() << std::endl;
     BOOST_CHECK(from_lower_triangular[i].size() == i);
   }
   std::vector<double> expected = {1};
@@ -60,14 +60,14 @@ BOOST_AUTO_TEST_CASE( full_square_distance_matrix )
   from_full_square = Gudhi::read_lower_triangular_matrix_from_csv_file<double>("full_square_distance_matrix.csv");
   for (auto& i : from_full_square) {
     for (auto j : i) {
-      std::cout << j << " ";
+      std::clog << j << " ";
     }
-    std::cout << std::endl;
+    std::clog << std::endl;
   }
-  std::cout << "from_full_square size = " << from_full_square.size() << std::endl;
+  std::clog << "from_full_square size = " << from_full_square.size() << std::endl;
   BOOST_CHECK(from_full_square.size() == 7);
   for (std::size_t i = 0; i < from_full_square.size(); i++) {
-    std::cout << "from_full_square[" << i << "] size = " << from_full_square[i].size() << std::endl;
+    std::clog << "from_full_square[" << i << "] size = " << from_full_square[i].size() << std::endl;
     BOOST_CHECK(from_full_square[i].size() == i);
   }  
 }
diff --git a/src/common/test/test_persistence_intervals_reader.cpp b/src/common/test/test_persistence_intervals_reader.cpp
index 8fb4377d..ac8d0981 100644
--- a/src/common/test/test_persistence_intervals_reader.cpp
+++ b/src/common/test/test_persistence_intervals_reader.cpp
@@ -35,18 +35,18 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_without_dimension )
   Persistence_intervals_by_dimension persistence_intervals_by_dimension =
       Gudhi::read_persistence_intervals_grouped_by_dimension("persistence_intervals_without_dimension.pers");
 
-  std::cout << "\nread_persistence_intervals_grouped_by_dimension - expected\n";
+  std::clog << "\nread_persistence_intervals_grouped_by_dimension - expected\n";
   for (auto map_iter : expected_intervals_by_dimension) {
-    std::cout << "key=" << map_iter.first;
+    std::clog << "key=" << map_iter.first;
     for (auto vec_iter : map_iter.second)
-      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+      std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
   }
 
-  std::cout << "\nread_persistence_intervals_grouped_by_dimension - read\n";
+  std::clog << "\nread_persistence_intervals_grouped_by_dimension - read\n";
   for (auto map_iter : persistence_intervals_by_dimension) {
-    std::cout << "key=" << map_iter.first;
+    std::clog << "key=" << map_iter.first;
     for (auto vec_iter : map_iter.second)
-      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+      std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
   }
 
   BOOST_CHECK(persistence_intervals_by_dimension == expected_intervals_by_dimension);
@@ -60,13 +60,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_without_dimension )
   Persistence_intervals persistence_intervals_in_dimension =
       Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_without_dimension.pers");
 
-  std::cout << "\nread_persistence_intervals_in_dimension - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension - read\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
@@ -103,18 +103,18 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_dimension )
   Persistence_intervals_by_dimension persistence_intervals_by_dimension =
       Gudhi::read_persistence_intervals_grouped_by_dimension("persistence_intervals_with_dimension.pers");
 
-  std::cout << "\nread_persistence_intervals_grouped_by_dimension - expected\n";
+  std::clog << "\nread_persistence_intervals_grouped_by_dimension - expected\n";
   for (auto map_iter : expected_intervals_by_dimension) {
-    std::cout << "key=" << map_iter.first;
+    std::clog << "key=" << map_iter.first;
     for (auto vec_iter : map_iter.second)
-      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+      std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
   }
 
-  std::cout << "\nread_persistence_intervals_grouped_by_dimension - read\n";
+  std::clog << "\nread_persistence_intervals_grouped_by_dimension - read\n";
   for (auto map_iter : persistence_intervals_by_dimension) {
-    std::cout << "key=" << map_iter.first;
+    std::clog << "key=" << map_iter.first;
     for (auto vec_iter : map_iter.second)
-      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+      std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
   }
 
   BOOST_CHECK(persistence_intervals_by_dimension == expected_intervals_by_dimension);
@@ -128,13 +128,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_dimension )
   Persistence_intervals persistence_intervals_in_dimension =
       Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_with_dimension.pers");
 
-  std::cout << "\nread_persistence_intervals_in_dimension - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension - read\n";
   for (auto vec_iter : persistence_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
@@ -143,13 +143,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_dimension )
   persistence_intervals_in_dimension =
         Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_with_dimension.pers", 0);
 
-  std::cout << "\nread_persistence_intervals_in_dimension 0 - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 0 - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension 0 - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 0 - read\n";
   for (auto vec_iter : persistence_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
@@ -159,13 +159,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_dimension )
   persistence_intervals_in_dimension =
         Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_with_dimension.pers", 1);
 
-  std::cout << "\nread_persistence_intervals_in_dimension 1 - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 1 - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension 1 - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 1 - read\n";
   for (auto vec_iter : persistence_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
@@ -173,13 +173,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_dimension )
   persistence_intervals_in_dimension =
         Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_with_dimension.pers", 2);
 
-  std::cout << "\nread_persistence_intervals_in_dimension 2 - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 2 - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension 2 - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 2 - read\n";
   for (auto vec_iter : persistence_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
@@ -188,13 +188,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_dimension )
   persistence_intervals_in_dimension =
         Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_with_dimension.pers", 3);
 
-  std::cout << "\nread_persistence_intervals_in_dimension 3 - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 3 - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension 3 - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 3 - read\n";
   for (auto vec_iter : persistence_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
@@ -212,18 +212,18 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_field )
   Persistence_intervals_by_dimension persistence_intervals_by_dimension =
       Gudhi::read_persistence_intervals_grouped_by_dimension("persistence_intervals_with_field.pers");
 
-  std::cout << "\nread_persistence_intervals_grouped_by_dimension - expected\n";
+  std::clog << "\nread_persistence_intervals_grouped_by_dimension - expected\n";
   for (auto map_iter : expected_intervals_by_dimension) {
-    std::cout << "key=" << map_iter.first;
+    std::clog << "key=" << map_iter.first;
     for (auto vec_iter : map_iter.second)
-      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+      std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
   }
 
-  std::cout << "\nread_persistence_intervals_grouped_by_dimension - read\n";
+  std::clog << "\nread_persistence_intervals_grouped_by_dimension - read\n";
   for (auto map_iter : persistence_intervals_by_dimension) {
-    std::cout << "key=" << map_iter.first;
+    std::clog << "key=" << map_iter.first;
     for (auto vec_iter : map_iter.second)
-      std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+      std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
   }
 
   BOOST_CHECK(persistence_intervals_by_dimension == expected_intervals_by_dimension);
@@ -237,13 +237,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_field )
   Persistence_intervals persistence_intervals_in_dimension =
       Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_with_field.pers");
 
-  std::cout << "\nread_persistence_intervals_in_dimension - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension - read\n";
   for (auto vec_iter : persistence_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
@@ -252,13 +252,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_field )
   persistence_intervals_in_dimension =
         Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_with_field.pers", 0);
 
-  std::cout << "\nread_persistence_intervals_in_dimension 0 - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 0 - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension 0 - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 0 - read\n";
   for (auto vec_iter : persistence_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
@@ -268,13 +268,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_field )
   persistence_intervals_in_dimension =
         Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_with_field.pers", 1);
 
-  std::cout << "\nread_persistence_intervals_in_dimension 1 - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 1 - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension 1 - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 1 - read\n";
   for (auto vec_iter : persistence_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
@@ -282,13 +282,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_field )
   persistence_intervals_in_dimension =
         Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_with_field.pers", 2);
 
-  std::cout << "\nread_persistence_intervals_in_dimension 2 - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 2 - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension 2 - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 2 - read\n";
   for (auto vec_iter : persistence_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
@@ -297,13 +297,13 @@ BOOST_AUTO_TEST_CASE( persistence_intervals_with_field )
   persistence_intervals_in_dimension =
         Gudhi::read_persistence_intervals_in_dimension("persistence_intervals_with_field.pers", 3);
 
-  std::cout << "\nread_persistence_intervals_in_dimension 3 - expected\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 3 - expected\n";
   for (auto vec_iter : expected_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
-  std::cout << "\nread_persistence_intervals_in_dimension 3 - read\n";
+  std::clog << "\nread_persistence_intervals_in_dimension 3 - read\n";
   for (auto vec_iter : persistence_intervals_in_dimension)
-    std::cout << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
+    std::clog << " [" << vec_iter.first << " ," << vec_iter.second << "] ";
 
   BOOST_CHECK(persistence_intervals_in_dimension == expected_intervals_in_dimension);
 
diff --git a/src/python/CMakeLists.txt b/src/python/CMakeLists.txt
index 090a7446..f00966a5 100644
--- a/src/python/CMakeLists.txt
+++ b/src/python/CMakeLists.txt
@@ -56,6 +56,7 @@ if(PYTHONINTERP_FOUND)
     # Modules that should not be auto-imported in __init__.py
     set(GUDHI_PYTHON_MODULES_EXTRA "${GUDHI_PYTHON_MODULES_EXTRA}'representations', ")
     set(GUDHI_PYTHON_MODULES_EXTRA "${GUDHI_PYTHON_MODULES_EXTRA}'wasserstein', ")
+    set(GUDHI_PYTHON_MODULES_EXTRA "${GUDHI_PYTHON_MODULES_EXTRA}'point_cloud', ")
 
     add_gudhi_debug_info("Python version ${PYTHON_VERSION_STRING}")
     add_gudhi_debug_info("Cython version ${CYTHON_VERSION}")
@@ -127,16 +128,6 @@ if(PYTHONINTERP_FOUND)
     endif ()
 
     if(CGAL_FOUND)
-      can_cgal_use_cxx11_thread_local()
-      if (NOT CGAL_CAN_USE_CXX11_THREAD_LOCAL_RESULT)
-        if(CMAKE_BUILD_TYPE MATCHES Debug)
-          add_GUDHI_PYTHON_lib("${Boost_THREAD_LIBRARY_DEBUG}")
-        else()
-          add_GUDHI_PYTHON_lib("${Boost_THREAD_LIBRARY_RELEASE}")
-        endif()
-        message("** Add Boost ${Boost_LIBRARY_DIRS}")
-        set(GUDHI_PYTHON_LIBRARY_DIRS "${GUDHI_PYTHON_LIBRARY_DIRS}'${Boost_LIBRARY_DIRS}', ")
-      endif()
       # Add CGAL compilation args
       if(CGAL_HEADER_ONLY)
         add_gudhi_debug_info("CGAL header only version ${CGAL_VERSION}")
@@ -181,7 +172,7 @@ if(PYTHONINTERP_FOUND)
         set(GUDHI_PYTHON_LIBRARY_DIRS "${GUDHI_PYTHON_LIBRARY_DIRS}'${MPFR_LIBRARIES_DIR}', ")
         message("** Add mpfr ${MPFR_LIBRARIES}")
       endif(MPFR_FOUND)
-endif(CGAL_FOUND)
+    endif(CGAL_FOUND)
 
     # Specific for Mac
     if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
@@ -226,6 +217,7 @@ endif(CGAL_FOUND)
     file(COPY "gudhi/persistence_graphical_tools.py" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/gudhi")
     file(COPY "gudhi/representations" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/gudhi/")
     file(COPY "gudhi/wasserstein.py" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/gudhi")
+    file(COPY "gudhi/point_cloud" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/gudhi")
 
     add_custom_command(
         OUTPUT gudhi.so
@@ -404,6 +396,9 @@ endif(CGAL_FOUND)
       add_gudhi_py_test(test_representations)
     endif()
 
+    # Time Delay
+    add_gudhi_py_test(test_time_delay)
+
     # Documentation generation is available through sphinx - requires all modules
     if(SPHINX_PATH)
       if(MATPLOTLIB_FOUND)
diff --git a/src/python/doc/persistence_graphical_tools_sum.inc b/src/python/doc/persistence_graphical_tools_sum.inc
index 0cdf8072..ef376802 100644
--- a/src/python/doc/persistence_graphical_tools_sum.inc
+++ b/src/python/doc/persistence_graphical_tools_sum.inc
@@ -2,11 +2,11 @@
    :widths: 30 50 20
 
    +-----------------------------------------------------------------+-----------------------------------------------------------------------+-----------------------------------------------+
-   | .. figure::                                                     | These graphical tools comes on top of persistence results and allows  | :Author: Vincent Rouvreau                     |
-   |      img/graphical_tools_representation.png                     | the user to build easily persistence barcode, diagram or density.     |                                               |
+   | .. figure::                                                     | These graphical tools comes on top of persistence results and allows  | :Author: Vincent Rouvreau, Theo Lacombe       |
+   |      img/graphical_tools_representation.png                     | the user to display easily persistence barcode, diagram or density.   |                                               |
    |                                                                 |                                                                       | :Introduced in: GUDHI 2.0.0                   |
-   |                                                                 |                                                                       |                                               |
-   |                                                                 |                                                                       | :Copyright: MIT                               |
+   |                                                                 | Note that these functions return the matplotlib axis, allowing        |                                               |
+   |                                                                 | for further modifications (title, aspect, etc.)                       | :Copyright: MIT                               |
    |                                                                 |                                                                       |                                               |
    |                                                                 |                                                                       | :Requires: matplotlib, numpy and scipy        |
    +-----------------------------------------------------------------+-----------------------------------------------------------------------+-----------------------------------------------+
diff --git a/src/python/doc/persistence_graphical_tools_user.rst b/src/python/doc/persistence_graphical_tools_user.rst
index 80002db6..91e52703 100644
--- a/src/python/doc/persistence_graphical_tools_user.rst
+++ b/src/python/doc/persistence_graphical_tools_user.rst
@@ -20,7 +20,7 @@ This function can display the persistence result as a barcode:
 .. plot::
    :include-source:
 
-    import matplotlib.pyplot as plot
+    import matplotlib.pyplot as plt
     import gudhi
 
     off_file = gudhi.__root_source_dir__ + '/data/points/tore3D_300.off'
@@ -31,7 +31,7 @@ This function can display the persistence result as a barcode:
     diag = simplex_tree.persistence(min_persistence=0.4)
 
     gudhi.plot_persistence_barcode(diag)
-    plot.show()
+    plt.show()
 
 Show persistence as a diagram
 -----------------------------
@@ -44,15 +44,31 @@ This function can display the persistence result as a diagram:
 .. plot::
    :include-source:
 
-    import matplotlib.pyplot as plot
+    import matplotlib.pyplot as plt
     import gudhi
 
     # rips_on_tore3D_1307.pers obtained from write_persistence_diagram method
     persistence_file=gudhi.__root_source_dir__ + \
         '/data/persistence_diagram/rips_on_tore3D_1307.pers'
-    gudhi.plot_persistence_diagram(persistence_file=persistence_file,
+    ax = gudhi.plot_persistence_diagram(persistence_file=persistence_file,
         legend=True)
-    plot.show()
+    # We can modify the title, aspect, etc.
+    ax.set_title("Persistence diagram of a torus")
+    ax.set_aspect("equal")  # forces to be square shaped
+    plt.show()
+
+Note that (as barcode and density) it can also take a simple `np.array` 
+of shape (N x 2) encoding a persistence diagram (in a given dimension).
+
+.. plot::
+    :include-source:
+    
+    import matplotlib.pyplot as plt
+    import gudhi
+    import numpy as np
+    d = np.array([[0, 1], [1, 2], [1, np.inf]])
+    gudhi.plot_persistence_diagram(d)
+    plt.show()
 
 Persistence density
 -------------------
@@ -65,7 +81,7 @@ If you want more information on a specific dimension, for instance:
 .. plot::
    :include-source:
 
-    import matplotlib.pyplot as plot
+    import matplotlib.pyplot as plt
     import gudhi
     # rips_on_tore3D_1307.pers obtained from write_persistence_diagram method
     persistence_file=gudhi.__root_source_dir__ + \
@@ -75,9 +91,9 @@ If you want more information on a specific dimension, for instance:
         only_this_dim=1)
     pers_diag = [(1, elt) for elt in birth_death]
     # Use subplots to display diagram and density side by side
-    fig, axes = plot.subplots(nrows=1, ncols=2, figsize=(12, 5))
+    fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(12, 5))
     gudhi.plot_persistence_diagram(persistence=pers_diag,
         axes=axes[0])
     gudhi.plot_persistence_density(persistence=pers_diag,
         dimension=1, legend=True, axes=axes[1])
-    plot.show()
+    plt.show()
diff --git a/src/python/doc/point_cloud.rst b/src/python/doc/point_cloud.rst
index d668428a..c0d4b303 100644
--- a/src/python/doc/point_cloud.rst
+++ b/src/python/doc/point_cloud.rst
@@ -20,3 +20,11 @@ Subsampling
    :members:
    :special-members:
    :show-inheritance:
+
+TimeDelayEmbedding
+------------------
+
+.. autoclass:: gudhi.point_cloud.timedelay.TimeDelayEmbedding
+   :members:
+   :special-members: __call__
+
diff --git a/src/python/doc/wasserstein_distance_user.rst b/src/python/doc/wasserstein_distance_user.rst
index 94b454e2..a9b21fa5 100644
--- a/src/python/doc/wasserstein_distance_user.rst
+++ b/src/python/doc/wasserstein_distance_user.rst
@@ -36,10 +36,10 @@ Note that persistence diagrams must be submitted as (n x 2) numpy arrays and mus
     import gudhi.wasserstein
     import numpy as np
 
-    diag1 = np.array([[2.7, 3.7],[9.6, 14.],[34.2, 34.974]])
-    diag2 = np.array([[2.8, 4.45],[9.5, 14.1]])
+    dgm1 = np.array([[2.7, 3.7],[9.6, 14.],[34.2, 34.974]])
+    dgm2 = np.array([[2.8, 4.45],[9.5, 14.1]])
 
-    message = "Wasserstein distance value = " + '%.2f' % gudhi.wasserstein.wasserstein_distance(diag1, diag2, order=1., internal_p=2.)
+    message = "Wasserstein distance value = " + '%.2f' % gudhi.wasserstein.wasserstein_distance(dgm1, dgm2, order=1., internal_p=2.)
     print(message)
 
 The output is:
@@ -47,3 +47,40 @@ The output is:
 .. testoutput::
 
     Wasserstein distance value = 1.45
+
+We can also have access to the optimal matching by letting `matching=True`. 
+It is encoded as a list of indices (i,j), meaning that the i-th point in X
+is mapped to the j-th point in Y. 
+An index of -1 represents the diagonal.
+
+.. testcode::
+
+    import gudhi.wasserstein
+    import numpy as np
+
+    dgm1 = np.array([[2.7, 3.7],[9.6, 14.],[34.2, 34.974]])
+    dgm2 = np.array([[2.8, 4.45], [5, 6], [9.5, 14.1]])
+    cost, matchings = gudhi.wasserstein.wasserstein_distance(dgm1, dgm2, matching=True, order=1, internal_p=2)
+
+    message_cost = "Wasserstein distance value = %.2f" %cost
+    print(message_cost)
+    dgm1_to_diagonal = matchings[matchings[:,1] == -1, 0]
+    dgm2_to_diagonal = matchings[matchings[:,0] == -1, 1]
+    off_diagonal_match = np.delete(matchings, np.where(matchings == -1)[0], axis=0)
+
+    for i,j in off_diagonal_match:
+        print("point %s in dgm1 is matched to point %s in dgm2" %(i,j))
+    for i in dgm1_to_diagonal:
+        print("point %s in dgm1 is matched to the diagonal" %i)
+    for j in dgm2_to_diagonal:
+        print("point %s in dgm2 is matched to the diagonal" %j)
+
+The output is:
+
+.. testoutput::
+    
+    Wasserstein distance value = 2.15
+    point 0 in dgm1 is matched to point 0 in dgm2
+    point 1 in dgm1 is matched to point 2 in dgm2
+    point 2 in dgm1 is matched to the diagonal
+    point 1 in dgm2 is matched to the diagonal
diff --git a/src/python/example/alpha_complex_diagram_persistence_from_off_file_example.py b/src/python/example/alpha_complex_diagram_persistence_from_off_file_example.py
index 4079a469..727af4fa 100755
--- a/src/python/example/alpha_complex_diagram_persistence_from_off_file_example.py
+++ b/src/python/example/alpha_complex_diagram_persistence_from_off_file_example.py
@@ -1,11 +1,15 @@
 #!/usr/bin/env python
 
 import argparse
+import errno
+import os
 import matplotlib.pyplot as plot
 import gudhi
 
-""" 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.
+""" 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) 2016 Inria
@@ -41,7 +45,7 @@ args = parser.parse_args()
 with open(args.file, "r") as f:
     first_line = f.readline()
     if (first_line == "OFF\n") or (first_line == "nOFF\n"):
-        print("#####################################################################")
+        print("##############################################################")
         print("AlphaComplex creation from points read in a OFF file")
 
         message = "AlphaComplex with max_edge_length=" + repr(args.max_alpha_square)
@@ -64,6 +68,7 @@ with open(args.file, "r") as f:
             gudhi.plot_persistence_diagram(diag, band=args.band)
             plot.show()
     else:
-        print(args.file, "is not a valid OFF file")
+        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                args.file)
 
     f.close()
diff --git a/src/python/example/alpha_complex_from_points_example.py b/src/python/example/alpha_complex_from_points_example.py
index 844d7a82..73faf17c 100755
--- a/src/python/example/alpha_complex_from_points_example.py
+++ b/src/python/example/alpha_complex_from_points_example.py
@@ -46,8 +46,14 @@ if simplex_tree.find([4]):
 else:
     print("[4] Not found...")
 
+# Some insertions, simplex_tree needs to initialize filtrations
+simplex_tree.initialize_filtration()
+
 print("dimension=", simplex_tree.dimension())
-print("filtrations=", simplex_tree.get_filtration())
+print("filtrations=")
+for simplex_with_filtration in simplex_tree.get_filtration():
+    print("(%s, %.2f)" % tuple(simplex_with_filtration))
+
 print("star([0])=", simplex_tree.get_star([0]))
 print("coface([0], 1)=", simplex_tree.get_cofaces([0], 1))
 
diff --git a/src/python/example/alpha_rips_persistence_bottleneck_distance.py b/src/python/example/alpha_rips_persistence_bottleneck_distance.py
index d5c33ec8..f156826d 100755
--- a/src/python/example/alpha_rips_persistence_bottleneck_distance.py
+++ b/src/python/example/alpha_rips_persistence_bottleneck_distance.py
@@ -3,9 +3,13 @@
 import gudhi
 import argparse
 import math
+import errno
+import os
 
-""" 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.
+""" 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) 2016 Inria
@@ -36,7 +40,7 @@ with open(args.file, "r") as f:
     first_line = f.readline()
     if (first_line == "OFF\n") or (first_line == "nOFF\n"):
         point_cloud = gudhi.read_points_from_off_file(off_file=args.file)
-        print("#####################################################################")
+        print("##############################################################")
         print("RipsComplex creation from points read in a OFF file")
 
         message = "RipsComplex with max_edge_length=" + repr(args.threshold)
@@ -46,14 +50,15 @@ with open(args.file, "r") as f:
             points=point_cloud, max_edge_length=args.threshold
         )
 
-        rips_stree = rips_complex.create_simplex_tree(max_dimension=args.max_dimension)
+        rips_stree = rips_complex.create_simplex_tree(
+            max_dimension=args.max_dimension)
 
         message = "Number of simplices=" + repr(rips_stree.num_simplices())
         print(message)
 
         rips_diag = rips_stree.persistence()
 
-        print("#####################################################################")
+        print("##############################################################")
         print("AlphaComplex creation from points read in a OFF file")
 
         message = "AlphaComplex with max_edge_length=" + repr(args.threshold)
@@ -93,13 +98,13 @@ with open(args.file, "r") as f:
             print(message)
             max_b_distance = max(bottleneck_distance, max_b_distance)
 
-        print(
-            "================================================================================"
-        )
+        print("==============================================================")
         message = "Bottleneck distance is " + repr(max_b_distance)
         print(message)
 
     else:
-        print(args.file, "is not a valid OFF file")
+        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                args.file)
+
 
     f.close()
diff --git a/src/python/example/euclidean_strong_witness_complex_diagram_persistence_from_off_file_example.py b/src/python/example/euclidean_strong_witness_complex_diagram_persistence_from_off_file_example.py
index 4903667e..e1e572df 100755
--- a/src/python/example/euclidean_strong_witness_complex_diagram_persistence_from_off_file_example.py
+++ b/src/python/example/euclidean_strong_witness_complex_diagram_persistence_from_off_file_example.py
@@ -1,11 +1,15 @@
 #!/usr/bin/env python
 
 import argparse
+import errno
+import os
 import matplotlib.pyplot as plot
 import gudhi
 
-""" 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.
+""" 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) 2016 Inria
@@ -44,8 +48,9 @@ args = parser.parse_args()
 with open(args.file, "r") as f:
     first_line = f.readline()
     if (first_line == "OFF\n") or (first_line == "nOFF\n"):
-        print("#####################################################################")
-        print("EuclideanStrongWitnessComplex creation from points read in a OFF file")
+        print("##############################################################")
+        print("EuclideanStrongWitnessComplex creation from points read "\
+            "in a OFF file")
 
         witnesses = gudhi.read_points_from_off_file(off_file=args.file)
         landmarks = gudhi.pick_n_random_points(
@@ -64,7 +69,8 @@ with open(args.file, "r") as f:
             witnesses=witnesses, landmarks=landmarks
         )
         simplex_tree = witness_complex.create_simplex_tree(
-            max_alpha_square=args.max_alpha_square, limit_dimension=args.limit_dimension
+            max_alpha_square=args.max_alpha_square,
+            limit_dimension=args.limit_dimension
         )
 
         message = "Number of simplices=" + repr(simplex_tree.num_simplices())
@@ -79,6 +85,7 @@ with open(args.file, "r") as f:
             gudhi.plot_persistence_diagram(diag, band=args.band)
             plot.show()
     else:
-        print(args.file, "is not a valid OFF file")
+        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                args.file)
 
     f.close()
diff --git a/src/python/example/euclidean_witness_complex_diagram_persistence_from_off_file_example.py b/src/python/example/euclidean_witness_complex_diagram_persistence_from_off_file_example.py
index 339a8577..58cb2bb5 100755
--- a/src/python/example/euclidean_witness_complex_diagram_persistence_from_off_file_example.py
+++ b/src/python/example/euclidean_witness_complex_diagram_persistence_from_off_file_example.py
@@ -1,11 +1,15 @@
 #!/usr/bin/env python
 
 import argparse
+import errno
+import os
 import matplotlib.pyplot as plot
 import gudhi
 
-""" 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.
+""" 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) 2016 Inria
@@ -78,6 +82,7 @@ with open(args.file, "r") as f:
             gudhi.plot_persistence_diagram(diag, band=args.band)
             plot.show()
     else:
-        print(args.file, "is not a valid OFF file")
+        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                args.file)
 
     f.close()
diff --git a/src/python/example/periodic_cubical_complex_barcode_persistence_from_perseus_file_example.py b/src/python/example/periodic_cubical_complex_barcode_persistence_from_perseus_file_example.py
index c692e66f..499171df 100755
--- a/src/python/example/periodic_cubical_complex_barcode_persistence_from_perseus_file_example.py
+++ b/src/python/example/periodic_cubical_complex_barcode_persistence_from_perseus_file_example.py
@@ -2,10 +2,14 @@
 
 import argparse
 import matplotlib.pyplot as plot
+import errno
+import os
 import gudhi
 
-""" 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.
+""" 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) 2016 Inria
@@ -57,9 +61,10 @@ parser.add_argument(
 args = parser.parse_args()
 
 if is_file_perseus(args.file):
-    print("#####################################################################")
+    print("##################################################################")
     print("PeriodicCubicalComplex creation")
-    periodic_cubical_complex = gudhi.PeriodicCubicalComplex(perseus_file=args.file)
+    periodic_cubical_complex = gudhi.PeriodicCubicalComplex(
+        perseus_file=args.file)
 
     print("persistence(homology_coeff_field=3, min_persistence=0)=")
     diag = periodic_cubical_complex.persistence(
@@ -73,4 +78,5 @@ if is_file_perseus(args.file):
         gudhi.plot_persistence_barcode(diag)
         plot.show()
 else:
-    print(args.file, "is not a valid perseus style file")
+    raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                            args.file)
diff --git a/src/python/example/rips_complex_diagram_persistence_from_off_file_example.py b/src/python/example/rips_complex_diagram_persistence_from_off_file_example.py
index c757aca7..6f992508 100755
--- a/src/python/example/rips_complex_diagram_persistence_from_off_file_example.py
+++ b/src/python/example/rips_complex_diagram_persistence_from_off_file_example.py
@@ -1,11 +1,15 @@
 #!/usr/bin/env python
 
 import argparse
+import errno
+import os
 import matplotlib.pyplot as plot
 import gudhi
 
-""" 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.
+""" 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) 2016 Inria
@@ -42,10 +46,11 @@ args = parser.parse_args()
 with open(args.file, "r") as f:
     first_line = f.readline()
     if (first_line == "OFF\n") or (first_line == "nOFF\n"):
-        print("#####################################################################")
+        print("##############################################################")
         print("RipsComplex creation from points read in a OFF file")
 
-        message = "RipsComplex with max_edge_length=" + repr(args.max_edge_length)
+        message = "RipsComplex with max_edge_length=" + \
+            repr(args.max_edge_length)
         print(message)
 
         point_cloud = gudhi.read_points_from_off_file(off_file=args.file)
@@ -68,6 +73,7 @@ with open(args.file, "r") as f:
             gudhi.plot_persistence_diagram(diag, band=args.band)
             plot.show()
     else:
-        print(args.file, "is not a valid OFF file")
+        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                args.file)
 
     f.close()
diff --git a/src/python/example/rips_complex_from_points_example.py b/src/python/example/rips_complex_from_points_example.py
index 59d8a261..c05703c6 100755
--- a/src/python/example/rips_complex_from_points_example.py
+++ b/src/python/example/rips_complex_from_points_example.py
@@ -22,6 +22,9 @@ rips = gudhi.RipsComplex(points=[[0, 0], [1, 0], [0, 1], [1, 1]], max_edge_lengt
 
 simplex_tree = rips.create_simplex_tree(max_dimension=1)
 
-print("filtrations=", simplex_tree.get_filtration())
+print("filtrations=")
+for simplex_with_filtration in simplex_tree.get_filtration():
+    print("(%s, %.2f)" % tuple(simplex_with_filtration))
+
 print("star([0])=", simplex_tree.get_star([0]))
 print("coface([0], 1)=", simplex_tree.get_cofaces([0], 1))
diff --git a/src/python/example/simplex_tree_example.py b/src/python/example/simplex_tree_example.py
index 30de00da..34833899 100755
--- a/src/python/example/simplex_tree_example.py
+++ b/src/python/example/simplex_tree_example.py
@@ -38,8 +38,15 @@ else:
 
 print("dimension=", st.dimension())
 
+print("simplices=")
+for simplex_with_filtration in st.get_simplices():
+    print("(%s, %.2f)" % tuple(simplex_with_filtration))
+
 st.initialize_filtration()
-print("filtration=", st.get_filtration())
+print("filtration=")
+for simplex_with_filtration in st.get_filtration():
+    print("(%s, %.2f)" % tuple(simplex_with_filtration))
+
 print("filtration[1, 2]=", st.filtration([1, 2]))
 print("filtration[4, 2]=", st.filtration([4, 2]))
 
diff --git a/src/python/example/tangential_complex_plain_homology_from_off_file_example.py b/src/python/example/tangential_complex_plain_homology_from_off_file_example.py
index f0df2189..85bade4a 100755
--- a/src/python/example/tangential_complex_plain_homology_from_off_file_example.py
+++ b/src/python/example/tangential_complex_plain_homology_from_off_file_example.py
@@ -1,11 +1,15 @@
 #!/usr/bin/env python
 
 import argparse
+import errno
+import os
 import matplotlib.pyplot as plot
 import gudhi
 
-""" 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.
+""" 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) 2016 Inria
@@ -19,7 +23,7 @@ __copyright__ = "Copyright (C) 2016 Inria"
 __license__ = "MIT"
 
 parser = argparse.ArgumentParser(
-    description="TangentialComplex creation from " "points read in a OFF file.",
+    description="TangentialComplex creation from points read in a OFF file.",
     epilog="Example: "
     "example/tangential_complex_plain_homology_from_off_file_example.py "
     "-f ../data/points/tore3D_300.off -i 3"
@@ -41,10 +45,11 @@ args = parser.parse_args()
 with open(args.file, "r") as f:
     first_line = f.readline()
     if (first_line == "OFF\n") or (first_line == "nOFF\n"):
-        print("#####################################################################")
+        print("##############################################################")
         print("TangentialComplex creation from points read in a OFF file")
 
-        tc = gudhi.TangentialComplex(intrisic_dim=args.intrisic_dim, off_file=args.file)
+        tc = gudhi.TangentialComplex(intrisic_dim=args.intrisic_dim,
+            off_file=args.file)
         tc.compute_tangential_complex()
         st = tc.create_simplex_tree()
 
@@ -60,6 +65,7 @@ with open(args.file, "r") as f:
             gudhi.plot_persistence_diagram(diag, band=args.band)
             plot.show()
     else:
-        print(args.file, "is not a valid OFF file")
+        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                args.file)
 
     f.close()
diff --git a/src/python/gudhi/alpha_complex.pyx b/src/python/gudhi/alpha_complex.pyx
index fff3e920..e04dc652 100644
--- a/src/python/gudhi/alpha_complex.pyx
+++ b/src/python/gudhi/alpha_complex.pyx
@@ -1,5 +1,7 @@
-# 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.
+# 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) 2016 Inria
@@ -7,6 +9,7 @@
 # Modification(s):
 #   - YYYY/MM Author: Description of the modification
 
+from __future__ import print_function
 from cython cimport numeric
 from libcpp.vector cimport vector
 from libcpp.utility cimport pair
@@ -69,7 +72,8 @@ cdef class AlphaComplex:
     def __cinit__(self, points = None, off_file = ''):
         if off_file:
             if os.path.isfile(off_file):
-                self.thisptr = new Alpha_complex_interface(off_file.encode('utf-8'), True)
+                self.thisptr = new Alpha_complex_interface(
+                    off_file.encode('utf-8'), True)
             else:
                 print("file " + off_file + " not found.")
         else:
diff --git a/src/python/gudhi/cubical_complex.pyx b/src/python/gudhi/cubical_complex.pyx
index cbeda014..d5ad1266 100644
--- a/src/python/gudhi/cubical_complex.pyx
+++ b/src/python/gudhi/cubical_complex.pyx
@@ -1,5 +1,7 @@
-# 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.
+# 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) 2016 Inria
@@ -7,12 +9,15 @@
 # Modification(s):
 #   - YYYY/MM Author: Description of the modification
 
+from __future__ import print_function
 from cython cimport numeric
 from libcpp.vector cimport vector
 from libcpp.utility cimport pair
 from libcpp.string cimport string
 from libcpp cimport bool
+import errno
 import os
+import sys
 
 import numpy as np
 
@@ -87,10 +92,12 @@ cdef class CubicalComplex:
             if os.path.isfile(perseus_file):
                 self.thisptr = new Bitmap_cubical_complex_base_interface(perseus_file.encode('utf-8'))
             else:
-                print("file " + perseus_file + " not found.")
+                raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                        perseus_file)
         else:
             print("CubicalComplex can be constructed from dimensions and "
-              "top_dimensional_cells or from a Perseus-style file name.")
+                "top_dimensional_cells or from a Perseus-style file name.",
+                file=sys.stderr)
 
     def __dealloc__(self):
         if self.thisptr != NULL:
@@ -199,5 +206,5 @@ cdef class CubicalComplex:
             intervals_result = self.pcohptr.intervals_in_dimension(dimension)
         else:
             print("intervals_in_dim function requires persistence function"
-                  " to be launched first.")
+                  " to be launched first.", file=sys.stderr)
         return np.array(intervals_result)
diff --git a/src/python/gudhi/nerve_gic.pyx b/src/python/gudhi/nerve_gic.pyx
index 45cc8eba..9c89b239 100644
--- a/src/python/gudhi/nerve_gic.pyx
+++ b/src/python/gudhi/nerve_gic.pyx
@@ -1,5 +1,7 @@
-# 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.
+# 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) 2018 Inria
@@ -7,11 +9,13 @@
 # Modification(s):
 #   - YYYY/MM Author: Description of the modification
 
+from __future__ import print_function
 from cython cimport numeric
 from libcpp.vector cimport vector
 from libcpp.utility cimport pair
 from libcpp.string cimport string
 from libcpp cimport bool
+import errno
 import os
 from libc.stdint cimport intptr_t
 
@@ -96,7 +100,8 @@ cdef class CoverComplex:
         return self.thisptr != NULL
 
     def set_point_cloud_from_range(self, cloud):
-        """ Reads and stores the input point cloud from a vector stored in memory.
+        """ Reads and stores the input point cloud from a vector stored in
+        memory.
 
         :param cloud: Input vector containing the point cloud.
         :type cloud: vector[vector[double]]
@@ -104,7 +109,8 @@ cdef class CoverComplex:
         return self.thisptr.set_point_cloud_from_range(cloud)
 
     def set_distances_from_range(self, distance_matrix):
-        """ Reads and stores the input distance matrix from a vector stored in memory.
+        """ Reads and stores the input distance matrix from a vector stored in
+        memory.
 
         :param distance_matrix: Input vector containing the distance matrix.
         :type distance_matrix: vector[vector[double]]
@@ -163,7 +169,8 @@ cdef class CoverComplex:
         """
         stree = SimplexTree()
         cdef intptr_t stree_int_ptr=stree.thisptr
-        self.thisptr.create_simplex_tree(<Simplex_tree_interface_full_featured*>stree_int_ptr)
+        self.thisptr.create_simplex_tree(
+            <Simplex_tree_interface_full_featured*>stree_int_ptr)
         return stree
 
     def find_simplices(self):
@@ -182,8 +189,8 @@ cdef class CoverComplex:
         if os.path.isfile(off_file):
             return self.thisptr.read_point_cloud(off_file.encode('utf-8'))
         else:
-            print("file " + off_file + " not found.")
-            return False
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                    off_file)
 
     def set_automatic_resolution(self):
         """Computes the optimal length of intervals (i.e. the smallest interval
@@ -214,7 +221,8 @@ cdef class CoverComplex:
         if os.path.isfile(color_file_name):
             self.thisptr.set_color_from_file(color_file_name.encode('utf-8'))
         else:
-            print("file " + color_file_name + " not found.")
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                    color_file_name)
 
     def set_color_from_range(self, color):
         """Computes the function used to color the nodes of the simplicial
@@ -235,7 +243,8 @@ cdef class CoverComplex:
         if os.path.isfile(cover_file_name):
             self.thisptr.set_cover_from_file(cover_file_name.encode('utf-8'))
         else:
-            print("file " + cover_file_name + " not found.")
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                    cover_file_name)
 
     def set_cover_from_function(self):
         """Creates a cover C from the preimages of the function f.
@@ -268,7 +277,8 @@ cdef class CoverComplex:
         if os.path.isfile(func_file_name):
             self.thisptr.set_function_from_file(func_file_name.encode('utf-8'))
         else:
-            print("file " + func_file_name + " not found.")
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                    func_file_name)
 
     def set_function_from_range(self, function):
         """Creates the function f from a vector stored in memory.
@@ -302,14 +312,15 @@ cdef class CoverComplex:
         """Creates a graph G from a file containing the edges.
 
         :param graph_file_name: Name of the input graph file. The graph file
-            contains one edge per line, each edge being represented by the IDs of
-            its two nodes.
+            contains one edge per line, each edge being represented by the IDs
+            of its two nodes.
         :type graph_file_name: string
         """
         if os.path.isfile(graph_file_name):
             self.thisptr.set_graph_from_file(graph_file_name.encode('utf-8'))
         else:
-            print("file " + graph_file_name + " not found.")
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                    graph_file_name)
 
     def set_graph_from_OFF(self):
         """Creates a graph G from the triangulation given by the input OFF
diff --git a/src/python/gudhi/off_reader.pyx b/src/python/gudhi/off_reader.pyx
index 7e6d9d80..a3200704 100644
--- a/src/python/gudhi/off_reader.pyx
+++ b/src/python/gudhi/off_reader.pyx
@@ -1,5 +1,7 @@
-# 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.
+# 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) 2016 Inria
@@ -7,9 +9,11 @@
 # Modification(s):
 #   - YYYY/MM Author: Description of the modification
 
+from __future__ import print_function
 from cython cimport numeric
 from libcpp.vector cimport vector
 from libcpp.string cimport string
+import errno
 import os
 
 __author__ = "Vincent Rouvreau"
@@ -32,6 +36,6 @@ def read_points_from_off_file(off_file=''):
         if os.path.isfile(off_file):
             return read_points_from_OFF_file(off_file.encode('utf-8'))
         else:
-            print("file " + off_file + " not found.")
-            return []
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+                                    off_file)
 
diff --git a/src/python/gudhi/periodic_cubical_complex.pyx b/src/python/gudhi/periodic_cubical_complex.pyx
index 37f76201..fd08b976 100644
--- a/src/python/gudhi/periodic_cubical_complex.pyx
+++ b/src/python/gudhi/periodic_cubical_complex.pyx
@@ -7,11 +7,13 @@
 # Modification(s):
 #   - YYYY/MM Author: Description of the modification
 
+from __future__ import print_function
 from cython cimport numeric
 from libcpp.vector cimport vector
 from libcpp.utility cimport pair
 from libcpp.string cimport string
 from libcpp cimport bool
+import sys
 import os
 
 import numpy as np
@@ -95,12 +97,12 @@ cdef class PeriodicCubicalComplex:
             if os.path.isfile(perseus_file):
                 self.thisptr = new Periodic_cubical_complex_base_interface(perseus_file.encode('utf-8'))
             else:
-                print("file " + perseus_file + " not found.")
+                print("file " + perseus_file + " not found.", file=sys.stderr)
         else:
             print("CubicalComplex can be constructed from dimensions, "
               "top_dimensional_cells and periodic_dimensions, or from "
               "top_dimensional_cells and periodic_dimensions or from "
-              "a Perseus-style file name.")
+              "a Perseus-style file name.", file=sys.stderr)
 
     def __dealloc__(self):
         if self.thisptr != NULL:
@@ -209,5 +211,5 @@ cdef class PeriodicCubicalComplex:
             intervals_result = self.pcohptr.intervals_in_dimension(dimension)
         else:
             print("intervals_in_dim function requires persistence function"
-                  " to be launched first.")
+                  " to be launched first.", file=sys.stderr)
         return np.array(intervals_result)
diff --git a/src/python/gudhi/persistence_graphical_tools.py b/src/python/gudhi/persistence_graphical_tools.py
index 246280de..cc3db467 100644
--- a/src/python/gudhi/persistence_graphical_tools.py
+++ b/src/python/gudhi/persistence_graphical_tools.py
@@ -5,6 +5,7 @@
 # Copyright (C) 2016 Inria
 #
 # Modification(s):
+#   - 2020/02 Theo Lacombe: Added more options for improved rendering and more flexibility.
 #   - YYYY/MM Author: Description of the modification
 
 from os import path
@@ -14,7 +15,7 @@ import numpy as np
 from gudhi.reader_utils import read_persistence_intervals_in_dimension
 from gudhi.reader_utils import read_persistence_intervals_grouped_by_dimension
 
-__author__ = "Vincent Rouvreau, Bertrand Michel"
+__author__ = "Vincent Rouvreau, Bertrand Michel, Theo Lacombe"
 __copyright__ = "Copyright (C) 2016 Inria"
 __license__ = "MIT"
 
@@ -43,6 +44,19 @@ def __min_birth_max_death(persistence, band=0.0):
         max_death += band
     return (min_birth, max_death)
 
+
+def _array_handler(a):
+    '''
+    :param a: if array, assumes it is a (n x 2) np.array and return a
+                persistence-compatible list (padding with 0), so that the
+                plot can be performed seamlessly.
+    '''
+    if isinstance(a[0][1], np.float64) or isinstance(a[0][1], float):
+        return [[0, x] for x in a]
+    else:
+        return a
+
+
 def plot_persistence_barcode(
     persistence=[],
     persistence_file="",
@@ -52,13 +66,16 @@ def plot_persistence_barcode(
     inf_delta=0.1,
     legend=False,
     colormap=None,
-    axes=None
+    axes=None,
+    fontsize=16,
 ):
     """This function plots the persistence bar code from persistence values list
+    , a np.array of shape (N x 2) (representing a diagram 
+    in a single homology dimension), 
     or from a :doc:`persistence file <fileformats>`.
 
-    :param persistence: Persistence intervals values list grouped by dimension.
-    :type persistence: list of tuples(dimension, tuple(birth, death)).
+    :param persistence: Persistence intervals values list. Can be grouped by dimension or not.
+    :type persistence: an array of (dimension, array of (birth, death)) or an array of (birth, death).
     :param persistence_file: A :doc:`persistence file <fileformats>` style name
         (reset persistence if both are set).
     :type persistence_file: string
@@ -81,11 +98,19 @@ def plot_persistence_barcode(
     :param axes: A matplotlib-like subplot axes. If None, the plot is drawn on
         a new set of axes.
     :type axes: `matplotlib.axes.Axes`
+    :param fontsize: Fontsize to use in axis.
+    :type fontsize: int
     :returns: (`matplotlib.axes.Axes`): The axes on which the plot was drawn.
     """
     try:
         import matplotlib.pyplot as plt
         import matplotlib.patches as mpatches
+        from matplotlib import rc
+        plt.rc('text', usetex=True)
+        plt.rc('font', family='serif')
+
+
+        persistence = _array_handler(persistence)
 
         if persistence_file != "":
             if path.isfile(persistence_file):
@@ -163,7 +188,7 @@ def plot_persistence_barcode(
                 loc="lower right",
             )
 
-        axes.set_title("Persistence barcode")
+        axes.set_title("Persistence barcode", fontsize=fontsize)
 
         # Ends plot on infinity value and starts a little bit before min_birth
         axes.axis([axis_start, infinity, 0, ind])
@@ -183,13 +208,16 @@ def plot_persistence_diagram(
     inf_delta=0.1,
     legend=False,
     colormap=None,
-    axes=None
+    axes=None,
+    fontsize=16,
+    greyblock=True
 ):
     """This function plots the persistence diagram from persistence values
-    list or from a :doc:`persistence file <fileformats>`.
+    list, a np.array of shape (N x 2) representing a diagram in a single
+    homology dimension, or from a :doc:`persistence file <fileformats>`.
 
-    :param persistence: Persistence intervals values list grouped by dimension.
-    :type persistence: list of tuples(dimension, tuple(birth, death)).
+    :param persistence: Persistence intervals values list. Can be grouped by dimension or not.
+    :type persistence: an array of (dimension, array of (birth, death)) or an array of (birth, death).
     :param persistence_file: A :doc:`persistence file <fileformats>` style name
         (reset persistence if both are set).
     :type persistence_file: string
@@ -214,11 +242,20 @@ def plot_persistence_diagram(
     :param axes: A matplotlib-like subplot axes. If None, the plot is drawn on
         a new set of axes.
     :type axes: `matplotlib.axes.Axes`
+    :param fontsize: Fontsize to use in axis.
+    :type fontsize: int
+    :param greyblock: if we want to plot a grey patch on the lower half plane for nicer rendering. Default True.
+    :type greyblock: boolean
     :returns: (`matplotlib.axes.Axes`): The axes on which the plot was drawn.
     """
     try:
         import matplotlib.pyplot as plt
         import matplotlib.patches as mpatches
+        from matplotlib import rc
+        plt.rc('text', usetex=True)
+        plt.rc('font', family='serif')
+
+        persistence = _array_handler(persistence)
 
         if persistence_file != "":
             if path.isfile(persistence_file):
@@ -256,19 +293,18 @@ def plot_persistence_diagram(
         # Replace infinity values with max_death + delta for diagram to be more
         # readable
         infinity = max_death + delta
+        axis_end = max_death + delta / 2
         axis_start = min_birth - delta
 
-        # line display of equation : birth = death
-        x = np.linspace(axis_start, infinity, 1000)
-        # infinity line and text
-        axes.plot(x, x, color="k", linewidth=1.0)
-        axes.plot(x, [infinity] * len(x), linewidth=1.0, color="k", alpha=alpha)
-        axes.text(axis_start, infinity, r"$\infty$", color="k", alpha=alpha)
         # bootstrap band
         if band > 0.0:
+            x = np.linspace(axis_start, infinity, 1000)
             axes.fill_between(x, x, x + band, alpha=alpha, facecolor="red")
-
+        # lower diag patch
+        if greyblock:
+            axes.add_patch(mpatches.Polygon([[axis_start, axis_start], [axis_end, axis_start], [axis_end, axis_end]], fill=True, color='lightgrey'))
         # Draw points in loop
+        pts_at_infty = False  # Records presence of pts at infty
         for interval in reversed(persistence):
             if float(interval[1][1]) != float("inf"):
                 # Finite death case
@@ -279,10 +315,23 @@ def plot_persistence_diagram(
                     color=colormap[interval[0]],
                 )
             else:
+                pts_at_infty = True
                 # Infinite death case for diagram to be nicer
                 axes.scatter(
                     interval[1][0], infinity, alpha=alpha, color=colormap[interval[0]]
                 )
+        if pts_at_infty:
+            # infinity line and text
+            axes.plot([axis_start, axis_end], [axis_start, axis_end], linewidth=1.0, color="k")
+            axes.plot([axis_start, axis_end], [infinity, infinity], linewidth=1.0, color="k", alpha=alpha)
+            # Infinity label
+            yt = axes.get_yticks()
+            yt = yt[np.where(yt < axis_end)] # to avoid ploting ticklabel higher than infinity
+            yt = np.append(yt, infinity)
+            ytl = ["%.3f" % e for e in yt]  # to avoid float precision error
+            ytl[-1] = r'$+\infty$'
+            axes.set_yticks(yt)
+            axes.set_yticklabels(ytl)
 
         if legend:
             dimensions = list(set(item[0] for item in persistence))
@@ -293,11 +342,11 @@ def plot_persistence_diagram(
                 ]
             )
 
-        axes.set_xlabel("Birth")
-        axes.set_ylabel("Death")
+        axes.set_xlabel("Birth", fontsize=fontsize)
+        axes.set_ylabel("Death", fontsize=fontsize)
+        axes.set_title("Persistence diagram", fontsize=fontsize)
         # Ends plot on infinity value and starts a little bit before min_birth
-        axes.axis([axis_start, infinity, axis_start, infinity + delta])
-        axes.set_title("Persistence diagram")
+        axes.axis([axis_start, axis_end, axis_start, infinity + delta/2])
         return axes
 
     except ImportError:
@@ -313,16 +362,22 @@ def plot_persistence_density(
     dimension=None,
     cmap=None,
     legend=False,
-    axes=None
+    axes=None,
+    fontsize=16,
+    greyblock=False
 ):
     """This function plots the persistence density from persistence
-    values list or from a :doc:`persistence file <fileformats>`. Be
+    values list, np.array of shape (N x 2) representing a diagram
+    in a single homology dimension,
+    or from a :doc:`persistence file <fileformats>`. Be
     aware that this function does not distinguish the dimension, it is
     up to you to select the required one. This function also does not handle
     degenerate data set (scipy correlation matrix inversion can fail).
 
-    :param persistence: Persistence intervals values list grouped by dimension.
-    :type persistence: list of tuples(dimension, tuple(birth, death)).
+    :param persistence: Persistence intervals values list. 
+                        Can be grouped by dimension or not.
+    :type persistence: an array of (dimension, array of (birth, death)) 
+                        or an array of (birth, death).
     :param persistence_file: A :doc:`persistence file <fileformats>`
         style name (reset persistence if both are set).
     :type persistence_file: string
@@ -355,11 +410,22 @@ def plot_persistence_density(
     :param axes: A matplotlib-like subplot axes. If None, the plot is drawn on
         a new set of axes.
     :type axes: `matplotlib.axes.Axes`
+    :param fontsize: Fontsize to use in axis.
+    :type fontsize: int
+    :param greyblock: if we want to plot a grey patch on the lower half plane 
+                         for nicer rendering. Default False.
+    :type greyblock: boolean
     :returns: (`matplotlib.axes.Axes`): The axes on which the plot was drawn.
     """
     try:
         import matplotlib.pyplot as plt
+        import matplotlib.patches as mpatches
         from scipy.stats import kde
+        from matplotlib import rc
+        plt.rc('text', usetex=True)
+        plt.rc('font', family='serif')
+
+        persistence = _array_handler(persistence)
 
         if persistence_file != "":
             if dimension is None:
@@ -418,12 +484,16 @@ def plot_persistence_density(
         # Make the plot
         img = axes.pcolormesh(xi, yi, zi.reshape(xi.shape), cmap=cmap)
 
+        if greyblock:
+            axes.add_patch(mpatches.Polygon([[birth.min(), birth.min()], [death.max(), birth.min()], [death.max(), death.max()]], fill=True, color='lightgrey'))
+
         if legend:
             plt.colorbar(img, ax=axes)
 
-        axes.set_xlabel("Birth")
-        axes.set_ylabel("Death")
-        axes.set_title("Persistence density")
+        axes.set_xlabel("Birth", fontsize=fontsize)
+        axes.set_ylabel("Death", fontsize=fontsize)
+        axes.set_title("Persistence density", fontsize=fontsize)
+
         return axes
 
     except ImportError:
diff --git a/src/python/gudhi/point_cloud/__init__.py b/src/python/gudhi/point_cloud/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/src/python/gudhi/point_cloud/__init__.py
diff --git a/src/python/gudhi/point_cloud/timedelay.py b/src/python/gudhi/point_cloud/timedelay.py
new file mode 100644
index 00000000..f01df442
--- /dev/null
+++ b/src/python/gudhi/point_cloud/timedelay.py
@@ -0,0 +1,95 @@
+# 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):       Martin Royer, Yuichi Ike, Masatoshi Takenouchi
+#
+# Copyright (C) 2020 Inria, Copyright (C) 2020 Fujitsu Laboratories Ltd.
+# Modification(s):
+#   - YYYY/MM Author: Description of the modification
+
+import numpy as np
+
+
+class TimeDelayEmbedding:
+    """Point cloud transformation class.
+    Embeds time-series data in the R^d according to [Takens' Embedding Theorem]
+    (https://en.wikipedia.org/wiki/Takens%27s_theorem) and obtains the 
+    coordinates of each point.
+
+    Parameters
+    ----------
+    dim : int, optional (default=3)
+        `d` of R^d to be embedded.
+    delay : int, optional (default=1)
+        Time-Delay embedding.
+    skip : int, optional (default=1)
+        How often to skip embedded points.
+
+    Example
+    -------
+
+    Given delay=3 and skip=2, a point cloud which is obtained by embedding
+    a scalar time-series into R^3 is as follows::
+
+        time-series = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        point cloud = [[1, 4, 7],
+                       [3, 6, 9]]
+
+    Given delay=1 and skip=1, a point cloud which is obtained by embedding
+    a 2D vector time-series data into R^4 is as follows::
+
+        time-series = [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]
+        point cloud = [[0, 1, 2, 3],
+                       [2, 3, 4, 5],
+                       [4, 5, 6, 7],
+                       [6, 7, 8, 9]]
+    """
+
+    def __init__(self, dim=3, delay=1, skip=1):
+        self._dim = dim
+        self._delay = delay
+        self._skip = skip
+
+    def __call__(self, ts):
+        """Transform method for single time-series data.
+
+        Parameters
+        ----------
+        ts : Iterable[float] or Iterable[Iterable[float]]
+            A single time-series data, with scalar or vector values.
+
+        Returns
+        -------
+        point cloud : n x dim numpy arrays
+            Makes point cloud from a single time-series data.
+        """
+        return self._transform(np.array(ts))
+
+    def fit(self, ts, y=None):
+        return self
+    
+    def _transform(self, ts):
+        """Guts of transform method."""
+        if ts.ndim == 1:
+            repeat = self._dim
+        else:
+            assert self._dim % ts.shape[1] == 0
+            repeat = self._dim // ts.shape[1]
+        end = len(ts) - self._delay * (repeat - 1)
+        short = np.arange(0, end, self._skip)
+        vertical = np.arange(0, repeat * self._delay, self._delay)
+        return ts[np.add.outer(short, vertical)].reshape(len(short), -1)
+
+    def transform(self, ts):
+        """Transform method for multiple time-series data.
+
+        Parameters
+        ----------
+        ts : Iterable[Iterable[float]] or Iterable[Iterable[Iterable[float]]]
+            Multiple time-series data, with scalar or vector values.
+
+        Returns
+        -------
+        point clouds : list of n x dim numpy arrays
+            Makes point cloud from each time-series data.
+        """
+        return [self._transform(np.array(s)) for s in ts]
diff --git a/src/python/gudhi/simplex_tree.pxd b/src/python/gudhi/simplex_tree.pxd
index 96d14079..82f155de 100644
--- a/src/python/gudhi/simplex_tree.pxd
+++ b/src/python/gudhi/simplex_tree.pxd
@@ -21,6 +21,22 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
     cdef cppclass Simplex_tree_options_full_featured:
         pass
 
+    cdef cppclass Simplex_tree_simplex_handle "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_full_featured>::Simplex_handle":
+        pass
+
+    cdef cppclass Simplex_tree_simplices_iterator "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_full_featured>::Complex_simplex_iterator":
+        Simplex_tree_simplices_iterator()
+        Simplex_tree_simplex_handle& operator*()
+        Simplex_tree_simplices_iterator operator++()
+        bint operator!=(Simplex_tree_simplices_iterator)
+
+    cdef cppclass Simplex_tree_skeleton_iterator "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_full_featured>::Skeleton_simplex_iterator":
+        Simplex_tree_skeleton_iterator()
+        Simplex_tree_simplex_handle& operator*()
+        Simplex_tree_skeleton_iterator operator++()
+        bint operator!=(Simplex_tree_skeleton_iterator)
+
+
     cdef cppclass Simplex_tree_interface_full_featured "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_full_featured>":
         Simplex_tree()
         double simplex_filtration(vector[int] simplex)
@@ -34,8 +50,6 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         bool find_simplex(vector[int] simplex)
         bool insert_simplex_and_subfaces(vector[int] simplex,
                                          double filtration)
-        vector[pair[vector[int], double]] get_filtration()
-        vector[pair[vector[int], double]] get_skeleton(int dimension)
         vector[pair[vector[int], double]] get_star(vector[int] simplex)
         vector[pair[vector[int], double]] get_cofaces(vector[int] simplex,
                                                           int dimension)
@@ -43,6 +57,14 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         void remove_maximal_simplex(vector[int] simplex)
         bool prune_above_filtration(double filtration)
         bool make_filtration_non_decreasing()
+        # Iterators over Simplex tree
+        pair[vector[int], double] get_simplex_and_filtration(Simplex_tree_simplex_handle f_simplex)
+        Simplex_tree_simplices_iterator get_simplices_iterator_begin()
+        Simplex_tree_simplices_iterator get_simplices_iterator_end()
+        vector[Simplex_tree_simplex_handle].const_iterator get_filtration_iterator_begin()
+        vector[Simplex_tree_simplex_handle].const_iterator get_filtration_iterator_end()
+        Simplex_tree_skeleton_iterator get_skeleton_iterator_begin(int dimension)
+        Simplex_tree_skeleton_iterator get_skeleton_iterator_end(int dimension)
 
 cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi":
     cdef cppclass Simplex_tree_persistence_interface "Gudhi::Persistent_cohomology_interface<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_full_featured>>":
diff --git a/src/python/gudhi/simplex_tree.pyx b/src/python/gudhi/simplex_tree.pyx
index b18627c4..c01cc905 100644
--- a/src/python/gudhi/simplex_tree.pyx
+++ b/src/python/gudhi/simplex_tree.pyx
@@ -7,6 +7,7 @@
 # Modification(s):
 #   - YYYY/MM Author: Description of the modification
 
+from cython.operator import dereference, preincrement
 from libc.stdint cimport intptr_t
 from numpy import array as np_array
 cimport simplex_tree
@@ -207,22 +208,34 @@ cdef class SimplexTree:
         return self.get_ptr().insert_simplex_and_subfaces(csimplex,
                                                         <double>filtration)
 
-    def get_filtration(self):
-        """This function returns a list of all simplices with their given
+    def get_simplices(self):
+        """This function returns a generator with simplices and their given
         filtration values.
 
+        :returns:  The simplices.
+        :rtype:  generator with tuples(simplex, filtration)
+        """
+        cdef Simplex_tree_simplices_iterator it = self.get_ptr().get_simplices_iterator_begin()
+        cdef Simplex_tree_simplices_iterator end = self.get_ptr().get_simplices_iterator_end()
+        cdef Simplex_tree_simplex_handle sh = dereference(it)
+
+        while it != end:
+            yield self.get_ptr().get_simplex_and_filtration(dereference(it))
+            preincrement(it)
+
+    def get_filtration(self):
+        """This function returns a generator with simplices and their given
+        filtration values sorted by increasing filtration values.
+
         :returns:  The simplices sorted by increasing filtration values.
-        :rtype:  list of tuples(simplex, filtration)
+        :rtype:  generator with tuples(simplex, filtration)
         """
-        cdef vector[pair[vector[int], double]] filtration \
-            = self.get_ptr().get_filtration()
-        ct = []
-        for filtered_complex in filtration:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            ct.append((v, filtered_complex.second))
-        return ct
+        cdef vector[Simplex_tree_simplex_handle].const_iterator it = self.get_ptr().get_filtration_iterator_begin()
+        cdef vector[Simplex_tree_simplex_handle].const_iterator end = self.get_ptr().get_filtration_iterator_end()
+
+        while it != end:
+            yield self.get_ptr().get_simplex_and_filtration(dereference(it))
+            preincrement(it)
 
     def get_skeleton(self, dimension):
         """This function returns the (simplices of the) skeleton of a maximum
@@ -233,15 +246,12 @@ cdef class SimplexTree:
         :returns:  The (simplices of the) skeleton of a maximum dimension.
         :rtype:  list of tuples(simplex, filtration)
         """
-        cdef vector[pair[vector[int], double]] skeleton \
-            = self.get_ptr().get_skeleton(<int>dimension)
-        ct = []
-        for filtered_simplex in skeleton:
-            v = []
-            for vertex in filtered_simplex.first:
-                v.append(vertex)
-            ct.append((v, filtered_simplex.second))
-        return ct
+        cdef Simplex_tree_skeleton_iterator it = self.get_ptr().get_skeleton_iterator_begin(dimension)
+        cdef Simplex_tree_skeleton_iterator end = self.get_ptr().get_skeleton_iterator_end(dimension)
+
+        while it != end:
+            yield self.get_ptr().get_simplex_and_filtration(dereference(it))
+            preincrement(it)
 
     def get_star(self, simplex):
         """This function returns the star of a given N-simplex.
diff --git a/src/python/gudhi/wasserstein.py b/src/python/gudhi/wasserstein.py
index 13102094..3dd993f9 100644
--- a/src/python/gudhi/wasserstein.py
+++ b/src/python/gudhi/wasserstein.py
@@ -30,8 +30,10 @@ def _build_dist_matrix(X, Y, order=2., internal_p=2.):
     :param order: exponent for the Wasserstein metric.
     :param internal_p: Ground metric (i.e. norm L^p).
     :returns: (n+1) x (m+1) np.array encoding the cost matrix C. 
-                For 1 <= i <= n, 1 <= j <= m, C[i,j] encodes the distance between X[i] and Y[j], while C[i, m+1] (resp. C[n+1, j]) encodes the distance (to the p) between X[i] (resp Y[j]) and its orthogonal proj onto the diagonal.
-                note also that C[n+1, m+1] = 0  (it costs nothing to move from the diagonal to the diagonal).
+                For 0 <= i < n, 0 <= j < m, C[i,j] encodes the distance between X[i] and Y[j], 
+                while C[i, m] (resp. C[n, j]) encodes the distance (to the p) between X[i] (resp Y[j]) 
+                and its orthogonal projection onto the diagonal.
+                note also that C[n, m] = 0  (it costs nothing to move from the diagonal to the diagonal).
     '''
     Xdiag = _proj_on_diag(X)
     Ydiag = _proj_on_diag(Y)
@@ -62,14 +64,20 @@ def _perstot(X, order, internal_p):
     return (np.sum(np.linalg.norm(X - Xdiag, ord=internal_p, axis=1)**order))**(1./order)
 
 
-def wasserstein_distance(X, Y, order=2., internal_p=2.):
+def wasserstein_distance(X, Y, matching=False, order=2., internal_p=2.):
     '''
-    :param X: (n x 2) numpy.array encoding the (finite points of the) first diagram. Must not contain essential points (i.e. with infinite coordinate).
+    :param X: (n x 2) numpy.array encoding the (finite points of the) first diagram. Must not contain essential points 
+                (i.e. with infinite coordinate).
     :param Y: (m x 2) numpy.array encoding the second diagram.
+    :param matching: if True, computes and returns the optimal matching between X and Y, encoded as
+                     a (n x 2) np.array  [...[i,j]...], meaning the i-th point in X is matched to
+                     the j-th point in Y, with the convention (-1) represents the diagonal.
     :param order: exponent for Wasserstein; Default value is 2.
-    :param internal_p: Ground metric on the (upper-half) plane (i.e. norm L^p in R^2); Default value is 2 (Euclidean norm).
-    :returns: the Wasserstein distance of order q (1 <= q < infinity) between persistence diagrams with respect to the internal_p-norm as ground metric.
-    :rtype: float
+    :param internal_p: Ground metric on the (upper-half) plane (i.e. norm L^p in R^2); 
+                       Default value is 2 (Euclidean norm).
+    :returns: the Wasserstein distance of order q (1 <= q < infinity) between persistence diagrams with 
+              respect to the internal_p-norm as ground metric.
+              If matching is set to True, also returns the optimal matching between X and Y.
     '''
     n = len(X)
     m = len(Y)
@@ -77,21 +85,40 @@ def wasserstein_distance(X, Y, order=2., internal_p=2.):
     # handle empty diagrams
     if X.size == 0:
         if Y.size == 0:
-            return 0.
+            if not matching:
+                return 0.
+            else:
+                return 0., np.array([])
         else:
-            return _perstot(Y, order, internal_p)
+            if not matching:
+                return _perstot(Y, order, internal_p)
+            else:
+                return _perstot(Y, order, internal_p), np.array([[-1, j] for j in range(m)])
     elif Y.size == 0:
-        return _perstot(X, order, internal_p)
+        if not matching:
+            return _perstot(X, order, internal_p)
+        else:
+            return _perstot(X, order, internal_p), np.array([[i, -1] for i in range(n)])
 
     M = _build_dist_matrix(X, Y, order=order, internal_p=internal_p)
-    a = np.full(n+1, 1. / (n + m) )  # weight vector of the input diagram. Uniform here.
-    a[-1] = a[-1] * m                # normalized so that we have a probability measure, required by POT
-    b = np.full(m+1, 1. / (n + m) )  # weight vector of the input diagram. Uniform here.
-    b[-1] = b[-1] * n                # so that we have a probability measure, required by POT
+    a = np.ones(n+1) # weight vector of the input diagram. Uniform here.
+    a[-1] = m
+    b = np.ones(m+1) # weight vector of the input diagram. Uniform here.
+    b[-1] = n
+
+    if matching:
+        P = ot.emd(a=a,b=b,M=M, numItermax=2000000)
+        ot_cost = np.sum(np.multiply(P,M))
+        P[-1, -1] = 0  # Remove matching corresponding to the diagonal
+        match = np.argwhere(P)
+        # Now we turn to -1 points encoding the diagonal
+        match[:,0][match[:,0] >= n] = -1
+        match[:,1][match[:,1] >= m] = -1
+        return ot_cost ** (1./order) , match
 
     # Comptuation of the otcost using the ot.emd2 library.
     # Note: it is the Wasserstein distance to the power q.
     # The default numItermax=100000 is not sufficient for some examples with 5000 points, what is a good value?
-    ot_cost = (n+m) * ot.emd2(a, b, M, numItermax=2000000)
+    ot_cost = ot.emd2(a, b, M, numItermax=2000000)
 
     return ot_cost ** (1./order)
diff --git a/src/python/include/Simplex_tree_interface.h b/src/python/include/Simplex_tree_interface.h
index 06f31341..4a7062d6 100644
--- a/src/python/include/Simplex_tree_interface.h
+++ b/src/python/include/Simplex_tree_interface.h
@@ -33,7 +33,10 @@ class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
   using Simplex_handle = typename Base::Simplex_handle;
   using Insertion_result = typename std::pair<Simplex_handle, bool>;
   using Simplex = std::vector<Vertex_handle>;
-  using Filtered_simplices = std::vector<std::pair<Simplex, Filtration_value>>;
+  using Simplex_and_filtration = std::pair<Simplex, Filtration_value>;
+  using Filtered_simplices = std::vector<Simplex_and_filtration>;
+  using Skeleton_simplex_iterator = typename Base::Skeleton_simplex_iterator;
+  using Complex_simplex_iterator = typename Base::Complex_simplex_iterator;
 
  public:
   bool find_simplex(const Simplex& vh) {
@@ -82,29 +85,12 @@ class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
     Base::initialize_filtration();
   }
 
-  Filtered_simplices get_filtration() {
-    Base::initialize_filtration();
-    Filtered_simplices filtrations;
-    for (auto f_simplex : Base::filtration_simplex_range()) {
-      Simplex simplex;
-      for (auto vertex : Base::simplex_vertex_range(f_simplex)) {
-        simplex.insert(simplex.begin(), vertex);
-      }
-      filtrations.push_back(std::make_pair(simplex, Base::filtration(f_simplex)));
-    }
-    return filtrations;
-  }
-
-  Filtered_simplices get_skeleton(int dimension) {
-    Filtered_simplices skeletons;
-    for (auto f_simplex : Base::skeleton_simplex_range(dimension)) {
-      Simplex simplex;
-      for (auto vertex : Base::simplex_vertex_range(f_simplex)) {
-        simplex.insert(simplex.begin(), vertex);
-      }
-      skeletons.push_back(std::make_pair(simplex, Base::filtration(f_simplex)));
+  Simplex_and_filtration get_simplex_and_filtration(Simplex_handle f_simplex) {
+    Simplex simplex;
+    for (auto vertex : Base::simplex_vertex_range(f_simplex)) {
+      simplex.insert(simplex.begin(), vertex);
     }
-    return skeletons;
+    return std::make_pair(std::move(simplex), Base::filtration(f_simplex));
   }
 
   Filtered_simplices get_star(const Simplex& simplex) {
@@ -135,6 +121,38 @@ class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
     Base::initialize_filtration();
     pcoh = new Gudhi::Persistent_cohomology_interface<Base>(*this);
   }
+
+  // Iterator over the simplex tree
+  Complex_simplex_iterator get_simplices_iterator_begin() {
+    // this specific case works because the range is just a pair of iterators - won't work if range was a vector
+    return Base::complex_simplex_range().begin();
+  }
+
+  Complex_simplex_iterator get_simplices_iterator_end() {
+    // this specific case works because the range is just a pair of iterators - won't work if range was a vector
+    return Base::complex_simplex_range().end();
+  }
+
+  typename std::vector<Simplex_handle>::const_iterator get_filtration_iterator_begin() {
+    // Base::initialize_filtration(); already performed in filtration_simplex_range
+    // this specific case works because the range is just a pair of iterators - won't work if range was a vector
+    return Base::filtration_simplex_range().begin();
+  }
+
+  typename std::vector<Simplex_handle>::const_iterator get_filtration_iterator_end() {
+    // this specific case works because the range is just a pair of iterators - won't work if range was a vector
+    return Base::filtration_simplex_range().end();
+  }
+
+  Skeleton_simplex_iterator get_skeleton_iterator_begin(int dimension) {
+    // this specific case works because the range is just a pair of iterators - won't work if range was a vector
+    return Base::skeleton_simplex_range(dimension).begin();
+  }
+
+  Skeleton_simplex_iterator get_skeleton_iterator_end(int dimension) {
+    // this specific case works because the range is just a pair of iterators - won't work if range was a vector
+    return Base::skeleton_simplex_range(dimension).end();
+  }
 };
 
 }  // namespace Gudhi
diff --git a/src/python/test/test_alpha_complex.py b/src/python/test/test_alpha_complex.py
index 3761fe16..77121302 100755
--- a/src/python/test/test_alpha_complex.py
+++ b/src/python/test/test_alpha_complex.py
@@ -40,7 +40,7 @@ def test_infinite_alpha():
     assert simplex_tree.num_simplices() == 11
     assert simplex_tree.num_vertices() == 4
 
-    assert simplex_tree.get_filtration() == [
+    assert list(simplex_tree.get_filtration()) == [
         ([0], 0.0),
         ([1], 0.0),
         ([2], 0.0),
@@ -53,6 +53,7 @@ def test_infinite_alpha():
         ([0, 1, 2], 0.5),
         ([1, 2, 3], 0.5),
     ]
+
     assert simplex_tree.get_star([0]) == [
         ([0], 0.0),
         ([0, 1], 0.25),
@@ -105,7 +106,7 @@ def test_filtered_alpha():
     else:
         assert False
 
-    assert simplex_tree.get_filtration() == [
+    assert list(simplex_tree.get_filtration()) == [
         ([0], 0.0),
         ([1], 0.0),
         ([2], 0.0),
diff --git a/src/python/test/test_cover_complex.py b/src/python/test/test_cover_complex.py
index 32bc5a26..260f6a5c 100755
--- a/src/python/test/test_cover_complex.py
+++ b/src/python/test/test_cover_complex.py
@@ -9,6 +9,7 @@
 """
 
 from gudhi import CoverComplex
+import pytest
 
 __author__ = "Vincent Rouvreau"
 __copyright__ = "Copyright (C) 2018 Inria"
@@ -24,7 +25,8 @@ def test_empty_constructor():
 def test_non_existing_file_read():
     # Try to open a non existing file
     cover = CoverComplex()
-    assert cover.read_point_cloud("pouetpouettralala.toubiloubabdou") == False
+    with pytest.raises(FileNotFoundError):
+        cover.read_point_cloud("pouetpouettralala.toubiloubabdou")
 
 
 def test_files_creation():
diff --git a/src/python/test/test_cubical_complex.py b/src/python/test/test_cubical_complex.py
index 8c1b2600..fce4875c 100755
--- a/src/python/test/test_cubical_complex.py
+++ b/src/python/test/test_cubical_complex.py
@@ -10,6 +10,7 @@
 
 from gudhi import CubicalComplex, PeriodicCubicalComplex
 import numpy as np
+import pytest
 
 __author__ = "Vincent Rouvreau"
 __copyright__ = "Copyright (C) 2016 Inria"
@@ -25,9 +26,8 @@ def test_empty_constructor():
 
 def test_non_existing_perseus_file_constructor():
     # Try to open a non existing file
-    cub = CubicalComplex(perseus_file="pouetpouettralala.toubiloubabdou")
-    assert cub.__is_defined() == False
-    assert cub.__is_persistence_defined() == False
+    with pytest.raises(FileNotFoundError):
+        cub = CubicalComplex(perseus_file="pouetpouettralala.toubiloubabdou")
 
 
 def test_dimension_or_perseus_file_constructor():
diff --git a/src/python/test/test_euclidean_witness_complex.py b/src/python/test/test_euclidean_witness_complex.py
index c18d2484..f3664d39 100755
--- a/src/python/test/test_euclidean_witness_complex.py
+++ b/src/python/test/test_euclidean_witness_complex.py
@@ -40,7 +40,7 @@ def test_witness_complex():
     assert landmarks[1] == euclidean_witness_complex.get_point(1)
     assert landmarks[2] == euclidean_witness_complex.get_point(2)
 
-    assert simplex_tree.get_filtration() == [
+    assert list(simplex_tree.get_filtration()) == [
         ([0], 0.0),
         ([1], 0.0),
         ([0, 1], 0.0),
@@ -78,13 +78,13 @@ def test_strong_witness_complex():
     assert landmarks[1] == euclidean_strong_witness_complex.get_point(1)
     assert landmarks[2] == euclidean_strong_witness_complex.get_point(2)
 
-    assert simplex_tree.get_filtration() == [([0], 0.0), ([1], 0.0), ([2], 0.0)]
+    assert list(simplex_tree.get_filtration()) == [([0], 0.0), ([1], 0.0), ([2], 0.0)]
 
     simplex_tree = euclidean_strong_witness_complex.create_simplex_tree(
         max_alpha_square=100.0
     )
 
-    assert simplex_tree.get_filtration() == [
+    assert list(simplex_tree.get_filtration()) == [
         ([0], 0.0),
         ([1], 0.0),
         ([2], 0.0),
diff --git a/src/python/test/test_rips_complex.py b/src/python/test/test_rips_complex.py
index b02a68e1..b86e7498 100755
--- a/src/python/test/test_rips_complex.py
+++ b/src/python/test/test_rips_complex.py
@@ -32,7 +32,7 @@ def test_rips_from_points():
     assert simplex_tree.num_simplices() == 10
     assert simplex_tree.num_vertices() == 4
 
-    assert simplex_tree.get_filtration() == [
+    assert list(simplex_tree.get_filtration()) == [
         ([0], 0.0),
         ([1], 0.0),
         ([2], 0.0),
@@ -44,6 +44,7 @@ def test_rips_from_points():
         ([1, 2], 1.4142135623730951),
         ([0, 3], 1.4142135623730951),
     ]
+
     assert simplex_tree.get_star([0]) == [
         ([0], 0.0),
         ([0, 1], 1.0),
@@ -95,7 +96,7 @@ def test_rips_from_distance_matrix():
     assert simplex_tree.num_simplices() == 10
     assert simplex_tree.num_vertices() == 4
 
-    assert simplex_tree.get_filtration() == [
+    assert list(simplex_tree.get_filtration()) == [
         ([0], 0.0),
         ([1], 0.0),
         ([2], 0.0),
@@ -107,6 +108,7 @@ def test_rips_from_distance_matrix():
         ([1, 2], 1.4142135623730951),
         ([0, 3], 1.4142135623730951),
     ]
+
     assert simplex_tree.get_star([0]) == [
         ([0], 0.0),
         ([0, 1], 1.0),
diff --git a/src/python/test/test_simplex_tree.py b/src/python/test/test_simplex_tree.py
index 1822c43b..f7848379 100755
--- a/src/python/test/test_simplex_tree.py
+++ b/src/python/test/test_simplex_tree.py
@@ -55,7 +55,7 @@ def test_insertion():
     assert st.filtration([1]) == 0.0
 
     # skeleton test
-    assert st.get_skeleton(2) == [
+    assert list(st.get_skeleton(2)) == [
         ([0, 1, 2], 4.0),
         ([0, 1], 0.0),
         ([0, 2], 4.0),
@@ -64,7 +64,7 @@ def test_insertion():
         ([1], 0.0),
         ([2], 4.0),
     ]
-    assert st.get_skeleton(1) == [
+    assert list(st.get_skeleton(1)) == [
         ([0, 1], 0.0),
         ([0, 2], 4.0),
         ([0], 0.0),
@@ -72,12 +72,12 @@ def test_insertion():
         ([1], 0.0),
         ([2], 4.0),
     ]
-    assert st.get_skeleton(0) == [([0], 0.0), ([1], 0.0), ([2], 4.0)]
+    assert list(st.get_skeleton(0)) == [([0], 0.0), ([1], 0.0), ([2], 4.0)]
 
     # remove_maximal_simplex test
     assert st.get_cofaces([0, 1, 2], 1) == []
     st.remove_maximal_simplex([0, 1, 2])
-    assert st.get_skeleton(2) == [
+    assert list(st.get_skeleton(2)) == [
         ([0, 1], 0.0),
         ([0, 2], 4.0),
         ([0], 0.0),
@@ -126,7 +126,8 @@ def test_expansion():
 
     assert st.num_vertices() == 7
     assert st.num_simplices() == 17
-    assert st.get_filtration() == [
+
+    assert list(st.get_filtration()) == [
         ([2], 0.1),
         ([3], 0.1),
         ([2, 3], 0.1),
@@ -151,7 +152,7 @@ def test_expansion():
     assert st.num_simplices() == 22
     st.initialize_filtration()
 
-    assert st.get_filtration() == [
+    assert list(st.get_filtration()) == [
         ([2], 0.1),
         ([3], 0.1),
         ([2, 3], 0.1),
@@ -248,3 +249,15 @@ def test_make_filtration_non_decreasing():
     assert st.filtration([3, 4, 5]) == 2.0
     assert st.filtration([3, 4]) == 2.0
     assert st.filtration([4, 5]) == 2.0
+
+def test_simplices_iterator():
+    st = SimplexTree()
+    
+    assert st.insert([0, 1, 2], filtration=4.0) == True
+    assert st.insert([2, 3, 4], filtration=2.0) == True
+
+    for simplex in st.get_simplices():
+        print("simplex is: ", simplex[0])
+        assert st.find(simplex[0]) == True
+        print("filtration is: ", simplex[1])
+        assert st.filtration(simplex[0]) == simplex[1]
diff --git a/src/python/test/test_subsampling.py b/src/python/test/test_subsampling.py
index fe0985fa..31f64e32 100755
--- a/src/python/test/test_subsampling.py
+++ b/src/python/test/test_subsampling.py
@@ -120,7 +120,6 @@ def test_simple_pick_n_random_points():
     # Go furter than point set on purpose
     for iter in range(1, 10):
         sub_set = gudhi.pick_n_random_points(points=point_set, nb_points=iter)
-        print(5)
         for sub in sub_set:
             found = False
             for point in point_set:
diff --git a/src/python/test/test_tangential_complex.py b/src/python/test/test_tangential_complex.py
index e650e99c..8668a2e0 100755
--- a/src/python/test/test_tangential_complex.py
+++ b/src/python/test/test_tangential_complex.py
@@ -37,7 +37,7 @@ def test_tangential():
     assert st.num_simplices() == 6
     assert st.num_vertices() == 4
 
-    assert st.get_filtration() == [
+    assert list(st.get_filtration()) == [
         ([0], 0.0),
         ([1], 0.0),
         ([2], 0.0),
@@ -45,6 +45,7 @@ def test_tangential():
         ([3], 0.0),
         ([1, 3], 0.0),
     ]
+
     assert st.get_cofaces([0], 1) == [([0, 2], 0.0)]
 
     assert point_list[0] == tc.get_point(0)
diff --git a/src/python/test/test_time_delay.py b/src/python/test/test_time_delay.py
new file mode 100755
index 00000000..1ead9bca
--- /dev/null
+++ b/src/python/test/test_time_delay.py
@@ -0,0 +1,43 @@
+from gudhi.point_cloud.timedelay import TimeDelayEmbedding
+import numpy as np
+
+
+def test_normal():
+    # Sample array
+    ts = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    # Normal case.
+    prep = TimeDelayEmbedding()
+    pointclouds = prep(ts)
+    assert (pointclouds[0] == np.array([1, 2, 3])).all()
+    assert (pointclouds[1] == np.array([2, 3, 4])).all()
+    assert (pointclouds[2] == np.array([3, 4, 5])).all()
+    assert (pointclouds[3] == np.array([4, 5, 6])).all()
+    assert (pointclouds[4] == np.array([5, 6, 7])).all()
+    assert (pointclouds[5] == np.array([6, 7, 8])).all()
+    assert (pointclouds[6] == np.array([7, 8, 9])).all()
+    assert (pointclouds[7] == np.array([8, 9, 10])).all()
+    # Delay = 3
+    prep = TimeDelayEmbedding(delay=3)
+    pointclouds = prep(ts)
+    assert (pointclouds[0] == np.array([1, 4, 7])).all()
+    assert (pointclouds[1] == np.array([2, 5, 8])).all()
+    assert (pointclouds[2] == np.array([3, 6, 9])).all()
+    assert (pointclouds[3] == np.array([4, 7, 10])).all()
+    # Skip = 3
+    prep = TimeDelayEmbedding(skip=3)
+    pointclouds = prep(ts)
+    assert (pointclouds[0] == np.array([1, 2, 3])).all()
+    assert (pointclouds[1] == np.array([4, 5, 6])).all()
+    assert (pointclouds[2] == np.array([7, 8, 9])).all()
+    # Delay = 2 / Skip = 2
+    prep = TimeDelayEmbedding(delay=2, skip=2)
+    pointclouds = prep(ts)
+    assert (pointclouds[0] == np.array([1, 3, 5])).all()
+    assert (pointclouds[1] == np.array([3, 5, 7])).all()
+    assert (pointclouds[2] == np.array([5, 7, 9])).all()
+
+    # Vector series
+    ts = np.arange(0, 10).reshape(-1, 2)
+    prep = TimeDelayEmbedding(dim=4)
+    prep.fit([ts])
+    assert (prep.transform([ts])[0] == [[0, 1, 2, 3], [2, 3, 4, 5], [4, 5, 6, 7], [6, 7, 8, 9]]).all()
diff --git a/src/python/test/test_wasserstein_distance.py b/src/python/test/test_wasserstein_distance.py
index 6a6b217b..0d70e11a 100755
--- a/src/python/test/test_wasserstein_distance.py
+++ b/src/python/test/test_wasserstein_distance.py
@@ -17,7 +17,7 @@ __author__ = "Theo Lacombe"
 __copyright__ = "Copyright (C) 2019 Inria"
 __license__ = "MIT"
 
-def _basic_wasserstein(wasserstein_distance, delta, test_infinity=True):
+def _basic_wasserstein(wasserstein_distance, delta, test_infinity=True, test_matching=True):
     diag1 = np.array([[2.7, 3.7], [9.6, 14.0], [34.2, 34.974]])
     diag2 = np.array([[2.8, 4.45], [9.5, 14.1]])
     diag3 = np.array([[0, 2], [4, 6]])
@@ -51,14 +51,27 @@ def _basic_wasserstein(wasserstein_distance, delta, test_infinity=True):
     assert wasserstein_distance(diag3, diag4, internal_p=1.,     order=2.) == approx(np.sqrt(5))
     assert wasserstein_distance(diag3, diag4, internal_p=4.5,    order=2.) == approx(np.sqrt(5))
 
-    if(not test_infinity):
-        return
+    if test_infinity:
+        diag5 = np.array([[0, 3], [4, np.inf]])
+        diag6 = np.array([[7, 8], [4, 6], [3, np.inf]])
 
-    diag5 = np.array([[0, 3], [4, np.inf]])
-    diag6 = np.array([[7, 8], [4, 6], [3, np.inf]])
+        assert wasserstein_distance(diag4, diag5) == np.inf
+        assert wasserstein_distance(diag5, diag6, order=1, internal_p=np.inf) == approx(4.)
+
+
+    if test_matching:
+        match = wasserstein_distance(emptydiag, emptydiag, matching=True, internal_p=1., order=2)[1]
+        assert np.array_equal(match, [])
+        match = wasserstein_distance(emptydiag, emptydiag, matching=True, internal_p=np.inf, order=2.24)[1]
+        assert np.array_equal(match, [])
+        match = wasserstein_distance(emptydiag, diag2, matching=True, internal_p=np.inf, order=2.)[1]
+        assert np.array_equal(match , [[-1, 0], [-1, 1]])
+        match = wasserstein_distance(diag2, emptydiag, matching=True, internal_p=np.inf, order=2.24)[1]
+        assert np.array_equal(match , [[0, -1], [1, -1]])
+        match = wasserstein_distance(diag1, diag2, matching=True, internal_p=2., order=2.)[1]
+        assert np.array_equal(match, [[0, 0], [1, 1], [2, -1]])
+        
 
-    assert wasserstein_distance(diag4, diag5) == np.inf
-    assert wasserstein_distance(diag5, diag6, order=1, internal_p=np.inf) == approx(4.)
 
 def hera_wrap(delta):
     def fun(*kargs,**kwargs):
@@ -66,8 +79,8 @@ def hera_wrap(delta):
     return fun
 
 def test_wasserstein_distance_pot():
-    _basic_wasserstein(pot, 1e-15, test_infinity=False)
+    _basic_wasserstein(pot, 1e-15, test_infinity=False, test_matching=True)
 
 def test_wasserstein_distance_hera():
-    _basic_wasserstein(hera_wrap(1e-12), 1e-12)
-    _basic_wasserstein(hera_wrap(.1), .1)
+    _basic_wasserstein(hera_wrap(1e-12), 1e-12, test_matching=False)
+    _basic_wasserstein(hera_wrap(.1), .1, test_matching=False)