Backmerge from trunk

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

Former-commit-id: 3f1b56bf4986df7bb2938ea2fff944eb9bf9b653

13 files changed, 398 insertions, 372 deletions

diff --git a/src/Simplex_tree/example/CMakeLists.txt b/src/Simplex_tree/example/CMakeLists.txt
index 2f924490..c70cfe35 100644
--- a/src/Simplex_tree/example/CMakeLists.txt
+++ b/src/Simplex_tree/example/CMakeLists.txt
@@ -1,9 +1,9 @@
 cmake_minimum_required(VERSION 2.6)
 project(GUDHISimplexTreeFromFile)
 
-add_executable ( simplex_tree_from_file simplex_tree_from_file.cpp )
-add_test(simplex_tree_from_file_2 ${CMAKE_CURRENT_BINARY_DIR}/simplex_tree_from_file ${CMAKE_SOURCE_DIR}/data/points/Klein_bottle_complex.txt 2)
-add_test(simplex_tree_from_file_3 ${CMAKE_CURRENT_BINARY_DIR}/simplex_tree_from_file ${CMAKE_SOURCE_DIR}/data/points/Klein_bottle_complex.txt 3)
+add_executable ( simplex_tree_from_cliques_of_graph simplex_tree_from_cliques_of_graph.cpp )
+add_test(simplex_tree_from_cliques_of_graph_2 ${CMAKE_CURRENT_BINARY_DIR}/simplex_tree_from_cliques_of_graph ${CMAKE_SOURCE_DIR}/data/points/Klein_bottle_complex.txt 2)
+add_test(simplex_tree_from_cliques_of_graph_3 ${CMAKE_CURRENT_BINARY_DIR}/simplex_tree_from_cliques_of_graph ${CMAKE_SOURCE_DIR}/data/points/Klein_bottle_complex.txt 3)
 
 add_executable ( simple_simplex_tree simple_simplex_tree.cpp )
 add_test(simple_simplex_tree ${CMAKE_CURRENT_BINARY_DIR}/simple_simplex_tree)
diff --git a/src/Simplex_tree/example/mini_simplex_tree.cpp b/src/Simplex_tree/example/mini_simplex_tree.cpp
index 08d626d3..7e48aaaf 100644
--- a/src/Simplex_tree/example/mini_simplex_tree.cpp
+++ b/src/Simplex_tree/example/mini_simplex_tree.cpp
@@ -58,11 +58,12 @@ int main() {
 
   auto edge02 = {0, 2};
   ST::Simplex_handle e = st.find(edge02);
-  assert(st.filtration(e) == 0); // We are not using filtrations so everything has value 0
-  for(ST::Simplex_handle t : st.cofaces_simplex_range(e, 1)) // Only coface is 012
-    {
-      for(ST::Vertex_handle v : st.simplex_vertex_range(t)) // v in { 0, 1, 2 }
+  // We are not using filtrations so everything has value 0
+  assert(st.filtration(e) == 0);
+  for (ST::Simplex_handle t : st.cofaces_simplex_range(e, 1)) {
+    // Only coface is 012
+    for (ST::Vertex_handle v : st.simplex_vertex_range(t))  // v in { 0, 1, 2 }
         std::cout << v;
       std::cout << '\n';
-    }
+  }
 }
diff --git a/src/Simplex_tree/example/simple_simplex_tree.cpp b/src/Simplex_tree/example/simple_simplex_tree.cpp
index a2e1f0e9..5146b906 100644
--- a/src/Simplex_tree/example/simple_simplex_tree.cpp
+++ b/src/Simplex_tree/example/simple_simplex_tree.cpp
@@ -20,9 +20,12 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <gudhi/graph_simplicial_complex.h>
+#include <gudhi/Simplex_tree.h>
+
 #include <iostream>
-#include "gudhi/graph_simplicial_complex.h"
-#include "gudhi/Simplex_tree.h"
+#include <utility>  // for pair
+#include <vector>
 
 using namespace Gudhi;
 
