Code review: Use std::clog instead of std::cout

13 files changed, 105 insertions, 105 deletions

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/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 d4e66d8d..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::cout << #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 ac9e987b..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::cout << "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::cout << result[i][j] << " ";
+      std::clog << result[i][j] << " ";
     }
-    std::cout << 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/include/gudhi/writing_persistence_to_file.h b/src/common/include/gudhi/writing_persistence_to_file.h
index 2e36b831..cdd8be0a 100644
--- a/src/common/include/gudhi/writing_persistence_to_file.h
+++ b/src/common/include/gudhi/writing_persistence_to_file.h
@@ -94,7 +94,7 @@ class Persistence_interval_common {
 **/
 template <typename Persistence_interval_range>
 void write_persistence_intervals_to_stream(const Persistence_interval_range& intervals,
-                                           std::ostream& out = std::cout) {
+                                           std::ostream& out = std::clog) {
   for (auto interval : intervals) {
     out << interval << "\n";
   }
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);