cpplint fixes

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

Former-commit-id: 1cab7ed83b02fd90ab57550ad5363dc36f8b8d05

8 files changed, 312 insertions, 308 deletions

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_file.cpp b/src/Simplex_tree/example/simplex_tree_from_file.cpp
index 20e8f067..58085014 100644
--- a/src/Simplex_tree/example/simplex_tree_from_file.cpp
+++ b/src/Simplex_tree/example/simplex_tree_from_file.cpp
@@ -1,59 +1,62 @@
- /*    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/>.
-  */
+/*    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 "gudhi/reader_utils.h"
-#include "gudhi/Simplex_tree.h"
+#include <string>
 
 using namespace Gudhi;
 
-int main (int argc, char * const argv[])
-{
+int main(int argc, char * const argv[]) {
   if (argc != 3) {
     std::cerr << "Usage: " << argv[0]
-      << " path_to_file_graph max_dim \n";
+        << " path_to_file_graph max_dim \n";
     return 0;
   }
-  std::string filegraph   = argv[1];
-  int max_dim       = atoi(argv[2]);
+  std::string filegraph = argv[1];
+  int max_dim = atoi(argv[2]);
 
   clock_t start, end;
-  //Construct the Simplex Tree
+  // 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
+  // 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 "
-       << (double)(end-start)/CLOCKS_PER_SEC << " s. \n";
+      << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
 
   start = clock();
-  st.expansion ( max_dim ); //expand the 1-skeleton until dimension max_dim
+  // 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 "
-       << (double)(end-start)/CLOCKS_PER_SEC << " s. \n";
+      << 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() << " ";
@@ -61,43 +64,50 @@ int main (int argc, char * const argv[])
   std::cout << std::endl << std::endl;
 
   std::cout << "Iterator on vertices: ";
-    for( auto vertex : st.complex_vertex_range() ) { std::cout << vertex << " "; }
+  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() )
-  {
+  for (auto simplex : st.complex_simplex_range()) {
     std::cout << "   ";
-    for( auto vertex : st.simplex_vertex_range(simplex) ) { std::cout << vertex << " "; }
+    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;
+  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() )
-  {
+  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 vertex : st.simplex_vertex_range(f_simplex)) {
+      std::cout << vertex << " ";
+    }
+    std::cout << std::endl;
 
-    for( auto b_simplex : st.boundary_simplex_range(f_simplex) )
-    {
+    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;
+      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/Simplex_tree_iterators.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h
index 06462c88..8cf5a67e 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,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_ITERATORS_H_
-#define SRC_SIMPLEX_TREE_INCLUDE_GUDHI_SIMPLEX_TREE_SIMPLEX_TREE_ITERATORS_H_
+#ifndef SIMPLEX_TREE_ITERATORS_H_
+#define SIMPLEX_TREE_ITERATORS_H_
 
 #include <boost/iterator/iterator_facade.hpp>
 
@@ -303,4 +303,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_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..7f735b7e 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_NODE_EXPLICIT_STORAGE_H_
+#define 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_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..52eeaaea 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,15 +20,15 @@
  *    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_
-
-#include "boost/container/flat_map.hpp"
-#include "Simplex_tree_node_explicit_storage.h"
+#ifndef SIMPLEX_TREE_SIBLINGS_H_
+#define SIMPLEX_TREE_SIBLINGS_H_
 
 #include <utility>
 #include <vector>
 
+#include "boost/container/flat_map.hpp"
+#include "Simplex_tree_node_explicit_storage.h"
+
 namespace Gudhi {
 
 /* \addtogroup simplex_tree
@@ -79,7 +79,7 @@ class Simplex_tree_siblings {
                  members.end()) {
     for (auto& map_el : members_) {
       map_el.second.assign_children(this);
-	}
+    }
   }
 
   /*
@@ -123,4 +123,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_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..a00dac27 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 INDEXING_TAG_H_
+#define 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  // INDEXING_TAG_H_