fix

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

Former-commit-id: 753dc7c276758bb612cf1be4ade131724716828d

5 files changed, 109 insertions, 236 deletions

diff --git a/src/Persistent_cohomology/example/alpha_shapes_persistence.cpp b/src/Persistent_cohomology/example/alpha_shapes_persistence.cpp
index 3a50c84c..1e907040 100644
--- a/src/Persistent_cohomology/example/alpha_shapes_persistence.cpp
+++ b/src/Persistent_cohomology/example/alpha_shapes_persistence.cpp
@@ -263,7 +263,6 @@ int main (int argc, char * const argv[])
       std::cout << "This shall not happen" << std::endl;
   }
   simplex_tree.set_filtration(filtration_max);
-  simplex_tree.set_num_simplices(count_vertices + count_edges + count_facets + count_cells);
   simplex_tree.set_dimension(dim_max);
 
 #ifdef DEBUG_TRACES
diff --git a/src/Persistent_cohomology/include/gudhi/Persistent_cohomology.h b/src/Persistent_cohomology/include/gudhi/Persistent_cohomology.h
index 896a7a9f..4c818ffa 100644
--- a/src/Persistent_cohomology/include/gudhi/Persistent_cohomology.h
+++ b/src/Persistent_cohomology/include/gudhi/Persistent_cohomology.h
@@ -230,9 +230,10 @@ class Persistent_cohomology {
       : cpx_(&cpx),
         dim_max_(cpx.dimension()),                       // upper bound on the dimension of the simplices
         coeff_field_(),                                  // initialize the field coefficient structure.
-        ds_rank_(cpx_->num_simplices()),                 // union-find
-        ds_parent_(cpx_->num_simplices()),               // union-find
-        ds_repr_(cpx_->num_simplices(), NULL),           // union-find -> annotation vectors
+        num_simplices_(cpx_->num_simplices()),           // num_simplices save to avoid to call thrice the function
+        ds_rank_(num_simplices_),                        // union-find
+        ds_parent_(num_simplices_),                      // union-find
+        ds_repr_(num_simplices_, NULL),                  // union-find -> annotation vectors
         dsets_(&ds_rank_[0], &ds_parent_[0]),            // union-find
         cam_(),                                          // collection of annotation vectors
         zero_cocycles_(),                                // union-find -> Simplex_key of creator for 0-homology
@@ -743,6 +744,7 @@ class Persistent_cohomology {
   Complex_ds * cpx_;
   int dim_max_;
   CoefficientField coeff_field_;
+  size_t num_simplices_;
 
   /*  Disjoint sets data structure to link the model of FilteredComplex
    * with the compressed annotation matrix.
diff --git a/src/Simplex_tree/example/simple_simplex_tree.cpp b/src/Simplex_tree/example/simple_simplex_tree.cpp
index 6d20e43e..a2e1f0e9 100644
--- a/src/Simplex_tree/example/simple_simplex_tree.cpp
+++ b/src/Simplex_tree/example/simple_simplex_tree.cpp
@@ -21,7 +21,6 @@
  */
 
 #include <iostream>
-#include <ctime>
 #include "gudhi/graph_simplicial_complex.h"
 #include "gudhi/Simplex_tree.h"
 
@@ -35,10 +34,6 @@ int main(int argc, char * const argv[]) {
   const Filtration_value SECOND_FILTRATION_VALUE = 0.2;
   const Filtration_value THIRD_FILTRATION_VALUE = 0.3;
   const Filtration_value FOURTH_FILTRATION_VALUE = 0.4;
-  Vertex_handle FIRST_VERTEX_HANDLE = (Vertex_handle) 0;
-  Vertex_handle SECOND_VERTEX_HANDLE = (Vertex_handle) 1;
-  Vertex_handle THIRD_VERTEX_HANDLE = (Vertex_handle) 2;
-  Vertex_handle FOURTH_VERTEX_HANDLE = (Vertex_handle) 3;
 
   // TEST OF INSERTION
   std::cout << "********************************************************************" << std::endl;
@@ -55,173 +50,132 @@ int main(int argc, char * const argv[]) {
 
   // ++ FIRST
   std::cout << "   * INSERT 0" << std::endl;
-  typeVectorVertex firstSimplexVector;
-  firstSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex firstSimplexVector = { 0 };
   typePairSimplexBool returnValue =
       simplexTree.insert_simplex(firstSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + 0 INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - 0 NOT INSERTED" << std::endl;
   }
 
   // ++ SECOND
   std::cout << "   * INSERT 1" << std::endl;
-  typeVectorVertex secondSimplexVector;
-  secondSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+  typeVectorVertex secondSimplexVector = { 1 };
   returnValue =
       simplexTree.insert_simplex(secondSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + 1 INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - 1 NOT INSERTED" << std::endl;
   }
 
   // ++ THIRD
   std::cout << "   * INSERT (0,1)" << std::endl;
-  typeVectorVertex thirdSimplexVector;
-  thirdSimplexVector.push_back(FIRST_VERTEX_HANDLE);
-  thirdSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+  typeVectorVertex thirdSimplexVector = { 0, 1 };
   returnValue =
       simplexTree.insert_simplex(thirdSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (0,1) INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - (0,1) NOT INSERTED" << std::endl;
   }
 
   // ++ FOURTH
   std::cout << "   * INSERT 2" << std::endl;
-  typeVectorVertex fourthSimplexVector;
-  fourthSimplexVector.push_back(THIRD_VERTEX_HANDLE);
+  typeVectorVertex fourthSimplexVector = { 2 };
   returnValue =
       simplexTree.insert_simplex(fourthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + 2 INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - 2 NOT INSERTED" << std::endl;
   }
 
   // ++ FIFTH
   std::cout << "   * INSERT (2,0)" << std::endl;
-  typeVectorVertex fifthSimplexVector;
-  fifthSimplexVector.push_back(THIRD_VERTEX_HANDLE);
-  fifthSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex fifthSimplexVector = { 2, 0 };
   returnValue =
       simplexTree.insert_simplex(fifthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (2,0) INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - (2,0) NOT INSERTED" << std::endl;
   }
 
   // ++ SIXTH
   std::cout << "   * INSERT (2,1)" << std::endl;
-  typeVectorVertex sixthSimplexVector;
-  sixthSimplexVector.push_back(THIRD_VERTEX_HANDLE);
-  sixthSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+  typeVectorVertex sixthSimplexVector = { 2, 1 };
   returnValue =
       simplexTree.insert_simplex(sixthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (2,1) INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - (2,1) NOT INSERTED" << std::endl;
   }
 
   // ++ SEVENTH
   std::cout << "   * INSERT (2,1,0)" << std::endl;
-  typeVectorVertex seventhSimplexVector;
-  seventhSimplexVector.push_back(THIRD_VERTEX_HANDLE);
-  seventhSimplexVector.push_back(SECOND_VERTEX_HANDLE);
-  seventhSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex seventhSimplexVector = { 2, 1, 0 };
   returnValue =
       simplexTree.insert_simplex(seventhSimplexVector, Filtration_value(THIRD_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (2,1,0) INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - (2,1,0) NOT INSERTED" << std::endl;
   }
 
   // ++ EIGHTH
   std::cout << "   * INSERT 3" << std::endl;
-  typeVectorVertex eighthSimplexVector;
-  eighthSimplexVector.push_back(FOURTH_VERTEX_HANDLE);
+  typeVectorVertex eighthSimplexVector = { 3 };
   returnValue =
       simplexTree.insert_simplex(eighthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + 3 INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - 3 NOT INSERTED" << std::endl;
   }
 
   // ++ NINETH
   std::cout << "   * INSERT (3,0)" << std::endl;
-  typeVectorVertex ninethSimplexVector;
-  ninethSimplexVector.push_back(FOURTH_VERTEX_HANDLE);
-  ninethSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex ninethSimplexVector = { 3, 0 };
   returnValue =
       simplexTree.insert_simplex(ninethSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (3,0) INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - (3,0) NOT INSERTED" << std::endl;
   }
 
   // ++ TENTH
   std::cout << "   * INSERT 0 (already inserted)" << std::endl;
-  typeVectorVertex tenthSimplexVector;
-  tenthSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex tenthSimplexVector = { 0 };
   returnValue =
       simplexTree.insert_simplex(tenthSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE)); // With a different filtration value
 
   if (returnValue.second == true) {
     std::cout << "   + 0 INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - 0 NOT INSERTED" << std::endl;
   }
 
   // ++ ELEVENTH
   std::cout << "   * INSERT (2,1,0) (already inserted)" << std::endl;
-  typeVectorVertex eleventhSimplexVector;
-  eleventhSimplexVector.push_back(THIRD_VERTEX_HANDLE);
-  eleventhSimplexVector.push_back(SECOND_VERTEX_HANDLE);
-  eleventhSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex eleventhSimplexVector = { 2, 1, 0 };
   returnValue =
       simplexTree.insert_simplex(eleventhSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (2,1,0) INSERTED" << std::endl;
-    int nb_simplices = simplexTree.num_simplices() + 1;
-    simplexTree.set_num_simplices(nb_simplices);
   } else {
     std::cout << "   - (2,1,0) NOT INSERTED" << std::endl;
   }
@@ -262,9 +216,7 @@ int main(int argc, char * const argv[]) {
   else
     std::cout << "***- NO IT ISN'T\n";
 
-  Vertex_handle UNKNOWN_VERTEX_HANDLE = (Vertex_handle) 15;
-  typeVectorVertex unknownSimplexVector;
-  unknownSimplexVector.push_back(UNKNOWN_VERTEX_HANDLE);
+  typeVectorVertex unknownSimplexVector = { 15 };
   simplexFound = simplexTree.find(unknownSimplexVector);
   std::cout << "**************IS THE SIMPLEX {15} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
@@ -279,9 +231,7 @@ int main(int argc, char * const argv[]) {
   else
     std::cout << "***- NO IT ISN'T\n";
 
-  typeVectorVertex otherSimplexVector;
-  otherSimplexVector.push_back(UNKNOWN_VERTEX_HANDLE);
-  otherSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+  typeVectorVertex otherSimplexVector = { 1, 15 };
   simplexFound = simplexTree.find(otherSimplexVector);
   std::cout << "**************IS THE SIMPLEX {15,1} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
@@ -289,10 +239,7 @@ int main(int argc, char * const argv[]) {
   else
     std::cout << "***- NO IT ISN'T\n";
 
-  typeVectorVertex invSimplexVector;
-  invSimplexVector.push_back(SECOND_VERTEX_HANDLE);
-  invSimplexVector.push_back(THIRD_VERTEX_HANDLE);
-  invSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex invSimplexVector = { 1, 2, 0 };
   simplexFound = simplexTree.find(invSimplexVector);
   std::cout << "**************IS THE SIMPLEX {1,2,0} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h
index 57e9b987..6b016fc3 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h
@@ -281,13 +281,17 @@ class Simplex_tree {
   Simplex_tree()
       : null_vertex_(-1),
       threshold_(0),
-      num_simplices_(0),
       root_(NULL, null_vertex_),
       filtration_vect_(),
       dimension_(-1) { }
 
   /** \brief Copy; copy the whole tree structure. */
-  Simplex_tree(Simplex_tree& copy) : null_vertex_(copy.null_vertex_), threshold_(copy.threshold_), num_simplices_(copy.num_simplices_), root_(NULL, -1, std::vector<std::pair<Vertex_handle, Node>> (copy.root_.members().begin(), copy.root_.members().end())), filtration_vect_(copy.filtration_vect_), dimension_(copy.dimension_) {
+  Simplex_tree(Simplex_tree& copy) : 	null_vertex_(copy.null_vertex_),
+  										threshold_(copy.threshold_),
+										num_simplices_(copy.num_simplices_),
+										root_(NULL, -1, std::vector<std::pair<Vertex_handle, Node>> (copy.root_.members().begin(), copy.root_.members().end())),
+										filtration_vect_(copy.filtration_vect_),
+										dimension_(copy.dimension_) {
 		rec_copy(&root_, &copy.root_);
 	}
 
@@ -407,14 +411,14 @@ class Simplex_tree {
    *
    * The filtration must be initialized. */
   static Simplex_key key(Simplex_handle sh) {
-	  return sh->second.key();
+    return sh->second.key();
   }
 
   /** \brief Returns the simplex associated to a key.
    *
    * The filtration must be initialized. */
   Simplex_handle simplex(Simplex_key key) const {
-	  return filtration_vect_[key];
+    return filtration_vect_[key];
   }
 
   /** \brief Returns the filtration value of a simplex.
@@ -458,13 +462,27 @@ class Simplex_tree {
     return root_.members_.size();
   }
 
-  /** \brief Returns the number of simplices in the complex.
-   *
-   * Does not count the empty simplex. */
-  unsigned int num_simplices() const {
-    return num_simplices_;
+ public:
+  /** \brief returns the number of simplices in the simplex_tree. */
+  size_t num_simplices() {
+    return num_simplices(&root_);
+  }
+
+ private:
+  /** \brief returns the number of simplices in the simplex_tree. */
+  size_t num_simplices(Siblings * sib) {
+    auto sib_begin = sib->members().begin();
+    auto sib_end = sib->members().end();
+    size_t simplices_number = sib_end - sib_begin;
+    for (auto sh = sib_begin; sh != sib_end; ++sh) {
+      if (has_children(sh)) {
+        simplices_number += num_simplices(sh->second.children());
+      }
+    }
+    return simplices_number;
   }
 
+ public:
   /** \brief Returns the dimension of a simplex.
    *
    * Must be different from null_simplex().*/
@@ -630,15 +648,9 @@ std::pair<Simplex_handle, bool> insert_simplex(const RandomAccessVertexRange & s
       }
       // N-Simplex insert
       std::pair<Simplex_handle, bool> returned = insert_simplex_rec(Nsimplex, filtration);
-      if (returned.second == true) {
-        num_simplices_++;
-      }
     } else if (Nsimplex.size() == 1) {
       // 1-Simplex insert - End of recursivity
       std::pair<Simplex_handle, bool> returned = insert_simplex_rec(Nsimplex, filtration);
-      if (returned.second == true) {
-        num_simplices_++;
-      }
     } else {
       // Nothing to insert - empty vector
     }
@@ -691,11 +703,6 @@ std::pair<Simplex_handle, bool> insert_simplex(const RandomAccessVertexRange & s
     threshold_ = fil;
   }
 
-  /** Set a number of simplices for the simplicial complex. */
-  void set_num_simplices(unsigned int num_simplices) {
-    num_simplices_ = num_simplices;
-  }
-
   /** Set a dimension for the simplicial complex. */
   void set_dimension(int dimension) {
     dimension_ = dimension;
@@ -749,18 +756,18 @@ std::pair<Simplex_handle, bool> insert_simplex(const RandomAccessVertexRange & s
 	}
 	
 
-/** \brief recursively insert the members of a Sibling into another, any time the key exists into the target Sibling
+/** \brief recursively insert the members of a Sibling into another, any time the replacedVertex appears into the target Sibling
 	\param sibInserted The sibling to be inserted
 	\param sibTarget The target sibling on which the other sibling is copied
-	\param key The key (Vertex_handle) needed to insert the sibling
+	\param replacedVertex The replacedVertex (Vertex_handle) needed to insert the sibling
 */
-	void rec_insert(Siblings * sibInserted, Siblings * sibTarget, Vertex_handle key)
+	void rec_insert(Siblings * sibInserted, Siblings * sibTarget, Vertex_handle replacedVertex)
 	{
 		for (auto sh = sibTarget->members().begin(); sh != sibTarget->members().end(); ++sh)
 		{
 			if (has_children(sh))
-				rec_insert(sibInserted, sh->second.children(), key);
-			if (sh->first == key)
+				rec_insert(sibInserted, sh->second.children(), replacedVertex);
+			if (sh->first == replacedVertex)
 				insert_members(sibTarget, sibInserted);
 		}
 	}
@@ -788,17 +795,17 @@ std::pair<Simplex_handle, bool> insert_simplex(const RandomAccessVertexRange & s
 		}
 	}
 
-/** \brief Erase every occurencies of a key in a Sibling
+/** \brief Erase every occurencies of a vertex in a Sibling
 	\param sib The sibling on which we wan't to erase the elements
-	\param key The key of the members we wan't to erase
+	\param deletedVertex The value of the members we wan't to erase
 */
-	void rec_delete(Siblings * sib, Vertex_handle key)
+	void rec_delete(Siblings * sib, Vertex_handle deletedVertex)
 	{
 		for (auto sh = sib->members().begin(); sh != sib->members().end(); ++sh)
 		{
 			if (has_children(sh))
-				rec_delete(sh->second.children(), key);
-			if (sh->first == key)
+				rec_delete(sh->second.children(), deletedVertex);
+			if (sh->first == deletedVertex)
 				sib->members_.erase(sh);
 		}
 	}
@@ -967,8 +974,6 @@ std::pair<Simplex_handle, bool> insert_simplex(const RandomAccessVertexRange & s
       dimension_ = 1;
     }
 
-    num_simplices_ = boost::num_vertices(skel_graph)
-        + boost::num_edges(skel_graph);
     root_.members_.reserve(boost::num_vertices(skel_graph));
 
     typename boost::graph_traits<OneSkeletonGraph>::vertex_iterator v_it,
@@ -1047,7 +1052,6 @@ std::pair<Simplex_handle, bool> insert_simplex(const RandomAccessVertexRange & s
                      root_sh->second.children()->members().end(),
                      s_h->second.filtration());
         if (inter.size() != 0) {
-          this->num_simplices_ += inter.size();
           Siblings * new_sib = new Siblings(siblings,  // oncles
                                             s_h->first,  // parent
                                             inter);  // boost::container::ordered_unique_range_t
@@ -1110,7 +1114,6 @@ std::pair<Simplex_handle, bool> insert_simplex(const RandomAccessVertexRange & s
   /** \brief Upper bound on the filtration values of the simplices.*/
   Filtration_value threshold_;
   /** \brief Total number of simplices in the complex, without the empty simplex.*/
-  unsigned int num_simplices_;
   /** \brief Set of simplex tree Nodes representing the vertices.*/
   Siblings root_;
   /** \brief Simplices ordered according to a filtration.*/
@@ -1135,17 +1138,13 @@ std::ostream& operator<<(std::ostream & os, Simplex_tree<T...> & st) {
 
 template<typename...T>
 std::istream& operator>>(std::istream & is, Simplex_tree<T...> & st) {
-  // assert(st.num_simplices() == 0);
-
   typedef Simplex_tree<T...> ST;
   std::vector<typename ST::Vertex_handle> simplex;
   typename ST::Filtration_value fil;
   typename ST::Filtration_value max_fil = 0;
   int max_dim = -1;
-  size_t num_simplices = 0;
   while (read_simplex(is, simplex, fil)) {
     // read all simplices in the file as a list of vertices
-    ++num_simplices;
     // Warning : simplex_size needs to be casted in int - Can be 0
     int dim = static_cast<int> (simplex.size() - 1);
     if (max_dim < dim) {
@@ -1158,7 +1157,6 @@ std::istream& operator>>(std::istream & is, Simplex_tree<T...> & st) {
     st.insert_simplex(simplex, fil);
     simplex.clear();
   }
-  st.set_num_simplices(num_simplices);
   st.set_dimension(max_dim);
   st.set_filtration(max_fil);
 
diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
index 4253e2e4..0c710651 100644
--- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
@@ -159,12 +159,17 @@ void set_and_test_simplex_tree_dim_fil(typeST& simplexTree, int vectorSize, cons
     std::cout << "   set_and_test_simplex_tree_dim_fil - max_fil=" << max_fil
         << std::endl;
   }
-  unsigned int nb_simplices = simplexTree.num_simplices() + 1;
-  simplexTree.set_num_simplices(nb_simplices);
-
+  
   BOOST_CHECK(simplexTree.dimension() == dim_max);
   BOOST_CHECK(AreAlmostTheSame(simplexTree.filtration(), max_fil));
-  BOOST_CHECK(simplexTree.num_simplices() == nb_simplices);
+
+  // Another way to count simplices:
+  long long int num_simp = 0;
+  for (auto f_simplex : simplexTree.complex_simplex_range()) {
+    num_simp++;
+  }
+  
+  BOOST_CHECK(simplexTree.num_simplices() == num_simp);
 }
 
 void test_cofaces(typeST& st, std::vector<Vertex_handle> v, int dim, std::vector<typeST::Simplex_handle> res) {
@@ -188,10 +193,6 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
   const Filtration_value SECOND_FILTRATION_VALUE = 0.2;
   const Filtration_value THIRD_FILTRATION_VALUE = 0.3;
   const Filtration_value FOURTH_FILTRATION_VALUE = 0.4;
-  Vertex_handle FIRST_VERTEX_HANDLE = (Vertex_handle) 0;
-  Vertex_handle SECOND_VERTEX_HANDLE = (Vertex_handle) 1;
-  Vertex_handle THIRD_VERTEX_HANDLE = (Vertex_handle) 2;
-  Vertex_handle FOURTH_VERTEX_HANDLE = (Vertex_handle) 3;
 
   // TEST OF INSERTION
   std::cout << "********************************************************************" << std::endl;
@@ -200,13 +201,10 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ FIRST
   std::cout << "   - INSERT 0" << std::endl;
-  typeVectorVertex firstSimplexVector;
-  firstSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex firstSimplexVector { 0 };
   BOOST_CHECK(firstSimplexVector.size() == 1);
-  typeSimplex firstSimplex = std::make_pair(
-                                            firstSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
-  typePairSimplexBool returnValue = st.insert_simplex(firstSimplex.first,
-                                                      firstSimplex.second);
+  typeSimplex firstSimplex = std::make_pair(firstSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+  typePairSimplexBool returnValue = st.insert_simplex(firstSimplex.first, firstSimplex.second);
 
   test_simplex_tree_insert_returns_true(returnValue);
   set_and_test_simplex_tree_dim_fil(st, firstSimplexVector.size(), firstSimplex.second);
@@ -214,13 +212,10 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ SECOND
   std::cout << "   - INSERT 1" << std::endl;
-  typeVectorVertex secondSimplexVector;
-  secondSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+  typeVectorVertex secondSimplexVector { 1 };
   BOOST_CHECK(secondSimplexVector.size() == 1);
-  typeSimplex secondSimplex = std::make_pair(
-                                             secondSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
-  returnValue =
-      st.insert_simplex(secondSimplex.first, secondSimplex.second);
+  typeSimplex secondSimplex = std::make_pair(secondSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+  returnValue = st.insert_simplex(secondSimplex.first, secondSimplex.second);
 
   test_simplex_tree_insert_returns_true(returnValue);
   set_and_test_simplex_tree_dim_fil(st, secondSimplexVector.size(), secondSimplex.second);
@@ -228,14 +223,10 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ THIRD
   std::cout << "   - INSERT (0,1)" << std::endl;
-  typeVectorVertex thirdSimplexVector;
-  thirdSimplexVector.push_back(FIRST_VERTEX_HANDLE);
-  thirdSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+  typeVectorVertex thirdSimplexVector { 0, 1 };
   BOOST_CHECK(thirdSimplexVector.size() == 2);
-  typeSimplex thirdSimplex = std::make_pair(
-                                            thirdSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
-  returnValue =
-      st.insert_simplex(thirdSimplex.first, thirdSimplex.second);
+  typeSimplex thirdSimplex = std::make_pair(thirdSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+  returnValue = st.insert_simplex(thirdSimplex.first, thirdSimplex.second);
 
   test_simplex_tree_insert_returns_true(returnValue);
   set_and_test_simplex_tree_dim_fil(st, thirdSimplexVector.size(), thirdSimplex.second);
@@ -243,13 +234,10 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ FOURTH
   std::cout << "   - INSERT 2" << std::endl;
-  typeVectorVertex fourthSimplexVector;
-  fourthSimplexVector.push_back(THIRD_VERTEX_HANDLE);
+  typeVectorVertex fourthSimplexVector { 2 };
   BOOST_CHECK(fourthSimplexVector.size() == 1);
-  typeSimplex fourthSimplex = std::make_pair(
-                                             fourthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
-  returnValue =
-      st.insert_simplex(fourthSimplex.first, fourthSimplex.second);
+  typeSimplex fourthSimplex = std::make_pair(fourthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+  returnValue = st.insert_simplex(fourthSimplex.first, fourthSimplex.second);
 
   test_simplex_tree_insert_returns_true(returnValue);
   set_and_test_simplex_tree_dim_fil(st, fourthSimplexVector.size(), fourthSimplex.second);
@@ -257,14 +245,10 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ FIFTH
   std::cout << "   - INSERT (2,0)" << std::endl;
-  typeVectorVertex fifthSimplexVector;
-  fifthSimplexVector.push_back(THIRD_VERTEX_HANDLE);
-  fifthSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex fifthSimplexVector { 2, 0 };
   BOOST_CHECK(fifthSimplexVector.size() == 2);
-  typeSimplex fifthSimplex = std::make_pair(
-                                            fifthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
-  returnValue =
-      st.insert_simplex(fifthSimplex.first, fifthSimplex.second);
+  typeSimplex fifthSimplex = std::make_pair(fifthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+  returnValue = st.insert_simplex(fifthSimplex.first, fifthSimplex.second);
 
   test_simplex_tree_insert_returns_true(returnValue);
   set_and_test_simplex_tree_dim_fil(st, fifthSimplexVector.size(), fifthSimplex.second);
@@ -272,14 +256,10 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ SIXTH
   std::cout << "   - INSERT (2,1)" << std::endl;
-  typeVectorVertex sixthSimplexVector;
-  sixthSimplexVector.push_back(THIRD_VERTEX_HANDLE);
-  sixthSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+  typeVectorVertex sixthSimplexVector { 2, 1 };
   BOOST_CHECK(sixthSimplexVector.size() == 2);
-  typeSimplex sixthSimplex = std::make_pair(
-                                            sixthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
-  returnValue =
-      st.insert_simplex(sixthSimplex.first, sixthSimplex.second);
+  typeSimplex sixthSimplex = std::make_pair(sixthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+  returnValue = st.insert_simplex(sixthSimplex.first, sixthSimplex.second);
 
   test_simplex_tree_insert_returns_true(returnValue);
   set_and_test_simplex_tree_dim_fil(st, sixthSimplexVector.size(), sixthSimplex.second);
@@ -287,15 +267,10 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ SEVENTH
   std::cout << "   - INSERT (2,1,0)" << std::endl;
-  typeVectorVertex seventhSimplexVector;
-  seventhSimplexVector.push_back(THIRD_VERTEX_HANDLE);
-  seventhSimplexVector.push_back(SECOND_VERTEX_HANDLE);
-  seventhSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex seventhSimplexVector { 2, 1, 0 };
   BOOST_CHECK(seventhSimplexVector.size() == 3);
-  typeSimplex seventhSimplex = std::make_pair(
-                                              seventhSimplexVector, Filtration_value(THIRD_FILTRATION_VALUE));
-  returnValue =
-      st.insert_simplex(seventhSimplex.first, seventhSimplex.second);
+  typeSimplex seventhSimplex = std::make_pair(seventhSimplexVector, Filtration_value(THIRD_FILTRATION_VALUE));
+  returnValue = st.insert_simplex(seventhSimplex.first, seventhSimplex.second);
 
   test_simplex_tree_insert_returns_true(returnValue);
   set_and_test_simplex_tree_dim_fil(st, seventhSimplexVector.size(), seventhSimplex.second);
@@ -303,13 +278,10 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ EIGHTH
   std::cout << "   - INSERT 3" << std::endl;
-  typeVectorVertex eighthSimplexVector;
-  eighthSimplexVector.push_back(FOURTH_VERTEX_HANDLE);
+  typeVectorVertex eighthSimplexVector { 3 };
   BOOST_CHECK(eighthSimplexVector.size() == 1);
-  typeSimplex eighthSimplex = std::make_pair(
-                                             eighthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
-  returnValue =
-      st.insert_simplex(eighthSimplex.first, eighthSimplex.second);
+  typeSimplex eighthSimplex = std::make_pair(eighthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+  returnValue = st.insert_simplex(eighthSimplex.first, eighthSimplex.second);
 
   test_simplex_tree_insert_returns_true(returnValue);
   set_and_test_simplex_tree_dim_fil(st, eighthSimplexVector.size(), eighthSimplex.second);
@@ -317,14 +289,10 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ NINETH
   std::cout << "   - INSERT (3,0)" << std::endl;
-  typeVectorVertex ninethSimplexVector;
-  ninethSimplexVector.push_back(FOURTH_VERTEX_HANDLE);
-  ninethSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex ninethSimplexVector { 3, 0 };
   BOOST_CHECK(ninethSimplexVector.size() == 2);
-  typeSimplex ninethSimplex = std::make_pair(
-                                             ninethSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
-  returnValue =
-      st.insert_simplex(ninethSimplex.first, ninethSimplex.second);
+  typeSimplex ninethSimplex = std::make_pair(ninethSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+  returnValue = st.insert_simplex(ninethSimplex.first, ninethSimplex.second);
 
   test_simplex_tree_insert_returns_true(returnValue);
   set_and_test_simplex_tree_dim_fil(st, ninethSimplexVector.size(), ninethSimplex.second);
@@ -332,13 +300,11 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ TENTH
   std::cout << "   - INSERT 0 (already inserted)" << std::endl;
-  typeVectorVertex tenthSimplexVector;
-  tenthSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex tenthSimplexVector { 0 };
   BOOST_CHECK(tenthSimplexVector.size() == 1);
-  typeSimplex tenthSimplex = std::make_pair(
-                                            tenthSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE)); // With a different filtration value
-  returnValue =
-      st.insert_simplex(tenthSimplex.first, tenthSimplex.second);
+  // With a different filtration value
+  typeSimplex tenthSimplex = std::make_pair(tenthSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
+  returnValue = st.insert_simplex(tenthSimplex.first, tenthSimplex.second);
 
   BOOST_CHECK(returnValue.second == false);
   typeST::Simplex_handle shReturned = returnValue.first; // Simplex_handle = boost::container::flat_map< Vertex_handle, Node >::iterator
@@ -349,15 +315,10 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 
   // ++ ELEVENTH
   std::cout << "   - INSERT (2,1,0) (already inserted)" << std::endl;
-  typeVectorVertex eleventhSimplexVector;
-  eleventhSimplexVector.push_back(THIRD_VERTEX_HANDLE);
-  eleventhSimplexVector.push_back(SECOND_VERTEX_HANDLE);
-  eleventhSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex eleventhSimplexVector { 2, 1, 0 };
   BOOST_CHECK(eleventhSimplexVector.size() == 3);
-  typeSimplex eleventhSimplex = std::make_pair(
-                                               eleventhSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
-  returnValue =
-      st.insert_simplex(eleventhSimplex.first, eleventhSimplex.second);
+  typeSimplex eleventhSimplex = std::make_pair(eleventhSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
+  returnValue = st.insert_simplex(eleventhSimplex.first, eleventhSimplex.second);
 
   BOOST_CHECK(returnValue.second == false);
   shReturned = returnValue.first; // Simplex_handle = boost::container::flat_map< Vertex_handle, Node >::iterator
@@ -417,15 +378,6 @@ BOOST_AUTO_TEST_CASE(simplex_tree_insertion) {
 }
 
 BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
-  Vertex_handle FIRST_VERTEX_HANDLE = (Vertex_handle) 0;
-  Vertex_handle SECOND_VERTEX_HANDLE = (Vertex_handle) 1;
-  Vertex_handle THIRD_VERTEX_HANDLE = (Vertex_handle) 2;
-  Vertex_handle FOURTH_VERTEX_HANDLE = (Vertex_handle) 3;
-  Vertex_handle FIFTH_VERTEX_HANDLE = (Vertex_handle) 4;
-  Vertex_handle SIXTH_VERTEX_HANDLE = (Vertex_handle) 5;
-  Vertex_handle SEVENTH_VERTEX_HANDLE = (Vertex_handle) 6;
-  Vertex_handle EIGHTH_VERTEX_HANDLE = (Vertex_handle) 7;
-
   // TEST OF INSERTION
   std::cout << "********************************************************************" << std::endl;
   std::cout << "TEST OF INSERTION" << std::endl;
@@ -433,10 +385,7 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
 
   // ++ FIRST
   std::cout << "   - INSERT (2,1,0)" << std::endl;
-  typeVectorVertex SimplexVector1;
-  SimplexVector1.push_back(THIRD_VERTEX_HANDLE);
-  SimplexVector1.push_back(SECOND_VERTEX_HANDLE);
-  SimplexVector1.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex SimplexVector1 { 2, 1, 0 };
   BOOST_CHECK(SimplexVector1.size() == 3);
   st.insert_simplex_and_subfaces(SimplexVector1);
 
@@ -444,8 +393,7 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
 
   // ++ SECOND
   std::cout << "   - INSERT 3" << std::endl;
-  typeVectorVertex SimplexVector2;
-  SimplexVector2.push_back(FOURTH_VERTEX_HANDLE);
+  typeVectorVertex SimplexVector2 { 3 };
   BOOST_CHECK(SimplexVector2.size() == 1);
   st.insert_simplex_and_subfaces(SimplexVector2);
 
@@ -453,9 +401,7 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
 
   // ++ THIRD
   std::cout << "   - INSERT (0,3)" << std::endl;
-  typeVectorVertex SimplexVector3;
-  SimplexVector3.push_back(FOURTH_VERTEX_HANDLE);
-  SimplexVector3.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex SimplexVector3 { 3, 0 };
   BOOST_CHECK(SimplexVector3.size() == 2);
   st.insert_simplex_and_subfaces(SimplexVector3);
 
@@ -463,9 +409,7 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
 
   // ++ FOURTH
   std::cout << "   - INSERT (1,0) (already inserted)" << std::endl;
-  typeVectorVertex SimplexVector4;
-  SimplexVector4.push_back(SECOND_VERTEX_HANDLE);
-  SimplexVector4.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex SimplexVector4 { 1, 0 };
   BOOST_CHECK(SimplexVector4.size() == 2);
   st.insert_simplex_and_subfaces(SimplexVector4);
 
@@ -473,10 +417,7 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
 
   // ++ FIFTH
   std::cout << "   - INSERT (3,4,5)" << std::endl;
-  typeVectorVertex SimplexVector5;
-  SimplexVector5.push_back(FOURTH_VERTEX_HANDLE);
-  SimplexVector5.push_back(FIFTH_VERTEX_HANDLE);
-  SimplexVector5.push_back(SIXTH_VERTEX_HANDLE);
+  typeVectorVertex SimplexVector5 { 3, 4, 5 };
   BOOST_CHECK(SimplexVector5.size() == 3);
   st.insert_simplex_and_subfaces(SimplexVector5);
 
@@ -484,11 +425,7 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
 
   // ++ SIXTH
   std::cout << "   - INSERT (0,1,6,7)" << std::endl;
-  typeVectorVertex SimplexVector6;
-  SimplexVector6.push_back(FIRST_VERTEX_HANDLE);
-  SimplexVector6.push_back(SECOND_VERTEX_HANDLE);
-  SimplexVector6.push_back(SEVENTH_VERTEX_HANDLE);
-  SimplexVector6.push_back(EIGHTH_VERTEX_HANDLE);
+  typeVectorVertex SimplexVector6 { 0, 1, 6, 7 };
   BOOST_CHECK(SimplexVector6.size() == 4);
   st.insert_simplex_and_subfaces(SimplexVector6);
 
@@ -525,8 +462,7 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
   // ------------------------------------------------------------------------------------------------------------------
   // Find in the simplex_tree
   // ------------------------------------------------------------------------------------------------------------------
-  typeVectorVertex simpleSimplexVector;
-  simpleSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+  typeVectorVertex simpleSimplexVector { 1 };
   Simplex_tree<>::Simplex_handle simplexFound = st.find(simpleSimplexVector);
   std::cout << "**************IS THE SIMPLEX {1} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != st.null_simplex())
@@ -536,9 +472,7 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
   // Check it is found
   BOOST_CHECK(simplexFound != st.null_simplex());
 
-  Vertex_handle UNKNOWN_VERTEX_HANDLE = (Vertex_handle) 15;
-  typeVectorVertex unknownSimplexVector;
-  unknownSimplexVector.push_back(UNKNOWN_VERTEX_HANDLE);
+  typeVectorVertex unknownSimplexVector { 15 };
   simplexFound = st.find(unknownSimplexVector);
   std::cout << "**************IS THE SIMPLEX {15} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != st.null_simplex())
@@ -557,9 +491,7 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
   // Check it is found
   BOOST_CHECK(simplexFound != st.null_simplex());
 
-  typeVectorVertex otherSimplexVector;
-  otherSimplexVector.push_back(UNKNOWN_VERTEX_HANDLE);
-  otherSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+  typeVectorVertex otherSimplexVector { 1, 15 };
   simplexFound = st.find(otherSimplexVector);
   std::cout << "**************IS THE SIMPLEX {15,1} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != st.null_simplex())
@@ -569,10 +501,7 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
   // Check it is NOT found
   BOOST_CHECK(simplexFound == st.null_simplex());
 
-  typeVectorVertex invSimplexVector;
-  invSimplexVector.push_back(SECOND_VERTEX_HANDLE);
-  invSimplexVector.push_back(THIRD_VERTEX_HANDLE);
-  invSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+  typeVectorVertex invSimplexVector { 1, 2, 0 };
   simplexFound = st.find(invSimplexVector);
   std::cout << "**************IS THE SIMPLEX {1,2,0} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != st.null_simplex())
@@ -582,8 +511,6 @@ BOOST_AUTO_TEST_CASE(NSimplexAndSubfaces_tree_insertion) {
   // Check it is found
   BOOST_CHECK(simplexFound != st.null_simplex());
 
-
-
   // Display the Simplex_tree - Can not be done in the middle of 2 inserts
   std::cout << "The complex contains " << st.num_simplices() << " simplices" << std::endl;
   std::cout << "   - dimension " << st.dimension() << "   - filtration " << st.filtration() << std::endl;