git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/Nerve_GIC@2838 636b058d-ea47-450e-bf9e-a15bfbe3eedb

Former-commit-id: aa674c458f110c5c7cc3f5c987b921fcc96e3e7e

6 files changed, 823 insertions, 296 deletions

diff --git a/src/Simplex_tree/test/CMakeLists.txt b/src/Simplex_tree/test/CMakeLists.txt
index 17b0f2c2..8684ad2a 100644
--- a/src/Simplex_tree/test/CMakeLists.txt
+++ b/src/Simplex_tree/test/CMakeLists.txt
@@ -3,13 +3,29 @@ project(Simplex_tree_tests)
 
 include(GUDHI_test_coverage)
 
+# Do not forget to copy test files in current binary dir
+file(COPY "simplex_tree_for_unit_test.txt" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
+
 add_executable ( Simplex_tree_test_unit simplex_tree_unit_test.cpp )
-target_link_libraries(Simplex_tree_test_unit ${Boost_SYSTEM_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+target_link_libraries(Simplex_tree_test_unit ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 if (TBB_FOUND)
   target_link_libraries(Simplex_tree_test_unit ${TBB_LIBRARIES})
 endif()
 
-# Do not forget to copy test files in current binary dir
-file(COPY "simplex_tree_for_unit_test.txt" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
-
 gudhi_add_coverage_test(Simplex_tree_test_unit)
+
+add_executable ( Simplex_tree_remove_test_unit simplex_tree_remove_unit_test.cpp )
+target_link_libraries(Simplex_tree_remove_test_unit ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+if (TBB_FOUND)
+  target_link_libraries(Simplex_tree_remove_test_unit ${TBB_LIBRARIES})
+endif()
+
+gudhi_add_coverage_test(Simplex_tree_remove_test_unit)
+
+add_executable ( Simplex_tree_iostream_operator_test_unit simplex_tree_iostream_operator_unit_test.cpp )
+target_link_libraries(Simplex_tree_iostream_operator_test_unit ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+if (TBB_FOUND)
+  target_link_libraries(Simplex_tree_iostream_operator_test_unit ${TBB_LIBRARIES})
+endif()
+
+gudhi_add_coverage_test(Simplex_tree_iostream_operator_test_unit)
diff --git a/src/Simplex_tree/test/README b/src/Simplex_tree/test/README
index 21c3d871..df2ab89a 100644
--- a/src/Simplex_tree/test/README
+++ b/src/Simplex_tree/test/README
@@ -9,6 +9,6 @@ make
 To launch with details:
 ***********************
 
-./SimplexTreeUT --report_level=detailed --log_level=all 
+./Simplex_tree_test_unit --report_level=detailed --log_level=all
 
    ==> echo $? returns 0 in case of success (non-zero otherwise)
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
new file mode 100644
index 00000000..19ce3321
--- /dev/null
+++ b/src/Simplex_tree/test/simplex_tree_graph_expansion_unit_test.cpp
@@ -0,0 +1,235 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <algorithm>
+#include <utility> // std::pair, std::make_pair
+#include <cmath> // float comparison
+#include <limits>
+#include <functional> // greater
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "simplex_tree"
+#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;
+
+
+bool AreAlmostTheSame(float a, float b) {
+  return std::fabs(a - b) < std::numeric_limits<float>::epsilon();
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_expansion_with_blockers_3, typeST, list_of_tested_variants) {
+  using Simplex_handle = typename typeST::Simplex_handle;
+  // Construct the Simplex Tree with a 1-skeleton graph example
+  typeST simplex_tree;
+
+  simplex_tree.insert_simplex({0, 1}, 0.);
+  simplex_tree.insert_simplex({0, 2}, 1.);
+  simplex_tree.insert_simplex({0, 3}, 2.);
+  simplex_tree.insert_simplex({1, 2}, 3.);
+  simplex_tree.insert_simplex({1, 3}, 4.);
+  simplex_tree.insert_simplex({2, 3}, 5.);
+  simplex_tree.insert_simplex({2, 4}, 6.);
+  simplex_tree.insert_simplex({3, 6}, 7.);
+  simplex_tree.insert_simplex({4, 5}, 8.);
+  simplex_tree.insert_simplex({4, 6}, 9.);
+  simplex_tree.insert_simplex({5, 6}, 10.);
+  simplex_tree.insert_simplex({6}, 10.);
+
+  simplex_tree.expansion_with_blockers(3, [&](Simplex_handle sh){
+      bool result = false;
+      std::cout << "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::cout << "] ( " << 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;
+
+      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";
+  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
+    std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex))
+      std::cout << "(" << vertex << ")";
+    std::cout << std::endl;
+  }
+
+  BOOST_CHECK(simplex_tree.num_simplices() == 23);
+  BOOST_CHECK(simplex_tree.dimension() == 3);
+  // {4, 5, 6} shall be blocked
+  BOOST_CHECK(simplex_tree.find({4, 5, 6}) == simplex_tree.null_simplex());
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,1,2})), 4.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,1,3})), 5.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,2,3})), 6.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({1,2,3})), 6.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,1,2,3})), 7.));
+
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_expansion_with_blockers_2, typeST, list_of_tested_variants) {
+  using Simplex_handle = typename typeST::Simplex_handle;
+  // Construct the Simplex Tree with a 1-skeleton graph example
+  typeST simplex_tree;
+
+  simplex_tree.insert_simplex({0, 1}, 0.);
+  simplex_tree.insert_simplex({0, 2}, 1.);
+  simplex_tree.insert_simplex({0, 3}, 2.);
+  simplex_tree.insert_simplex({1, 2}, 3.);
+  simplex_tree.insert_simplex({1, 3}, 4.);
+  simplex_tree.insert_simplex({2, 3}, 5.);
+  simplex_tree.insert_simplex({2, 4}, 6.);
+  simplex_tree.insert_simplex({3, 6}, 7.);
+  simplex_tree.insert_simplex({4, 5}, 8.);
+  simplex_tree.insert_simplex({4, 6}, 9.);
+  simplex_tree.insert_simplex({5, 6}, 10.);
+  simplex_tree.insert_simplex({6}, 10.);
+
+  simplex_tree.expansion_with_blockers(2, [&](Simplex_handle sh){
+      bool result = false;
+      std::cout << "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::cout << "] ( " << 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;
+
+      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";
+  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
+    std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex))
+      std::cout << "(" << vertex << ")";
+    std::cout << std::endl;
+  }
+
+  BOOST_CHECK(simplex_tree.num_simplices() == 22);
+  BOOST_CHECK(simplex_tree.dimension() == 2);
+  // {4, 5, 6} shall be blocked
+  BOOST_CHECK(simplex_tree.find({4, 5, 6}) == simplex_tree.null_simplex());
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,1,2})), 4.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,1,3})), 5.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,2,3})), 6.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({1,2,3})), 6.));
+  BOOST_CHECK(simplex_tree.find({0,1,2,3}) == simplex_tree.null_simplex());
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_expansion, typeST, list_of_tested_variants) {
+  // Construct the Simplex Tree with a 1-skeleton graph example
+  typeST simplex_tree;
+
+  simplex_tree.insert_simplex({0, 1}, 0.);
+  simplex_tree.insert_simplex({0, 2}, 1.);
+  simplex_tree.insert_simplex({0, 3}, 2.);
+  simplex_tree.insert_simplex({1, 2}, 3.);
+  simplex_tree.insert_simplex({1, 3}, 4.);
+  simplex_tree.insert_simplex({2, 3}, 5.);
+  simplex_tree.insert_simplex({2, 4}, 6.);
+  simplex_tree.insert_simplex({3, 6}, 7.);
+  simplex_tree.insert_simplex({4, 5}, 8.);
+  simplex_tree.insert_simplex({4, 6}, 9.);
+  simplex_tree.insert_simplex({5, 6}, 10.);
+  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";
+  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
+    std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex))
+      std::cout << "(" << vertex << ")";
+    std::cout << std::endl;
+  }
+
+  BOOST_CHECK(simplex_tree.num_simplices() == 24);
+  BOOST_CHECK(simplex_tree.dimension() == 3);
+
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({4,5,6})), 10.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,1,2})), 3.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,1,3})), 4.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,2,3})), 5.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({1,2,3})), 5.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,1,2,3})), 5.));
+
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_expansion_2, typeST, list_of_tested_variants) {
+  // Construct the Simplex Tree with a 1-skeleton graph example
+  typeST simplex_tree;
+
+  simplex_tree.insert_simplex({0, 1}, 0.);
+  simplex_tree.insert_simplex({0, 2}, 1.);
+  simplex_tree.insert_simplex({0, 3}, 2.);
+  simplex_tree.insert_simplex({1, 2}, 3.);
+  simplex_tree.insert_simplex({1, 3}, 4.);
+  simplex_tree.insert_simplex({2, 3}, 5.);
+  simplex_tree.insert_simplex({2, 4}, 6.);
+  simplex_tree.insert_simplex({3, 6}, 7.);
+  simplex_tree.insert_simplex({4, 5}, 8.);
+  simplex_tree.insert_simplex({4, 6}, 9.);
+  simplex_tree.insert_simplex({5, 6}, 10.);
+  simplex_tree.insert_simplex({6}, 10.);
+
+  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";
+  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
+    std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex))
+      std::cout << "(" << vertex << ")";
+    std::cout << std::endl;
+  }
+
+  BOOST_CHECK(simplex_tree.num_simplices() == 23);
+  BOOST_CHECK(simplex_tree.dimension() == 2);
+
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({4,5,6})), 10.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,1,2})), 3.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,1,3})), 4.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({0,2,3})), 5.));
+  BOOST_CHECK(AreAlmostTheSame(simplex_tree.filtration(simplex_tree.find({1,2,3})), 5.));
+  BOOST_CHECK(simplex_tree.find({0,1,2,3}) == simplex_tree.null_simplex());
+}
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
new file mode 100644
index 00000000..ecb9f025
--- /dev/null
+++ b/src/Simplex_tree/test/simplex_tree_iostream_operator_unit_test.cpp
@@ -0,0 +1,136 @@
+#include <iostream>
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "simplex_tree_iostream_operator"
+#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;
+
+struct MyOptions : Simplex_tree_options_full_featured {
+  // Not doing persistence, so we don't need those
+  static const bool store_key = false;
+  static const bool store_filtration = false;
+  // I have few vertices
+  typedef short Vertex_handle;
+};
+
+typedef boost::mpl::list<Simplex_tree<>,
+                         Simplex_tree<Simplex_tree_options_fast_persistence>
+                        > 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;
+
+  Stree_type st;
+
+  st.insert_simplex_and_subfaces({0, 1, 6, 7}, 4.0);
+  st.insert_simplex_and_subfaces({3, 4, 5}, 3.0);
+  st.insert_simplex_and_subfaces({3, 0}, 2.0);
+  st.insert_simplex_and_subfaces({2, 1, 0}, 3.0);
+
+  st.initialize_filtration();
+  // Display the Simplex_tree
+  std::cout << "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;
+  for (auto f_simplex : st.filtration_simplex_range()) {
+    std::cout << "   " << "[" << st.filtration(f_simplex) << "] ";
+    for (auto vertex : st.simplex_vertex_range(f_simplex)) {
+      std::cout << (int) vertex << " ";
+    }
+    std::cout << std::endl;
+  }
+
+  // st:
+  //    1   6
+  //    o---o
+  //   /X\7/
+  //  o---o---o---o
+  //  2   0   3\X/4
+  //            o
+  //            5
+  std::string iostream_file("simplex_tree_for_iostream_operator_unit_test.txt");
+  std::ofstream simplex_tree_ostream(iostream_file.c_str());
+  simplex_tree_ostream << st;
+  simplex_tree_ostream.close();
+
+  Stree_type read_st;
+  std::ifstream simplex_tree_istream(iostream_file.c_str());
+  simplex_tree_istream >> read_st;
+
+  // Display the Simplex_tree
+  std::cout << "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;
+  for (auto f_simplex : read_st.filtration_simplex_range()) {
+    std::cout << "   " << "[" << read_st.filtration(f_simplex) << "] ";
+    for (auto vertex : read_st.simplex_vertex_range(f_simplex)) {
+      std::cout << (int) vertex << " ";
+    }
+    std::cout << std::endl;
+  }
+
+  BOOST_CHECK(st == read_st);
+}
+
+
+BOOST_AUTO_TEST_CASE(mini_iostream_operator) {
+  std::cout << "********************************************************************" << std::endl;
+  std::cout << "MINI SIMPLEX TREE IOSTREAM OPERATOR" << std::endl;
+
+  Simplex_tree<MyOptions> st;
+
+  st.insert_simplex_and_subfaces({0, 1, 6, 7});
+  st.insert_simplex_and_subfaces({3, 4, 5});
+  st.insert_simplex_and_subfaces({3, 0});
+  st.insert_simplex_and_subfaces({2, 1, 0});
+
+  st.initialize_filtration();
+  // Display the Simplex_tree
+  std::cout << "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) << "] ";
+    for (auto vertex : st.simplex_vertex_range(f_simplex)) {
+      std::cout << (int) vertex << " ";
+    }
+    std::cout << std::endl;
+  }
+
+  // st:
+  //    1   6
+  //    o---o
+  //   /X\7/
+  //  o---o---o---o
+  //  2   0   3\X/4
+  //            o
+  //            5
+  std::string iostream_file("simplex_tree_for_iostream_operator_unit_test.txt");
+  std::ofstream simplex_tree_ostream(iostream_file.c_str());
+  simplex_tree_ostream << st;
+  simplex_tree_ostream.close();
+
+  Simplex_tree<MyOptions> read_st;
+  std::ifstream simplex_tree_istream(iostream_file.c_str());
+  simplex_tree_istream >> read_st;
+
+  // Display the Simplex_tree
+  std::cout << "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;
+  for (auto f_simplex : read_st.filtration_simplex_range()) {
+    std::cout << "   " << "[" << read_st.filtration(f_simplex) << "] ";
+    for (auto vertex : read_st.simplex_vertex_range(f_simplex)) {
+      std::cout << (int) vertex << " ";
+    }
+    std::cout << std::endl;
+  }
+
+  BOOST_CHECK(st == read_st);
+}
diff --git a/src/Simplex_tree/test/simplex_tree_remove_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_remove_unit_test.cpp
new file mode 100644
index 00000000..dc37375c
--- /dev/null
+++ b/src/Simplex_tree/test/simplex_tree_remove_unit_test.cpp
@@ -0,0 +1,427 @@
+#include <iostream>
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "simplex_tree_remove"
+#include <boost/test/unit_test.hpp>
+
+//  ^
+// /!\ Nothing else from Simplex_tree shall be included to test includes are well defined.
+#include "gudhi/Simplex_tree.h"
+
+using namespace Gudhi;
+
+struct MyOptions : Simplex_tree_options_full_featured {
+  // Not doing persistence, so we don't need those
+  static const bool store_key = false;
+  static const bool store_filtration = false;
+  // I have few vertices
+  typedef short Vertex_handle;
+};
+
+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;
+
+  Mini_stree st;
+
+  st.insert_simplex_and_subfaces({0, 1, 6, 7});
+  st.insert_simplex_and_subfaces({3, 4, 5});
+
+  // Constructs a copy at this state for further test purpose
+  Mini_stree st_pruned = st;
+
+  st.insert_simplex_and_subfaces({3, 0});
+  st.insert_simplex_and_subfaces({2, 1, 0});
+
+  // Constructs a copy at this state for further test purpose
+  Mini_stree st_complete = st;
+  // st_complete and st:
+  //    1   6
+  //    o---o
+  //   /X\7/
+  //  o---o---o---o
+  //  2   0   3\X/4
+  //            o
+  //            5
+  // st_pruned:
+  //    1   6
+  //    o---o
+  //     \7/
+  //      o   o---o
+  //      0   3\X/4
+  //            o
+  //            5
+
+#ifdef GUDHI_DEBUG
+  std::cout << "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;
+  st.remove_maximal_simplex(st.find({0, 2}));
+  std::cout << "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;
+  st.remove_maximal_simplex(st.find({1, 2}));
+  std::cout << "st.remove_maximal_simplex({2})" << std::endl;
+  st.remove_maximal_simplex(st.find({2}));
+  std::cout << "st.remove_maximal_simplex({3})" << std::endl;
+  st.remove_maximal_simplex(st.find({0, 3}));
+  
+  BOOST_CHECK(st == st_pruned);
+  // Remove all, but as the simplex tree is not storing filtration, there is no modification
+  st.prune_above_filtration(0.0);
+  BOOST_CHECK(st == st_pruned);
+  
+  Mini_stree st_wo_seven;
+
+  st_wo_seven.insert_simplex_and_subfaces({0, 1, 6});
+  st_wo_seven.insert_simplex_and_subfaces({3, 4, 5});
+  // st_wo_seven:
+  //    1   6
+  //    o---o
+  //     \X/
+  //      o   o---o
+  //      0   3\X/4
+  //            o
+  //            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;
+  st.remove_maximal_simplex(st.find({0, 1, 6, 7}));
+  std::cout << "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;
+  st.remove_maximal_simplex(st.find({0, 6, 7}));
+  std::cout << "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;
+  st.remove_maximal_simplex(st.find({1, 6, 7}));
+  std::cout << "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;
+  st.remove_maximal_simplex(st.find({6, 7}));
+  std::cout << "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;
+  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()
+            << " | 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;
+  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;
+
+  Mini_stree st;
+
+  st.insert_simplex_and_subfaces({0, 1, 2});
+  st.insert_simplex_and_subfaces({0, 1, 3});
+  st.insert_simplex_and_subfaces({1, 2, 3, 4});
+  st.insert_simplex_and_subfaces({1, 2, 3, 5});
+  st.insert_simplex_and_subfaces({6, 7, 8, 9});
+  st.insert_simplex_and_subfaces({6, 7, 8, 10});
+
+  BOOST_CHECK(st.upper_bound_dimension() == 3);
+  BOOST_CHECK(st.dimension() == 3);
+
+  std::cout << "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;
+  BOOST_CHECK(st.upper_bound_dimension() == 3);
+  BOOST_CHECK(st.dimension() == 3);
+
+  std::cout << "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;
+  BOOST_CHECK(st.upper_bound_dimension() == 3);
+  BOOST_CHECK(st.dimension() == 3);
+
+  std::cout << "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;
+  BOOST_CHECK(st.upper_bound_dimension() == 3);
+  BOOST_CHECK(st.dimension() == 3);
+
+  std::cout << "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;
+  BOOST_CHECK(st.upper_bound_dimension() == 3);
+  BOOST_CHECK(st.dimension() == 2);
+  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+
+  std::cout << "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;
+  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;
+  st.insert_simplex_and_subfaces({1, 2, 3, 4});
+  std::cout << "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;
+  st.remove_maximal_simplex(st.find({1, 2, 3, 5}));
+  std::cout << "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;
+  st.remove_maximal_simplex(st.find({1, 2, 3, 4}));
+  std::cout << "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::cout << "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;
+  BOOST_CHECK(st.upper_bound_dimension() == 3);
+  BOOST_CHECK(st.dimension() == 3);
+
+  std::cout << "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;
+  BOOST_CHECK(st.upper_bound_dimension() == 3);
+  BOOST_CHECK(st.dimension() == 2);
+  std::cout << "st.dimension()=" << st.dimension() << std::endl;
+
+  std::cout << "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;
+  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;
+  st.insert_simplex_and_subfaces({1, 2, 3, 4});
+  std::cout << "st.upper_bound_dimension()=" << st.upper_bound_dimension() << std::endl;
+  BOOST_CHECK(st.upper_bound_dimension() == 3);
+  BOOST_CHECK(st.dimension() == 3);
+
+
+  // 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;
+  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);
+
+
+  // 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;
+  BOOST_CHECK(st.upper_bound_dimension() == 6);
+  // check dimension() do not launch lower_upper_bound_dimension()
+  BOOST_CHECK(st.dimension() == 6);
+
+
+  // Reset with the correct value
+  st.set_dimension(3);
+  std::cout << "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;
+  st.insert_simplex_and_subfaces({0, 1, 2, 3, 4, 5, 6});
+  std::cout << "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;
+  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;
+  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;
+
+  Stree st;
+
+  st.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
+  st.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
+
+  // Constructs a copy at this state for further test purpose
+  Stree st_pruned = st;
+  st_pruned.initialize_filtration();  // reset
+
+  st.insert_simplex_and_subfaces({3, 0}, 3.0);
+  st.insert_simplex_and_subfaces({2, 1, 0}, 4.0);
+
+  // Constructs a copy at this state for further test purpose
+  Stree st_complete = st;
+  // st_complete and st:
+  //    1   6
+  //    o---o
+  //   /X\7/
+  //  o---o---o---o
+  //  2   0   3\X/4
+  //            o
+  //            5
+  // st_pruned:
+  //    1   6
+  //    o---o
+  //     \7/
+  //      o   o---o
+  //      0   3\X/4
+  //            o
+  //            5
+
+  bool simplex_is_changed = false;
+  // Check the no action cases
+  // greater than initial filtration value
+  simplex_is_changed = st.prune_above_filtration(10.0);
+  if (simplex_is_changed)
+    st.initialize_filtration();
+  BOOST_CHECK(st == st_complete);
+  BOOST_CHECK(!simplex_is_changed);
+  // equal to initial filtration value
+  simplex_is_changed = st.prune_above_filtration(6.0);
+  if (simplex_is_changed)
+    st.initialize_filtration();
+  BOOST_CHECK(st == st_complete);
+  BOOST_CHECK(!simplex_is_changed);
+  // lower than initial filtration value, but still greater than the maximum filtration value
+  simplex_is_changed = st.prune_above_filtration(5.0);
+  if (simplex_is_changed)
+    st.initialize_filtration();
+  BOOST_CHECK(st == st_complete);
+  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;
+  for (auto f_simplex : st.filtration_simplex_range()) {
+    std::cout << "   " << "[" << st.filtration(f_simplex) << "] ";
+    for (auto vertex : st.simplex_vertex_range(f_simplex)) {
+      std::cout << (int) vertex << " ";
+    }
+    std::cout << std::endl;
+  }
+
+  // Check the pruned cases
+  simplex_is_changed = st.prune_above_filtration(2.5);
+  if (simplex_is_changed)
+    st.initialize_filtration();
+  BOOST_CHECK(st == st_pruned);
+  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;
+
+  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;
+
+  BOOST_CHECK(st == st_pruned);
+  BOOST_CHECK(!simplex_is_changed);
+
+  Stree st_empty;
+  simplex_is_changed = st.prune_above_filtration(0.0);
+  BOOST_CHECK(simplex_is_changed == true);
+  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::cout << " - 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;
+  BOOST_CHECK(st.upper_bound_dimension() == -1);
+
+  BOOST_CHECK(st == st_empty);
+  BOOST_CHECK(simplex_is_changed);
+
+  // Test case to the limit
+  simplex_is_changed = st.prune_above_filtration(-1.0);
+  if (simplex_is_changed)
+    st.initialize_filtration();
+  BOOST_CHECK(st == st_empty);
+  BOOST_CHECK(!simplex_is_changed);
+}
+
+BOOST_AUTO_TEST_CASE(mini_prune_above_filtration) {
+  std::cout << "********************************************************************" << std::endl;
+  std::cout << "MINI PRUNE ABOVE FILTRATION" << std::endl;
+
+  Mini_stree st;
+
+  st.insert_simplex_and_subfaces({0, 1, 6, 7});
+  st.insert_simplex_and_subfaces({3, 4, 5});
+  st.insert_simplex_and_subfaces({3, 0});
+  st.insert_simplex_and_subfaces({2, 1, 0});
+
+  // st:
+  //    1   6
+  //    o---o
+  //   /X\7/
+  //  o---o---o---o
+  //  2   0   3\X/4
+  //            o
+  //            5
+
+  st.initialize_filtration();
+  
+  // Display the Simplex_tree
+  std::cout << "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
+  bool simplex_is_changed = st.prune_above_filtration(1.0);
+  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;
+  BOOST_CHECK(!simplex_is_changed);
+  BOOST_CHECK(st.num_simplices() == 27);
+
+  simplex_is_changed = st.prune_above_filtration(0.0);
+  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;
+  BOOST_CHECK(!simplex_is_changed);
+  BOOST_CHECK(st.num_simplices() == 27);
+
+  // Test case to the limit
+  simplex_is_changed = st.prune_above_filtration(-1.0);
+  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;
+  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;
+
+}
diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
index b06d7ec9..580d610a 100644
--- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
@@ -26,7 +26,6 @@ void test_empty_simplex_tree(typeST& tst) {
   typedef typename typeST::Vertex_handle Vertex_handle;
   const Vertex_handle DEFAULT_VERTEX_VALUE = Vertex_handle(- 1);
   BOOST_CHECK(tst.null_vertex() == DEFAULT_VERTEX_VALUE);
-  BOOST_CHECK(tst.filtration() == 0.0);
   BOOST_CHECK(tst.num_vertices() == (size_t) 0);
   BOOST_CHECK(tst.num_simplices() == (size_t) 0);
   typename typeST::Siblings* STRoot = tst.root();
@@ -98,12 +97,11 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_from_file, typeST, list_of_tested_var
 
   // Display the Simplex_tree
   std::cout << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
-  std::cout << "   - dimension " << st.dimension() << "   - filtration " << st.filtration() << std::endl;
+  std::cout << "   - dimension " << st.dimension() << std::endl;
 
   // Check
   BOOST_CHECK(st.num_simplices() == 143353);
   BOOST_CHECK(st.dimension() == 3);
-  BOOST_CHECK(AreAlmostTheSame(st.filtration(), 0.4));
 
   int previous_size = 0;
   for (auto f_simplex : st.filtration_simplex_range()) {
@@ -147,7 +145,6 @@ void test_simplex_tree_insert_returns_true(const typePairSimplexBool& returnValu
 }
 
 // Global variables
-double max_fil = 0.0;
 int dim_max = -1;
 
 template<class typeST, class Filtration_value>
@@ -158,15 +155,8 @@ void set_and_test_simplex_tree_dim_fil(typeST& simplexTree, int vectorSize, cons
     std::cout << "   set_and_test_simplex_tree_dim_fil - dim_max=" << dim_max
         << std::endl;
   }
-  if (fil > max_fil) {
-    max_fil = fil;
-    simplexTree.set_filtration(max_fil);
-    std::cout << "   set_and_test_simplex_tree_dim_fil - max_fil=" << max_fil
-        << std::endl;
-  }
 
   BOOST_CHECK(simplexTree.dimension() == dim_max);
-  BOOST_CHECK(AreAlmostTheSame(simplexTree.filtration(), max_fil));
 
   // Another way to count simplices:
   size_t num_simp = 0;
@@ -190,7 +180,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   const Filtration_value FOURTH_FILTRATION_VALUE = 0.4;
   // reset since we run the test several times
   dim_max = -1;
-  max_fil = 0.0;
 
   // TEST OF INSERTION
   std::cout << "********************************************************************" << std::endl;
@@ -308,9 +297,9 @@ 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;
   BOOST_CHECK(st.num_vertices() == (size_t) 4); // Not incremented !!
   BOOST_CHECK(st.dimension() == dim_max);
-  BOOST_CHECK(AreAlmostTheSame(st.filtration(), max_fil));
 
   // ++ ELEVENTH
   std::cout << "   - INSERT (2,1,0) (already inserted)" << std::endl;
@@ -325,7 +314,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
   BOOST_CHECK(shReturned == typename typeST::Simplex_handle(nullptr));
   BOOST_CHECK(st.num_vertices() == (size_t) 4); // Not incremented !!
   BOOST_CHECK(st.dimension() == dim_max);
-  BOOST_CHECK(AreAlmostTheSame(st.filtration(), max_fil));
 
   /* Inserted simplex:        */
   /*    1                     */
@@ -365,7 +353,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_insertion, typeST, list_of_tested_var
 
   // 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() << "   - filtration " << st.filtration() << 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;
   for (auto f_simplex : st.filtration_simplex_range()) {
     std::cout << "   " << "[" << st.filtration(f_simplex) << "] ";
@@ -575,7 +563,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(NSimplexAndSubfaces_tree_insertion, typeST, list_o
 
   // 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() << "   - filtration " << st.filtration() << 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;
   for (auto f_simplex : st.filtration_simplex_range()) {
     std::cout << "   " << "[" << st.filtration(f_simplex) << "] ";
@@ -630,9 +618,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(coface_on_simplex_tree, typeST, list_of_tested_var
   /*            o             */
   /*            5             */
 
-  // FIXME
-  st.set_dimension(3);
-
   std::vector<typename typeST::Vertex_handle> simplex_result;
   std::vector<typename typeST::Simplex_handle> result;
   std::cout << "First test - Star of (3):" << std::endl;
@@ -729,9 +714,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(copy_move_on_simplex_tree, typeST, list_of_tested_
   /*            o             */
   /*            5             */
 
-  // FIXME
-  st.set_dimension(3);
-
   std::cout << "Printing st - address = " << &st << std::endl;
 
   // Copy constructor  
@@ -756,7 +738,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(copy_move_on_simplex_tree, typeST, list_of_tested_
   typeST st_empty;
   // Check st has been emptied by the move
   BOOST_CHECK(st == st_empty);
-  BOOST_CHECK(st.filtration() == 0);
   BOOST_CHECK(st.dimension() == -1);
   BOOST_CHECK(st.num_simplices() == 0);
   BOOST_CHECK(st.num_vertices() == (size_t)0);
@@ -882,271 +863,3 @@ BOOST_AUTO_TEST_CASE(make_filtration_non_decreasing) {
   BOOST_CHECK(st == st_other_copy);
   
 }
-
-struct MyOptions : Simplex_tree_options_full_featured {
-  // Not doing persistence, so we don't need those
-  static const bool store_key = false;
-  static const bool store_filtration = false;
-  // I have few vertices
-  typedef short Vertex_handle;
-};
-
-BOOST_AUTO_TEST_CASE(remove_maximal_simplex) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "REMOVE MAXIMAL SIMPLEX" << std::endl;
-
-
-  typedef Simplex_tree<MyOptions> miniST;
-  miniST st;
-
-  // FIXME
-  st.set_dimension(3);
-
-  st.insert_simplex_and_subfaces({0, 1, 6, 7});
-  st.insert_simplex_and_subfaces({3, 4, 5});
-
-  // Constructs a copy at this state for further test purpose
-  miniST st_pruned = st;
-
-  st.insert_simplex_and_subfaces({3, 0});
-  st.insert_simplex_and_subfaces({2, 1, 0});
-
-  // Constructs a copy at this state for further test purpose
-  miniST st_complete = st;
-  // st_complete and st:
-  //    1   6
-  //    o---o
-  //   /X\7/
-  //  o---o---o---o
-  //  2   0   3\X/4
-  //            o
-  //            5
-  // st_pruned:
-  //    1   6
-  //    o---o
-  //     \7/
-  //      o   o---o
-  //      0   3\X/4
-  //            o
-  //            5
-
-#ifdef GUDHI_DEBUG
-  std::cout << "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
-  
-  st.remove_maximal_simplex(st.find({0, 2}));
-  st.remove_maximal_simplex(st.find({0, 1, 2}));
-  st.remove_maximal_simplex(st.find({1, 2}));
-  st.remove_maximal_simplex(st.find({2}));
-  st.remove_maximal_simplex(st.find({0, 3}));
-  
-  BOOST_CHECK(st == st_pruned);
-  // Remove all, but as the simplex tree is not storing filtration, there is no modification
-  st.prune_above_filtration(0.0);
-  BOOST_CHECK(st == st_pruned);
-  
-  miniST st_wo_seven;
-  // FIXME
-  st_wo_seven.set_dimension(3);
-
-  st_wo_seven.insert_simplex_and_subfaces({0, 1, 6});
-  st_wo_seven.insert_simplex_and_subfaces({3, 4, 5});
-  // st_wo_seven:
-  //    1   6
-  //    o---o
-  //     \X/
-  //      o   o---o
-  //      0   3\X/4
-  //            o
-  //            5
-
-  // Remove all 7 to test the both remove_maximal_simplex cases (when _members is empty or not)
-  st.remove_maximal_simplex(st.find({0, 1, 6, 7}));
-  st.remove_maximal_simplex(st.find({0, 1, 7}));
-  st.remove_maximal_simplex(st.find({0, 6, 7}));
-  st.remove_maximal_simplex(st.find({0, 7}));
-  st.remove_maximal_simplex(st.find({1, 6, 7}));
-  st.remove_maximal_simplex(st.find({1, 7}));
-  st.remove_maximal_simplex(st.find({6, 7}));
-  st.remove_maximal_simplex(st.find({7}));
-  
-  BOOST_CHECK(st == st_wo_seven);
-}
-
-BOOST_AUTO_TEST_CASE(prune_above_filtration) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "PRUNE ABOVE FILTRATION" << std::endl;
-  typedef Simplex_tree<> typeST;
-  typeST st;
-
-  // FIXME
-  st.set_dimension(3);
-
-  st.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
-  st.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
-
-  // Constructs a copy at this state for further test purpose
-  typeST st_pruned = st;
-  st_pruned.initialize_filtration();  // reset
-
-  st.insert_simplex_and_subfaces({3, 0}, 3.0);
-  st.insert_simplex_and_subfaces({2, 1, 0}, 4.0);
-
-  // Constructs a copy at this state for further test purpose
-  typeST st_complete = st;
-  // st_complete and st:
-  //    1   6
-  //    o---o
-  //   /X\7/
-  //  o---o---o---o
-  //  2   0   3\X/4
-  //            o
-  //            5
-  // st_pruned:
-  //    1   6
-  //    o---o
-  //     \7/
-  //      o   o---o
-  //      0   3\X/4
-  //            o
-  //            5
-
-  bool simplex_is_changed = false;
-  // Check the no action cases
-  // greater than initial filtration value
-  simplex_is_changed = st.prune_above_filtration(10.0);
-  if (simplex_is_changed)
-    st.initialize_filtration();
-  BOOST_CHECK(st == st_complete);
-  BOOST_CHECK(!simplex_is_changed);
-  // equal to initial filtration value
-  simplex_is_changed = st.prune_above_filtration(6.0);
-  if (simplex_is_changed)
-    st.initialize_filtration();
-  BOOST_CHECK(st == st_complete);
-  BOOST_CHECK(!simplex_is_changed);
-  // lower than initial filtration value, but still greater than the maximum filtration value
-  simplex_is_changed = st.prune_above_filtration(5.0);
-  if (simplex_is_changed)
-    st.initialize_filtration();
-  BOOST_CHECK(st == st_complete);
-  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;
-  for (auto f_simplex : st.filtration_simplex_range()) {
-    std::cout << "   " << "[" << st.filtration(f_simplex) << "] ";
-    for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-      std::cout << (int) vertex << " ";
-    }
-    std::cout << std::endl;
-  }
-
-  // Check the pruned cases
-  simplex_is_changed = st.prune_above_filtration(2.5);
-  if (simplex_is_changed)
-    st.initialize_filtration();
-  BOOST_CHECK(st == st_pruned);
-  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;
-
-  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;
-
-  BOOST_CHECK(st == st_pruned);
-  BOOST_CHECK(!simplex_is_changed);
-
-  typeST st_empty;
-  // FIXME
-  st_empty.set_dimension(3);
-  simplex_is_changed = st.prune_above_filtration(0.0);
-  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::cout << " - dimension " << st.dimension() << std::endl;
-
-  BOOST_CHECK(st == st_empty);
-  BOOST_CHECK(simplex_is_changed);
-
-  // Test case to the limit
-  simplex_is_changed = st.prune_above_filtration(-1.0);
-  if (simplex_is_changed)
-    st.initialize_filtration();
-  BOOST_CHECK(st == st_empty);
-  BOOST_CHECK(!simplex_is_changed);
-}
-
-BOOST_AUTO_TEST_CASE(mini_prune_above_filtration) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "MINI PRUNE ABOVE FILTRATION" << std::endl;
-  typedef Simplex_tree<MyOptions> typeST;
-  typeST st;
-
-  // FIXME
-  st.set_dimension(3);
-
-  st.insert_simplex_and_subfaces({0, 1, 6, 7});
-  st.insert_simplex_and_subfaces({3, 4, 5});
-  st.insert_simplex_and_subfaces({3, 0});
-  st.insert_simplex_and_subfaces({2, 1, 0});
-
-  // st:
-  //    1   6
-  //    o---o
-  //   /X\7/
-  //  o---o---o---o
-  //  2   0   3\X/4
-  //            o
-  //            5
-
-  st.initialize_filtration();
-  
-  // Display the Simplex_tree
-  std::cout << "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
-  bool simplex_is_changed = st.prune_above_filtration(1.0);
-  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;
-  BOOST_CHECK(!simplex_is_changed);
-  BOOST_CHECK(st.num_simplices() == 27);
-
-  simplex_is_changed = st.prune_above_filtration(0.0);
-  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;
-  BOOST_CHECK(!simplex_is_changed);
-  BOOST_CHECK(st.num_simplices() == 27);
-
-  // Test case to the limit
-  simplex_is_changed = st.prune_above_filtration(-1.0);
-  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;
-  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;
-
-}
\ No newline at end of file