@@ -38,7 +41,7 @@ int main(int argc, char * const argv[]) {
   // TEST OF INSERTION
   std::cout << "********************************************************************" << std::endl;
   std::cout << "EXAMPLE OF SIMPLE INSERTION" << std::endl;
-  //Construct the Simplex Tree
+  // Construct the Simplex Tree
   Simplex_tree<> simplexTree;
 
   /* Simplex to be inserted:  */
@@ -159,8 +162,8 @@ int main(int argc, char * const argv[]) {
   // ++ TENTH
   std::cout << "   * INSERT 0 (already inserted)" << std::endl;
   typeVectorVertex tenthSimplexVector = { 0 };
-  returnValue =
-      simplexTree.insert_simplex(tenthSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE)); // With a different filtration value
+  // With a different filtration value
+  returnValue = simplexTree.insert_simplex(tenthSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + 0 INSERTED" << std::endl;
@@ -181,18 +184,18 @@ int main(int argc, char * const argv[]) {
   }
 
   // ++ GENERAL VARIABLE SET
-  simplexTree.set_filtration(FOURTH_FILTRATION_VALUE); // Max filtration value
-  simplexTree.set_dimension(2); // Max dimension = 2 -> (2,1,0)
+  simplexTree.set_filtration(FOURTH_FILTRATION_VALUE);  // Max filtration value
+  simplexTree.set_dimension(2);  // Max dimension = 2 -> (2,1,0)
 
-  std::cout << "********************************************************************" << std::endl;
+  std::cout << "********************************************************************\n";
   // Display the Simplex_tree - Can not be done in the middle of 2 inserts
-  std::cout << "* The complex contains " << simplexTree.num_simplices() << " simplices" << std::endl;
-  std::cout << "   - dimension " << simplexTree.dimension() << "   - filtration " << simplexTree.filtration() << std::endl;
-  std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+  std::cout << "* The complex contains " << simplexTree.num_simplices() << " simplices\n";
+  std::cout << "   - dimension " << simplexTree.dimension() << "   - filtration " << simplexTree.filtration() << "\n";
+  std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
   for (auto f_simplex : simplexTree.filtration_simplex_range()) {
     std::cout << "   " << "[" << simplexTree.filtration(f_simplex) << "] ";
     for (auto vertex : simplexTree.simplex_vertex_range(f_simplex)) {
-      std::cout << (int) vertex << " ";
+      std::cout << static_cast<int>(vertex) << " ";
     }
     std::cout << std::endl;
   }
diff --git a/src/Simplex_tree/example/simplex_tree_from_alpha_shapes_3.cpp b/src/Simplex_tree/example/simplex_tree_from_alpha_shapes_3.cpp
index 5f797e93..45efe3ed 100644
--- a/src/Simplex_tree/example/simplex_tree_from_alpha_shapes_3.cpp
+++ b/src/Simplex_tree/example/simplex_tree_from_alpha_shapes_3.cpp
@@ -1,24 +1,28 @@
- /*    This file is part of the Gudhi Library. The Gudhi library
-  *    (Geometric Understanding in Higher Dimensions) is a generic C++
-  *    library for computational topology.
-  *
-  *    Author(s):       Vincent Rouvreau
-  *
-  *    Copyright (C) 2014  INRIA Saclay (France)
-  *
-  *    This program is free software: you can redistribute it and/or modify
-  *    it under the terms of the GNU General Public License as published by
-  *    the Free Software Foundation, either version 3 of the License, or
-  *    (at your option) any later version.
-  *
-  *    This program is distributed in the hope that it will be useful,
-  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
-  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  *    GNU General Public License for more details.
-  *
-  *    You should have received a copy of the GNU General Public License
-  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-  */
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
+ *
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2014  INRIA Saclay (France)
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gudhi/graph_simplicial_complex.h>
+#include <gudhi/Simplex_tree.h>
+#include <boost/variant.hpp>
 
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/Delaunay_triangulation_3.h>
@@ -27,32 +31,34 @@
 
 #include <fstream>
 #include <cmath>
-
-#include "gudhi/graph_simplicial_complex.h"
-#include "gudhi/Simplex_tree.h"
-#include <boost/variant.hpp>
+#include <string>
+#include <tuple>  // for tuple<>
+#include <map>
+#include <utility>  // for pair<>
+#include <list>
+#include <vector>
 
 // Alpha_shape_3 templates type definitions
 typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
-typedef CGAL::Alpha_shape_vertex_base_3<Kernel>             Vb;
-typedef CGAL::Alpha_shape_cell_base_3<Kernel>               Fb;
-typedef CGAL::Triangulation_data_structure_3<Vb,Fb>         Tds;
-typedef CGAL::Delaunay_triangulation_3<Kernel,Tds>          Triangulation_3;
-typedef CGAL::Alpha_shape_3<Triangulation_3>                Alpha_shape_3;
+typedef CGAL::Alpha_shape_vertex_base_3<Kernel> Vb;
+typedef CGAL::Alpha_shape_cell_base_3<Kernel> Fb;
+typedef CGAL::Triangulation_data_structure_3<Vb, Fb> Tds;
+typedef CGAL::Delaunay_triangulation_3<Kernel, Tds> Triangulation_3;
+typedef CGAL::Alpha_shape_3<Triangulation_3> Alpha_shape_3;
 
 // From file type definition
-typedef Kernel::Point_3                                     Point;
+typedef Kernel::Point_3 Point;
 
 // filtration with alpha values needed type definition
 typedef Alpha_shape_3::FT Alpha_value_type;
-typedef CGAL::Object      Object;
+typedef CGAL::Object Object;
 typedef CGAL::Dispatch_output_iterator<
-  CGAL::cpp11::tuple<Object, Alpha_value_type>,
-  CGAL::cpp11::tuple<std::back_insert_iterator< std::vector<Object> >, std::back_insert_iterator< std::vector<Alpha_value_type> >
-                     > > Dispatch;
-typedef Alpha_shape_3::Cell_handle   Cell_handle;
-typedef Alpha_shape_3::Facet         Facet;
-typedef Alpha_shape_3::Edge          Edge;
+CGAL::cpp11::tuple<Object, Alpha_value_type>,
+CGAL::cpp11::tuple<std::back_insert_iterator< std::vector<Object> >,
+    std::back_insert_iterator< std::vector<Alpha_value_type> > > > Dispatch;
+typedef Alpha_shape_3::Cell_handle Cell_handle;
+typedef Alpha_shape_3::Facet Facet;
+typedef Alpha_shape_3::Edge Edge;
 typedef std::list<Alpha_shape_3::Vertex_handle> Vertex_list;
 
 // gudhi type definition
@@ -61,225 +67,209 @@ typedef std::map<Alpha_shape_3::Vertex_handle, Simplex_tree_vertex > Alpha_shape
 typedef std::pair<Alpha_shape_3::Vertex_handle, Simplex_tree_vertex> Alpha_shape_simplex_tree_pair;
 typedef std::vector< Simplex_tree_vertex > Simplex_tree_vector_vertex;
 
-//#define DEBUG_TRACES
-
-Vertex_list from (const Cell_handle& ch)
-{
-	Vertex_list the_list;
-	for (auto i = 0; i < 4; i++)
-	{
+Vertex_list from(const Cell_handle& ch) {
+  Vertex_list the_list;
+  for (auto i = 0; i < 4; i++) {
 #ifdef DEBUG_TRACES
-		std::cout << "from cell[" << i << "]=" << ch->vertex(i)->point() << std::endl;
-#endif // DEBUG_TRACES
-		the_list.push_back(ch->vertex(i));
-	}
-	return the_list;
+    std::cout << "from cell[" << i << "]=" << ch->vertex(i)->point() << std::endl;
+#endif  // DEBUG_TRACES
+    the_list.push_back(ch->vertex(i));
+  }
+  return the_list;
 }
-Vertex_list from (const Facet& fct)
-{
-	Vertex_list the_list;
-	for (auto i = 0; i < 4; i++)
-	{
-		if (fct.second != i)
-		{
+
+Vertex_list from(const Facet& fct) {
+  Vertex_list the_list;
+  for (auto i = 0; i < 4; i++) {
+    if (fct.second != i) {
 #ifdef DEBUG_TRACES
-			std::cout << "from facet=[" << i << "]" << fct.first->vertex(i)->point() << std::endl;
-#endif // DEBUG_TRACES
-			the_list.push_back(fct.first->vertex(i));
-		}
-	}
-	return the_list;
+      std::cout << "from facet=[" << i << "]" << fct.first->vertex(i)->point() << std::endl;
+#endif  // DEBUG_TRACES
+      the_list.push_back(fct.first->vertex(i));
+    }
+  }
+  return the_list;
 }
-Vertex_list from (const Edge& edg)
-{
-	Vertex_list the_list;
-	for (auto i = 0; i < 4; i++)
-	{
-		if ((edg.second == i) ||(edg.third == i))
-		{
+
+Vertex_list from(const Edge& edg) {
+  Vertex_list the_list;
+  for (auto i = 0; i < 4; i++) {
+    if ((edg.second == i) || (edg.third == i)) {
 #ifdef DEBUG_TRACES
-			std::cout << "from edge[" << i << "]=" << edg.first->vertex(i)->point() << std::endl;
-#endif // DEBUG_TRACES
-			the_list.push_back(edg.first->vertex(i));
-		}
-	}
-	return the_list;
+      std::cout << "from edge[" << i << "]=" << edg.first->vertex(i)->point() << std::endl;
+#endif  // DEBUG_TRACES
+      the_list.push_back(edg.first->vertex(i));
+    }
+  }
+  return the_list;
 }
-Vertex_list from (const Alpha_shape_3::Vertex_handle& vh)
-{
-	Vertex_list the_list;
+
+Vertex_list from(const Alpha_shape_3::Vertex_handle& vh) {
+  Vertex_list the_list;
 #ifdef DEBUG_TRACES
-	std::cout << "from vertex=" << vh->point() << std::endl;
-#endif // DEBUG_TRACES
-	the_list.push_back(vh);
-	return the_list;
+  std::cout << "from vertex=" << vh->point() << std::endl;
+#endif  // DEBUG_TRACES
+  the_list.push_back(vh);
+  return the_list;
 }
 
+int main(int argc, char * const argv[]) {
+  // program args management
+  if (argc != 2) {
+    std::cerr << "Usage: " << argv[0]
+        << " path_to_file_graph \n";
+    return 0;
+  }
 
-int main (int argc, char * const argv[])
-{
-	// program args management
-	if (argc != 2) {
-		std::cerr << "Usage: " << argv[0]
-		                               << " path_to_file_graph \n";
-		return 0; // ----- >>
-	}
-
-	// Read points from file
-	std::string filegraph   = argv[1];
-	std::list<Point> lp;
-	std::ifstream is(filegraph.c_str());
-	int n;
-	is >> n;
+  // Read points from file
+  std::string filegraph = argv[1];
+  std::list<Point> lp;
+  std::ifstream is(filegraph.c_str());
+  int n;
+  is >> n;
 #ifdef DEBUG_TRACES
-	std::cout << "Reading " << n << " points " << std::endl;
-#endif // DEBUG_TRACES
-	Point p;
-	for( ; n>0 ; n--)    {
-		is >> p;
-		lp.push_back(p);
-	}
+  std::cout << "Reading " << n << " points " << std::endl;
+#endif  // DEBUG_TRACES
+  Point p;
+  for (; n > 0; n--) {
+    is >> p;
+    lp.push_back(p);
+  }
 
-	// alpha shape construction from points. CGAL has a strange behavior in REGULARIZED mode.
-	Alpha_shape_3 as(lp.begin(),lp.end(),0,Alpha_shape_3::GENERAL);
+  // alpha shape construction from points. CGAL has a strange behavior in REGULARIZED mode.
+  Alpha_shape_3 as(lp.begin(), lp.end(), 0, Alpha_shape_3::GENERAL);
 #ifdef DEBUG_TRACES
-	std::cout << "Alpha shape computed in GENERAL mode" << std::endl;
-#endif // DEBUG_TRACES
+  std::cout << "Alpha shape computed in GENERAL mode" << std::endl;
+#endif  // DEBUG_TRACES
 
-	// filtration with alpha values from alpha shape
-	std::vector<Object> the_objects;
-	std::vector<Alpha_value_type> the_alpha_values;
+  // filtration with alpha values from alpha shape
+  std::vector<Object> the_objects;
+  std::vector<Alpha_value_type> the_alpha_values;
 
-	Dispatch disp = CGAL::dispatch_output<Object, Alpha_value_type>( std::back_inserter(the_objects), std::back_inserter(the_alpha_values));
+  Dispatch disp = CGAL::dispatch_output<Object, Alpha_value_type>(std::back_inserter(the_objects),
+      std::back_inserter(the_alpha_values));
 
-	as.filtration_with_alpha_values(disp);
+  as.filtration_with_alpha_values(disp);
 #ifdef DEBUG_TRACES
-	std::cout << "filtration_with_alpha_values returns : " << the_objects.size() << " objects" << std::endl;
-#endif // DEBUG_TRACES
+  std::cout << "filtration_with_alpha_values returns : " << the_objects.size() << " objects" << std::endl;
+#endif  // DEBUG_TRACES
 
-	Alpha_shape_3::size_type count_vertices = 0;
-	Alpha_shape_3::size_type count_edges    = 0;
-	Alpha_shape_3::size_type count_facets   = 0;
-	Alpha_shape_3::size_type count_cells    = 0;
+  Alpha_shape_3::size_type count_vertices = 0;
+  Alpha_shape_3::size_type count_edges = 0;
+  Alpha_shape_3::size_type count_facets = 0;
+  Alpha_shape_3::size_type count_cells = 0;
 
-	// Loop on objects vector
-	Vertex_list vertex_list;
-	Gudhi::Simplex_tree<> simplex_tree;
-	Alpha_shape_simplex_tree_map map_cgal_simplex_tree;
-	std::vector<Alpha_value_type>::iterator the_alpha_value_iterator = the_alpha_values.begin();
-	for(auto object_iterator: the_objects)
-	{
-		// Retrieve Alpha shape vertex list from object
-		if (const Cell_handle* cell = CGAL::object_cast<Cell_handle>(&object_iterator))
-		{
-			vertex_list = from(*cell);
-			count_cells++;
-		}
-		else if (const Facet* facet = CGAL::object_cast<Facet>(&object_iterator))
-		{
-			vertex_list = from(*facet);
-			count_facets++;
-		}
-		else if (const Edge* edge = CGAL::object_cast<Edge>(&object_iterator))
-		{
-			vertex_list = from(*edge);
-			count_edges++;
-		}
-		else if (const Alpha_shape_3::Vertex_handle* vertex = CGAL::object_cast<Alpha_shape_3::Vertex_handle>(&object_iterator))
-		{
-			count_vertices++;
-			vertex_list = from(*vertex);
-		}
-		// Construction of the vector of simplex_tree vertex from list of alpha_shapes vertex
-		Simplex_tree_vector_vertex the_simplex_tree;
-		for (auto the_alpha_shape_vertex:vertex_list)
-		{
-			Alpha_shape_simplex_tree_map::iterator the_map_iterator = map_cgal_simplex_tree.find(the_alpha_shape_vertex);
-			if (the_map_iterator == map_cgal_simplex_tree.end())
-			{
-				// alpha shape not found
-				Simplex_tree_vertex vertex = map_cgal_simplex_tree.size();
+  // Loop on objects vector
+  Vertex_list vertex_list;
+  Gudhi::Simplex_tree<> simplex_tree;
+  Alpha_shape_simplex_tree_map map_cgal_simplex_tree;
+  std::vector<Alpha_value_type>::iterator the_alpha_value_iterator = the_alpha_values.begin();
+  for (auto object_iterator : the_objects) {
+    // Retrieve Alpha shape vertex list from object
+    if (const Cell_handle * cell = CGAL::object_cast<Cell_handle>(&object_iterator)) {
+      vertex_list = from(*cell);
+      count_cells++;
+    } else if (const Facet * facet = CGAL::object_cast<Facet>(&object_iterator)) {
+      vertex_list = from(*facet);
+      count_facets++;
+    } else if (const Edge * edge = CGAL::object_cast<Edge>(&object_iterator)) {
+      vertex_list = from(*edge);
+      count_edges++;
+    } else if (const Alpha_shape_3::Vertex_handle * vertex =
+              CGAL::object_cast<Alpha_shape_3::Vertex_handle>(&object_iterator)) {
+      count_vertices++;
+      vertex_list = from(*vertex);
+    }
+    // Construction of the vector of simplex_tree vertex from list of alpha_shapes vertex
+    Simplex_tree_vector_vertex the_simplex_tree;
+    for (auto the_alpha_shape_vertex : vertex_list) {
+      Alpha_shape_simplex_tree_map::iterator the_map_iterator = map_cgal_simplex_tree.find(the_alpha_shape_vertex);
+      if (the_map_iterator == map_cgal_simplex_tree.end()) {
+        // alpha shape not found
+        Simplex_tree_vertex vertex = map_cgal_simplex_tree.size();
 #ifdef DEBUG_TRACES
-				std::cout << "vertex [" << the_alpha_shape_vertex->point() << "] not found - insert_simplex " << vertex << std::endl;
-#endif // DEBUG_TRACES
-				the_simplex_tree.push_back(vertex);
-				map_cgal_simplex_tree.insert(Alpha_shape_simplex_tree_pair(the_alpha_shape_vertex,vertex));
-			} else
-			{
-				// alpha shape found
-				Simplex_tree_vertex vertex = the_map_iterator->second;
+        std::cout << "vertex [" << the_alpha_shape_vertex->point() << "] not found - insert_simplex " << vertex << "\n";
+#endif  // DEBUG_TRACES
+        the_simplex_tree.push_back(vertex);
+        map_cgal_simplex_tree.insert(Alpha_shape_simplex_tree_pair(the_alpha_shape_vertex, vertex));
+      } else {
+        // alpha shape found
+        Simplex_tree_vertex vertex = the_map_iterator->second;
 #ifdef DEBUG_TRACES
-				std::cout << "vertex [" << the_alpha_shape_vertex->point() << "] found in " << vertex << std::endl;
-#endif // DEBUG_TRACES
-				the_simplex_tree.push_back(vertex);
-			}
-		}
-		// Construction of the simplex_tree
+        std::cout << "vertex [" << the_alpha_shape_vertex->point() << "] found in " << vertex << std::endl;
+#endif  // DEBUG_TRACES
+        the_simplex_tree.push_back(vertex);
+      }
+    }
+    // Construction of the simplex_tree
 #ifdef DEBUG_TRACES
-		std::cout << "filtration = " << *the_alpha_value_iterator << std::endl;
-#endif // DEBUG_TRACES
-		simplex_tree.insert_simplex(the_simplex_tree, std::sqrt(*the_alpha_value_iterator));
-		if (the_alpha_value_iterator != the_alpha_values.end())
-			++the_alpha_value_iterator;
-		else
-			std::cout << "This shall not happen" << std::endl;
-	}
+    std::cout << "filtration = " << *the_alpha_value_iterator << std::endl;
+#endif  // DEBUG_TRACES
+    simplex_tree.insert_simplex(the_simplex_tree, std::sqrt(*the_alpha_value_iterator));
+    if (the_alpha_value_iterator != the_alpha_values.end())
+      ++the_alpha_value_iterator;
+    else
+      std::cerr << "This shall not happen" << std::endl;
+  }
 #ifdef DEBUG_TRACES
-	std::cout << "vertices \t\t" << count_vertices << std::endl;
-	std::cout << "edges \t\t"    << count_edges << std::endl;
-	std::cout << "facets \t\t"   << count_facets << std::endl;
-	std::cout << "cells \t\t"    << count_cells << std::endl;
+  std::cout << "vertices \t\t" << count_vertices << std::endl;
+  std::cout << "edges \t\t" << count_edges << std::endl;
+  std::cout << "facets \t\t" << count_facets << std::endl;
+  std::cout << "cells \t\t" << count_cells << std::endl;
 
 
-	std::cout << "Information of the Simplex Tree: " << std::endl;
-	std::cout << "  Number of vertices = " << simplex_tree.num_vertices() << " ";
-	std::cout << "  Number of simplices = " << simplex_tree.num_simplices() << std::endl << std::endl;
-#endif // DEBUG_TRACES
+  std::cout << "Information of the Simplex Tree:\n";
+  std::cout << "  Number of vertices = " << simplex_tree.num_vertices() << " ";
+  std::cout << "  Number of simplices = " << simplex_tree.num_simplices() << std::endl << std::endl;
+#endif  // DEBUG_TRACES
 
 #ifdef DEBUG_TRACES
-	std::cout << "Iterator on vertices: " << std::endl;
-	for( auto vertex : simplex_tree.complex_vertex_range() )
-	{ std::cout << vertex << " "; }
-#endif // DEBUG_TRACES
+  std::cout << "Iterator on vertices: \n";
+  for (auto vertex : simplex_tree.complex_vertex_range()) {
+    std::cout << vertex << " ";
+  }
+#endif  // DEBUG_TRACES
 
-	std::cout << simplex_tree << std::endl;
+  std::cout << simplex_tree << std::endl;
 
 #ifdef DEBUG_TRACES
-	std::cout << std::endl << std::endl << "Iterator on simplices: " << std::endl;
-	for( auto simplex : simplex_tree.complex_simplex_range() )
-	{
-		std::cout << "   ";
-		for( auto vertex : simplex_tree.simplex_vertex_range(simplex) ) { std::cout << vertex << " "; }
-		std::cout << std::endl;
-	}
-#endif // DEBUG_TRACES
+  std::cout << std::endl << std::endl << "Iterator on simplices:\n";
+  for (auto simplex : simplex_tree.complex_simplex_range()) {
+    std::cout << "   ";
+    for (auto vertex : simplex_tree.simplex_vertex_range(simplex)) {
+      std::cout << vertex << " ";
+    }
+    std::cout << std::endl;
+  }
+#endif  // DEBUG_TRACES
 #ifdef DEBUG_TRACES
-	std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
-	for( auto f_simplex : simplex_tree.filtration_simplex_range() )
-	{ std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
-	for( auto vertex : simplex_tree.simplex_vertex_range(f_simplex) )
-	{ std::cout << vertex << " "; }
-	std::cout << std::endl;
-	}
-#endif // DEBUG_TRACES
+  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:\n";
+  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
+    std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex)) {
+      std::cout << vertex << " ";
+    }
+    std::cout << std::endl;
+  }
+#endif  // DEBUG_TRACES
 #ifdef DEBUG_TRACES
-	std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, and their boundary simplices:" << std::endl;
-	for( auto f_simplex : simplex_tree.filtration_simplex_range() )
-	{
-		std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
-		for( auto vertex : simplex_tree.simplex_vertex_range(f_simplex) )
-		{ std::cout << vertex << " "; }
-		std::cout << std::endl;
+  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, and their boundary simplices:\n";
+  for (auto f_simplex : simplex_tree.filtration_simplex_range()) {
+    std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+    for (auto vertex : simplex_tree.simplex_vertex_range(f_simplex)) {
+      std::cout << vertex << " ";
+    }
+    std::cout << std::endl;
 
-		for( auto b_simplex : simplex_tree.boundary_simplex_range(f_simplex) )
-		{
-			std::cout << "      " << "[" << simplex_tree.filtration(b_simplex) << "] ";
-			for( auto vertex : simplex_tree.simplex_vertex_range(b_simplex) )
-			{ std::cout << vertex << " "; }
-			std::cout << std::endl;
-		}
-	}
-#endif // DEBUG_TRACES
+    for (auto b_simplex : simplex_tree.boundary_simplex_range(f_simplex)) {
+      std::cout << "      " << "[" << simplex_tree.filtration(b_simplex) << "] ";
+      for (auto vertex : simplex_tree.simplex_vertex_range(b_simplex)) {
+        std::cout << vertex << " ";
+      }
+      std::cout << std::endl;
+    }
+  }
+#endif  // DEBUG_TRACES
 
-	return 0;
+  return 0;
 }
diff --git a/src/Simplex_tree/example/simplex_tree_from_cliques_of_graph.cpp b/src/Simplex_tree/example/simplex_tree_from_cliques_of_graph.cpp
new file mode 100644
index 00000000..58085014
--- /dev/null
+++ b/src/Simplex_tree/example/simplex_tree_from_cliques_of_graph.cpp
@@ -0,0 +1,114 @@
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
+ *
+ *    Author(s):       Clément Maria
+ *
+ *    Copyright (C) 2014  INRIA Sophia Antipolis-Méditerranée (France)
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gudhi/reader_utils.h>
+#include <gudhi/Simplex_tree.h>
+
+#include <iostream>
+#include <ctime>
+#include <string>
+
+using namespace Gudhi;
+
+int main(int argc, char * const argv[]) {
+  if (argc != 3) {
+    std::cerr << "Usage: " << argv[0]
+        << " path_to_file_graph max_dim \n";
+    return 0;
+  }
+  std::string filegraph = argv[1];
+  int max_dim = atoi(argv[2]);
+
+  clock_t start, end;
+  // Construct the Simplex Tree
+  Simplex_tree<> st;
+
+  start = clock();
+  auto g = read_graph(filegraph);
+  // insert the graph in the simplex tree as 1-skeleton
+  st.insert_graph(g);
+  end = clock();
+  std::cout << "Insert the 1-skeleton in the simplex tree in "
+      << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
+
+  start = clock();
+  // expand the 1-skeleton until dimension max_dim
+  st.expansion(max_dim);
+  end = clock();
+  std::cout << "max_dim = " << max_dim << "\n";
+  std::cout << "Expand the simplex tree in "
+      << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
+
+  std::cout << "Information of the Simplex Tree: " << std::endl;
+  std::cout << "  Number of vertices = " << st.num_vertices() << " ";
+  std::cout << "  Number of simplices = " << st.num_simplices() << std::endl;
+  std::cout << std::endl << std::endl;
+
+  std::cout << "Iterator on vertices: ";
+  for (auto vertex : st.complex_vertex_range()) {
+    std::cout << vertex << " ";
+  }
+
+  std::cout << std::endl;
+
+  std::cout << std::endl << std::endl;
+
+  std::cout << "Iterator on simplices: " << std::endl;
+  for (auto simplex : st.complex_simplex_range()) {
+    std::cout << "   ";
+    for (auto vertex : st.simplex_vertex_range(simplex)) {
+      std::cout << vertex << " ";
+    }
+    std::cout << std::endl;
+  }
+
+  std::cout << std::endl << 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 << vertex << " ";
+    }
+    std::cout << std::endl;
+  }
+
+  std::cout << std::endl << std::endl;
+
+  std::cout << "Iterator on Simplices in the filtration, and their boundary simplices:" << 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 << vertex << " ";
+    }
+    std::cout << std::endl;
+
+    for (auto b_simplex : st.boundary_simplex_range(f_simplex)) {
+      std::cout << "      " << "[" << st.filtration(b_simplex) << "] ";
+      for (auto vertex : st.simplex_vertex_range(b_simplex)) {
+        std::cout << vertex << " ";
+      }
+      std::cout << std::endl;
+    }
+  }
+  return 0;
+}
diff --git a/src/Simplex_tree/example/simplex_tree_from_file.cpp b/src/Simplex_tree/example/simplex_tree_from_file.cpp
deleted file mode 100644
index 20e8f067..00000000
--- a/src/Simplex_tree/example/simplex_tree_from_file.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
- /*    This file is part of the Gudhi Library. The Gudhi library
-  *    (Geometric Understanding in Higher Dimensions) is a generic C++
-  *    library for computational topology.
-  *
-  *    Author(s):       Clément Maria
-  *
-  *    Copyright (C) 2014  INRIA Sophia Antipolis-Méditerranée (France)
-  *
-  *    This program is free software: you can redistribute it and/or modify
-  *    it under the terms of the GNU General Public License as published by
-  *    the Free Software Foundation, either version 3 of the License, or
-  *    (at your option) any later version.
-  *
-  *    This program is distributed in the hope that it will be useful,
-  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
-  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  *    GNU General Public License for more details.
-  *
-  *    You should have received a copy of the GNU General Public License
-  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-  */
-
-#include <iostream>
-#include <ctime>
-#include "gudhi/reader_utils.h"
-#include "gudhi/Simplex_tree.h"
-
-using namespace Gudhi;
-
-int main (int argc, char * const argv[])
-{
-  if (argc != 3) {
-    std::cerr << "Usage: " << argv[0]
-      << " path_to_file_graph max_dim \n";
-    return 0;
-  }
-  std::string filegraph   = argv[1];
-  int max_dim       = atoi(argv[2]);
-
-  clock_t start, end;
-  //Construct the Simplex Tree
-  Simplex_tree<> st;
-
-  start = clock();
-  auto g = read_graph(filegraph);
-  st.insert_graph (g); //insert the graph in the simplex tree as 1-skeleton
-  end = clock();
-  std::cout << "Insert the 1-skeleton in the simplex tree in "
-       << (double)(end-start)/CLOCKS_PER_SEC << " s. \n";
-
-  start = clock();
-  st.expansion ( max_dim ); //expand the 1-skeleton until dimension max_dim
-  end = clock();
-  std::cout << "max_dim = " << max_dim << "\n";
-  std::cout << "Expand the simplex tree in "
-       << (double)(end-start)/CLOCKS_PER_SEC << " s. \n";
-
-  std::cout << "Information of the Simplex Tree: " << std::endl;
-  std::cout << "  Number of vertices = " << st.num_vertices() << " ";
-  std::cout << "  Number of simplices = " << st.num_simplices() << std::endl;
-  std::cout << std::endl << std::endl;
-
-  std::cout << "Iterator on vertices: ";
-    for( auto vertex : st.complex_vertex_range() ) { std::cout << vertex << " "; }
-
-  std::cout << std::endl;
-
-  std::cout << std::endl << std::endl;
-
-  std::cout << "Iterator on simplices: " << std::endl;
-  for( auto simplex : st.complex_simplex_range() )
-  {
-    std::cout << "   ";
-    for( auto vertex : st.simplex_vertex_range(simplex) ) { std::cout << vertex << " "; }
-    std::cout << std::endl;
-  }
-
-  std::cout << std::endl << 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 << vertex << " "; } std::cout << std::endl;
-  }
-
-  std::cout << std::endl << std::endl;
-
-  std::cout << "Iterator on Simplices in the filtration, and their boundary simplices:" << 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 << vertex << " "; } std::cout << std::endl;
-
-    for( auto b_simplex : st.boundary_simplex_range(f_simplex) )
-    {
-      std::cout << "      " << "[" << st.filtration(b_simplex) << "] ";
-    for( auto vertex : st.simplex_vertex_range(b_simplex) )
-      { std::cout << vertex << " "; } std::cout << std::endl;
-    }
-  }
-  return 0;
-}
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h
index 6a47083c..c7a0b5d5 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h
@@ -119,7 +119,9 @@ class Simplex_tree {
   /* Type of node in the simplex tree. */
   typedef Simplex_tree_node_explicit_storage<Simplex_tree> Node;
   /* Type of dictionary Vertex_handle -> Node for traversing the simplex tree. */
-  // Note: this wastes space when Vertex_handle is 32 bits and Node is aligned on 64 bits. It would be better to use a flat_set (with our own comparator) where we can control the layout of the struct (put Vertex_handle and Simplex_key next to each other).
+  // Note: this wastes space when Vertex_handle is 32 bits and Node is aligned on 64 bits. It would be better to use a
+  // flat_set (with our own comparator) where we can control the layout of the struct (put Vertex_handle and
+  // Simplex_key next to each other).
   typedef typename boost::container::flat_map<Vertex_handle, Node> Dictionary;
 
   /* \brief Set of nodes sharing a same parent in the simplex tree. */
@@ -130,7 +132,7 @@ class Simplex_tree {
     Key_simplex_base_real() : key_(-1) {}
     void assign_key(Simplex_key k) { key_ = k; }
     Simplex_key key() const { return key_; }
-    private:
+   private:
     Simplex_key key_;
   };
   struct Key_simplex_base_dummy {
@@ -144,7 +146,7 @@ class Simplex_tree {
     Filtration_simplex_base_real() : filt_(0) {}
     void assign_filtration(Filtration_value f) { filt_ = f; }
     Filtration_value filtration() const { return filt_; }
-    private:
+   private:
     Filtration_value filt_;
   };
   struct Filtration_simplex_base_dummy {
@@ -152,7 +154,8 @@ class Simplex_tree {
     void assign_filtration(Filtration_value f) { assert(f == 0); }
     Filtration_value filtration() const { return 0; }
   };
-  typedef typename std::conditional<Options::store_filtration, Filtration_simplex_base_real, Filtration_simplex_base_dummy>::type Filtration_simplex_base;
+  typedef typename std::conditional<Options::store_filtration, Filtration_simplex_base_real,
+    Filtration_simplex_base_dummy>::type Filtration_simplex_base;
 
  public:
   /** \brief Handle type to a simplex contained in the simplicial complex represented
@@ -270,7 +273,7 @@ class Simplex_tree {
    * The filtration must be valid. If the filtration has not been initialized yet, the
    * method initializes it (i.e. order the simplices). If the complex has changed since the last time the filtration
    * was initialized, please call `initialize_filtration()` to recompute it. */
-  Filtration_simplex_range const& filtration_simplex_range(Indexing_tag=Indexing_tag()) {
+  Filtration_simplex_range const& filtration_simplex_range(Indexing_tag = Indexing_tag()) {
     if (filtration_vect_.empty()) {
       initialize_filtration();
     }
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 06462c88..372ef329 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
@@ -20,10 +20,14 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_SIMPLEX_TREE_ITERATORS_H_
-#define SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_SIMPLEX_TREE_ITERATORS_H_
+#ifndef SIMPLEX_TREE_SIMPLEX_TREE_ITERATORS_H_
+#define SIMPLEX_TREE_SIMPLEX_TREE_ITERATORS_H_
 
 #include <boost/iterator/iterator_facade.hpp>
+#include <boost/version.hpp>
+#if BOOST_VERSION >= 105600
+# include <boost/container/static_vector.hpp>
+#endif
 
 #include <vector>
 
@@ -131,8 +135,7 @@ class Simplex_tree_boundary_simplex_iterator : public boost::iterator_facade<
     }
 
     Siblings * for_sib = sib_;
-    for (typename std::vector<Vertex_handle>::reverse_iterator rit = suffix_
-        .rbegin(); rit != suffix_.rend(); ++rit) {
+    for (auto rit = suffix_.rbegin(); rit != suffix_.rend(); ++rit) {
       sh_ = for_sib->find(*rit);
       for_sib = sh_->second.children();
     }
@@ -142,9 +145,18 @@ class Simplex_tree_boundary_simplex_iterator : public boost::iterator_facade<
     sib_ = sib_->oncles();
   }
 
+  // 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
@@ -303,4 +315,4 @@ class Simplex_tree_skeleton_simplex_iterator : public boost::iterator_facade<
 /* @} */  // end addtogroup simplex_tree
 }  // namespace Gudhi
 
-#endif  // SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_SIMPLEX_TREE_ITERATORS_H_
+#endif  // SIMPLEX_TREE_SIMPLEX_TREE_ITERATORS_H_
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_node_explicit_storage.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_node_explicit_storage.h
index c49e30b9..25d4888a 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_node_explicit_storage.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_node_explicit_storage.h
@@ -20,8 +20,8 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_SIMPLEX_TREE_NODE_EXPLICIT_STORAGE_H_
-#define SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_SIMPLEX_TREE_NODE_EXPLICIT_STORAGE_H_
+#ifndef SIMPLEX_TREE_SIMPLEX_TREE_NODE_EXPLICIT_STORAGE_H_
+#define SIMPLEX_TREE_SIMPLEX_TREE_NODE_EXPLICIT_STORAGE_H_
 
 #include <vector>
 
@@ -47,7 +47,7 @@ struct Simplex_tree_node_explicit_storage : SimplexTree::Filtration_simplex_base
   Simplex_tree_node_explicit_storage(Siblings * sib = nullptr,
                                      Filtration_value filtration = 0)
       : children_(sib) {
-	  this->assign_filtration(filtration);
+    this->assign_filtration(filtration);
   }
 
   /*
@@ -69,4 +69,4 @@ struct Simplex_tree_node_explicit_storage : SimplexTree::Filtration_simplex_base
 /* @} */  // end addtogroup simplex_tree
 }  // namespace Gudhi
 
-#endif  // SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_SIMPLEX_TREE_NODE_EXPLICIT_STORAGE_H_
+#endif  // SIMPLEX_TREE_SIMPLEX_TREE_NODE_EXPLICIT_STORAGE_H_
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_siblings.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_siblings.h
index d20a91d7..158ee1f7 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_siblings.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_siblings.h
@@ -20,11 +20,12 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_SIMPLEX_TREE_SIBLINGS_H_
-#define SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_SIMPLEX_TREE_SIBLINGS_H_
+#ifndef SIMPLEX_TREE_SIMPLEX_TREE_SIBLINGS_H_
+#define SIMPLEX_TREE_SIMPLEX_TREE_SIBLINGS_H_
 
-#include "boost/container/flat_map.hpp"
-#include "Simplex_tree_node_explicit_storage.h"
+#include <gudhi/Simplex_tree/Simplex_tree_node_explicit_storage.h>
+
+#include <boost/container/flat_map.hpp>
 
 #include <utility>
 #include <vector>
@@ -79,7 +80,7 @@ class Simplex_tree_siblings {
                  members.end()) {
     for (auto& map_el : members_) {
       map_el.second.assign_children(this);
-	}
+    }
   }
 
   /*
@@ -123,4 +124,4 @@ class Simplex_tree_siblings {
 /* @} */  // end addtogroup simplex_tree
 }  // namespace Gudhi
 
