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

1 files changed, 69 insertions, 70 deletions

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;