Merge master and fix conflicts

6 files changed, 273 insertions, 108 deletions

diff --git a/src/Simplex_tree/example/simple_simplex_tree.cpp b/src/Simplex_tree/example/simple_simplex_tree.cpp
index ca39df5b..e8bec596 100644
--- a/src/Simplex_tree/example/simple_simplex_tree.cpp
+++ b/src/Simplex_tree/example/simple_simplex_tree.cpp
@@ -166,7 +166,6 @@ int main(int argc, char* const argv[]) {
   // ++ GENERAL VARIABLE SET
 
   std::clog << "********************************************************************\n";
-  // Display the Simplex_tree - Can not be done in the middle of 2 inserts
   std::clog << "* The complex contains " << simplexTree.num_simplices() << " simplices\n";
   std::clog << "   - dimension " << simplexTree.dimension() << "\n";
   std::clog << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h
index 6e80b77f..430d1ac4 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h
@@ -24,6 +24,7 @@
 #include <boost/iterator/transform_iterator.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/range/adaptor/reversed.hpp>
+#include <boost/container/static_vector.hpp>
 
 #ifdef GUDHI_USE_TBB
 #include <tbb/parallel_sort.h>
@@ -246,8 +247,8 @@ class Simplex_tree {
    * which is consequenlty
    * equal to \f$(-1)^{\text{dim} \sigma}\f$ the canonical orientation on the simplex.
    */
-  Simplex_vertex_range simplex_vertex_range(Simplex_handle sh) {
-    assert(sh != null_simplex());  // Empty simplex
+  Simplex_vertex_range simplex_vertex_range(Simplex_handle sh) const {
+    GUDHI_CHECK(sh != null_simplex(), "empty simplex");
     return Simplex_vertex_range(Simplex_vertex_iterator(this, sh),
                                 Simplex_vertex_iterator(this));
   }
@@ -450,6 +451,15 @@ class Simplex_tree {
     return true;
   }
 
+  /** \brief Returns the filtration value of a simplex.
+   *
+   * Same as `filtration()`, but does not handle `null_simplex()`.
+   */
+  static Filtration_value filtration_(Simplex_handle sh) {
+    GUDHI_CHECK (sh != null_simplex(), "null simplex");
+    return sh->second.filtration();
+  }
+
  public:
   /** \brief Returns the key associated to a simplex.
    *
@@ -755,12 +765,7 @@ class Simplex_tree {
     if (first == last)
       return { null_simplex(), true }; // FIXME: false would make more sense to me.
 
-    // Copy before sorting
-    // Thread local is not available on XCode version < V.8 - It will slow down computation
-#ifdef GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    thread_local
-#endif  // GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    std::vector<Vertex_handle> copy;
+    thread_local std::vector<Vertex_handle> copy;
     copy.clear();
     copy.insert(copy.end(), first, last);
     std::sort(copy.begin(), copy.end());
@@ -827,7 +832,7 @@ class Simplex_tree {
 
   /** Returns the Siblings containing a simplex.*/
   template<class SimplexHandle>
-  Siblings* self_siblings(SimplexHandle sh) {
+  static Siblings* self_siblings(SimplexHandle sh) {
     if (sh->second.children()->parent() == sh->first)
       return sh->second.children()->oncles();
     else
@@ -1123,10 +1128,7 @@ class Simplex_tree {
     Dictionary_it next = siblings->members().begin();
     ++next;
 
-#ifdef GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    thread_local
-#endif  // GUDHI_CAN_USE_CXX11_THREAD_LOCAL
-    std::vector<std::pair<Vertex_handle, Node> > inter;
+    thread_local std::vector<std::pair<Vertex_handle, Node> > inter;
     for (Dictionary_it s_h = siblings->members().begin();
          s_h != siblings->members().end(); ++s_h, ++next) {
       Simplex_handle root_sh = find_vertex(s_h->first);
@@ -1317,6 +1319,8 @@ class Simplex_tree {
    * \post Some simplex tree functions require the filtration to be valid. `make_filtration_non_decreasing()`
    * function is not launching `initialize_filtration()` but returns the filtration modification information. If the
    * complex has changed , please call `initialize_filtration()` to recompute it.
+   * 
+   * If a simplex has a `NaN` filtration value, it is considered lower than any other defined filtration value.
    */
   bool make_filtration_non_decreasing() {
     bool modified = false;
@@ -1347,7 +1351,9 @@ class Simplex_tree {
                                                               });
 
       Filtration_value max_filt_border_value = filtration(*max_border);
-      if (simplex.second.filtration() < max_filt_border_value) {
+      // Replacing if(f<max) with if(!(f>=max)) would mean that if f is NaN, we replace it with the max of the children.
+      // That seems more useful than keeping NaN.
+      if (!(simplex.second.filtration() >= max_filt_border_value)) {
         // Store the filtration modification information
         modified = true;
         simplex.second.assign_filtration(max_filt_border_value);
@@ -1465,6 +1471,66 @@ class Simplex_tree {
     }
   }
 
+  /** \brief Returns a vertex of `sh` that has the same filtration value as `sh` if it exists, and `null_vertex()` otherwise.
+   *
+   * For a lower-star filtration built with `make_filtration_non_decreasing()`, this is a way to invert the process and find out which vertex had its filtration value propagated to `sh`.
+   * If several vertices have the same filtration value, the one it returns is arbitrary. */
+  Vertex_handle vertex_with_same_filtration(Simplex_handle sh) {
+    auto filt = filtration_(sh);
+    for(auto v : simplex_vertex_range(sh))
+      if(filtration_(find_vertex(v)) == filt)
+        return v;
+    return null_vertex();
+  }
+
+  /** \brief Returns an edge of `sh` that has the same filtration value as `sh` if it exists, and `null_simplex()` otherwise.
+   *
+   * For a flag-complex built with `expansion()`, this is a way to invert the process and find out which edge had its filtration value propagated to `sh`.
+   * If several edges have the same filtration value, the one it returns is arbitrary.
+   *
+   * \pre `sh` must have dimension at least 1. */
+  Simplex_handle edge_with_same_filtration(Simplex_handle sh) {
+    // See issue #251 for potential speed improvements.
+    auto&& vertices = simplex_vertex_range(sh); // vertices in decreasing order
+    auto end = std::end(vertices);
+    auto vi = std::begin(vertices);
+    GUDHI_CHECK(vi != end, "empty simplex");
+    auto v0 = *vi;
+    ++vi;
+    GUDHI_CHECK(vi != end, "simplex of dimension 0");
+    if(std::next(vi) == end) return sh; // shortcut for dimension 1
+    boost::container::static_vector<Vertex_handle, 40> suffix;
+    suffix.push_back(v0);
+    auto filt = filtration_(sh);
+    do
+    {
+      Vertex_handle v = *vi;
+      auto&& children1 = find_vertex(v)->second.children()->members_;
+      for(auto w : suffix){
+        // Can we take advantage of the fact that suffix is ordered?
+        Simplex_handle s = children1.find(w);
+        if(filtration_(s) == filt)
+          return s;
+      }
+      suffix.push_back(v);
+    }
+    while(++vi != end);
+    return null_simplex();
+  }
+
+  /** \brief Returns a minimal face of `sh` that has the same filtration value as `sh`.
+   *
+   * For a filtration built with `make_filtration_non_decreasing()`, this is a way to invert the process and find out which simplex had its filtration value propagated to `sh`.
+   * If several minimal (for inclusion) simplices have the same filtration value, the one it returns is arbitrary, and it is not guaranteed to be the one with smallest dimension. */
+  Simplex_handle minimal_simplex_with_same_filtration(Simplex_handle sh) {
+    auto filt = filtration_(sh);
+    // Naive implementation, it can be sped up.
+    for(auto b : boundary_simplex_range(sh))
+      if(filtration_(b) == filt)
+        return minimal_simplex_with_same_filtration(b);
+    return sh; // None of its faces has the same filtration.
+  }
+
  private:
   Vertex_handle null_vertex_;
   /** \brief Total number of simplices in the complex, without the empty simplex.*/
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h
index efccf2f2..9007b6bd 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h
@@ -15,9 +15,7 @@
 
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/version.hpp>
-#if BOOST_VERSION >= 105600
-# include <boost/container/static_vector.hpp>
-#endif
+#include <boost/container/static_vector.hpp>
 
 #include <vector>
 
@@ -42,13 +40,13 @@ class Simplex_tree_simplex_vertex_iterator : public boost::iterator_facade<
   typedef typename SimplexTree::Siblings Siblings;
   typedef typename SimplexTree::Vertex_handle Vertex_handle;
 
-  explicit Simplex_tree_simplex_vertex_iterator(SimplexTree * st)
+  explicit Simplex_tree_simplex_vertex_iterator(SimplexTree const* st)
       :  // any end() iterator
         sib_(nullptr),
         v_(st->null_vertex()) {
   }
 
-  Simplex_tree_simplex_vertex_iterator(SimplexTree * st, Simplex_handle sh)
+  Simplex_tree_simplex_vertex_iterator(SimplexTree const* st, Simplex_handle sh)
       : sib_(st->self_siblings(sh)),
         v_(sh->first) {
   }
@@ -166,15 +164,11 @@ class Simplex_tree_boundary_simplex_iterator : public boost::iterator_facade<
   // Most of the storage should be moved to the range, iterators should be light.
   Vertex_handle last_;  // last vertex of the simplex
   Vertex_handle next_;  // next vertex to push in suffix_
-#if BOOST_VERSION >= 105600
   // 40 seems a conservative bound on the dimension of a Simplex_tree for now,
   // as it would not fit on the biggest hard-drive.
   boost::container::static_vector<Vertex_handle, 40> suffix_;
   // static_vector still has some overhead compared to a trivial hand-made
   // version using std::aligned_storage, or compared to making suffix_ static.
-#else
-  std::vector<Vertex_handle> suffix_;
-#endif
   Siblings * sib_;  // where the next search will start from
   Simplex_handle sh_;  // current Simplex_handle in the boundary
   SimplexTree * st_;  // simplex containing the simplicial complex
diff --git a/src/Simplex_tree/test/CMakeLists.txt b/src/Simplex_tree/test/CMakeLists.txt
index 8b9163f5..cf2b0153 100644
--- a/src/Simplex_tree/test/CMakeLists.txt
+++ b/src/Simplex_tree/test/CMakeLists.txt
@@ -28,3 +28,9 @@ if (TBB_FOUND)
   target_link_libraries(Simplex_tree_ctor_and_move_test_unit ${TBB_LIBRARIES})
 endif()
 gudhi_add_boost_test(Simplex_tree_ctor_and_move_test_unit)
+
+add_executable ( Simplex_tree_make_filtration_non_decreasing_test_unit simplex_tree_make_filtration_non_decreasing_unit_test.cpp )
+if (TBB_FOUND)
+  target_link_libraries(Simplex_tree_make_filtration_non_decreasing_test_unit ${TBB_LIBRARIES})
+endif()
+gudhi_add_boost_test(Simplex_tree_make_filtration_non_decreasing_test_unit)
diff --git a/src/Simplex_tree/test/simplex_tree_make_filtration_non_decreasing_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_make_filtration_non_decreasing_unit_test.cpp
new file mode 100644
index 00000000..e0e7cadf
--- /dev/null
+++ b/src/Simplex_tree/test/simplex_tree_make_filtration_non_decreasing_unit_test.cpp
@@ -0,0 +1,148 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2020 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#include <iostream>
+#include <limits>  // for NaN
+#include <cmath>  // for isNaN
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "simplex_tree_make_filtration_non_decreasing"
+#include <boost/test/unit_test.hpp>
+#include <boost/mpl/list.hpp>
+
+//  ^
+// /!\ Nothing else from Simplex_tree shall be included to test includes are well defined.
+#include "gudhi/Simplex_tree.h"
+
+using namespace Gudhi;
+
+typedef boost::mpl::list<Simplex_tree<>, Simplex_tree<Simplex_tree_options_fast_persistence>> list_of_tested_variants;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(make_filtration_non_decreasing, typeST, list_of_tested_variants) {
+  typeST st;
+
+  st.insert_simplex_and_subfaces({2, 1, 0}, 2.0);
+  st.insert_simplex_and_subfaces({3, 0}, 2.0);
+  st.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
+  
+  /* Inserted simplex:     */
+  /*    1                  */
+  /*    o                  */
+  /*   /X\                 */
+  /*  o---o---o---o        */
+  /*  2   0   3\X/4        */
+  /*            o          */
+  /*            5          */
+
+  std::clog << "Check default insertion ensures the filtration values are non decreasing" << std::endl;
+  BOOST_CHECK(!st.make_filtration_non_decreasing());
+
+  // Because of non decreasing property of simplex tree, { 0 } , { 1 } and { 0, 1 } are going to be set from value 2.0
+  // to 1.0
+  st.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
+  
+  // Inserted simplex:
+  //    1   6
+  //    o---o
+  //   /X\7/
+  //  o---o---o---o
+  //  2   0   3\X/4
+  //            o
+  //            5
+  
+  std::clog << "Check default second insertion ensures the filtration values are non decreasing" << std::endl;
+  BOOST_CHECK(!st.make_filtration_non_decreasing());
+  
+  // Copy original simplex tree
+  typeST st_copy = st;
+
+  // Modify specific values for st to become like st_copy thanks to make_filtration_non_decreasing
+  st.assign_filtration(st.find({0,1,6,7}), 0.8);
+  st.assign_filtration(st.find({0,1,6}), 0.9);
+  st.assign_filtration(st.find({0,6}), 0.6);
+  st.assign_filtration(st.find({3,4,5}), 1.2);
+  st.assign_filtration(st.find({3,4}), 1.1);
+  st.assign_filtration(st.find({4,5}), 1.99);
+  
+  std::clog << "Check the simplex_tree is rolled back in case of decreasing filtration values" << std::endl;
+  BOOST_CHECK(st.make_filtration_non_decreasing());
+  BOOST_CHECK(st == st_copy);
+
+  // Other simplex tree
+  typeST st_other;
+  st_other.insert_simplex_and_subfaces({2, 1, 0}, 3.0);  // This one is different from st
+  st_other.insert_simplex_and_subfaces({3, 0}, 2.0);
+  st_other.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
+  st_other.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
+
+  // Modify specific values for st to become like st_other thanks to make_filtration_non_decreasing
+  st.assign_filtration(st.find({2}), 3.0);
+  // By modifying just the simplex {2}
+  // {0,1,2}, {1,2} and {0,2} will be modified
+  
+  std::clog << "Check the simplex_tree is repaired in case of decreasing filtration values" << std::endl;
+  BOOST_CHECK(st.make_filtration_non_decreasing());
+  BOOST_CHECK(st == st_other);
+
+  // Modify specific values for st still to be non-decreasing
+  st.assign_filtration(st.find({0,1,2}), 10.0);
+  st.assign_filtration(st.find({0,2}), 9.0);
+  st.assign_filtration(st.find({0,1,6,7}), 50.0);
+  st.assign_filtration(st.find({0,1,6}), 49.0);
+  st.assign_filtration(st.find({0,1,7}), 48.0);
+  // Other copy simplex tree
+  typeST st_other_copy = st;
+  
+  std::clog << "Check the simplex_tree is not modified in case of non-decreasing filtration values" << std::endl;
+  BOOST_CHECK(!st.make_filtration_non_decreasing());
+  BOOST_CHECK(st == st_other_copy);
+  
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(make_filtration_non_decreasing_on_nan_values, typeST, list_of_tested_variants) {
+  typeST st;
+
+  st.insert_simplex_and_subfaces({2, 1, 0}, std::numeric_limits<double>::quiet_NaN());
+  st.insert_simplex_and_subfaces({3, 0},    std::numeric_limits<double>::quiet_NaN());
+  st.insert_simplex_and_subfaces({3, 4, 5}, std::numeric_limits<double>::quiet_NaN());
+  
+  /* Inserted simplex:     */
+  /*    1                  */
+  /*    o                  */
+  /*   /X\                 */
+  /*  o---o---o---o        */
+  /*  2   0   3\X/4        */
+  /*            o          */
+  /*            5          */
+
+  std::clog << "SPECIFIC CASE:" << std::endl;
+  std::clog << "Insertion with NaN values does not ensure the filtration values are non decreasing" << std::endl;
+  st.make_filtration_non_decreasing();
+
+  std::clog << "Check all filtration values are NaN" << std::endl;
+  for (auto f_simplex : st.complex_simplex_range()) {
+    BOOST_CHECK(std::isnan(st.filtration(f_simplex)));
+  }
+
+  st.assign_filtration(st.find({0}), 0.);
+  st.assign_filtration(st.find({1}), 0.);
+  st.assign_filtration(st.find({2}), 0.);
+  st.assign_filtration(st.find({3}), 0.);
+  st.assign_filtration(st.find({4}), 0.);
+  st.assign_filtration(st.find({5}), 0.);
+
+  std::clog << "Check make_filtration_non_decreasing is modifying the simplicial complex" << std::endl;
+  BOOST_CHECK(st.make_filtration_non_decreasing());
+  
+  std::clog << "Check all filtration values are now defined" << std::endl;
+  for (auto f_simplex : st.complex_simplex_range()) {
+    BOOST_CHECK(!std::isnan(st.filtration(f_simplex)));
+  }
+}
diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
index 7746fa2a..9b5fa8fe 100644
--- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
@@ -791,90 +791,6 @@ BOOST_AUTO_TEST_CASE(non_contiguous) {
   BOOST_CHECK(++i == std::end(b));
 }
 
-BOOST_AUTO_TEST_CASE(make_filtration_non_decreasing) {
-  std::clog << "********************************************************************" << std::endl;
-  std::clog << "MAKE FILTRATION NON DECREASING" << std::endl;
-  typedef Simplex_tree<> typeST;
-  typeST st;
-
-  st.insert_simplex_and_subfaces({2, 1, 0}, 2.0);
-  st.insert_simplex_and_subfaces({3, 0}, 2.0);
-  st.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
-  
-  /* Inserted simplex:     */
-  /*    1                  */
-  /*    o                  */
-  /*   /X\                 */
-  /*  o---o---o---o        */
-  /*  2   0   3\X/4        */
-  /*            o          */
-  /*            5          */
-
-  std::clog << "Check default insertion ensures the filtration values are non decreasing" << std::endl;
-  BOOST_CHECK(!st.make_filtration_non_decreasing());
-
-  // Because of non decreasing property of simplex tree, { 0 } , { 1 } and { 0, 1 } are going to be set from value 2.0
-  // to 1.0
-  st.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
-  
-  // Inserted simplex:
-  //    1   6
-  //    o---o
-  //   /X\7/
-  //  o---o---o---o
-  //  2   0   3\X/4
-  //            o
-  //            5
-  
-  std::clog << "Check default second insertion ensures the filtration values are non decreasing" << std::endl;
-  BOOST_CHECK(!st.make_filtration_non_decreasing());
-  
-  // Copy original simplex tree
-  typeST st_copy = st;
-
-  // Modify specific values for st to become like st_copy thanks to make_filtration_non_decreasing
-  st.assign_filtration(st.find({0,1,6,7}), 0.8);
-  st.assign_filtration(st.find({0,1,6}), 0.9);
-  st.assign_filtration(st.find({0,6}), 0.6);
-  st.assign_filtration(st.find({3,4,5}), 1.2);
-  st.assign_filtration(st.find({3,4}), 1.1);
-  st.assign_filtration(st.find({4,5}), 1.99);
-  
-  std::clog << "Check the simplex_tree is rolled back in case of decreasing filtration values" << std::endl;
-  BOOST_CHECK(st.make_filtration_non_decreasing());
-  BOOST_CHECK(st == st_copy);
-
-  // Other simplex tree
-  typeST st_other;
-  st_other.insert_simplex_and_subfaces({2, 1, 0}, 3.0);  // This one is different from st
-  st_other.insert_simplex_and_subfaces({3, 0}, 2.0);
-  st_other.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
-  st_other.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
-
-  // Modify specific values for st to become like st_other thanks to make_filtration_non_decreasing
-  st.assign_filtration(st.find({2}), 3.0);
-  // By modifying just the simplex {2}
-  // {0,1,2}, {1,2} and {0,2} will be modified
-  
-  std::clog << "Check the simplex_tree is repaired in case of decreasing filtration values" << std::endl;
-  BOOST_CHECK(st.make_filtration_non_decreasing());
-  BOOST_CHECK(st == st_other);
-
-  // Modify specific values for st still to be non-decreasing
-  st.assign_filtration(st.find({0,1,2}), 10.0);
-  st.assign_filtration(st.find({0,2}), 9.0);
-  st.assign_filtration(st.find({0,1,6,7}), 50.0);
-  st.assign_filtration(st.find({0,1,6}), 49.0);
-  st.assign_filtration(st.find({0,1,7}), 48.0);
-  // Other copy simplex tree
-  typeST st_other_copy = st;
-  
-  std::clog << "Check the simplex_tree is not modified in case of non-decreasing filtration values" << std::endl;
-  BOOST_CHECK(!st.make_filtration_non_decreasing());
-  BOOST_CHECK(st == st_other_copy);
-  
-}
-
 
 typedef boost::mpl::list<boost::adjacency_list<boost::setS, boost::vecS, boost::directedS,
                                                boost::property<vertex_filtration_t, double>,
@@ -986,5 +902,41 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(insert_duplicated_vertices, typeST, list_of_tested
             << " - num_simplices = " << st.num_simplices() << std::endl;
   BOOST_CHECK(st.dimension() == 1);
   BOOST_CHECK(st.num_simplices() == st.num_vertices() + 1);
+}
 
+BOOST_AUTO_TEST_CASE_TEMPLATE(generators, typeST, list_of_tested_variants) {
+  std::cout << "********************************************************************" << std::endl;
+  std::cout << "TEST FIND GENERATORS" << std::endl;
+  {
+    typeST st;
+    st.insert_simplex_and_subfaces({0,1,2,3,4,5,6},0);
+    st.assign_filtration(st.find({0,2,4}), 10);
+    st.assign_filtration(st.find({1,5}), 20);
+    st.assign_filtration(st.find({1,2,4}), 30);
+    st.assign_filtration(st.find({3}), 5);
+    st.make_filtration_non_decreasing();
+    BOOST_CHECK(st.filtration(st.find({1,2}))==0);
+    BOOST_CHECK(st.filtration(st.find({0,1,2,3,4}))==30);
+    BOOST_CHECK(st.minimal_simplex_with_same_filtration(st.find({0,1,2,3,4,5}))==st.find({1,2,4}));
+    BOOST_CHECK(st.minimal_simplex_with_same_filtration(st.find({0,2,3}))==st.find({3}));
+    auto s=st.minimal_simplex_with_same_filtration(st.find({0,2,6}));
+    BOOST_CHECK(s==st.find({0})||s==st.find({2})||s==st.find({6}));
+    BOOST_CHECK(st.vertex_with_same_filtration(st.find({2}))==2);
+    BOOST_CHECK(st.vertex_with_same_filtration(st.find({1,5}))==st.null_vertex());
+    BOOST_CHECK(st.vertex_with_same_filtration(st.find({5,6}))>=5);
+  }
+  {
+    typeST st;
+    st.insert_simplex_and_subfaces({0,1}, 8);
+    st.insert_simplex_and_subfaces({0,2}, 10);
+    st.insert_simplex_and_subfaces({3,4}, 6);
+    st.insert_simplex_and_subfaces({1,2}, 5);
+    st.insert_simplex_and_subfaces({1,5}, 4);
+    st.insert_simplex_and_subfaces({0,5}, 3);
+    st.insert_simplex_and_subfaces({2,5}, 2);
+    st.insert_simplex_and_subfaces({1,3}, 9);
+    st.expansion(50);
+    BOOST_CHECK(st.edge_with_same_filtration(st.find({0,1,2,5}))==st.find({0,2}));
+    BOOST_CHECK(st.edge_with_same_filtration(st.find({1,5}))==st.find({1,5}));
+  }
 }