cpplint fixes on Contraction + warning fixes + Hide Hasse complex for Gudhi version 1.2.0

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

Former-commit-id: ed7bf90a9ae0b000b995c6ae4bbdaedbb1a65dd5

18 files changed, 598 insertions, 706 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 76e55d43..ae089562 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -75,9 +75,6 @@ else()
   add_subdirectory(src/Skeleton_blocker/test) 
   add_subdirectory(src/Skeleton_blocker/example) 
   add_subdirectory(src/Contraction/example)
-  add_subdirectory(src/Hasse_complex/example)
-  add_subdirectory(src/Bottleneck/example)
-  add_subdirectory(src/Bottleneck/test)
 
   # data points generator
   add_subdirectory(data/points/generator)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index b782b9f3..a84090e9 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -48,8 +48,6 @@ else()
   add_subdirectory(example/Persistent_cohomology)                   
   add_subdirectory(example/Skeleton_blocker)                   
   add_subdirectory(example/Contraction)                   
-  add_subdirectory(example/Hasse_complex)
-  add_subdirectory(example/Bottleneck)
 
   # data points generator
   add_subdirectory(data/points/generator)
diff --git a/src/Contraction/include/gudhi/Contraction/CGAL_queue/Modifiable_priority_queue.h b/src/Contraction/include/gudhi/Contraction/CGAL_queue/Modifiable_priority_queue.h
index f4eb59fd..28ae535d 100644
--- a/src/Contraction/include/gudhi/Contraction/CGAL_queue/Modifiable_priority_queue.h
+++ b/src/Contraction/include/gudhi/Contraction/CGAL_queue/Modifiable_priority_queue.h
@@ -21,10 +21,12 @@
 
 #define CGAL_SURFACE_MESH_SIMPLIFICATION_USE_RELAXED_HEAP
 
-#include <climits> // Neeeded by the following Boost header for CHAR_BIT.
 #include <boost/optional.hpp>
 #include <boost/pending/relaxed_heap.hpp>
 
+#include <climits>  // Neeeded by the following Boost header for CHAR_BIT.
+#include <functional>  // for less
+
 namespace CGAL {
 
 template <class IndexedType_, class Compare_ = std::less<IndexedType_>, class ID_ = boost::identity_property_map>
@@ -94,6 +96,6 @@ class Modifiable_priority_queue {
   Heap mHeap;
 };
 
-}  //namespace CGAL
+}  // namespace CGAL
 
 #endif  // CONTRACTION_CGAL_MODIFIABLE_PRIORITY_QUEUE_H
