Fix cpplint and warnings

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

Former-commit-id: afc7d137b66225954ebfe37a823f1f0b6bcfe7a5

28 files changed, 458 insertions, 454 deletions

diff --git a/src/Skeleton_blocker/concept/SkeletonBlockerDS.h b/src/Skeleton_blocker/concept/SkeletonBlockerDS.h
index 3c650f99..d82425a0 100644
--- a/src/Skeleton_blocker/concept/SkeletonBlockerDS.h
+++ b/src/Skeleton_blocker/concept/SkeletonBlockerDS.h
@@ -1,128 +1,129 @@
-/*
- * SkeletonBlockerDS.h
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
  *
- *  Created on: Feb 20, 2014 
- *      Author: David Salinas
- *  Copyright 2013 INRIA. All rights reserved
+ *    Author(s):       David Salinas
+ *
+ *    Copyright (C) 2014  INRIA
+ *
+ *    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/>.
  */
 
-#ifndef GUDHI_SKELETONBLOCKERDS_H_
-#define GUDHI_SKELETONBLOCKERDS_H_
-
+#ifndef CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERDS_H_
+#define CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERDS_H_
 
 namespace Gudhi {
 
 namespace skeleton_blocker {
 
-
-
 /** \brief Concept for the template class passed for Skeleton_blocker_complex.
  * Most importantly, it contains the nodes for vertices and edges
  * (Graph_vertex and Graph_edge) that are stored in the simplicial 
  * complex. The user can redefine these classes to attach
  * additional information to vertices and edges.
  */
-struct SkeletonBlockerDS
-{
-	/**
-	 * @brief index that allows to find the vertex in the boost graph
-	 */
-	typedef int boost_vertex_handle;
-
-
-	/**
-	 * @brief Root_vertex_handle and Vertex_handle are similar to global and local vertex descriptor
-	 * used in <a href="http://www.boost.org/doc/libs/1_38_0/libs/graph/doc/subgraph.html">boost subgraphs</a>
-	 * and allow to localize a vertex of a subcomplex on its parent root complex.
-	 *
-	 * In gross, vertices are stored in a vector
-	 * and the Root_vertex_handle and Vertex_handle store indices of a vertex in this vector.
-	 *
-	 * For the root simplicial complex, the Root_vertex_handle and Vertex_handle of a vertex
-	 * are the same.
-	 *
-	 *
-	 * For a subcomplex L of a simplicial complex K, the local descriptor, ie the Vertex_handle, of a
-	 * vertex v (that belongs to L)  is its position in the vector of vertices
-	 * of the subcomplex L whereas its Root_vertex_handle (global descriptor) is the position of v in the vector of the
-	 * vertices of the root simplicial complex K.
-	 */
-	struct Root_vertex_handle{
-
-		boost_vertex_handle vertex;
-
-		friend ostream& operator << (ostream& o, const Root_vertex_handle & v);
-	};
-
-	/**
-	 * A Vertex_handle must be Default Constructible, Assignable and Equality Comparable.
-	 */
-	struct Vertex_handle{
-		boost_vertex_handle vertex;
-
-		friend ostream& operator << (ostream& o, const Vertex_handle & v);
-	};
-
-
-	/**
-	 * \brief The type of vertices that are stored the boost graph.
-	 * A Vertex must be Default Constructible and Equality Comparable.
-	 *
-	 */
-	struct Graph_vertex{
-		/** \brief Used to deactivate a vertex for example when contracting an edge.
-		 * It allows in some cases to remove the vertex at low cost.
-		 */
-		void deactivate();
-
-		/** \brief Used to activate a vertex.
-		 */
-		void activate();
-
-		/** \brief Tells if the vertex is active.
-		 */
-		bool is_active() const;
-
-		void set_id(Root_vertex_handle i);
-		Root_vertex_handle get_id() const;
-		virtual string to_string() const ;
-		friend ostream& operator << (ostream& o, const Graph_vertex & v);
-	};
-
-
-	/**
-	 * \brief The type of edges that are stored the boost graph.
-	 * An Edge must be Default Constructible and Equality Comparable.
-	 */
-	struct Graph_edge{
-		/**
-		 * @brief Allows to modify vertices of the edge.
-		 */
-		void setId(Root_vertex_handle a,Root_vertex_handle b);
-
-		/**
-		 * @brief Returns the first vertex of the edge.
-		 */
-		Root_vertex_handle first() const ;
-
-		/**
-		 * @brief Returns the second vertex of the edge.
-		 */
-		Root_vertex_handle second() const ;
-
-		friend ostream& operator << (ostream& o, const Simple_edge & v);
-	};
-
-
+struct SkeletonBlockerDS {
+  /**
+   * @brief index that allows to find the vertex in the boost graph
+   */
+  typedef int boost_vertex_handle;
+
+  /**
+   * @brief Root_vertex_handle and Vertex_handle are similar to global and local vertex descriptor
+   * used in <a href="http://www.boost.org/doc/libs/1_38_0/libs/graph/doc/subgraph.html">boost subgraphs</a>
+   * and allow to localize a vertex of a subcomplex on its parent root complex.
+   *
+   * In gross, vertices are stored in a vector
+   * and the Root_vertex_handle and Vertex_handle store indices of a vertex in this vector.
+   *
+   * For the root simplicial complex, the Root_vertex_handle and Vertex_handle of a vertex
+   * are the same.
+   *
+   *
+   * For a subcomplex L of a simplicial complex K, the local descriptor, ie the Vertex_handle, of a
+   * vertex v (that belongs to L)  is its position in the vector of vertices
+   * of the subcomplex L whereas its Root_vertex_handle (global descriptor) is the position of v in the vector of the
+   * vertices of the root simplicial complex K.
+   */
+  struct Root_vertex_handle {
+    boost_vertex_handle vertex;
+
+    friend ostream& operator<<(ostream& o, const Root_vertex_handle & v);
+  };
+
+  /**
+   * A Vertex_handle must be Default Constructible, Assignable and Equality Comparable.
+   */
+  struct Vertex_handle {
+    boost_vertex_handle vertex;
+
+    friend ostream& operator<<(ostream& o, const Vertex_handle & v);
+  };
+
+  /**
+   * \brief The type of vertices that are stored the boost graph.
+   * A Vertex must be Default Constructible and Equality Comparable.
+   *
+   */
+  struct Graph_vertex {
+    /** \brief Used to deactivate a vertex for example when contracting an edge.
+     * It allows in some cases to remove the vertex at low cost.
+     */
+    void deactivate();
+
+    /** \brief Used to activate a vertex.
+     */
+    void activate();
+
+    /** \brief Tells if the vertex is active.
+     */
+    bool is_active() const;
+
+    void set_id(Root_vertex_handle i);
+    Root_vertex_handle get_id() const;
+    virtual string to_string() const;
+    friend ostream& operator<<(ostream& o, const Graph_vertex & v);
+  };
+
+  /**
+   * \brief The type of edges that are stored the boost graph.
+   * An Edge must be Default Constructible and Equality Comparable.
+   */
+  struct Graph_edge {
+    /**
+     * @brief Allows to modify vertices of the edge.
+     */
+    void setId(Root_vertex_handle a, Root_vertex_handle b);
+
+    /**
+     * @brief Returns the first vertex of the edge.
+     */
+    Root_vertex_handle first() const;
+
+    /**
+     * @brief Returns the second vertex of the edge.
+     */
+    Root_vertex_handle second() const;
+
+    friend ostream& operator<<(ostream& o, const Simple_edge & v);
+  };
 };
 
-
-
 }  // namespace skeleton_blocker
 
 namespace skbl = skeleton_blocker;
 
 }  // namespace Gudhi
 
-
-#endif /* GUDHI_SKELETONBLOCKERDS_H_ */
+#endif  // CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERDS_H_
diff --git a/src/Skeleton_blocker/concept/SkeletonBlockerGeometricDS.h b/src/Skeleton_blocker/concept/SkeletonBlockerGeometricDS.h
index c5d52800..6017df1a 100644
--- a/src/Skeleton_blocker/concept/SkeletonBlockerGeometricDS.h
+++ b/src/Skeleton_blocker/concept/SkeletonBlockerGeometricDS.h
@@ -1,13 +1,27 @@
-/*
- * SkeletonBlockerGeometricDS.h
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
  *
- *  Created on: Feb 20, 2014 
- *      Author: David Salinas
- *  Copyright 2013 INRIA. All rights reserved
+ *    Author(s):       David Salinas
+ *
+ *    Copyright (C) 2014  INRIA
+ *
+ *    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/>.
  */
 
-#ifndef GUDHI_SKELETONBLOCKERGEOMETRICDS_H_
-#define GUDHI_SKELETONBLOCKERGEOMETRICDS_H_
+#ifndef CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERGEOMETRICDS_H_
+#define CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERGEOMETRICDS_H_
 
 namespace Gudhi {
 namespace skeleton_blocker {
@@ -20,52 +34,51 @@ namespace skeleton_blocker {
  * Graph_edge must specify how to access to an index.
  * 
  */
- //todo the index is just for contraction, to remove
-template<typename GeometryTrait>
-struct SkeletonBlockerGeometricDS : public SkeletonBlockerDS
-{
+//todo the index is just for contraction, to remove
 
-	/**
-	 * Geometry information.
-	 */
-	typedef GeometryTrait GT ;
+template<typename GeometryTrait>
+struct SkeletonBlockerGeometricDS : public SkeletonBlockerDS {
+  /**
+   * Geometry information.
+   */
+  typedef GeometryTrait GT;
 
-	/**
-	 * Type of point (should be the same as GT::Point).
-	 */
-	typedef typename GeometryTrait::Point Point;
+  /**
+   * Type of point (should be the same as GT::Point).
+   */
+  typedef typename GeometryTrait::Point Point;
 
-	/**
-	 * @brief Vertex that stores a point.
-	 */
-	class Graph_vertex : public SkeletonBlockerDS::Graph_vertex{
-	public:
-		/**
-		 * @brief Access to the point.
-		 */
-		Point& point();
-		/**
-		 * @brief Access to the point.
-		 */
-		const Point& point();
-	};
+  /**
+   * @brief Vertex that stores a point.
+   */
+  class Graph_vertex : public SkeletonBlockerDS::Graph_vertex {
+   public:
+    /**
+     * @brief Access to the point.
+     */
+    Point& point();
+    /**
+     * @brief Access to the point.
+     */
+    const Point& point();
+  };
 
-	/**
-	 * @brief Edge that allows to access to an index.
-	 * The indices of the edges are used to store heap information
-	 * in the edge contraction algorithm.
-	 */
-	class Graph_Edge : public SkeletonBlockerDS::Graph_edge{
-	public:
-		/**
-		 * @brief Access to the index.
-		 */
-		int& index();
-		/**
-		 * @brief Access to the index.
-		 */
-		int index();
-	};
+  /**
+   * @brief Edge that allows to access to an index.
+   * The indices of the edges are used to store heap information
+   * in the edge contraction algorithm.
+   */
+  class Graph_Edge : public SkeletonBlockerDS::Graph_edge {
+   public:
+    /**
+     * @brief Access to the index.
+     */
+    int& index();
+    /**
+     * @brief Access to the index.
+     */
+    int index();
+  };
 };
 
 }  // namespace skeleton_blocker
@@ -74,4 +87,4 @@ namespace skbl = skeleton_blocker;
 
 }  // namespace Gudhi
 
-#endif /* GUDHI_SKELETONBLOCKERGEOMETRICDS_H_ */
+#endif  // CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERGEOMETRICDS_H_
diff --git a/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp b/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp
index 171f35f2..5f89536b 100644
--- a/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp
+++ b/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
diff --git a/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp b/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp
index 8d9d1a67..7df0e3c9 100644
--- a/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp
+++ b/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
diff --git a/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp b/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp
index 1f937170..e2a04d75 100644
--- a/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp
+++ b/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -65,7 +65,7 @@ int main(int argc, char *argv[]) {
   // For instance, to test if the link contains the vertex that was labeled i:
   for (int i = 0; i < 5; ++i)
     cout << "link.contains_vertex(Root_vertex_handle(" << i << ")):" <<
-        link.contains_vertex(Root_vertex_handle(i)) << endl;
+      link.contains_vertex(Root_vertex_handle(i)) << endl;
 
   return EXIT_SUCCESS;
 }
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
index 822282fd..85fada4f 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
@@ -1,24 +1,24 @@
- /*    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):       David Salinas
-  *
-  *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (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):       David Salinas
+ *
+ *    Copyright (C) 2014  INRIA
+ *
+ *    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/>.
+ */
 
 #ifndef SKELETON_BLOCKER_H_
 #define SKELETON_BLOCKER_H_
@@ -63,7 +63,7 @@ when \f$ \tau \neq \sigma\f$ we say that \f$ \tau\f$ is a proper-face of \f$ \si
 An abstract simplicial complex is a set of simplices that contains all the faces of its simplices.
 The 1-skeleton of a simplicial complex (or its graph) consists of its elements of dimension lower than 2.
 
-*\image html "ds_representation.png" "Skeleton-blocker representation" width=20cm
+ *\image html "ds_representation.png" "Skeleton-blocker representation" width=20cm
 
 
 To encode, a simplicial complex, one can encodes all its simplices. 
@@ -85,7 +85,7 @@ in next figure. Storing the graph and blockers of such simplicial complexes is m
 their simplices.
 
 
-*\image html "blockers_curve.png" "Number of blockers of random triangulations of 3-spheres" width=10cm
+ *\image html "blockers_curve.png" "Number of blockers of random triangulations of 3-spheres" width=10cm
 
 
 
@@ -127,46 +127,46 @@ such as the Simplex Tree. The following example computes the Euler Characteristi
 of a simplicial complex.
 
   \code{.cpp}
-	typedef Skeleton_blocker_complex<Skeleton_blocker_simple_traits> Complex;
-	typedef Complex::Vertex_handle Vertex_handle;
-	typedef Complex::Simplex Simplex;
-
-  	const int n = 15;
-
-	// build a full complex with 10 vertices and 2^n-1 simplices
-	Complex complex;
-	for(int i=0;i<n;i++)
-		complex.add_vertex();
-	for(int i=0;i<n;i++)
-		for(int j=0;j<i;j++)
-			complex.add_edge_without_blockers(Vertex_handle(i),Vertex_handle(j));
-
-	// this is just to illustrate iterators, to count number of vertices
-	// or edges, complex.num_vertices() and complex.num_edges() are
-	// more appropriated!
-	unsigned num_vertices = 0;
-	for(auto v : complex.vertex_range()){
-		++num_vertices;
-	}
-
-	unsigned num_edges = 0;
-	for(auto e : complex.edge_range())
-		++num_edges;
-
-	unsigned euler = 0;
-	unsigned num_simplices = 0;
-	// we use a reference to a simplex instead of a copy
-	// value here because a simplex is a set of integers
-	// and copying it cost time
-	for(const Simplex & s : complex.star_simplex_range()){
-		++num_simplices;
-		if(s.dimension()%2 == 0) 
-			euler += 1;
-		else 
-			euler -= 1;
-	}
-	std::cout << "Saw "<<num_vertices<<" vertices, "<<num_edges<<" edges and "<<num_simplices<<" simplices"<<std::endl;
-	std::cout << "The Euler Characteristic is "<<euler<<std::endl;
+        typedef Skeleton_blocker_complex<Skeleton_blocker_simple_traits> Complex;
+        typedef Complex::Vertex_handle Vertex_handle;
+        typedef Complex::Simplex Simplex;
+
+        const int n = 15;
+
+        // build a full complex with 10 vertices and 2^n-1 simplices
+        Complex complex;
+        for(int i=0;i<n;i++)
+                complex.add_vertex();
+        for(int i=0;i<n;i++)
+                for(int j=0;j<i;j++)
+                        complex.add_edge_without_blockers(Vertex_handle(i),Vertex_handle(j));
+
+        // this is just to illustrate iterators, to count number of vertices
+        // or edges, complex.num_vertices() and complex.num_edges() are
+        // more appropriated!
+        unsigned num_vertices = 0;
+        for(auto v : complex.vertex_range()){
+                ++num_vertices;
+        }
+
+        unsigned num_edges = 0;
+        for(auto e : complex.edge_range())
+                ++num_edges;
+
+        unsigned euler = 0;
+        unsigned num_simplices = 0;
+        // we use a reference to a simplex instead of a copy
+        // value here because a simplex is a set of integers
+        // and copying it cost time
+        for(const Simplex & s : complex.star_simplex_range()){
+                ++num_simplices;
+                if(s.dimension()%2 == 0) 
+                        euler += 1;
+                else 
+                        euler -= 1;
+        }
+        std::cout << "Saw "<<num_vertices<<" vertices, "<<num_edges<<" edges and "<<num_simplices<<" simplices"<<std::endl;
+        std::cout << "The Euler Characteristic is "<<euler<<std::endl;
   \endcode
 
 
@@ -181,43 +181,43 @@ The Euler Characteristic is 1
 \subsection s Constructing a skeleton-blockers from a list of maximal faces or from a list of faces
 
   \code{.cpp}
-	std::vector<Simplex> simplices;
-
-	//add 4 triangles of a tetrahedron 0123
-	simplices.push_back(Simplex(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2)));
-	simplices.push_back(Simplex(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3)));
-	simplices.push_back(Simplex(Vertex_handle(3),Vertex_handle(0),Vertex_handle(2)));
-	simplices.push_back(Simplex(Vertex_handle(3),Vertex_handle(0),Vertex_handle(1)));
-
-	Complex complex;
-	//get complex from top faces
-	make_complex_from_top_faces(complex,simplices.begin(),simplices.end());
-
-	std::cout << "Simplices:"<<std::endl;
-	for(const Simplex & s : complex.star_simplex_range())
-		std::cout << s << " ";
-	std::cout << std::endl;
-
-	//One blocker as simplex 0123 is not in the complex but all its proper faces are.
-	std::cout << "Blockers: "<<complex.blockers_to_string()<<std::endl;
-
-	//now build a complex from its full list of simplices
-	simplices.clear();
-	simplices.push_back(Simplex(Vertex_handle(0)));
-	simplices.push_back(Simplex(Vertex_handle(1)));
-	simplices.push_back(Simplex(Vertex_handle(2)));
-	simplices.push_back(Simplex(Vertex_handle(0),Vertex_handle(1)));
-	simplices.push_back(Simplex(Vertex_handle(1),Vertex_handle(2)));
-	simplices.push_back(Simplex(Vertex_handle(2),Vertex_handle(0)));
-	complex = Complex(simplices.begin(),simplices.end());
-
-	std::cout << "Simplices:"<<std::endl;
-	for(const Simplex & s : complex.star_simplex_range())
-		std::cout << s << " ";
-	std::cout << std::endl;
-
-	//One blocker as simplex 012 is not in the complex but all its proper faces are.
-	std::cout << "Blockers: "<<complex.blockers_to_string()<<std::endl;
+        std::vector<Simplex> simplices;
+
+        //add 4 triangles of a tetrahedron 0123
+        simplices.push_back(Simplex(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2)));
+        simplices.push_back(Simplex(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3)));
+        simplices.push_back(Simplex(Vertex_handle(3),Vertex_handle(0),Vertex_handle(2)));
+        simplices.push_back(Simplex(Vertex_handle(3),Vertex_handle(0),Vertex_handle(1)));
+
+        Complex complex;
+        //get complex from top faces
+        make_complex_from_top_faces(complex,simplices.begin(),simplices.end());
+
+        std::cout << "Simplices:"<<std::endl;
+        for(const Simplex & s : complex.star_simplex_range())
+                std::cout << s << " ";
+        std::cout << std::endl;
+
+        //One blocker as simplex 0123 is not in the complex but all its proper faces are.
+        std::cout << "Blockers: "<<complex.blockers_to_string()<<std::endl;
+
+        //now build a complex from its full list of simplices
+        simplices.clear();
+        simplices.push_back(Simplex(Vertex_handle(0)));
+        simplices.push_back(Simplex(Vertex_handle(1)));
+        simplices.push_back(Simplex(Vertex_handle(2)));
+        simplices.push_back(Simplex(Vertex_handle(0),Vertex_handle(1)));
+        simplices.push_back(Simplex(Vertex_handle(1),Vertex_handle(2)));
+        simplices.push_back(Simplex(Vertex_handle(2),Vertex_handle(0)));
+        complex = Complex(simplices.begin(),simplices.end());
+
+        std::cout << "Simplices:"<<std::endl;
+        for(const Simplex & s : complex.star_simplex_range())
+                std::cout << s << " ";
+        std::cout << std::endl;
+
+        //One blocker as simplex 012 is not in the complex but all its proper faces are.
+        std::cout << "Blockers: "<<complex.blockers_to_string()<<std::endl;
  \endcode
 \verbatim
 ./SkeletonBlockerFromSimplices
