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

7 files changed, 467 insertions, 361 deletions

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}));
+  }
 }