diff --git a/src/Contraction/include/gudhi/Contraction/policies/Contraction_visitor.h b/src/Contraction/include/gudhi/Contraction/policies/Contraction_visitor.h
index b8b1e87a..7ee05aad 100644
--- a/src/Contraction/include/gudhi/Contraction/policies/Contraction_visitor.h
+++ b/src/Contraction/include/gudhi/Contraction/policies/Contraction_visitor.h
@@ -1,32 +1,32 @@
- /*    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/>.
-  */
-
-#ifndef GUDHI_CONTRACTION_VISITOR_H_
-#define GUDHI_CONTRACTION_VISITOR_H_
-
-#include "gudhi/Contraction/Edge_profile.h"
-#include "boost/optional.hpp"
-
-namespace Gudhi{
+/*    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/>.
+ */
+
+#ifndef CONTRACTION_POLICIES_CONTRACTION_VISITOR_H_
+#define CONTRACTION_POLICIES_CONTRACTION_VISITOR_H_
+
+#include <gudhi/Contraction/Edge_profile.h>
+#include <boost/optional.hpp>
+
+namespace Gudhi {
 
 namespace contraction {
 
@@ -36,66 +36,56 @@ namespace contraction {
  *@ingroup contr
  */
 template <typename EdgeProfile>
-class Contraction_visitor {//: public Dummy_complex_visitor<typename EdgeProfile::Vertex_handle>  {
-public:
-	//typedef typename ComplexType::GeometryTrait GT;
-	typedef EdgeProfile Profile;
-	typedef double FT;
-	typedef typename Profile::Complex Complex;
-	typedef Complex ComplexType;
-	typedef typename ComplexType::Point Point;
-
-
-	virtual ~Contraction_visitor(){};
-
-	/**
-	 * @brief Called before the edge contraction process starts.
-	 */
-	virtual void on_started (ComplexType & complex){}
-
-	/**
-	 * @brief Called when the algorithm stops.
-	 */
-	virtual void on_stop_condition_reached (){}
-
-
-	/**
-	 * @brief Called during the collecting phase (when a cost is assigned to the edges), for each edge collected.
-	 */
-	virtual void on_collected (const Profile &profile, boost::optional< FT > cost){}
-
-	/**
-	 * @brief Called during the processing phase (when edges are contracted), for each edge that is selected.
-	 */
-	virtual void on_selected (const Profile &profile, boost::optional< FT > cost, int initial_count, int current_count){}
-
-
-	/**
-	 * @brief Called when an edge is about to be contracted and replaced by a vertex whose position is *placement.
-	 */
-	virtual void on_contracting(const Profile &profile, boost::optional< Point > placement){
-	}
-
-
-
-	/**
-	 * @brief Called when after an edge has been contracted onto a new point placement.
-	 * A possibility would to remove popable blockers at this point for instance.
-	 */
-	virtual void on_contracted(const Profile  &profile, boost::optional< Point > placement){
-
-	}
-
-
-	/**
-	 * @brief Called for each selected edge which cannot be contracted because the ValidContractionPredicate is false
-	 */
-	virtual void on_non_valid(const Profile  &profile){}
-
+class Contraction_visitor {  // : public Dummy_complex_visitor<typename EdgeProfile::Vertex_handle>  {
+ public:
+  // typedef typename ComplexType::GeometryTrait GT;
+  typedef EdgeProfile Profile;
+  typedef double FT;
+  typedef typename Profile::Complex Complex;
+  typedef Complex ComplexType;
+  typedef typename ComplexType::Point Point;
+
+  virtual ~Contraction_visitor() { }
+
+  /**
+   * @brief Called before the edge contraction process starts.
+   */
+  virtual void on_started(ComplexType & complex) { }
+
+  /**
+   * @brief Called when the algorithm stops.
+   */
+  virtual void on_stop_condition_reached() { }
+
+  /**
+   * @brief Called during the collecting phase (when a cost is assigned to the edges), for each edge collected.
+   */
+  virtual void on_collected(const Profile &profile, boost::optional< FT > cost) { }
+
+  /**
+   * @brief Called during the processing phase (when edges are contracted), for each edge that is selected.
+   */
+  virtual void on_selected(const Profile &profile, boost::optional< FT > cost, int initial_count, int current_count) { }
+
+  /**
+   * @brief Called when an edge is about to be contracted and replaced by a vertex whose position is *placement.
+   */
+  virtual void on_contracting(const Profile &profile, boost::optional< Point > placement) { }
+
+  /**
+   * @brief Called when after an edge has been contracted onto a new point placement.
+   * A possibility would to remove popable blockers at this point for instance.
+   */
+  virtual void on_contracted(const Profile &profile, boost::optional< Point > placement) { }
+
+  /**
+   * @brief Called for each selected edge which cannot be contracted because the ValidContractionPredicate is false
+   */
+  virtual void on_non_valid(const Profile &profile) { }
 };
 
 }  // namespace contraction
 
-}  // namespace GUDHI
+}  // namespace Gudhi
 
-#endif /* GUDHI_CONTRACTION_VISITOR_H_ */
+#endif  // CONTRACTION_POLICIES_CONTRACTION_VISITOR_H_
diff --git a/src/Contraction/include/gudhi/Contraction/policies/Cost_policy.h b/src/Contraction/include/gudhi/Contraction/policies/Cost_policy.h
index 3cb18c86..f4d343ec 100644
--- a/src/Contraction/include/gudhi/Contraction/policies/Cost_policy.h
+++ b/src/Contraction/include/gudhi/Contraction/policies/Cost_policy.h
@@ -1,51 +1,53 @@
- /*    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/>.
-  */
-
-#ifndef GUDHI_COST_POLICY_H_
-#define GUDHI_COST_POLICY_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.
+ *
+ *    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/>.
+ */
+
+#ifndef CONTRACTION_POLICIES_COST_POLICY_H_
+#define CONTRACTION_POLICIES_COST_POLICY_H_
 
 #include <boost/optional.hpp>
 
-namespace Gudhi{
+namespace Gudhi {
 
 namespace contraction {
 
 /**
-*@brief Policy to specify the cost of contracting an edge.
+ *@brief Policy to specify the cost of contracting an edge.
  *@ingroup contr
-*/ 
-template< typename EdgeProfile> class Cost_policy{
-public:
-	typedef typename EdgeProfile::Point Point;
-	typedef typename EdgeProfile::Graph_vertex Graph_vertex;
+ */
+template< typename EdgeProfile>
+class Cost_policy {
+ public:
+  typedef typename EdgeProfile::Point Point;
+  typedef typename EdgeProfile::Graph_vertex Graph_vertex;
 
-	typedef boost::optional<double> Cost_type;
+  typedef boost::optional<double> Cost_type;
 
-	virtual Cost_type operator()(const EdgeProfile& profile, const boost::optional<Point>& placement) const =0;
-	virtual ~Cost_policy(){
-	};
+  virtual Cost_type operator()(const EdgeProfile& profile, const boost::optional<Point>& placement) const = 0;
+
+  virtual ~Cost_policy() { }
 };
 
 }  // namespace contraction
 
-}  // namespace GUDHI
-#endif /* GUDHI_COST_POLICY_H_ */
+}  // namespace Gudhi
+
+#endif  // CONTRACTION_POLICIES_COST_POLICY_H_
diff --git a/src/Contraction/include/gudhi/Contraction/policies/Dummy_valid_contraction.h b/src/Contraction/include/gudhi/Contraction/policies/Dummy_valid_contraction.h
index de473944..5d329496 100644
--- a/src/Contraction/include/gudhi/Contraction/policies/Dummy_valid_contraction.h
+++ b/src/Contraction/include/gudhi/Contraction/policies/Dummy_valid_contraction.h
@@ -1,51 +1,49 @@
- /*    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/>.
-  */
-
-#ifndef GUDHI_DUMMY_VALID_CONTRACTION_H_
-#define GUDHI_DUMMY_VALID_CONTRACTION_H_
-
-#include "Valid_contraction_policy.h"
-
-namespace Gudhi{
+/*    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/>.
+ */
+
+#ifndef CONTRACTION_POLICIES_DUMMY_VALID_CONTRACTION_H_
+#define CONTRACTION_POLICIES_DUMMY_VALID_CONTRACTION_H_
+
+#include <gudhi/Contraction/policies/Valid_contraction_policy.h>
+
+namespace Gudhi {
 
 namespace contraction {
 
-
-
-  /**
-  *@brief Policy that accept all edge contraction.
-  */
-template< typename EdgeProfile> class Dummy_valid_contraction : public Valid_contraction_policy<EdgeProfile>{
-public:
-	typedef typename EdgeProfile::Point Point;
-	bool operator()(const EdgeProfile& profile,const boost::optional<Point>& placement){
-		return true;
-	}
+/**
+ *@brief Policy that accept all edge contraction.
+ */
+template< typename EdgeProfile>
+class Dummy_valid_contraction : public Valid_contraction_policy<EdgeProfile> {
+ public:
+  typedef typename EdgeProfile::Point Point;
+
+  bool operator()(const EdgeProfile& profile, const boost::optional<Point>& placement) {
+    return true;
+  }
 };
 
 }  // namespace contraction
 
-}  // namespace GUDHI
-
-
+}  // namespace Gudhi
 
-#endif /* GUDHI_DUMMY_VALID_CONTRACTION_H_ */
+#endif  // CONTRACTION_POLICIES_DUMMY_VALID_CONTRACTION_H_
diff --git a/src/Contraction/include/gudhi/Contraction/policies/Edge_length_cost.h b/src/Contraction/include/gudhi/Contraction/policies/Edge_length_cost.h
index b22ada0d..e4beb220 100644
--- a/src/Contraction/include/gudhi/Contraction/policies/Edge_length_cost.h
+++ b/src/Contraction/include/gudhi/Contraction/policies/Edge_length_cost.h
@@ -1,56 +1,56 @@
- /*    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/>.
-  */
-
-#ifndef GUDHI_EDGE_LENGTH_COST_H_
-#define GUDHI_EDGE_LENGTH_COST_H_
-
-#include "Cost_policy.h"
-
-namespace Gudhi{
+/*    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/>.
+ */
 
-namespace contraction {
+#ifndef CONTRACTION_POLICIES_DUMMY_EDGE_LENGTH_COST_H_
+#define CONTRACTION_POLICIES_DUMMY_EDGE_LENGTH_COST_H_
+
+#include <gudhi/Contraction/policies/Cost_policy.h>
 
+namespace Gudhi {
+
+namespace contraction {
 
 /**
  * @brief return a cost corresponding to the squared length of the edge
  */
-template< typename EdgeProfile> class Edge_length_cost : public Cost_policy<EdgeProfile>{
-public:
-	typedef typename Cost_policy<EdgeProfile>::Cost_type Cost_type;
-	typedef typename EdgeProfile::Point Point;
-	Cost_type operator()(const EdgeProfile& profile, const boost::optional<Point>& placement) const override{
-		double res = 0;
-		auto p0_coord = profile.p0().begin();
-		auto p1_coord = profile.p1().begin();
-		for(; p0_coord != profile.p0().end(); p0_coord++, p1_coord++){
-			res += (*p0_coord - *p1_coord) * (*p0_coord - *p1_coord);
-		}
-		return res;
-	}
-
+template< typename EdgeProfile>
+class Edge_length_cost : public Cost_policy<EdgeProfile> {
+ public:
+  typedef typename Cost_policy<EdgeProfile>::Cost_type Cost_type;
+  typedef typename EdgeProfile::Point Point;
+
+  Cost_type operator()(const EdgeProfile& profile, const boost::optional<Point>& placement) const override {
+    double res = 0;
+    auto p0_coord = profile.p0().begin();
+    auto p1_coord = profile.p1().begin();
+    for (; p0_coord != profile.p0().end(); p0_coord++, p1_coord++) {
+      res += (*p0_coord - *p1_coord) * (*p0_coord - *p1_coord);
+    }
+    return res;
+  }
 };
 
 }  // namespace contraction
 
-}  // namespace GUDHI
+}  // namespace Gudhi
 
-#endif /* GUDHI_EDGE_LENGTH_COST_H_ */
+#endif  // CONTRACTION_POLICIES_DUMMY_EDGE_LENGTH_COST_H_
diff --git a/src/Contraction/include/gudhi/Contraction/policies/First_vertex_placement.h b/src/Contraction/include/gudhi/Contraction/policies/First_vertex_placement.h
index 93abac35..1f68db0d 100644
--- a/src/Contraction/include/gudhi/Contraction/policies/First_vertex_placement.h
+++ b/src/Contraction/include/gudhi/Contraction/policies/First_vertex_placement.h
@@ -1,53 +1,52 @@
- /*    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/>.
-  */
-
-#ifndef GUDHI_FIRST_VERTEX_PLACEMENT_H_
-#define GUDHI_FIRST_VERTEX_PLACEMENT_H_
-
-#include "Placement_policy.h"
-
-namespace Gudhi{
+/*    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/>.
+ */
 
-namespace contraction {
+#ifndef CONTRACTION_POLICIES_FIRST_VERTEX_PLACEMENT_H_
+#define CONTRACTION_POLICIES_FIRST_VERTEX_PLACEMENT_H_
+
+#include <gudhi/Contraction/policies/Placement_policy.h>
+
+namespace Gudhi {
 
+namespace contraction {
 
 /**
  * @brief Places the contracted point onto the first point of the edge
  */
-template< typename EdgeProfile> class First_vertex_placement : public Placement_policy<EdgeProfile>{
-
-public:
-	typedef typename EdgeProfile::Point Point;
-	typedef typename EdgeProfile::Edge_handle Edge_handle;
+template< typename EdgeProfile>
+class First_vertex_placement : public Placement_policy<EdgeProfile> {
+ public:
+  typedef typename EdgeProfile::Point Point;
+  typedef typename EdgeProfile::Edge_handle Edge_handle;
 
-	typedef typename Placement_policy<EdgeProfile>::Placement_type Placement_type;
+  typedef typename Placement_policy<EdgeProfile>::Placement_type Placement_type;
 
-	Placement_type operator()(const EdgeProfile& profile) const override{
-		return Placement_type(profile.p0());
-	}
+  Placement_type operator()(const EdgeProfile& profile) const override {
+    return Placement_type(profile.p0());
+  }
 };
-}  // namespace contraction
 
-}  // namespace GUDHI
+}  // namespace contraction
 
+}  // namespace Gudhi
 
-#endif /* GUDHI_FIRST_VERTEX_PLACEMENT_H_ */
+#endif  // CONTRACTION_POLICIES_FIRST_VERTEX_PLACEMENT_H_
diff --git a/src/Contraction/include/gudhi/Contraction/policies/Link_condition_valid_contraction.h b/src/Contraction/include/gudhi/Contraction/policies/Link_condition_valid_contraction.h
index c901e629..919df243 100644
--- a/src/Contraction/include/gudhi/Contraction/policies/Link_condition_valid_contraction.h
+++ b/src/Contraction/include/gudhi/Contraction/policies/Link_condition_valid_contraction.h
@@ -1,54 +1,56 @@
- /*    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/>.
-  */
-
-#ifndef GUDHI_LINK_CONDITION_VALID_CONTRACTION_H_
-#define GUDHI_LINK_CONDITION_VALID_CONTRACTION_H_
-
-#include "gudhi/Utils.h"
-#include "Valid_contraction_policy.h"
-
-
-namespace Gudhi{
+/*    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/>.
+ */
+
+#ifndef CONTRACTION_POLICIES_LINK_CONDITION_VALID_CONTRACTION_H_
+#define CONTRACTION_POLICIES_LINK_CONDITION_VALID_CONTRACTION_H_
+
+#include <gudhi/Utils.h>
+#include <gudhi/Contraction/policies/Valid_contraction_policy.h>
+
+
+namespace Gudhi {
 
 namespace contraction {
 
-
-  /**
-  *@brief Policy that only accept edges verifying the link condition (and therefore whose contraction preserving homotopy type). 
-  *@ingroup contr
-  */
-template< typename EdgeProfile> class Link_condition_valid_contraction : public Valid_contraction_policy<EdgeProfile>{
-public:
-	typedef typename EdgeProfile::Edge_handle Edge_handle;
-	typedef typename EdgeProfile::Point Point;
-	//typedef typename EdgeProfile::Edge_handle Edge_handle;
-	bool operator()(const EdgeProfile& profile,const boost::optional<Point>& placement) const override{
-		Edge_handle edge(profile.edge_handle());
-		DBGMSG("Link_condition_valid_contraction:",profile.complex().link_condition(edge));
-		return profile.complex().link_condition(edge);
-	}
+/**
+ *@brief Policy that only accept edges verifying the link condition (and therefore whose contraction preserving homotopy type). 
+ *@ingroup contr
+ */
+template< typename EdgeProfile>
+class Link_condition_valid_contraction : public Valid_contraction_policy<EdgeProfile> {
+ public:
+  typedef typename EdgeProfile::Edge_handle Edge_handle;
+  typedef typename EdgeProfile::Point Point;
+  // typedef typename EdgeProfile::Edge_handle Edge_handle;
+
+  bool operator()(const EdgeProfile& profile, const boost::optional<Point>& placement) const override {
+    Edge_handle edge(profile.edge_handle());
+    DBGMSG("Link_condition_valid_contraction:", profile.complex().link_condition(edge));
+    return profile.complex().link_condition(edge);
+  }
 };
+
 }  // namespace contraction
 
-}  // namespace GUDHI
+}  // namespace Gudhi
 
-#endif /* GUDHI_LINK_CONDITION_VALID_CONTRACTION_H_ */
+#endif  // CONTRACTION_POLICIES_LINK_CONDITION_VALID_CONTRACTION_H_
diff --git a/src/Contraction/include/gudhi/Contraction/policies/Middle_placement.h b/src/Contraction/include/gudhi/Contraction/policies/Middle_placement.h
index 30f0a570..4b59f1b5 100644
--- a/src/Contraction/include/gudhi/Contraction/policies/Middle_placement.h
+++ b/src/Contraction/include/gudhi/Contraction/policies/Middle_placement.h
@@ -1,52 +1,51 @@
- /*    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/>.
-  */
-
-#ifndef GUDHI_MIDDLE_PLACEMENT_H_
-#define GUDHI_MIDDLE_PLACEMENT_H_
-
-#include "Placement_policy.h"
-
-
-namespace Gudhi{
+/*    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/>.
+ */
+
+#ifndef CONTRACTION_POLICIES_MIDDLE_PLACEMENT_H_
+#define CONTRACTION_POLICIES_MIDDLE_PLACEMENT_H_
+
+#include <gudhi/Contraction/policies/Placement_policy.h>
+
+namespace Gudhi {
 
 namespace contraction {
 
+template< typename EdgeProfile>
+class Middle_placement : public Placement_policy<EdgeProfile> {
+ public:
+  typedef typename EdgeProfile::Point Point;
+  typedef typename EdgeProfile::Edge_handle Edge_handle;
+  typedef typename EdgeProfile::Graph_vertex Graph_vertex;
 
-  
-template< typename EdgeProfile> class Middle_placement : public Placement_policy<EdgeProfile>{
+  typedef typename Placement_policy<EdgeProfile>::Placement_type Placement_type;
 
-public:
-	typedef typename EdgeProfile::Point Point;
-	typedef typename EdgeProfile::Edge_handle Edge_handle;
-	typedef typename EdgeProfile::Graph_vertex Graph_vertex;
-
-	typedef typename Placement_policy<EdgeProfile>::Placement_type Placement_type;
-
-	Placement_type operator()(const EdgeProfile& profile) const override{
-		//todo compute the middle
-		return Placement_type(profile.p0());
-	}
+  Placement_type operator()(const EdgeProfile& profile) const override {
+    // todo compute the middle
+    return Placement_type(profile.p0());
+  }
 };
+
 }  // namespace contraction
-}  // namespace GUDHI
 
-#endif /* GUDHI_MIDDLE_PLACEMENT_H_ */
+}  // namespace Gudhi
+
+#endif  // CONTRACTION_POLICIES_MIDDLE_PLACEMENT_H_
diff --git a/src/Contraction/include/gudhi/Contraction/policies/Placement_policy.h b/src/Contraction/include/gudhi/Contraction/policies/Placement_policy.h
index 3a804cf0..34ffa49f 100644
--- a/src/Contraction/include/gudhi/Contraction/policies/Placement_policy.h
+++ b/src/Contraction/include/gudhi/Contraction/policies/Placement_policy.h
@@ -1,49 +1,51 @@
- /*    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/>.
-  */
-
-#ifndef GUDHI_PLACEMENT_POLICY_H_
-#define GUDHI_PLACEMENT_POLICY_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.
+ *
+ *    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/>.
+ */
+
+#ifndef CONTRACTION_POLICIES_PLACEMENT_POLICY_H_
+#define CONTRACTION_POLICIES_PLACEMENT_POLICY_H_
 
 #include <boost/optional.hpp>
 
 namespace Gudhi {
+
 namespace contraction {
 
+/**
+ *@brief Policy to specify where the merged point had to be placed after an edge contraction. 
+ *@ingroup contr
+ */
+template< typename EdgeProfile>
+class Placement_policy {
+ public:
+  typedef typename EdgeProfile::Point Point;
+  typedef boost::optional<Point> Placement_type;
 
-  /**
-  *@brief Policy to specify where the merged point had to be placed after an edge contraction. 
-  *@ingroup contr
-  */
-template< typename EdgeProfile> class Placement_policy{
-public:
-	typedef typename EdgeProfile::Point Point;
-	typedef boost::optional<Point> Placement_type;
+  virtual Placement_type operator()(const EdgeProfile& profile) const = 0;
 
-	virtual Placement_type operator()(const EdgeProfile& profile) const=0;
-	virtual ~Placement_policy(){};
+  virtual ~Placement_policy() { }
 };
 
-
 }  // namespace contraction
-}  // namespace GUDHI
 
-#endif /* GUDHI_PLACEMENT_POLICY_H_ */
+}  // namespace Gudhi
+
+#endif  // CONTRACTION_POLICIES_PLACEMENT_POLICY_H_
diff --git a/src/Contraction/include/gudhi/Contraction/policies/Valid_contraction_policy.h b/src/Contraction/include/gudhi/Contraction/policies/Valid_contraction_policy.h
index bee2ecd7..78d61173 100644
--- a/src/Contraction/include/gudhi/Contraction/policies/Valid_contraction_policy.h
+++ b/src/Contraction/include/gudhi/Contraction/policies/Valid_contraction_policy.h
@@ -1,47 +1,51 @@
- /*    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/>.
-  */
-
-#ifndef GUDHI_VALID_CONTRACTION_POLICY_H_
-#define GUDHI_VALID_CONTRACTION_POLICY_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.
+ *
+ *    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/>.
+ */
+
+#ifndef CONTRACTION_POLICIES_VALID_CONTRACTION_POLICY_H_
+#define CONTRACTION_POLICIES_VALID_CONTRACTION_POLICY_H_
 
 namespace Gudhi {
+
 namespace contraction {
 
-  /**
-  *@brief Policy to specify if an edge contraction is valid or not. 
-  *@ingroup contr
-  */
-template< typename EdgeProfile> class Valid_contraction_policy{
-public:
-	typedef typename EdgeProfile::Point Point;
-	typedef typename EdgeProfile::Edge_handle Edge_handle;
-	typedef typename EdgeProfile::Graph_vertex Graph_vertex;
-
-	virtual bool operator()(const EdgeProfile& profile,const boost::optional<Point>& placement) const =0;
-	virtual ~Valid_contraction_policy(){};
+/**
+ *@brief Policy to specify if an edge contraction is valid or not. 
+ *@ingroup contr
+ */
+template< typename EdgeProfile>
+class Valid_contraction_policy {
+ public:
+  typedef typename EdgeProfile::Point Point;
+  typedef typename EdgeProfile::Edge_handle Edge_handle;
+  typedef typename EdgeProfile::Graph_vertex Graph_vertex;
+
+  virtual bool operator()(const EdgeProfile& profile, const boost::optional<Point>& placement) const = 0;
+
+  virtual ~Valid_contraction_policy() { }
 };
 
 }  // namespace contraction
-}  // namespace GUDHI
+
+}  // namespace Gudhi
 
 
-#endif /* GUDHI_VALID_CONTRACTION_POLICY_H_ */
+#endif  // CONTRACTION_POLICIES_VALID_CONTRACTION_POLICY_H_
diff --git a/src/Hasse_complex/example/CMakeLists.txt b/src/Hasse_complex/example/CMakeLists.txt
deleted file mode 100644
index 564df49d..00000000
--- a/src/Hasse_complex/example/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.6)
-project(GUDHIHasseComplexExample)
-
-add_executable ( hasse_complex_from_simplex_tree hasse_complex_from_simplex_tree.cpp )
-add_test(hasse_complex_from_simplex_tree ${CMAKE_CURRENT_BINARY_DIR}/hasse_complex_from_simplex_tree)
diff --git a/src/Hasse_complex/example/hasse_complex_from_simplex_tree.cpp b/src/Hasse_complex/example/hasse_complex_from_simplex_tree.cpp
deleted file mode 100644
index 1de43ab7..00000000
--- a/src/Hasse_complex/example/hasse_complex_from_simplex_tree.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-/*    This file is part of the Gudhi Library. The Gudhi library
- *    (Geometric Understanding in Higher Dimensions) is a generic C++
- *    library for computational topology.
- *
- *    Author(s):       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 <iostream>
-#include <ctime>
-#include "gudhi/graph_simplicial_complex.h"
-#include "gudhi/Simplex_tree.h"
-
-using namespace Gudhi;
-
-typedef std::vector< Vertex_handle > typeVectorVertex;
-typedef std::pair<typeVectorVertex, Filtration_value> typeSimplex;
-typedef std::pair< Simplex_tree<>::Simplex_handle, bool > typePairSimplexBool;
-typedef Simplex_tree<> typeST;
-
-int main(int argc, char * const argv[]) {
-  // TEST OF INSERTION
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "TEST OF INSERTION" << std::endl;
-  typeST st;
-
-  // ++ FIRST
-  std::cout << "   - INSERT (2,1,0)" << std::endl;
-  typeVectorVertex SimplexVector1;
-  SimplexVector1.push_back(2);
-  SimplexVector1.push_back(1);
-  SimplexVector1.push_back(0);
-  st.insert_simplex_and_subfaces(SimplexVector1, 0.3);
-
-  // ++ SECOND
-  std::cout << "   - INSERT 3" << std::endl;
-  typeVectorVertex SimplexVector2;
-  SimplexVector2.push_back(3);
-  st.insert_simplex_and_subfaces(SimplexVector2, 0.1);
-
-  // ++ THIRD
-  std::cout << "   - INSERT (0,3)" << std::endl;
-  typeVectorVertex SimplexVector3;
-  SimplexVector3.push_back(3);
-  SimplexVector3.push_back(0);
-  st.insert_simplex_and_subfaces(SimplexVector3, 0.2);
-
-  // ++ FOURTH
-  std::cout << "   - INSERT (1,0) (already inserted)" << std::endl;
-  typeVectorVertex SimplexVector4;
-  SimplexVector4.push_back(1);
-  SimplexVector4.push_back(0);
-  st.insert_simplex_and_subfaces(SimplexVector4, 0.2);
-
-  // ++ FIFTH
-  std::cout << "   - INSERT (3,4,5)" << std::endl;
-  typeVectorVertex SimplexVector5;
-  SimplexVector5.push_back(3);
-  SimplexVector5.push_back(4);
-  SimplexVector5.push_back(5);
-  st.insert_simplex_and_subfaces(SimplexVector5, 0.3);
-
-  // ++ SIXTH
-  std::cout << "   - INSERT (0,1,6,7)" << std::endl;
-  typeVectorVertex SimplexVector6;
-  SimplexVector6.push_back(0);
-  SimplexVector6.push_back(1);
-  SimplexVector6.push_back(6);
-  SimplexVector6.push_back(7);
-  st.insert_simplex_and_subfaces(SimplexVector6, 0.4);
-
-  /* Inserted simplex:         */
-  /*    1   6                  */
-  /*    o---o                  */
-  /*   /X\7/      4            */
-  /*  o---o---o---o            */
-  /*  2   0   3\X/             */
-  /*            o              */
-  /*            5              */
-
-  /* In other words:          */
-  /*   A facet [2,1,0]        */
-  /*   An edge [0,3]          */
-  /*   A facet [3,4,5]        */
-  /*   A cell  [0,1,6,7]      */
-  /*   A cell  [4,5,8,9]      */
-  /*   A facet [9,10,11]      */
-  /*   An edge [11,6]         */
-  /*   An edge [10,12,2]      */
-
-  // ++ GENERAL VARIABLE SET
-  st.set_filtration(0.4); // Max filtration value
-  st.set_dimension(3); // Max dimension = 3 -> (0,1,6,7)
-
-  std::cout << "The complex contains " << st.num_simplices() << " simplices - " << st.num_vertices() << " vertices " << std::endl;
-  std::cout << "   - dimension " << st.dimension() << "   - filtration " << st.filtration() << std::endl;
-  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
-  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 << (int)vertex;
-    }
-  }
-
-  return 0;
-}
diff --git a/src/Hasse_complex/include/gudhi/Hasse_complex.h b/src/Hasse_complex/include/gudhi/Hasse_complex.h
index 427d9916..c3a84c02 100644
--- a/src/Hasse_complex/include/gudhi/Hasse_complex.h
+++ b/src/Hasse_complex/include/gudhi/Hasse_complex.h
@@ -1,208 +1,233 @@
- /*    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/>.
-  */
-
-#ifndef GUDHI_HASSE_DIAGRAM_H
-#define GUDHI_HASSE_DIAGRAM_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.
+ *
+ *    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/>.
+ */
+
+#ifndef HASSE_COMPLEX_H_
+#define HASSE_COMPLEX_H_
 
-#include <algorithm>
 #include <boost/iterator/counting_iterator.hpp>
 
-namespace Gudhi{
+#include <algorithm>
+
+namespace Gudhi {
 
 template < class HasseCpx >
-struct Hasse_simplex 
-{
-//Complex_ds must verify that cpx->key(sh) is the order of sh in the filtration
+struct Hasse_simplex {
+  // Complex_ds must verify that cpx->key(sh) is the order of sh in the filtration
+
   template< class Complex_ds >
-  Hasse_simplex ( Complex_ds &                        cpx
-                , typename Complex_ds::Simplex_handle sh )
-  : key_(cpx.key(sh))
-  , filtration_(cpx.filtration(sh))
-  , boundary_()
-  {
-    boundary_.reserve(cpx.dimension(sh)+1);
-    for( auto b_sh : cpx.boundary_simplex_range(sh) )
-    { boundary_.push_back( cpx.key(b_sh) ); }
+  Hasse_simplex(Complex_ds & cpx
+                , typename Complex_ds::Simplex_handle sh)
+      : key_(cpx.key(sh))
+      , filtration_(cpx.filtration(sh))
+      , boundary_() {
+    boundary_.reserve(cpx.dimension(sh) + 1);
+    for (auto b_sh : cpx.boundary_simplex_range(sh)) {
+      boundary_.push_back(cpx.key(b_sh));
+    }
   }
 
-  Hasse_simplex ( typename HasseCpx::Simplex_key key
+  Hasse_simplex(typename HasseCpx::Simplex_key key
                 , typename HasseCpx::Filtration_value fil
                 , std::vector<typename HasseCpx::Simplex_handle> boundary)
-  : key_(key)
-  , filtration_(fil)
-  , boundary_(boundary) {}
+      : key_(key)
+      , filtration_(fil)
+      , boundary_(boundary) { }
 
-  typename HasseCpx::Simplex_key                 key_;
-  typename HasseCpx::Filtration_value            filtration_;
+  typename HasseCpx::Simplex_key key_;
+  typename HasseCpx::Filtration_value filtration_;
   std::vector<typename HasseCpx::Simplex_handle> boundary_;
 };
 
-
-
-/** \brief Data structure representing a Hasse diagram, i.e. 
-  * a complex where all codimension 1 incidence 
-  * relations are explicitly encoded.
-  *
-  * \implements FilteredComplex
-  * \ingroup simplex_tree
-  */
-template < typename FiltrationValue     = double
-         , typename SimplexKey          = int   
-         , typename VertexHandle        = int 
-         >
-class Hasse_complex 
-{
-public:
-
-  typedef Hasse_simplex<Hasse_complex>         Hasse_simp;
-  typedef FiltrationValue                      Filtration_value;
-  typedef SimplexKey                           Simplex_key;
-  typedef int                                  Simplex_handle; //index in vector complex_
-
-  typedef boost::counting_iterator< Simplex_handle >          Filtration_simplex_iterator;
-  typedef boost::iterator_range<Filtration_simplex_iterator>  Filtration_simplex_range;  
-
-  typedef typename std::vector< Simplex_handle >::iterator    Boundary_simplex_iterator;
-  typedef boost::iterator_range<Boundary_simplex_iterator>    Boundary_simplex_range;  
-
-  typedef typename std::vector< Simplex_handle >::iterator    Skeleton_simplex_iterator;
-  typedef boost::iterator_range< Skeleton_simplex_iterator >  Skeleton_simplex_range;
-
-
-/*  only dimension 0 skeleton_simplex_range(...) */
-  Skeleton_simplex_range skeleton_simplex_range( int dim = 0 ) {
-    if(dim != 0) { std::cerr << "Dimension must be 0 \n"; }
-    return Skeleton_simplex_range(vertices_.begin(),vertices_.end());
+/** \private 
+ * \brief Data structure representing a Hasse diagram, i.e. 
+ * a complex where all codimension 1 incidence 
+ * relations are explicitly encoded.
+ *
+ * \implements FilteredComplex
+ * \ingroup simplex_tree
+ */
+template < typename FiltrationValue = double
+, typename SimplexKey = int
+, typename VertexHandle = int
+>
+class Hasse_complex {
+ public:
+
+  typedef Hasse_simplex<Hasse_complex> Hasse_simp;
+  typedef FiltrationValue Filtration_value;
+  typedef SimplexKey Simplex_key;
+  typedef int Simplex_handle;  //index in vector complex_
+
+  typedef boost::counting_iterator< Simplex_handle > Filtration_simplex_iterator;
+  typedef boost::iterator_range<Filtration_simplex_iterator> Filtration_simplex_range;
+
+  typedef typename std::vector< Simplex_handle >::iterator Boundary_simplex_iterator;
+  typedef boost::iterator_range<Boundary_simplex_iterator> Boundary_simplex_range;
+
+  typedef typename std::vector< Simplex_handle >::iterator Skeleton_simplex_iterator;
+  typedef boost::iterator_range< Skeleton_simplex_iterator > Skeleton_simplex_range;
+
+  /*  only dimension 0 skeleton_simplex_range(...) */
+  Skeleton_simplex_range skeleton_simplex_range(int dim = 0) {
+    if (dim != 0) {
+      std::cerr << "Dimension must be 0 \n";
+    }
+    return Skeleton_simplex_range(vertices_.begin(), vertices_.end());
   }
 
   template < class Complex_ds >
   Hasse_complex(Complex_ds & cpx)
-  : complex_()
-  , vertices_()
-  , threshold_(cpx.filtration())
-  , num_vertices_()
-  , dim_max_(cpx.dimension())
-  {
+      : complex_()
+      , vertices_()
+      , threshold_(cpx.filtration())
+      , num_vertices_()
+      , dim_max_(cpx.dimension()) {
     complex_.reserve(cpx.num_simplices());
     int idx = 0;
-    for(auto cpx_sh : cpx.filtration_simplex_range())
-    { 
-      complex_.push_back(Hasse_simp(cpx,cpx_sh)); 
-      if(dimension(idx) == 0) { vertices_.push_back(idx); } 
-      ++idx; 
+    for (auto cpx_sh : cpx.filtration_simplex_range()) {
+      complex_.push_back(Hasse_simp(cpx, cpx_sh));
+      if (dimension(idx) == 0) {
+        vertices_.push_back(idx);
+      }
+      ++idx;
     }
   }
 
   Hasse_complex()
-  : complex_()
-  , vertices_()
-  , threshold_(0)
-  , num_vertices_(0)
-  , dim_max_(-1) {}
-
-  size_t num_simplices() { return complex_.size(); }
+      : complex_()
+      , vertices_()
+      , threshold_(0)
+      , num_vertices_(0)
+      , dim_max_(-1) { }
+
+  size_t num_simplices() {
+    return complex_.size();
+  }
 
-  Filtration_simplex_range filtration_simplex_range() 
-  { return Filtration_simplex_range( Filtration_simplex_iterator(0)
-                                   , Filtration_simplex_iterator(complex_.size()) ); }
+  Filtration_simplex_range filtration_simplex_range() {
+    return Filtration_simplex_range(Filtration_simplex_iterator(0)
+                                    , Filtration_simplex_iterator(complex_.size()));
+  }
 
-  Simplex_key key( Simplex_handle sh ) { return complex_[sh].key_; }
+  Simplex_key key(Simplex_handle sh) {
+    return complex_[sh].key_;
+  }
 
-  Simplex_key null_key() { return -1; }
+  Simplex_key null_key() {
+    return -1;
+  }
 
-  Simplex_handle simplex( Simplex_key key ) 
-  {
-    if(key == null_key()) return null_simplex();
+  Simplex_handle simplex(Simplex_key key) {
+    if (key == null_key()) return null_simplex();
     return key;
   }
 
-  Simplex_handle null_simplex() { return -1; }
+  Simplex_handle null_simplex() {
+    return -1;
+  }
 
-  Filtration_value filtration( Simplex_handle sh ) {
-    if( sh == null_simplex() ) { return filtration(); }
+  Filtration_value filtration(Simplex_handle sh) {
+    if (sh == null_simplex()) {
+      return filtration();
+    }
     return complex_[sh].filtration_;
   }
 
-  Filtration_value filtration() { return threshold_; }
+  Filtration_value filtration() {
+    return threshold_;
+  }
+
+  int dimension(Simplex_handle sh) {
+    if (complex_[sh].boundary_.empty()) return 0;
+    return complex_[sh].boundary_.size() - 1;
+  }
 
-  int dimension ( Simplex_handle sh ) { 
-    if(complex_[sh].boundary_.empty()) return 0;
-    return complex_[sh].boundary_.size()-1; 
+  int dimension() {
+    return dim_max_;
   }
-  int dimension () { return dim_max_; }
 
-  std::pair<Simplex_handle,Simplex_handle> endpoints( Simplex_handle sh ) 
-  { return std::pair<Simplex_handle,Simplex_handle>( complex_[sh].boundary_[0]
-                                                   , complex_[sh].boundary_[1] ) ;}
+  std::pair<Simplex_handle, Simplex_handle> endpoints(Simplex_handle sh) {
+    return std::pair<Simplex_handle, Simplex_handle>(complex_[sh].boundary_[0]
+                                                     , complex_[sh].boundary_[1]);
+  }
 
-  void assign_key( Simplex_handle sh, Simplex_key key) { complex_[sh].key_ = key; }
+  void assign_key(Simplex_handle sh, Simplex_key key) {
+    complex_[sh].key_ = key;
+  }
 
-  Boundary_simplex_range boundary_simplex_range ( Simplex_handle sh ) 
-  { return Boundary_simplex_range( complex_[sh].boundary_.begin()
-                                 , complex_[sh].boundary_.end() ); }
+  Boundary_simplex_range boundary_simplex_range(Simplex_handle sh) {
+    return Boundary_simplex_range(complex_[sh].boundary_.begin()
+                                  , complex_[sh].boundary_.end());
+  }
 
-  void display_simplex(Simplex_handle sh)
-  {
+  void display_simplex(Simplex_handle sh) {
     std::cout << dimension(sh) << "  ";
-    for(auto sh_b : boundary_simplex_range(sh)) std::cout << sh_b << " ";
+    for (auto sh_b : boundary_simplex_range(sh)) std::cout << sh_b << " ";
     std::cout << "  " << filtration(sh) << "         key=" << key(sh);
   }
 
-  void initialize_filtration()
-  {
+  void initialize_filtration() {
     Simplex_key key = 0;
-    for(auto & h_simp : complex_) { h_simp.key_ = key; ++key; }
+    for (auto & h_simp : complex_) {
+      h_simp.key_ = key;
+      ++key;
+    }
   }
 
-  std::vector< Hasse_simp >   complex_;
+  std::vector< Hasse_simp > complex_;
   std::vector<Simplex_handle> vertices_;
-  Filtration_value            threshold_;
-  size_t                      num_vertices_;
-  int                         dim_max_;
+  Filtration_value threshold_;
+  size_t num_vertices_;
+  int dim_max_;
 };
 
 template< typename T1, typename T2, typename T3 >
-std::istream& operator>> ( std::istream                & is 
-                         , Hasse_complex< T1, T2, T3 > & hcpx )
-{
+std::istream& operator>>(std::istream & is
+                         , Hasse_complex< T1, T2, T3 > & hcpx) {
   assert(hcpx.num_simplices() == 0);
 
   size_t num_simp;
   is >> num_simp;
-  hcpx.complex_.reserve(num_simp); 
-
-  std::vector< typename Hasse_complex<T1,T2,T3>::Simplex_key >  boundary;
-  typename Hasse_complex<T1,T2,T3>::Filtration_value            fil;
-  typename Hasse_complex<T1,T2,T3>::Filtration_value            max_fil = 0 ;
-  int                                                           max_dim = -1;
-  int                                                           key     = 0 ;
-  while(read_hasse_simplex( is, boundary, fil )) //read all simplices in the file as a list of vertices
+  hcpx.complex_.reserve(num_simp);
+
+  std::vector< typename Hasse_complex<T1, T2, T3>::Simplex_key > boundary;
+  typename Hasse_complex<T1, T2, T3>::Filtration_value fil;
+  typename Hasse_complex<T1, T2, T3>::Filtration_value max_fil = 0;
+  int max_dim = -1;
+  int key = 0;
+  while (read_hasse_simplex(is, boundary, fil))  //read all simplices in the file as a list of vertices
   {
-    //insert every simplex in the simplex tree
-    hcpx.complex_.push_back( Hasse_simplex< Hasse_complex<T1,T2,T3> >(key,fil,boundary));
+    // insert every simplex in the simplex tree
+    hcpx.complex_.push_back(Hasse_simplex< Hasse_complex<T1, T2, T3> >(key, fil, boundary));
 
-    if(max_dim < hcpx.dimension(key)) { max_dim = hcpx.dimension(key); }
-    if(hcpx.dimension(key) == 0)      { hcpx.vertices_.push_back(key); }
-    if(max_fil < fil)                 { max_fil = fil;                 }
+    if (max_dim < hcpx.dimension(key)) {
+      max_dim = hcpx.dimension(key);
+    }
+    if (hcpx.dimension(key) == 0) {
+      hcpx.vertices_.push_back(key);
+    }
+    if (max_fil < fil) {
+      max_fil = fil;
+    }
 
     ++key;
     boundary.clear();
@@ -214,6 +239,6 @@ std::istream& operator>> ( std::istream                & is
   return is;
 }
 
-}  // namespace GUDHI
+}  // namespace Gudhi
 
-#endif // GUDHI_HASSE_DIAGRAM_H
+#endif  // HASSE_COMPLEX_H_
diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
index 1539ad2b..fff00d77 100644
--- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
@@ -108,6 +108,7 @@ BOOST_AUTO_TEST_CASE(simplex_tree_from_file) {
     // Size of simplex
     int size = 0;
     for (auto vertex : st.simplex_vertex_range(f_simplex)) {
+      // Remove warning
       (void) vertex;
       size++;
     }
@@ -164,6 +165,8 @@ void set_and_test_simplex_tree_dim_fil(typeST& simplexTree, int vectorSize, cons
   // Another way to count simplices:
   size_t num_simp = 0;
   for (auto f_simplex : simplexTree.complex_simplex_range()) {
+    // Remove warning
+    (void) f_simplex;
     num_simp++;
   }
 
diff --git a/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp b/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp
index 3dc38572..319e3c43 100644
--- a/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp
+++ b/src/Skeleton_blocker/test/TestSkeletonBlockerComplex.cpp
@@ -343,7 +343,7 @@ bool test_iterator_simplices3(){
 bool test_iterator_simplices4(){
 	Complex empty_complex;
 	for(auto v : empty_complex.vertex_range()){
-		v;
+		(void) v;
 	}
 	for(auto e : empty_complex.edge_range()){
 		empty_complex[e];
diff --git a/src/common/include/gudhi/Off_reader.h b/src/common/include/gudhi/Off_reader.h
index b70e7897..81b9e634 100644
--- a/src/common/include/gudhi/Off_reader.h
+++ b/src/common/include/gudhi/Off_reader.h
@@ -166,7 +166,7 @@ class Off_reader {
       iss >> num_face_vertices;
       std::vector<int> face;
       face.assign(std::istream_iterator<int>(iss), std::istream_iterator<int>());
-      if (!face.size() == off_info_.num_vertices) return false;
+      if (face.size() != off_info_.dim) return false;
       visitor.maximal_face(face);
     }
     return true;