@@ -240,8 +240,8 @@ their collaboration to write the two initial papers
 
 
 \copyright GNU General Public License v3.                         
-*/
-/** @} */  // end defgroup
+ */
+/** @} */ // end defgroup
 
 }  // namespace skeleton_blocker
 
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h
index 32f40a4b..ba3636bc 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_COMPLEX_VISITOR_H_
 #define SKELETON_BLOCKER_SKELETON_BLOCKER_COMPLEX_VISITOR_H_
 
@@ -27,7 +28,7 @@
 namespace Gudhi {
 
 namespace skeleton_blocker {
-// todo rajouter les const
+// TODO(DS): to be constified
 
 /**
  *@class Skeleton_blocker_complex_visitor
@@ -36,7 +37,7 @@ namespace skeleton_blocker {
 template<typename Vertex_handle>
 class Skeleton_blocker_complex_visitor {
  public:
-  virtual ~Skeleton_blocker_complex_visitor() {}
+  virtual ~Skeleton_blocker_complex_visitor() { }
 
   virtual void on_add_vertex(Vertex_handle) = 0;
   virtual void on_remove_vertex(Vertex_handle) = 0;
@@ -61,9 +62,9 @@ class Skeleton_blocker_complex_visitor {
   virtual void on_swaped_edge(Vertex_handle a, Vertex_handle b,
                               Vertex_handle x) = 0;
   virtual void on_add_blocker(
-      const Skeleton_blocker_simplex<Vertex_handle>&) = 0;
+                              const Skeleton_blocker_simplex<Vertex_handle>&) = 0;
   virtual void on_delete_blocker(
-      const Skeleton_blocker_simplex<Vertex_handle>*) = 0;
+                                 const Skeleton_blocker_simplex<Vertex_handle>*) = 0;
 };
 
 /**
@@ -73,24 +74,23 @@ class Skeleton_blocker_complex_visitor {
  */
 template<typename Vertex_handle>
 class Dummy_complex_visitor : public Skeleton_blocker_complex_visitor<
-    Vertex_handle> {
+Vertex_handle> {
  public:
-  void on_add_vertex(Vertex_handle) {
-  }
-  void on_remove_vertex(Vertex_handle) {
-  }
-  void on_add_edge_without_blockers(Vertex_handle a, Vertex_handle b) {
-  }
-  void on_remove_edge(Vertex_handle a, Vertex_handle b) {
-  }
-  void on_changed_edge(Vertex_handle a, Vertex_handle b) {
-  }
-  void on_swaped_edge(Vertex_handle a, Vertex_handle b, Vertex_handle x) {
-  }
-  void on_add_blocker(const Skeleton_blocker_simplex<Vertex_handle>&) {
-  }
-  void on_delete_blocker(const Skeleton_blocker_simplex<Vertex_handle>*) {
-  }
+  void on_add_vertex(Vertex_handle) { }
+
+  void on_remove_vertex(Vertex_handle) { }
+
+  void on_add_edge_without_blockers(Vertex_handle a, Vertex_handle b) { }
+
+  void on_remove_edge(Vertex_handle a, Vertex_handle b) { }
+
+  void on_changed_edge(Vertex_handle a, Vertex_handle b) { }
+
+  void on_swaped_edge(Vertex_handle a, Vertex_handle b, Vertex_handle x) { }
+
+  void on_add_blocker(const Skeleton_blocker_simplex<Vertex_handle>&) { }
+
+  void on_delete_blocker(const Skeleton_blocker_simplex<Vertex_handle>*) { }
 };
 
 /**
@@ -100,29 +100,36 @@ class Dummy_complex_visitor : public Skeleton_blocker_complex_visitor<
  */
 template<typename Vertex_handle>
 class Print_complex_visitor : public Skeleton_blocker_complex_visitor<
-    Vertex_handle> {
+Vertex_handle> {
  public:
   void on_add_vertex(Vertex_handle v) {
     std::cerr << "on_add_vertex:" << v << std::endl;
   }
+
   void on_remove_vertex(Vertex_handle v) {
     std::cerr << "on_remove_vertex:" << v << std::endl;
   }
+
   void on_add_edge_without_blockers(Vertex_handle a, Vertex_handle b) {
     std::cerr << "on_add_edge_without_blockers:" << a << "," << b << std::endl;
   }
+
   void on_remove_edge(Vertex_handle a, Vertex_handle b) {
     std::cerr << "on_remove_edge:" << a << "," << b << std::endl;
   }
+
   void on_changed_edge(Vertex_handle a, Vertex_handle b) {
     std::cerr << "on_changed_edge:" << a << "," << b << std::endl;
   }
+
   void on_swaped_edge(Vertex_handle a, Vertex_handle b, Vertex_handle x) {
     std::cerr << "on_swaped_edge:" << a << "," << b << "," << x << std::endl;
   }
+
   void on_add_blocker(const Skeleton_blocker_simplex<Vertex_handle>& b) {
     std::cerr << "on_add_blocker:" << b << std::endl;
   }
+
   void on_delete_blocker(const Skeleton_blocker_simplex<Vertex_handle>* b) {
     std::cerr << "on_delete_blocker:" << b << std::endl;
   }
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h
index 3bfb5d11..d4b60613 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_LINK_SUPERIOR_H_
 #define SKELETON_BLOCKER_SKELETON_BLOCKER_LINK_SUPERIOR_H_
 
@@ -36,7 +37,7 @@ template<class ComplexType> class Skeleton_blocker_sub_complex;
  */
 template<typename ComplexType>
 class Skeleton_blocker_link_superior : public Skeleton_blocker_link_complex<
-    ComplexType> {
+ComplexType> {
   typedef typename ComplexType::Edge_handle Edge_handle;
 
   typedef typename ComplexType::boost_vertex_handle boost_vertex_handle;
@@ -54,20 +55,17 @@ class Skeleton_blocker_link_superior : public Skeleton_blocker_link_complex<
   typedef typename ComplexType::Root_simplex_handle::Simplex_vertex_const_iterator IdSimplexConstIterator;
 
   Skeleton_blocker_link_superior()
-      : Skeleton_blocker_link_complex<ComplexType>(true) {
-  }
+      : Skeleton_blocker_link_complex<ComplexType>(true) { }
 
   Skeleton_blocker_link_superior(const ComplexType & parent_complex,
                                  Simplex& alpha_parent_adress)
       : Skeleton_blocker_link_complex<ComplexType>(parent_complex,
-                                                   alpha_parent_adress, true) {
-  }
+                                                   alpha_parent_adress, true) { }
 
   Skeleton_blocker_link_superior(const ComplexType & parent_complex,
                                  Vertex_handle a_parent_adress)
       : Skeleton_blocker_link_complex<ComplexType>(parent_complex,
-                                                   a_parent_adress, true) {
-  }
+                                                   a_parent_adress, true) { }
 };
 
 }  // namespace skeleton_blocker
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h
index ba46c49e..747e60f1 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_OFF_IO_H_
 #define SKELETON_BLOCKER_SKELETON_BLOCKER_OFF_IO_H_
 
@@ -49,8 +50,8 @@ class Skeleton_blocker_off_flag_visitor_reader {
       load_only_points_(load_only_points) { }
 
   void init(int dim, int num_vertices, int num_faces, int num_edges) {
-    // todo do an assert to check that this number are correctly read
-    // todo reserve size for vector points
+    // TODO(DS): do an assert to check that this number are correctly read
+    // TODO(DS): reserve size for vector points
   }
 
   void point(const std::vector<double>& point) {
@@ -108,7 +109,7 @@ class Skeleton_blocker_off_visitor_reader {
 
   void done() {
     complex_ = make_complex_from_top_faces<Complex>(maximal_faces_.begin(), maximal_faces_.end(),
-                                           points_.begin(), points_.end() );
+                                                    points_.begin(), points_.end());
   }
 };
 
@@ -140,7 +141,7 @@ class Skeleton_blocker_off_reader {
   }
 
   /**
-   * return true iff reading did not meet problems.
+   * return true if reading did not meet problems.
    */
   bool is_valid() const {
     return valid_;
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h
index fb4a1106..275376e6 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_GEOMETRIC_TRAITS_H_
 #define SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_GEOMETRIC_TRAITS_H_
 
@@ -39,7 +40,7 @@ namespace skeleton_blocker {
  */
 template<typename GeometryTrait>
 struct Skeleton_blocker_simple_geometric_traits :
-    public Skeleton_blocker_simple_traits {
+public Skeleton_blocker_simple_traits {
  public:
   typedef GeometryTrait GT;
   typedef typename GT::Point Point;
@@ -57,19 +58,20 @@ struct Skeleton_blocker_simple_geometric_traits :
     Point& point() {
       return point_;
     }
+
     const Point& point() const {
       return point_;
     }
   };
 
   class Simple_geometric_edge :
-      public Skeleton_blocker_simple_traits::Graph_edge {
+  public Skeleton_blocker_simple_traits::Graph_edge {
     int index_;
    public:
     Simple_geometric_edge()
         : Skeleton_blocker_simple_traits::Graph_edge(),
-          index_(-1) {
-    }
+        index_(-1) { }
+
     /**
      * @brief Allows to modify the index of the edge.
      * The indices of the edge are used to store heap information
@@ -78,6 +80,7 @@ struct Skeleton_blocker_simple_geometric_traits :
     int& index() {
       return index_;
     }
+
     int index() const {
       return index_;
     }
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h
index 31bec3b6..469717ae 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_TRAITS_H_
 #define SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_TRAITS_H_
 
@@ -48,9 +49,9 @@ struct Skeleton_blocker_simple_traits {
    */
   struct Root_vertex_handle {
     typedef int boost_vertex_handle;
+
     explicit Root_vertex_handle(boost_vertex_handle val = -1)
-        : vertex(val) {
-    }
+        : vertex(val) { }
     boost_vertex_handle vertex;
 
     bool operator!=(const Root_vertex_handle& other) const {
@@ -65,8 +66,8 @@ struct Skeleton_blocker_simple_traits {
       return this->vertex < other.vertex;
     }
 
-    friend std::ostream& operator <<(std::ostream& o,
-                                     const Root_vertex_handle & v) {
+    friend std::ostream& operator<<(std::ostream& o,
+                                    const Root_vertex_handle & v) {
       o << v.vertex;
       return o;
     }
@@ -74,11 +75,13 @@ struct Skeleton_blocker_simple_traits {
 
   struct Vertex_handle {
     typedef int boost_vertex_handle;
+
     explicit Vertex_handle(boost_vertex_handle val = -1)
-        : vertex(val) {
-    }
+        : vertex(val) { }
 
-    operator int() const { return static_cast<int>(vertex); }
+    operator int() const {
+      return static_cast<int> (vertex);
+    }
 
     boost_vertex_handle vertex;
 
@@ -94,7 +97,7 @@ struct Skeleton_blocker_simple_traits {
       return this->vertex < other.vertex;
     }
 
-    friend std::ostream& operator <<(std::ostream& o, const Vertex_handle & v) {
+    friend std::ostream& operator<<(std::ostream& o, const Vertex_handle & v) {
       o << v.vertex;
       return o;
     }
@@ -105,21 +108,24 @@ struct Skeleton_blocker_simple_traits {
     Root_vertex_handle id_;
 
    public:
-    virtual ~Graph_vertex() {
-    }
+    virtual ~Graph_vertex() { }
 
     void activate() {
       is_active_ = true;
     }
+
     void deactivate() {
       is_active_ = false;
     }
+
     bool is_active() const {
       return is_active_;
     }
+
     void set_id(Root_vertex_handle i) {
       id_ = i;
     }
+
     Root_vertex_handle get_id() const {
       return id_;
     }
@@ -130,7 +136,7 @@ struct Skeleton_blocker_simple_traits {
       return res.str();
     }
 
-    friend std::ostream& operator <<(std::ostream& o, const Graph_vertex & v) {
+    friend std::ostream& operator<<(std::ostream& o, const Graph_vertex & v) {
       o << v.to_string();
       return o;
     }
@@ -142,15 +148,16 @@ struct Skeleton_blocker_simple_traits {
     int index_;
 
    public:
+
     Graph_edge()
         : a_(-1),
-          b_(-1),
-          index_(-1) {
-    }
+        b_(-1),
+        index_(-1) { }
 
     int& index() {
       return index_;
     }
+
     int index() const {
       return index_;
     }
@@ -168,7 +175,7 @@ struct Skeleton_blocker_simple_traits {
       return b_;
     }
 
-    friend std::ostream& operator <<(std::ostream& o, const Graph_edge & v) {
+    friend std::ostream& operator<<(std::ostream& o, const Graph_edge & v) {
       o << "(" << v.a_ << "," << v.b_ << " - id = " << v.index();
       return o;
     }
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h
index 3c7f1dd5..aa6f2215 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -63,7 +63,6 @@ class Skeleton_blocker_simplex {
    */
   //@{
 
-  // Skeleton_blocker_simplex():simplex_set() {}
   void clear() {
     simplex_set.clear();
   }
@@ -89,8 +88,7 @@ class Skeleton_blocker_simplex {
     add_vertex(v);
   }
 
-  void add_vertices() {
-  }
+  void add_vertices() { }
 
   /**
    * Initialize a simplex with a string such as {0,1,2}
@@ -192,7 +190,6 @@ class Skeleton_blocker_simplex {
     return simplex_set.crend();
   }
 
-
   typename std::set<T>::iterator begin() {
     return simplex_set.begin();
   }
@@ -236,6 +233,7 @@ class Skeleton_blocker_simplex {
     assert(!empty());
     return *(simplex_set.rbegin());
   }
+
   /**
    * @return true iff the simplex contains the simplex a.
    */
@@ -351,8 +349,8 @@ class Skeleton_blocker_simplex {
 
   //@}
 
-  friend std::ostream& operator <<(std::ostream& o,
-                                   const Skeleton_blocker_simplex & sigma) {
+  friend std::ostream& operator<<(std::ostream& o,
+                                  const Skeleton_blocker_simplex & sigma) {
     bool first = true;
     o << "{";
     for (auto i : sigma) {
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h
index 196fe8c0..fadf6619 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -159,7 +159,7 @@ class Skeleton_blocker_sub_complex : public ComplexType {
       if (simplex.contains(*blocker)) {
         Root_simplex_handle blocker_root(parent_complex.get_id(*(blocker)));
         Simplex blocker_restr(
-            *(this->get_simplex_address(blocker_root)));
+                              *(this->get_simplex_address(blocker_root)));
         this->add_blocker(new Simplex(blocker_restr));
       }
     }
@@ -190,14 +190,15 @@ class Skeleton_blocker_sub_complex : public ComplexType {
   //  */
   // boost::optional<Simplex> get_address(const Root_simplex_handle & s) const;
 
-// private:
+  // private:
   /**
    *  same as get_address except that it will return a simplex in any case.
    *  The vertices that were not found are not added.
    */
   // @remark should be private but problem with VS
+
   std::vector<boost::optional<Vertex_handle> > get_addresses(
-      const Root_simplex_handle & s) const {
+                                                             const Root_simplex_handle & s) const {
     std::vector < boost::optional<Vertex_handle> > res;
     for (auto i : s) {
       res.push_back(get_address(i));
@@ -214,14 +215,14 @@ class Skeleton_blocker_sub_complex : public ComplexType {
  */
 template<typename ComplexType>
 bool proper_face_in_union(
-    Skeleton_blocker_sub_complex<ComplexType> & link,
-    std::vector<boost::optional<typename ComplexType::Vertex_handle> > & addresses_sigma_in_link,
-    int vertex_to_be_ignored) {
+                          Skeleton_blocker_sub_complex<ComplexType> & link,
+                          std::vector<boost::optional<typename ComplexType::Vertex_handle> > & addresses_sigma_in_link,
+                          std::size_t vertex_to_be_ignored) {
   // we test that all vertices of 'addresses_sigma_in_link' but 'vertex_to_be_ignored'
   // are in link1 if it is the case we construct the corresponding simplex
   bool vertices_sigma_are_in_link = true;
   typename ComplexType::Simplex sigma_in_link;
-  for (int i = 0; i < addresses_sigma_in_link.size(); ++i) {
+  for (std::size_t i = 0; i < addresses_sigma_in_link.size(); ++i) {
     if (i != vertex_to_be_ignored) {
       if (!addresses_sigma_in_link[i]) {
         vertices_sigma_are_in_link = false;
@@ -236,43 +237,24 @@ bool proper_face_in_union(
   return vertices_sigma_are_in_link && link.contains(sigma_in_link);
 }
 
-/*
- template<typename ComplexType>
- bool
- proper_faces_in_union(Skeleton_blocker_simplex<typename ComplexType::Root_vertex_handle> & sigma, Skeleton_blocker_sub_complex<ComplexType> & link1, Skeleton_blocker_sub_complex<ComplexType> & link2)
- {
- typedef typename ComplexType::Vertex_handle  Vertex_handle;
- std::vector<boost::optional<Vertex_handle> > addresses_sigma_in_link1 = link1.get_addresses(sigma);
- std::vector<boost::optional<Vertex_handle> > addresses_sigma_in_link2 = link2.get_addresses(sigma);
-
- for (int current_index = 0; current_index < addresses_sigma_in_link1.size(); ++current_index)
- {
-
- if (!proper_face_in_union(link1, addresses_sigma_in_link1, current_index)
- && !proper_face_in_union(link2, addresses_sigma_in_link2, current_index)){
- return false;
- }
- }
- return true;
- }*/
-
 // Remark: this function should be friend in order to leave get_adresses private
 // however doing so seemes currently not possible due to a visual studio bug c2668
 // "the compiler does not support partial ordering of template functions as specified in the C++ Standard"
 // http://www.serkey.com/error-c2668-ambiguous-call-to-overloaded-function-bb45ft.html
+
 template<typename ComplexType>
 bool proper_faces_in_union(
-    Skeleton_blocker_simplex<typename ComplexType::Root_vertex_handle> & sigma,
-    Skeleton_blocker_sub_complex<ComplexType> & link1,
-    Skeleton_blocker_sub_complex<ComplexType> & link2) {
+                           Skeleton_blocker_simplex<typename ComplexType::Root_vertex_handle> & sigma,
+                           Skeleton_blocker_sub_complex<ComplexType> & link1,
+                           Skeleton_blocker_sub_complex<ComplexType> & link2) {
   typedef typename ComplexType::Vertex_handle Vertex_handle;
   std::vector < boost::optional<Vertex_handle> > addresses_sigma_in_link1 =
       link1.get_addresses(sigma);
   std::vector < boost::optional<Vertex_handle> > addresses_sigma_in_link2 =
       link2.get_addresses(sigma);
 
-  for (int current_index = 0; current_index < addresses_sigma_in_link1.size();
-      ++current_index) {
+  for (std::size_t current_index = 0; current_index < addresses_sigma_in_link1.size();
+       ++current_index) {
     if (!proper_face_in_union(link1, addresses_sigma_in_link1, current_index)
         && !proper_face_in_union(link2, addresses_sigma_in_link2,
                                  current_index)) {
@@ -289,4 +271,3 @@ namespace skbl = skeleton_blocker;
 }  // namespace Gudhi
 
 #endif  // SKELETON_BLOCKER_SKELETON_BLOCKER_SUB_COMPLEX_H_
-
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Top_faces.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Top_faces.h
index 39d95661..2b681752 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Top_faces.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Top_faces.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
 #define SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
 
@@ -69,4 +70,4 @@ namespace skbl = skeleton_blocker;
 
 }  // namespace Gudhi
 
-#endif  // SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
+#endif   // SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Trie.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Trie.h
index cdc47b8a..ccc7c36b 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Trie.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Trie.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Méditerranée (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -21,7 +21,6 @@
  * 
  */
 
-
 #ifndef SKELETON_BLOCKER_INTERNAL_TRIE_H_
 #define SKELETON_BLOCKER_INTERNAL_TRIE_H_
 
@@ -46,6 +45,7 @@ struct Trie {
   const Trie* parent_;
 
  public:
+
   Trie() : parent_(0) { }
 
   Trie(Vertex_handle v_) : v(v_), parent_(0) { }
@@ -80,6 +80,7 @@ struct Trie {
  private:
   // go down recursively in the tree while advancing the simplex iterator.
   // when it reaches a leaf, it inserts the remaining that is not present
+
   void add_simplex_helper(Simplex_vertex_const_iterator s_it, Simplex_vertex_const_iterator s_end) {
     assert(*s_it == v);
     ++s_it;
@@ -105,6 +106,7 @@ struct Trie {
   }
 
  public:
+
   /**
    * adds the simplex to the trie
    */
@@ -240,7 +242,7 @@ struct Tries {
 
   std::vector<Simplex> next_dimension_simplices() const {
     std::vector<Simplex> res;
-    while (!to_see_.empty() && to_see_.front()->simplex().dimension() == current_dimension_) {
+    while (!(to_see_.empty()) && (to_see_.front()->simplex().dimension() == current_dimension_)) {
       res.emplace_back(to_see_.front()->simplex());
       for (auto child : to_see_.front()->childs)
         to_see_.push_back(child.get());
@@ -257,7 +259,7 @@ struct Tries {
 
  private:
   mutable std::deque<STrie*> to_see_;
-  mutable unsigned current_dimension_ = 0;
+  mutable int current_dimension_ = 0;
   std::vector<STrie*> cofaces_;
 };
 
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h
index 4dbc9ed3..4049fb0b 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_
 #define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_
 
@@ -46,6 +47,7 @@ ReturnType
   MapIteratorType end_of_map;
 
  public:
+
   Blocker_iterator_internal() : current_position() { }
 
   Blocker_iterator_internal(MapIteratorType position, MapIteratorType end_of_map_) :
@@ -64,6 +66,7 @@ ReturnType
   }
 
  private:
+
   /**
    * Let the current pair be (v,sigma) where v is a vertex and sigma is a blocker.
    * If v is not the first vertex of sigma then we already have seen sigma as a blocker
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h
index 15618932..b90dcf34 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_EDGES_ITERATORS_H_
 #define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_EDGES_ITERATORS_H_
 
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h
index cc3ed276..1351614f 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h
@@ -4,7 +4,7 @@
   *
   *    Author(s):       David Salinas
   *
-  *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+  *    Copyright (C) 2014  INRIA
   *
   *    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
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h
index 3b941be5..c9482263 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_
 #define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_
 
@@ -68,10 +69,10 @@ public boost::iterator_facade < Simplex_around_vertex_iterator<SkeletonBlockerCo
   Vertex_handle v;
   std::shared_ptr<Link> link_v;
   std::shared_ptr<Trie> trie;
-  std::list<Trie*> nodes_to_be_seen;  // todo deque
+  std::list<Trie*> nodes_to_be_seen; // todo deque
 
  public:
-  Simplex_around_vertex_iterator() : complex(0) {}
+  Simplex_around_vertex_iterator() : complex(0) { }
 
   Simplex_around_vertex_iterator(const Complex* complex_, Vertex_handle v_) :
       complex(complex_),
@@ -81,15 +82,16 @@ public boost::iterator_facade < Simplex_around_vertex_iterator<SkeletonBlockerCo
     compute_trie_and_nodes_to_be_seen();
   }
 
-  // todo avoid useless copy
-  // todo currently just work if copy begin iterator
+  // TODO(DS): avoid useless copy
+  // TODO(DS): currently just work if copy begin iterator
   Simplex_around_vertex_iterator(const Simplex_around_vertex_iterator& other) :
       complex(other.complex),
       v(other.v),
       link_v(other.link_v),
       trie(other.trie),
       nodes_to_be_seen(other.nodes_to_be_seen) {
-    if (!other.is_end()) {}
+    if (!other.is_end()) {
+    }
   }
 
   /**
@@ -159,7 +161,7 @@ public boost::iterator_facade < Simplex_around_vertex_iterator<SkeletonBlockerCo
 
     bool both_non_empty = !nodes_to_be_seen.empty() && !other.nodes_to_be_seen.empty();
 
-    if (!both_non_empty) return false;  // one is empty the other is not
+    if (!both_non_empty) return false; // one is empty the other is not
 
     bool same_node = (**(nodes_to_be_seen.begin()) == **(other.nodes_to_be_seen.begin()));
     return same_node;
@@ -238,7 +240,6 @@ public boost::iterator_facade < Simplex_iterator<SkeletonBlockerComplex>
   }
 
  private:
-  // todo return to private
   Simplex_iterator(const Complex* complex, bool end) :
       complex_(complex) {
     set_end();
@@ -306,7 +307,7 @@ public boost::iterator_facade < Simplex_iterator<SkeletonBlockerComplex>
 
 /**
  * Iterator through the maximal faces of the coboundary of a simplex.
- */ 
+ */
 template<typename SkeletonBlockerComplex, typename Link>
 class Simplex_coboundary_iterator :
 public boost::iterator_facade < Simplex_coboundary_iterator<SkeletonBlockerComplex, Link>
@@ -329,7 +330,7 @@ public boost::iterator_facade < Simplex_coboundary_iterator<SkeletonBlockerCompl
   Complex_vertex_iterator link_vertex_end;
 
  public:
-  Simplex_coboundary_iterator() : complex(0) {}
+  Simplex_coboundary_iterator() : complex(0) { }
 
   Simplex_coboundary_iterator(const Complex* complex_, const Simplex& sigma_) :
       complex(complex_),
@@ -347,9 +348,9 @@ public boost::iterator_facade < Simplex_coboundary_iterator<SkeletonBlockerCompl
       link(other.link),
       current_vertex(other.current_vertex),
       link_vertex_end(other.link_vertex_end) { }
-  
+
   // returns an iterator to the end
-  Simplex_coboundary_iterator(const Complex* complex_,const Simplex& sigma_, bool end) :
+  Simplex_coboundary_iterator(const Complex* complex_, const Simplex& sigma_, bool end) :
       complex(complex_),
       sigma(sigma_) {
     // to represent an end iterator without having to build a useless link, we use
@@ -361,7 +362,7 @@ public boost::iterator_facade < Simplex_coboundary_iterator<SkeletonBlockerCompl
     return complex->convert_handle_from_another_complex(*link, link_vh);
   }
 
-public:
+ public:
   friend std::ostream& operator<<(std::ostream& stream, const Simplex_coboundary_iterator& sci) {
     return stream;
   }
@@ -369,8 +370,8 @@ public:
   // assume that iterator points to the same complex and comes from the same simplex
   bool equal(const Simplex_coboundary_iterator& other) const {
     assert(complex == other.complex && sigma == other.sigma);
-    if(is_end()) return other.is_end();
-    if(other.is_end()) return is_end();
+    if (is_end()) return other.is_end();
+    if (other.is_end()) return is_end();
     return *current_vertex == *(other.current_vertex);
   }
 
@@ -384,13 +385,12 @@ public:
     return res;
   }
 
-private:
+ private:
   bool is_end() const {
     return !link || current_vertex == link_vertex_end;
   }
 };
 
-
 }  // namespace skeleton_blocker
 
 namespace skbl = skeleton_blocker;
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h
index b2dd9a21..4e0dbb74 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_
 #define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_
 
@@ -135,7 +136,7 @@ typename SkeletonBlockerComplex::Simplex const
   Triangle_iterator(const SkeletonBlockerComplex* complex) :
       complex_(complex),
       current_vertex_(complex->vertex_range().begin()),
-      current_triangle_(complex, *current_vertex_),  // xxx this line is problematic is the complex is empty
+      current_triangle_(complex, *current_vertex_), // xxx this line is problematic is the complex is empty
       is_end_(false) {
     assert(!complex->empty());
     gotoFirstTriangle();
@@ -172,7 +173,8 @@ typename SkeletonBlockerComplex::Simplex const
     bool both_arent_finished = !is_finished() && !other.is_finished();
     // if the two iterators are not finished, they must have the same state
     return (complex_ == other.complex_) && (both_are_finished || ((both_arent_finished) &&
-        current_vertex_ == other.current_vertex_ && current_triangle_ == other.current_triangle_));
+                                                                  current_vertex_ == other.current_vertex_ &&
+                                                                  current_triangle_ == other.current_triangle_));
   }
 
   Simplex dereference() const {
@@ -183,8 +185,8 @@ typename SkeletonBlockerComplex::Simplex const
   // goto the next vertex that has a triangle pending or the
   // end vertex iterator if none exists
   void goto_next_vertex() {
-    assert(current_triangle_.finished());  // we mush have consume all triangles passing through the vertex
-    assert(!is_finished());  // we must not be done
+    assert(current_triangle_.finished()); // we mush have consume all triangles passing through the vertex
+    assert(!is_finished()); // we must not be done
 
     ++current_vertex_;
 
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h
index f06cab71..9e9ae961 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
 #define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
 
@@ -103,7 +104,7 @@ class Vertex_iterator : public boost::iterator_facade< Vertex_iterator <Skeleton
 };
 
 template<typename SkeletonBlockerComplex>
-class Neighbors_vertices_iterator: public boost::iterator_facade < Neighbors_vertices_iterator<SkeletonBlockerComplex>
+class Neighbors_vertices_iterator : public boost::iterator_facade < Neighbors_vertices_iterator<SkeletonBlockerComplex>
 , typename SkeletonBlockerComplex::Vertex_handle const
 , boost::forward_traversal_tag
 , typename SkeletonBlockerComplex::Vertex_handle const> {
@@ -122,9 +123,6 @@ class Neighbors_vertices_iterator: public boost::iterator_facade < Neighbors_ver
   boost_adjacency_iterator end_;
 
  public:
-  // boost_adjacency_iterator ai, ai_end;
-  // for (tie(ai, ai_end) = adjacent_vertices(v.vertex, skeleton); ai != ai_end; ++ai) {
-
   Neighbors_vertices_iterator() : complex(NULL) { }
 
   Neighbors_vertices_iterator(const Complex* complex_, Vertex_handle v_) :
@@ -157,7 +155,7 @@ class Neighbors_vertices_iterator: public boost::iterator_facade < Neighbors_ver
   }
 
  private:
-  // todo remove this ugly hack
+  // TODO(DS): remove this ugly hack
   void set_end() {
     current_ = end_;
   }
@@ -170,5 +168,3 @@ namespace skbl = skeleton_blocker;
 }  // namespace Gudhi
 
 #endif  // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
-
-
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_complex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_complex.h
index 7a6d1d50..c1a0cf2d 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_complex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_complex.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -104,8 +104,8 @@ class Skeleton_blocker_complex {
   typedef typename Simplex::Simplex_vertex_const_iterator Simplex_handle_iterator;
 
  protected:
-  typedef typename boost::adjacency_list<boost::setS,  // edges
-  boost::vecS,  // vertices
+  typedef typename boost::adjacency_list<boost::setS, // edges
+  boost::vecS, // vertices
   boost::undirectedS, Graph_vertex, Graph_edge> Graph;
   // todo/remark : edges are not sorted, it heavily penalizes computation for SuperiorLink
   // (eg Link with greater vertices)
@@ -211,7 +211,6 @@ class Skeleton_blocker_complex {
       add_edge_without_blockers(e.first, e.second);
   }
 
-
   template<typename SimpleHandleOutputIterator>
   void add_blockers(SimpleHandleOutputIterator simplices_begin, SimpleHandleOutputIterator simplices_end) {
     Tries<Simplex> tries(num_vertices(), simplices_begin, simplices_end);
@@ -414,7 +413,8 @@ class Skeleton_blocker_complex {
   /**
    */
   bool contains_vertex(Vertex_handle u) const {
-    if (u.vertex < 0 || u.vertex >= boost::num_vertices(skeleton))
+    Vertex_handle num_vertices(boost::num_vertices(skeleton));
+    if (u.vertex < 0 || u.vertex >= num_vertices)
       return false;
     return (*this)[u].is_active();
   }
@@ -441,11 +441,11 @@ class Skeleton_blocker_complex {
    * @brief Given an Id return the address of the vertex having this Id in the complex.
    * @remark For a simplicial complex, the address is the id but it may not be the case for a SubComplex.
    */
-  virtual boost::optional<Vertex_handle> get_address(
-                                                     Root_vertex_handle id) const {
+  virtual boost::optional<Vertex_handle> get_address(Root_vertex_handle id) const {
     boost::optional<Vertex_handle> res;
-    if (id.vertex < boost::num_vertices(skeleton))
-      res = Vertex_handle(id.vertex);  // xxx
+    int num_vertices = boost::num_vertices(skeleton);
+    if (id.vertex < num_vertices)
+      res = Vertex_handle(id.vertex); // xxx
     return res;
   }
 
@@ -560,7 +560,7 @@ class Skeleton_blocker_complex {
     return res;
   }
 
-    /**
+  /**
    * @brief Adds all edges of s in the complex.
    */
   void add_edge(const Simplex& s) {
@@ -591,7 +591,6 @@ class Skeleton_blocker_complex {
     return *edge_handle;
   }
 
-
   /**
    * @brief Adds all edges of s in the complex without adding blockers.
    */
@@ -844,12 +843,13 @@ class Skeleton_blocker_complex {
     boost_adjacency_iterator ai, ai_end;
     for (tie(ai, ai_end) = adjacent_vertices(v.vertex, skeleton); ai != ai_end;
          ++ai) {
+      Vertex_handle value(*ai);
       if (keep_only_superior) {
-        if (*ai > v.vertex) {
-          n.add_vertex(Vertex_handle(*ai));
+        if (value > v.vertex) {
+          n.add_vertex(value);
         }
       } else {
-        n.add_vertex(Vertex_handle(*ai));
+        n.add_vertex(value);
       }
     }
   }
@@ -929,7 +929,7 @@ class Skeleton_blocker_complex {
   // xxx rename get_address et place un using dans sub_complex
 
   boost::optional<Simplex> get_simplex_address(
-                                                      const Root_simplex_handle& s) const {
+                                               const Root_simplex_handle& s) const {
     boost::optional<Simplex> res;
 
     Simplex s_address;
@@ -1001,10 +1001,9 @@ class Skeleton_blocker_complex {
     return std::distance(triangles.begin(), triangles.end());
   }
 
-
   /*
    * @brief returns the number of simplices of a given dimension in the complex.
-   */  
+   */
   size_t num_simplices() const {
     auto simplices = complex_simplex_range();
     return std::distance(simplices.begin(), simplices.end());
@@ -1012,8 +1011,8 @@ class Skeleton_blocker_complex {
 
   /*
    * @brief returns the number of simplices of a given dimension in the complex.
-   */  
-  size_t num_simplices(unsigned dimension) const {
+   */
+  size_t num_simplices(int dimension) const {
     // TODO(DS): iterator on k-simplices
     size_t res = 0;
     for (const auto& s : complex_simplex_range())
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_geometric_complex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_geometric_complex.h
index 1130ca9f..95331b7a 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_geometric_complex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_geometric_complex.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_GEOMETRIC_COMPLEX_H_
 #define SKELETON_BLOCKER_GEOMETRIC_COMPLEX_H_
 
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_link_complex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_link_complex.h
index 1bd66289..906d3e86 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_link_complex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_link_complex.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_LINK_COMPLEX_H_
 #define SKELETON_BLOCKER_LINK_COMPLEX_H_
 
@@ -39,7 +40,7 @@ template<class ComplexType> class Skeleton_blocker_sub_complex;
  */
 template<typename ComplexType>
 class Skeleton_blocker_link_complex : public Skeleton_blocker_sub_complex<
-    ComplexType> {
+ComplexType> {
   template<typename T> friend class Skeleton_blocker_link_superior;
   typedef typename ComplexType::Edge_handle Edge_handle;
 
@@ -60,8 +61,7 @@ class Skeleton_blocker_link_complex : public Skeleton_blocker_sub_complex<
   typedef typename ComplexType::Root_simplex_handle::Simplex_vertex_const_iterator Root_simplex_handle_iterator;
 
   explicit Skeleton_blocker_link_complex(bool only_superior_vertices = false)
-      : only_superior_vertices_(only_superior_vertices) {
-  }
+      : only_superior_vertices_(only_superior_vertices) { }
 
   /**
    * If the parameter only_superior_vertices is true,
@@ -95,10 +95,10 @@ class Skeleton_blocker_link_complex : public Skeleton_blocker_sub_complex<
    */
   Skeleton_blocker_link_complex(const ComplexType & parent_complex,
                                 Edge_handle edge, bool only_superior_vertices =
-                                    false)
+                                false)
       : only_superior_vertices_(only_superior_vertices) {
     Simplex alpha_simplex(parent_complex.first_vertex(edge),
-                                 parent_complex.second_vertex(edge));
+                          parent_complex.second_vertex(edge));
     build_link(parent_complex, alpha_simplex);
   }
 
@@ -151,7 +151,7 @@ class Skeleton_blocker_link_complex : public Skeleton_blocker_sub_complex<
                              bool only_superior_vertices) {
     // for a vertex we know exactly the number of vertices of the link (and the size of the corresponding vector
     this->skeleton.m_vertices.reserve(
-        parent_complex.degree(alpha_parent_adress));
+                                      parent_complex.degree(alpha_parent_adress));
 
     // For all vertex 'v' in this intersection, we go through all its adjacent blockers.
     // If one blocker minus 'v' is included in alpha then the vertex is not in the link complex.
@@ -169,21 +169,21 @@ class Skeleton_blocker_link_complex : public Skeleton_blocker_sub_complex<
       return;
 
     for (auto x_link = this->vertex_range().begin();
-        x_link != this->vertex_range().end(); ++x_link) {
+         x_link != this->vertex_range().end(); ++x_link) {
       for (auto y_link = x_link; ++y_link != this->vertex_range().end();) {
         Vertex_handle x_parent = *parent_complex.get_address(
-            this->get_id(*x_link));
+                                                             this->get_id(*x_link));
         Vertex_handle y_parent = *parent_complex.get_address(
-            this->get_id(*y_link));
+                                                             this->get_id(*y_link));
         if (parent_complex.contains_edge(x_parent, y_parent)) {
           // we check that there is no blocker subset of alpha passing trough x and y
           bool new_edge = true;
           for (auto blocker_parent : parent_complex.const_blocker_range(
-              x_parent)) {
+                                                                        x_parent)) {
             if (!is_alpha_blocker || *blocker_parent != alpha_parent_adress) {
               if (blocker_parent->contains(y_parent)) {
                 new_edge = !(alpha_parent_adress.contains_difference(
-                    *blocker_parent, x_parent, y_parent));
+                                                                     *blocker_parent, x_parent, y_parent));
                 if (!new_edge)
                   break;
               }
@@ -202,7 +202,7 @@ class Skeleton_blocker_link_complex : public Skeleton_blocker_sub_complex<
    * It assumes that other_complex have a vertex 'this.get_id(address)'
    */
   boost::optional<Vertex_handle> give_equivalent_vertex(
-      const ComplexType & other_complex, Vertex_handle address) const {
+                                                        const ComplexType & other_complex, Vertex_handle address) const {
     Root_vertex_handle id((*this)[address].get_id());
     return other_complex.get_address(id);
   }
@@ -269,7 +269,7 @@ class Skeleton_blocker_link_complex : public Skeleton_blocker_sub_complex<
                   bool only_vertices = false) {
     assert(is_alpha_blocker || parent_complex.contains(alpha_parent_adress));
     compute_link_vertices(parent_complex, alpha_parent_adress, only_superior_vertices_);
-    if(!only_vertices) {
+    if (!only_vertices) {
       compute_link_edges(parent_complex, alpha_parent_adress, is_alpha_blocker);
       compute_link_blockers(parent_complex, alpha_parent_adress, is_alpha_blocker);
     }
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_simplifiable_complex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_simplifiable_complex.h
index 171efd4b..fcb6bafe 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_simplifiable_complex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_simplifiable_complex.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SIMPLIFIABLE_COMPLEX_H_
 #define SKELETON_BLOCKER_SIMPLIFIABLE_COMPLEX_H_
 
@@ -33,7 +34,7 @@ namespace Gudhi {
 namespace skeleton_blocker {
 
 /**
- * Returns true iff the blocker 'sigma' is popable.
+ * Returns true if the blocker 'sigma' is popable.
  * To define popable, let us call 'L' the complex that
  * consists in the current complex without the blocker 'sigma'.
  * A blocker 'sigma' is then "popable" if the link of 'sigma'
@@ -146,7 +147,7 @@ void Skeleton_blocker_complex<SkeletonBlockerDS>::remove_star(Vertex_handle v) {
  */
 template<typename SkeletonBlockerDS>
 void Skeleton_blocker_complex<SkeletonBlockerDS>::update_blockers_after_remove_star_of_vertex_or_edge(
-    const Simplex& simplex_to_be_removed) {
+                                                                                                      const Simplex& simplex_to_be_removed) {
   std::list <Blocker_handle> blockers_to_update;
   if (simplex_to_be_removed.empty()) return;
 
@@ -224,8 +225,6 @@ void Skeleton_blocker_complex<SkeletonBlockerDS>::add_simplex(const Simplex& sig
   add_blockers_after_simplex_insertion(sigma);
 }
 
-
-
 template<typename SkeletonBlockerDS>
 void Skeleton_blocker_complex<SkeletonBlockerDS>::add_blockers_after_simplex_insertion(Simplex sigma) {
   if (sigma.dimension() < 1) return;
@@ -385,7 +384,7 @@ Skeleton_blocker_complex<SkeletonBlockerDS>::contract_edge(Vertex_handle a, Vert
 
 template<typename SkeletonBlockerDS>
 void Skeleton_blocker_complex<SkeletonBlockerDS>::get_blockers_to_be_added_after_contraction(Vertex_handle a,
-    Vertex_handle b, std::set<Simplex>& blockers_to_add) {
+                                                                                             Vertex_handle b, std::set<Simplex>& blockers_to_add) {
   blockers_to_add.clear();
 
   typedef Skeleton_blocker_link_complex<Skeleton_blocker_complex<SkeletonBlockerDS> > LinkComplexType;
diff --git a/src/Skeleton_blocker/test/TestGeometricComplex.cpp b/src/Skeleton_blocker/test/TestGeometricComplex.cpp
index 9edb13fe..102162c5 100644
--- a/src/Skeleton_blocker/test/TestGeometricComplex.cpp
+++ b/src/Skeleton_blocker/test/TestGeometricComplex.cpp
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
diff --git a/src/Skeleton_blocker/test/TestSimplifiable.cpp b/src/Skeleton_blocker/test/TestSimplifiable.cpp
index 76736240..6646734d 100644
--- a/src/Skeleton_blocker/test/TestSimplifiable.cpp
+++ b/src/Skeleton_blocker/test/TestSimplifiable.cpp
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -20,14 +20,12 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 #include <fstream>
 #include <sstream>
 #include "gudhi/Test.h"
-//#include "Skeleton_blocker/Simplex.h"
 #include "gudhi/Skeleton_blocker.h"
 
 
@@ -406,11 +404,11 @@ int main(int argc, char *argv[]) {
   tests_simplifiable_complex.add("Test collapse 2", test_collapse2);
   tests_simplifiable_complex.add("Test collapse 3", test_collapse3);
 
-  tests_simplifiable_complex.add("Test add edge",test_add_edge);
+  tests_simplifiable_complex.add("Test add edge", test_add_edge);
   tests_simplifiable_complex.add("Test add simplex", test_add_simplex);
   tests_simplifiable_complex.add("Test add simplex2", test_add_simplex2);
-  tests_simplifiable_complex.add("Test add simplex3",test_add_simplex3);
-  tests_simplifiable_complex.add("Test add simplex4",test_add_simplex4);
+  tests_simplifiable_complex.add("Test add simplex3", test_add_simplex3);
+  tests_simplifiable_complex.add("Test add simplex4", test_add_simplex4);
 
 
   tests_simplifiable_complex.run();
diff --git a/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp b/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp
index 6e891483..f61cffac 100644
--- a/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp
+++ b/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    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
@@ -27,10 +27,6 @@
 #include "gudhi/Debug_utils.h"
 #include "gudhi/Test.h"
 #include "gudhi/Skeleton_blocker.h"
-//#include "gudhi/Skeleton_blocker_link_complex.h"
-//#include "gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h"
-//#include "gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h"
-//#include "gudhi/Skeleton_blocker/internal/Trie.h"
 
 using namespace std;
 
@@ -946,7 +942,4 @@ int main(int argc, char *argv[]) {
   } else {
     return EXIT_FAILURE;
   }
-
-  //	test_iterator_simplices();
 }
-