-#endif  // SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_SIMPLEX_TREE_SIBLINGS_H_
+#endif  // SIMPLEX_TREE_SIMPLEX_TREE_SIBLINGS_H_
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/indexing_tag.h b/src/Simplex_tree/include/gudhi/Simplex_tree/indexing_tag.h
index 69ffa44b..0adeb46d 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree/indexing_tag.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree/indexing_tag.h
@@ -20,8 +20,8 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_INDEXING_TAG_H_
-#define SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_INDEXING_TAG_H_
+#ifndef SIMPLEX_TREE_INDEXING_TAG_H_
+#define SIMPLEX_TREE_INDEXING_TAG_H_
 
 namespace Gudhi {
 
@@ -36,4 +36,4 @@ struct linear_indexing_tag {
 //  struct zigzag_indexing_tag {};
 }  // namespace Gudhi
 
-#endif  // SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_INDEXING_TAG_H_
+#endif  // SIMPLEX_TREE_INDEXING_TAG_H_
diff --git a/src/Simplex_tree/test/CMakeLists.txt b/src/Simplex_tree/test/CMakeLists.txt
index b6a1c0b6..c9eae163 100644
--- a/src/Simplex_tree/test/CMakeLists.txt
+++ b/src/Simplex_tree/test/CMakeLists.txt
@@ -17,6 +17,9 @@ endif()
 add_executable ( SimplexTreeUT simplex_tree_unit_test.cpp )
 target_link_libraries(SimplexTreeUT ${Boost_SYSTEM_LIBRARY} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 
+# Do not forget to copy test files in current binary dir
+file(COPY "simplex_tree_for_unit_test.txt" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
+
 # Unitary tests
 add_test(NAME SimplexTreeUT
   COMMAND ${CMAKE_CURRENT_BINARY_DIR}/SimplexTreeUT 
diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
index a4871cfd..00cf69bc 100644
--- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
@@ -108,6 +108,7 @@ BOOST_AUTO_TEST_CASE(simplex_tree_from_file) {
     // Size of simplex
     int size = 0;
     for (auto vertex : st.simplex_vertex_range(f_simplex)) {
+      // Remove warning
       (void) vertex;
       size++;
     }
@@ -164,6 +165,8 @@ void set_and_test_simplex_tree_dim_fil(typeST& simplexTree, int vectorSize, cons
   // Another way to count simplices:
   size_t num_simp = 0;
   for (auto f_simplex : simplexTree.complex_simplex_range()) {
+    // Remove warning
+    (void) f_simplex;
     num_simp++;
   }