Merge last trunk modifications

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

Former-commit-id: 22158e5d4aae2b6c0e5502c585cb6c513c08ac63

25 files changed, 661 insertions, 319 deletions

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 1ff95c3d..5f7d7622 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -268,8 +268,6 @@ class Alpha_complex {
       return false;  // ----- >>
     }
 
-    complex.set_dimension(triangulation_->maximal_dimension());
-
     // --------------------------------------------------------------------------------------------
     // Simplex_tree construction from loop on triangulation finite full cells list
     if (triangulation_->number_of_vertices() > 0) {
diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
index 7380547f..166373fe 100644
--- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
@@ -159,7 +159,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
   BOOST_CHECK(simplex_tree.num_simplices() == 15);
 
   std::cout << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
-  BOOST_CHECK(simplex_tree.dimension() == 4);
+  BOOST_CHECK(simplex_tree.dimension() == 3);
   std::cout << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
   BOOST_CHECK(simplex_tree.num_vertices() == 4);
 
@@ -232,7 +232,7 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
   BOOST_CHECK(simplex_tree.num_simplices() == 10);
 
   std::cout << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
-  BOOST_CHECK(simplex_tree.dimension() == 4);
+  BOOST_CHECK(simplex_tree.dimension() == 1);
   std::cout << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
   BOOST_CHECK(simplex_tree.num_vertices() == 4);
 
diff --git a/src/Persistent_cohomology/example/alpha_complex_3d_persistence.cpp b/src/Persistent_cohomology/example/alpha_complex_3d_persistence.cpp
index de9b8cdf..26196a6f 100644
--- a/src/Persistent_cohomology/example/alpha_complex_3d_persistence.cpp
+++ b/src/Persistent_cohomology/example/alpha_complex_3d_persistence.cpp
@@ -198,7 +198,6 @@ int main(int argc, char* const argv[]) {
     else
       std::cout << "This shall not happen" << std::endl;
   }
-  simplex_tree.set_dimension(dim_max);
 
 #ifdef DEBUG_TRACES
   std::cout << "vertices \t\t" << count_vertices << std::endl;
diff --git a/src/Persistent_cohomology/example/exact_alpha_complex_3d_persistence.cpp b/src/Persistent_cohomology/example/exact_alpha_complex_3d_persistence.cpp
index 5f078251..2e2bfd2f 100644
--- a/src/Persistent_cohomology/example/exact_alpha_complex_3d_persistence.cpp
+++ b/src/Persistent_cohomology/example/exact_alpha_complex_3d_persistence.cpp
@@ -200,7 +200,6 @@ int main(int argc, char* const argv[]) {
     else
       std::cout << "This shall not happen" << std::endl;
   }
-  simplex_tree.set_dimension(dim_max);
 
 #ifdef DEBUG_TRACES
   std::cout << "vertices \t\t" << count_vertices << std::endl;
diff --git a/src/Persistent_cohomology/example/periodic_alpha_complex_3d_persistence.cpp b/src/Persistent_cohomology/example/periodic_alpha_complex_3d_persistence.cpp
index e6355e6b..c6d3e236 100644
--- a/src/Persistent_cohomology/example/periodic_alpha_complex_3d_persistence.cpp
+++ b/src/Persistent_cohomology/example/periodic_alpha_complex_3d_persistence.cpp
@@ -220,7 +220,6 @@ int main(int argc, char* const argv[]) {
     else
       std::cout << "This shall not happen" << std::endl;
   }
-  simplex_tree.set_dimension(dim_max);
 
 #ifdef DEBUG_TRACES
   std::cout << "vertices \t\t" << count_vertices << std::endl;
diff --git a/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp b/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp
index 8214d66a..8ef479d4 100644
--- a/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp
+++ b/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp
@@ -142,7 +142,6 @@ int main(int argc, char * const argv[]) {
   /*   An edge [11,6]         */
   /*   An edge [10,12,2]      */
 
-  st.set_dimension(2);
 
   std::cout << "The complex contains " << st.num_simplices() << " simplices - " << st.num_vertices() << " vertices "
       << std::endl;
diff --git a/src/Persistent_cohomology/example/plain_homology.cpp b/src/Persistent_cohomology/example/plain_homology.cpp
index 50f692f2..a5ae09c8 100644
--- a/src/Persistent_cohomology/example/plain_homology.cpp
+++ b/src/Persistent_cohomology/example/plain_homology.cpp
@@ -64,8 +64,6 @@ int main() {
   st.insert_simplex_and_subfaces(edge03);
   st.insert_simplex(edge13);
   st.insert_simplex(vertex4);
-  // FIXME: Remove this line
-  st.set_dimension(2);
 
   // Sort the simplices in the order of the filtration
   st.initialize_filtration();
diff --git a/src/Persistent_cohomology/example/weighted_alpha_complex_3d_persistence.cpp b/src/Persistent_cohomology/example/weighted_alpha_complex_3d_persistence.cpp
index 4bddbe82..249a7ece 100644
--- a/src/Persistent_cohomology/example/weighted_alpha_complex_3d_persistence.cpp
+++ b/src/Persistent_cohomology/example/weighted_alpha_complex_3d_persistence.cpp
@@ -245,7 +245,6 @@ int main(int argc, char* const argv[]) {
     else
       std::cout << "This shall not happen" << std::endl;
   }
-  simplex_tree.set_dimension(dim_max);
 
 #ifdef DEBUG_TRACES
   std::cout << "vertices \t\t" << count_vertices << std::endl;
diff --git a/src/Persistent_cohomology/test/betti_numbers_unit_test.cpp b/src/Persistent_cohomology/test/betti_numbers_unit_test.cpp
index da418034..0a08d200 100644
--- a/src/Persistent_cohomology/test/betti_numbers_unit_test.cpp
+++ b/src/Persistent_cohomology/test/betti_numbers_unit_test.cpp
@@ -62,8 +62,6 @@ BOOST_AUTO_TEST_CASE( plain_homology_betti_numbers )
   st.insert_simplex_and_subfaces(edge04);
   st.insert_simplex(edge14);
   st.insert_simplex(vertex5);
-  // FIXME: Remove this line
-  st.set_dimension(3);
 
   // Sort the simplices in the order of the filtration
   st.initialize_filtration();
@@ -170,8 +168,6 @@ BOOST_AUTO_TEST_CASE( betti_numbers )
   st.insert_simplex_and_subfaces(edge04, 2.0);
   st.insert_simplex(edge14, 2.0);
   st.insert_simplex(vertex5, 1.0);
-  // FIXME: Remove this line
-  st.set_dimension(3);
 
   // Sort the simplices in the order of the filtration
   st.initialize_filtration();
diff --git a/src/Persistent_cohomology/test/persistent_cohomology_unit_test.cpp b/src/Persistent_cohomology/test/persistent_cohomology_unit_test.cpp
index f53987b6..a1c106d5 100644
--- a/src/Persistent_cohomology/test/persistent_cohomology_unit_test.cpp
+++ b/src/Persistent_cohomology/test/persistent_cohomology_unit_test.cpp
@@ -196,8 +196,6 @@ BOOST_AUTO_TEST_CASE( persistence_constructor_exception )
   // To make number of simplices = 255
   const short simplex_0[] = {0, 1, 2, 3, 4, 5, 6, 7};
   st.insert_simplex_and_subfaces(simplex_0);
-  // FIXME: Remove this line
-  st.set_dimension(8);
 
   // Sort the simplices in the order of the filtration
   st.initialize_filtration();
diff --git a/src/Simplex_tree/example/mini_simplex_tree.cpp b/src/Simplex_tree/example/mini_simplex_tree.cpp
index ad99df23..19e45361 100644
--- a/src/Simplex_tree/example/mini_simplex_tree.cpp
+++ b/src/Simplex_tree/example/mini_simplex_tree.cpp
@@ -52,8 +52,6 @@ int main() {
   auto edge03 = {0, 3};
   st.insert_simplex_and_subfaces(triangle012);
   st.insert_simplex_and_subfaces(edge03);
-  // FIXME: Remove this line
-  st.set_dimension(2);
 
   auto edge02 = {0, 2};
   ST::Simplex_handle e = st.find(edge02);
diff --git a/src/Simplex_tree/example/simple_simplex_tree.cpp b/src/Simplex_tree/example/simple_simplex_tree.cpp
index 09cda526..b6b65b88 100644
--- a/src/Simplex_tree/example/simple_simplex_tree.cpp
+++ b/src/Simplex_tree/example/simple_simplex_tree.cpp
@@ -185,7 +185,6 @@ int main(int argc, char * const argv[]) {
   }
 
   // ++ GENERAL VARIABLE SET
-  simplexTree.set_dimension(2);  // Max dimension = 2 -> (2,1,0)
 
   std::cout << "********************************************************************\n";
   // Display the Simplex_tree - Can not be done in the middle of 2 inserts
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h
index 8ab3da41..7da767cb 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h
@@ -482,7 +482,17 @@ class Simplex_tree {
   }
 
   /** \brief Returns an upper bound on the dimension of the simplicial complex. */
-  int dimension() const {
+  int upper_bound_dimension() const {
+    return dimension_;
+  }
+
+  /** \brief Returns the dimension of the simplicial complex.
+      \details This function is not constant time because it can recompute dimension if required (can be triggered by
+      `remove_maximal_simplex()` or `prune_above_filtration()`).
+  */
+  int dimension() {
+    if (dimension_to_be_lowered_)
+      lower_upper_bound_dimension();
     return dimension_;
   }
 
@@ -591,7 +601,11 @@ class Simplex_tree {
       // if filtration value unchanged
       return std::pair<Simplex_handle, bool>(null_simplex(), false);
     }
-    // otherwise the insertion has succeeded
+    // otherwise the insertion has succeeded - size is a size_type
+    if (static_cast<int>(simplex.size()) - 1 > dimension_) {
+      // Update dimension if needed
+      dimension_ = static_cast<int>(simplex.size()) - 1;
+    }
     return res_insert;
   }
 
@@ -1254,6 +1268,9 @@ class Simplex_tree {
    * \post Some simplex tree functions require the filtration to be valid. `prune_above_filtration()`
    * function is not launching `initialize_filtration()` but returns the filtration modification information. If the
    * complex has changed , please call `initialize_filtration()` to recompute it.
+   * \post Note that the dimension of the simplicial complex may be lower after calling `prune_above_filtration()`
+   * than it was before. However, `upper_bound_dimension()` will return the old value, which remains a valid upper
+   * bound. If you care, you can call `dimension()` to recompute the exact dimension.
    */
   bool prune_above_filtration(Filtration_value filtration) {
     return rec_prune_above_filtration(root(), filtration);
@@ -1265,6 +1282,8 @@ class Simplex_tree {
     auto last = std::remove_if(list.begin(), list.end(), [=](Dit_value_t& simplex) {
         if (simplex.second.filtration() <= filt) return false;
         if (has_children(&simplex)) rec_delete(simplex.second.children());
+        // dimension may need to be lowered
+        dimension_to_be_lowered_ = true;
         return true;
       });
 
@@ -1273,6 +1292,8 @@ class Simplex_tree {
       // Removing the whole siblings, parent becomes a leaf.
       sib->oncles()->members()[sib->parent()].assign_children(sib->oncles());
       delete sib;
+      // dimension may need to be lowered
+      dimension_to_be_lowered_ = true;
       return true;
     } else {
       // Keeping some elements of siblings. Remove the others, and recurse in the remaining ones.
@@ -1284,13 +1305,46 @@ class Simplex_tree {
     return modified;
   }
 
+ private:
+  /** \brief Deep search simplex tree dimension recompute.
+   * @return True if the dimension was modified, false otherwise.
+   * \pre Be sure the simplex tree has not a too low dimension value as the deep search stops when the former dimension
+   * has been reached (cf. `upper_bound_dimension()` and `set_dimension()` methods).
+   */
+  bool lower_upper_bound_dimension() {
+    // reset automatic detection to recompute
+    dimension_to_be_lowered_ = false;
+    int new_dimension = -1;
+    // Browse the tree from the left to the right as higher dimension cells are more likely on the left part of the tree
+    for (Simplex_handle sh : complex_simplex_range()) {
+#ifdef DEBUG_TRACES
+      for (auto vertex : simplex_vertex_range(sh)) {
+        std::cout << " " << vertex;
+      }
+      std::cout << std::endl;
+#endif  // DEBUG_TRACES
+
+      int sh_dimension = dimension(sh);
+      if (sh_dimension >= dimension_)
+        // Stop browsing as soon as the dimension is reached, no need to go furter
+        return false;
+      new_dimension = std::max(new_dimension, sh_dimension);
+    }
+    dimension_ = new_dimension;
+    return true;
+  }
+
+
  public:
   /** \brief Remove a maximal simplex.
    * @param[in] sh Simplex handle on the maximal simplex to remove.
    * @return a boolean value that is an implementation detail, and that the user is supposed to ignore
    * \pre Please check the simplex has no coface before removing it.
    * \exception std::invalid_argument In debug mode, if sh has children.
-   * \post Be aware that removing is shifting data in a flat_map (initialize_filtration to be done).
+   * \post Be aware that removing is shifting data in a flat_map (`initialize_filtration()` to be done).
+   * \post Note that the dimension of the simplicial complex may be lower after calling `remove_maximal_simplex()`
+   * than it was before. However, `upper_bound_dimension()` will return the old value, which remains a valid upper
+   * bound. If you care, you can call `dimension()` to recompute the exact dimension.
    * \internal @return true if the leaf's branch has no other leaves (branch's children has been re-assigned), false otherwise.
    */
   bool remove_maximal_simplex(Simplex_handle sh) {
@@ -1309,6 +1363,8 @@ class Simplex_tree {
       // Sibling is emptied : must be deleted, and its parent must point on his own Sibling
       child->oncles()->members().at(child->parent()).assign_children(child->oncles());
       delete child;
+      // dimension may need to be lowered
+      dimension_to_be_lowered_ = true;
       return true;
     }
     return false;
@@ -1323,6 +1379,7 @@ class Simplex_tree {
   std::vector<Simplex_handle> filtration_vect_;
   /** \brief Upper bound on the dimension of the simplicial complex.*/
   int dimension_;
+  bool dimension_to_be_lowered_ = false;
 };
 
 // Print a Simplex_tree in os.
diff --git a/src/Simplex_tree/test/CMakeLists.txt b/src/Simplex_tree/test/CMakeLists.txt
index fc34e6aa..8684ad2a 100644
--- a/src/Simplex_tree/test/CMakeLists.txt
+++ b/src/Simplex_tree/test/CMakeLists.txt
@@ -3,21 +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_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_test_unit_graph_expansion simplex_tree_graph_expansion_unit_test.cpp )
-target_link_libraries(Simplex_tree_test_unit_graph_expansion ${Boost_SYSTEM_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+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_test_unit_graph_expansion ${TBB_LIBRARIES})
+  target_link_libraries(Simplex_tree_iostream_operator_test_unit ${TBB_LIBRARIES})
 endif()
 
-gudhi_add_coverage_test(Simplex_tree_test_unit_graph_expansion)
+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_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 17ddc605..580d610a 100644
--- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
@@ -297,6 +297,7 @@ 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);
 
@@ -617,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;
@@ -716,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  
@@ -868,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;
-
-}
diff --git a/src/Witness_complex/include/gudhi/Strong_witness_complex.h b/src/Witness_complex/include/gudhi/Strong_witness_complex.h
index 6f4bcf60..c18335d3 100644
--- a/src/Witness_complex/include/gudhi/Strong_witness_complex.h
+++ b/src/Witness_complex/include/gudhi/Strong_witness_complex.h
@@ -127,7 +127,6 @@ class Strong_witness_complex {
       if ((Landmark_id)simplex.size() - 1 > complex_dim)
         complex_dim = simplex.size() - 1;
     }
-    complex.set_dimension(complex_dim);
     return true;
   }
 
diff --git a/src/Witness_complex/include/gudhi/Witness_complex.h b/src/Witness_complex/include/gudhi/Witness_complex.h
index bcfe8484..53c38520 100644
--- a/src/Witness_complex/include/gudhi/Witness_complex.h
+++ b/src/Witness_complex/include/gudhi/Witness_complex.h
@@ -130,7 +130,6 @@ class Witness_complex {
       }
       k++;
     }
-    complex.set_dimension(k-1);
     return true;
   }
 
diff --git a/src/cmake/modules/GUDHI_third_party_libraries.cmake b/src/cmake/modules/GUDHI_third_party_libraries.cmake
index f2bbafdc..8269c3bf 100644
--- a/src/cmake/modules/GUDHI_third_party_libraries.cmake
+++ b/src/cmake/modules/GUDHI_third_party_libraries.cmake
@@ -54,10 +54,12 @@ if(CGAL_FOUND)
       endforeach(CGAL_INCLUDE_DIR ${CGAL_INCLUDE_DIRS})
     endif(NOT CGAL_VERSION VERSION_GREATER 4.9.0)
 
-    # For dev version
-    include_directories(BEFORE "src/common/include/gudhi_patches")
-    # For user version
-    include_directories(BEFORE "include/gudhi_patches")
+    if (NOT CGAL_VERSION VERSION_GREATER 4.11.0)
+      # For dev version
+      include_directories(BEFORE "src/common/include/gudhi_patches")
+      # For user version
+      include_directories(BEFORE "include/gudhi_patches")
+    endif (NOT CGAL_VERSION VERSION_GREATER 4.11.0)
   endif()
 endif()
 
diff --git a/src/cmake/modules/GUDHI_user_version_target.cmake b/src/cmake/modules/GUDHI_user_version_target.cmake
index cff64ad2..4abc2574 100644
--- a/src/cmake/modules/GUDHI_user_version_target.cmake
+++ b/src/cmake/modules/GUDHI_user_version_target.cmake
@@ -48,7 +48,11 @@ if (NOT CMAKE_VERSION VERSION_LESS 2.8.11)
                      copy_directory ${CMAKE_SOURCE_DIR}/src/GudhUI ${GUDHI_USER_VERSION_DIR}/GudhUI)
   
   set(GUDHI_DIRECTORIES "doc;example;concept;utilities")
-  set(GUDHI_INCLUDE_DIRECTORIES "include/gudhi;include/gudhi_patches")
+  if (NOT CGAL_VERSION VERSION_GREATER 4.11.0)
+    set(GUDHI_INCLUDE_DIRECTORIES "include/gudhi;include/gudhi_patches")
+  else ()
+      set(GUDHI_INCLUDE_DIRECTORIES "include/gudhi")
+  endif ()
 
   foreach(GUDHI_MODULE ${GUDHI_MODULES_FULL_LIST})
     foreach(GUDHI_DIRECTORY ${GUDHI_DIRECTORIES})
diff --git a/src/cython/example/simplex_tree_example.py b/src/cython/example/simplex_tree_example.py
index 831d9da8..51a60e73 100755
--- a/src/cython/example/simplex_tree_example.py
+++ b/src/cython/example/simplex_tree_example.py
@@ -48,8 +48,6 @@ if st.insert([0, 1, 2], filtration=4.0):
 else:
     print("Not inserted...")
 
-# FIXME: Remove this line
-st.set_dimension(3)
 print("dimension=", st.dimension())
 
 st.initialize_filtration()
diff --git a/src/cython/include/Tangential_complex_interface.h b/src/cython/include/Tangential_complex_interface.h
index 5e9dc0e4..ecf014b3 100644
--- a/src/cython/include/Tangential_complex_interface.h
+++ b/src/cython/include/Tangential_complex_interface.h
@@ -106,8 +106,6 @@ class Tangential_complex_interface {
 
   void create_simplex_tree(Simplex_tree<>* simplex_tree) {
     int max_dim = tangential_complex_->create_complex<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_full_featured>>(*simplex_tree);
-    // FIXME
-    simplex_tree->set_dimension(max_dim);
     simplex_tree->initialize_filtration();
   }
 
diff --git a/src/cython/test/test_simplex_tree.py b/src/cython/test/test_simplex_tree.py
index 4d452d7d..801d52b7 100755
--- a/src/cython/test/test_simplex_tree.py
+++ b/src/cython/test/test_simplex_tree.py
@@ -34,9 +34,13 @@ def test_insertion():
 
     # insert test
     assert st.insert([0, 1]) == True
+
+    assert st.dimension() == 1
+
     assert st.insert([0, 1, 2], filtration=4.0) == True
-    # FIXME: Remove this line
-    st.set_dimension(2)
+
+    assert st.dimension() == 2
+
     assert st.num_simplices() == 7
     assert st.num_vertices() == 3
 
@@ -86,8 +90,9 @@ def test_insertion():
     assert st.find([2]) == True
 
     st.initialize_filtration()
-    assert st.persistence() == [(1, (4.0, float('inf'))), (0, (0.0, float('inf')))]
+    assert st.persistence(persistence_dim_max = True) == [(1, (4.0, float('inf'))), (0, (0.0, float('inf')))]
     assert st.__is_persistence_defined() == True
+
     assert st.betti_numbers() == [1, 1]
     assert st.persistent_betti_numbers(-0.1, 10000.0) == [0, 0]
     assert st.persistent_betti_numbers(0.0, 10000.0) == [1, 0]