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

5 files changed, 48 insertions, 48 deletions

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 ba5ddafd..ab099c04 100644
--- a/src/Nerve_GIC/include/gudhi/GIC.h
+++ b/src/Nerve_GIC/include/gudhi/GIC.h
@@ -407,7 +407,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 +417,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 +431,7 @@ class Cover_complex {
         }
       }
       output.close();
-      if (verbose) std::cout << std::endl;
+      if (verbose) std::clog << std::endl;
     }
   }
 
@@ -451,8 +451,8 @@ 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);
 
@@ -487,7 +487,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;
   }
@@ -579,7 +579,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 +589,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;
     }
 
@@ -637,7 +637,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 +663,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 +681,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 +698,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 +715,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 +764,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;
       tbb::mutex covermutex, idmutex;
       tbb::parallel_for(0, res, [&](int i){
         // Compute connected components
@@ -800,7 +800,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 +894,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;
       tbb::mutex coverMutex; tbb::mutex mindistMutex;
       tbb::parallel_for(0, m, [&](int i){
         int seed = voronoi_subsamples[i];
@@ -916,7 +916,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(
@@ -1054,7 +1054,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 +1090,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 +1137,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 +1185,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 +1199,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;
@@ -1215,7 +1215,7 @@ class Cover_complex {
     unsigned int sz = distribution.size();
     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;
 
@@ -1241,7 +1241,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);
       }
 
@@ -1258,7 +1258,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;
   }
 
@@ -1273,7 +1273,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;
   }
 
@@ -1286,7 +1286,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;
   }
 
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;
       }
     }
   }