Fix cpplint on examples.

Bug fix on persistence_from_simple_simplex_tree.
Add persistence examples tests.



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

Former-commit-id: 9b7b73abb4a5d6bb110376deb689247bfdae035c

15 files changed, 1008 insertions, 1023 deletions

diff --git a/src/Contraction/example/Garland_heckbert.cpp b/src/Contraction/example/Garland_heckbert.cpp
index a41f65aa..70f29b6a 100644
--- a/src/Contraction/example/Garland_heckbert.cpp
+++ b/src/Contraction/example/Garland_heckbert.cpp
@@ -1,7 +1,4 @@
-/*
- * Garland_heckbert.h
- *  Created on: Feb 10, 2015
- * This file is part of the Gudhi Library. The Gudhi library 
+/* This file is part of the Gudhi Library. The Gudhi library 
  *    (Geometric Understanding in Higher Dimensions) is a generic C++ 
  *    library for computational topology.
  *
@@ -28,12 +25,13 @@
 #ifndef GARLAND_HECKBERT_H_
 #define GARLAND_HECKBERT_H_
 
+#include <gudhi/Point.h>
+#include <gudhi/Edge_contraction.h>
+#include <gudhi/Skeleton_blocker.h>
+#include <gudhi/Off_reader.h>
+
 #include <boost/timer/timer.hpp>
 #include <iostream>
-#include "gudhi/Point.h"
-#include "gudhi/Edge_contraction.h"
-#include "gudhi/Skeleton_blocker.h"
-#include "gudhi/Off_reader.h"
 
 #include "Garland_heckbert/Error_quadric.h"
 
@@ -51,7 +49,6 @@ struct Geometry_trait {
  */
 struct Garland_heckbert_traits : public Skeleton_blocker_simple_geometric_traits<Geometry_trait> {
  public:
-
   struct Garland_heckbert_vertex : public Simple_geometric_vertex {
     Error_quadric<Geometry_trait::Point> quadric;
   };
@@ -68,6 +65,7 @@ typedef Skeleton_blocker_contractor<Complex> Complex_contractor;
  */
 class GH_placement : public Gudhi::contraction::Placement_policy<EdgeProfile> {
   Complex& complex_;
+
  public:
   typedef Gudhi::contraction::Placement_policy<EdgeProfile>::Placement_type Placement_type;
 
@@ -91,8 +89,8 @@ class GH_placement : public Gudhi::contraction::Placement_policy<EdgeProfile> {
  */
 class GH_cost : public Gudhi::contraction::Cost_policy<EdgeProfile> {
   Complex& complex_;
- public:
 
+ public:
   typedef Gudhi::contraction::Cost_policy<EdgeProfile>::Cost_type Cost_type;
 
   GH_cost(Complex& complex) : complex_(complex) { }
@@ -115,13 +113,13 @@ class GH_cost : public Gudhi::contraction::Cost_policy<EdgeProfile> {
  */
 class GH_visitor : public Gudhi::contraction::Contraction_visitor<EdgeProfile> {
   Complex& complex_;
- public:
 
+ public:
   GH_visitor(Complex& complex) : complex_(complex) { }
 
-  //Compute quadrics for every vertex v
-  //The quadric of v consists in the sum of quadric
-  //of every triangles passing through v weighted by its area
+  // Compute quadrics for every vertex v
+  // The quadric of v consists in the sum of quadric
+  // of every triangles passing through v weighted by its area
 
   void on_started(Complex & complex) override {
     for (auto v : complex.vertex_range()) {
@@ -147,7 +145,8 @@ class GH_visitor : public Gudhi::contraction::Contraction_visitor<EdgeProfile> {
 
 int main(int argc, char *argv[]) {
   if (argc != 4) {
-    std::cerr << "Usage " << argv[0] << " input.off output.off N to load the file input.off, contract N edges and save the result to output.off.\n";
+    std::cerr << "Usage " << argv[0] << " input.off output.off N to load the file input.off, contract N edges and save "
+        << "the result to output.off.\n";
     return EXIT_FAILURE;
   }
 
@@ -172,8 +171,7 @@ int main(int argc, char *argv[]) {
                                 new GH_cost(complex),
                                 new GH_placement(complex),
                                 contraction::make_link_valid_contraction<EdgeProfile>(),
-                                new GH_visitor(complex)
-                                );
+                                new GH_visitor(complex));
 
   std::cout << "Contract " << num_contractions << " edges" << std::endl;
   contractor.contract_edges(num_contractions);
@@ -183,7 +181,7 @@ int main(int argc, char *argv[]) {
       complex.num_edges() << " edges and" <<
       complex.num_triangles() << " triangles." << std::endl;
 
-  //write simplified complex
+  // write simplified complex
   Skeleton_blocker_off_writer<Complex> off_writer(argv[2], complex);
 
   return EXIT_SUCCESS;
@@ -191,4 +189,4 @@ int main(int argc, char *argv[]) {
 
 
 
-#endif /* GARLAND_HECKBERT_H_ */
+#endif  // GARLAND_HECKBERT_H_
diff --git a/src/Contraction/example/Garland_heckbert/Error_quadric.h b/src/Contraction/example/Garland_heckbert/Error_quadric.h
index 72134c9d..a033aa00 100644
--- a/src/Contraction/example/Garland_heckbert/Error_quadric.h
+++ b/src/Contraction/example/Garland_heckbert/Error_quadric.h
@@ -1,164 +1,182 @@
-/*

- * Error_quadric.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: 24 janv. 2014

- *      Author: dsalinas

+ *    Author(s):       David Salinas

+ *

+ *    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 ERROR_QUADRIC_H_

 #define ERROR_QUADRIC_H_

 

-#include <vector>

-#include <utility>

 #include <boost/optional/optional.hpp>

 

+#include <vector>

+#include <utility>

 

-template <typename Point> class Error_quadric{

-private :

-	double coeff[10];

-

-public :

-	Error_quadric(){

-		clear();

-	}

-

-	/**

-	 * Quadric corresponding to the L2 distance to the plane.

-	 *

-	 * According to the notation of Garland Heckbert, they

-	 * denote a quadric symetric matrix as :

-	 * Q = [ q11 q12 q13 q14]

-	 *     [ q12 q22 q23 q24]

-	 *     [ q13 q23 q33 q34]

-	 *     [ q14 q24 q34 q44]

-	 *

-	 * which is represented by a vector with 10 elts that

-	 * are denoted ci for clarity with :

-	 * Q = [ c0  c1  c2  c3 ]

-	 *     [ c1  c4  c5  c6 ]

-	 *     [ c2  c5  c7  c8 ]

-	 *     [ c3  c6  c8  c9 ]

-	 *

-	 * The constructor return the quadrics that represents

-	 * the squared distance to the plane defined by triangle p0,p1,p2

-	 * times the area of triangle p0,p1,p2.

-	 */

-	Error_quadric(const Point & p0,const Point & p1,const Point & p2){

-

-		Point normal(unit_normal(p0,p1,p2));

-		double a=normal[0];

-		double b=normal[1];

-		double c=normal[2];

-		double d= -a*p0[0]-b*p0[1]-c*p0[2];

-		coeff[0] = a*a ;

-		coeff[1] = a*b ;

-		coeff[2] = a*c ;

-		coeff[3] = a*d ;

-		coeff[4] = b*b ;

-		coeff[5] = b*c ;

-		coeff[6] = b*d ;

-		coeff[7] = c*c ;

-		coeff[8] = c*d ;

-		coeff[9] = d*d ;

-

-		double area_p0p1p2 = std::sqrt(squared_area(p0,p1,p2));

-		for(auto& x : coeff)

-			x*= area_p0p1p2;

-	}

-

-

-	inline double squared_area(const Point& p0,const Point& p1,const Point& p2) {

-		//if (x1,x2,x3) = p1-p0 and (y1,y2,y3) = p2-p0

-		//then the squared area is = (u^2+v^2+w^2)/4

-		//with:		u = x2 * y3 - x3 * y2;

-		//		    v = x3 * y1 - x1 * y3;

-		//	     	w = x1 * y2 - x2 * y1;

-		Point p0p1(p1-p0);

-		Point p0p2(p2-p0);

-		double A = p0p1[1] * p0p2[2] - p0p1[2] * p0p2[1];

-		double B = p0p1[2] * p0p2[0] - p0p1[0] * p0p2[2];

-		double C = p0p1[0] * p0p2[1] - p0p1[1] * p0p2[0];

-		return 1./4. * (A*A+B*B+C*C);

-	}

-

-

-	void clear(){

-		for(auto& x:coeff)

-			x=0;

-	}

-

-	Error_quadric& operator+=(const Error_quadric& other){

-		if(this!=&other)

-			for(int i = 0 ; i < 10; ++i)

-				coeff[i] += other.coeff[i];

-		return *this;

-	}

-

-	/**

-	 * @return The quadric quost defined by the scalar product v^T Q v where Q is the quadratic form of Garland/Heckbert

-	 */

-	inline double cost(const Point& point) const{

-		double cost =

-				coeff[0]*point.x()*point.x()+coeff[4]*point.y()*point.y()+coeff[7]*point.z()*point.z()

-				+2*(coeff[1]*point.x()*point.y()+coeff[5]*point.y()*point.z()+coeff[2]*point.z()*point.x())

-				+2*(coeff[3]*point.x()+coeff[6]*point.y()+coeff[8]*point.z())

-				+coeff[9];

-		if(cost<0) return 0;

-		else {

-			return cost;

-		}

-	}

-

-	inline double grad_determinant() const{

-		return

-				coeff[0] * coeff[4] * coeff[7]

-				                            -  coeff[0] * coeff[5] * coeff[5]

-				                                                           -  coeff[1] * coeff[1] * coeff[7]

-				                                                                                          +2*coeff[1] * coeff[5] * coeff[2]

-				                                                                                                                         -  coeff[4] * coeff[2] * coeff[2];

-	}

-

-	/**

-	 * Return the point such that it minimizes the gradient of the quadric.

-	 * Det must be passed with the determinant value of the gradient (should be non zero).

-	 */

-	inline Point solve_linear_gradient(double det) const{

-		return Point({

-				(-coeff[1]*coeff[5]*coeff[8]+coeff[1]*coeff[7]*coeff[6]+coeff[2]*coeff[8]*coeff[4]-coeff[2]*coeff[5]*coeff[6]-coeff[3]*coeff[4]*coeff[7]+coeff[3]*coeff[5]*coeff[5])/ det,

-				(coeff[0]*coeff[5]*coeff[8]-coeff[0]*coeff[7]*coeff[6]-coeff[5]*coeff[2]*coeff[3]-coeff[1]*coeff[2]*coeff[8]+coeff[6]*coeff[2]*coeff[2]+coeff[1]*coeff[3]*coeff[7])/det,

-				(-coeff[8]*coeff[0]*coeff[4]+coeff[8]*coeff[1]*coeff[1]+coeff[2]*coeff[3]*coeff[4]+coeff[5]*coeff[0]*coeff[6]-coeff[5]*coeff[1]*coeff[3]-coeff[1]*coeff[2]*coeff[6])/det

-		});

-	}

-

-

-	/**

-	 * returns the point that minimizes the quadric.

-	 * It inverses the quadric if its determinant is higher that a given threshold .

-	 * If the determinant is lower than this value the returned value is uninitialized.

-	 */

-	boost::optional<Point> min_cost(double scale=1) const{

-		//		const double min_determinant = 1e-4 * scale*scale;

-		const double min_determinant = 1e-5;

-		boost::optional<Point> pt_res;

-		double det = grad_determinant();

-		if (std::abs(det)>min_determinant)

-			pt_res = solve_linear_gradient(det);

-		return pt_res;

-	}

-

-	friend std::ostream& operator<< (std::ostream& stream, const Error_quadric& quadric) {

-		stream << "\n[ "<<quadric.coeff[0]<<","<<quadric.coeff[1]<<","<<quadric.coeff[2]<<","<<quadric.coeff[3]<<";\n";

-		stream <<    " "<<quadric.coeff[1]<<","<<quadric.coeff[4]<<","<<quadric.coeff[5]<<","<<quadric.coeff[6]<<";\n";

-		stream <<    " "<<quadric.coeff[2]<<","<<quadric.coeff[5]<<","<<quadric.coeff[7]<<","<<quadric.coeff[8]<<";\n";

-		stream <<    " "<<quadric.coeff[3]<<","<<quadric.coeff[6]<<","<<quadric.coeff[8]<<","<<quadric.coeff[9]<<"]";

-		return stream;

-	}

-

-

+template <typename Point> class Error_quadric {

+ private:

+  double coeff[10];

+

+ public:

+  Error_quadric() {

+    clear();

+  }

+

+  /**

+   * Quadric corresponding to the L2 distance to the plane.

+   *

+   * According to the notation of Garland Heckbert, they

+   * denote a quadric symetric matrix as :

+   * Q = [ q11 q12 q13 q14]

+   *     [ q12 q22 q23 q24]

+   *     [ q13 q23 q33 q34]

+   *     [ q14 q24 q34 q44]

+   *

+   * which is represented by a vector with 10 elts that

+   * are denoted ci for clarity with :

+   * Q = [ c0  c1  c2  c3 ]

+   *     [ c1  c4  c5  c6 ]

+   *     [ c2  c5  c7  c8 ]

+   *     [ c3  c6  c8  c9 ]

+   *

+   * The constructor return the quadrics that represents

+   * the squared distance to the plane defined by triangle p0,p1,p2

+   * times the area of triangle p0,p1,p2.

+   */

+  Error_quadric(const Point & p0, const Point & p1, const Point & p2) {

+    Point normal(unit_normal(p0, p1, p2));

+    double a = normal[0];

+    double b = normal[1];

+    double c = normal[2];

+    double d = -a * p0[0] - b * p0[1] - c * p0[2];

+    coeff[0] = a*a;

+    coeff[1] = a*b;

+    coeff[2] = a*c;

+    coeff[3] = a*d;

+    coeff[4] = b*b;

+    coeff[5] = b*c;

+    coeff[6] = b*d;

+    coeff[7] = c*c;

+    coeff[8] = c*d;

+    coeff[9] = d*d;

+

+    double area_p0p1p2 = std::sqrt(squared_area(p0, p1, p2));

+    for (auto& x : coeff)

+      x *= area_p0p1p2;

+  }

+

+  inline double squared_area(const Point& p0, const Point& p1, const Point& p2) {

+    // if (x1,x2,x3) = p1-p0 and (y1,y2,y3) = p2-p0

+    // then the squared area is = (u^2+v^2+w^2)/4

+    // with: u = x2 * y3 - x3 * y2;

+    //       v = x3 * y1 - x1 * y3;

+    //       w = x1 * y2 - x2 * y1;

+    Point p0p1(p1 - p0);

+    Point p0p2(p2 - p0);

+    double A = p0p1[1] * p0p2[2] - p0p1[2] * p0p2[1];

+    double B = p0p1[2] * p0p2[0] - p0p1[0] * p0p2[2];

+    double C = p0p1[0] * p0p2[1] - p0p1[1] * p0p2[0];

+    return 1. / 4. * (A * A + B * B + C * C);

+  }

+

+  void clear() {

+    for (auto& x : coeff)

+      x = 0;

+  }

+

+  Error_quadric& operator+=(const Error_quadric& other) {

+    if (this != &other) {

+      for (int i = 0; i < 10; ++i)

+        coeff[i] += other.coeff[i];

+    }

+    return *this;

+  }

+

+  /**

+   * @return The quadric quost defined by the scalar product v^T Q v where Q is the quadratic form of Garland/Heckbert

+   */

+  inline double cost(const Point& point) const {

+    double cost =

+        coeff[0] * point.x() * point.x() + coeff[4] * point.y() * point.y() + coeff[7] * point.z() * point.z()

+        + 2 * (coeff[1] * point.x() * point.y() + coeff[5] * point.y() * point.z() + coeff[2] * point.z() * point.x())

+        + 2 * (coeff[3] * point.x() + coeff[6] * point.y() + coeff[8] * point.z())

+        + coeff[9];

+    if (cost < 0) {

+      return 0;

+    } else {

+      return cost;

+    }

+  }

+

+  inline double grad_determinant() const {

+    return

+    coeff[0] * coeff[4] * coeff[7]

+        - coeff[0] * coeff[5] * coeff[5]

+        - coeff[1] * coeff[1] * coeff[7]

+        + 2 * coeff[1] * coeff[5] * coeff[2]

+        - coeff[4] * coeff[2] * coeff[2];

+  }

+

+  /**

+   * Return the point such that it minimizes the gradient of the quadric.

+   * Det must be passed with the determinant value of the gradient (should be non zero).

+   */

+  inline Point solve_linear_gradient(double det) const {

+    return Point({

+                 (-coeff[1] * coeff[5] * coeff[8] + coeff[1] * coeff[7] * coeff[6] + coeff[2] * coeff[8] * coeff[4] -

+                     coeff[2] * coeff[5] * coeff[6] - coeff[3] * coeff[4] * coeff[7] + coeff[3] * coeff[5] * coeff[5])

+                     / det,

+                 (coeff[0] * coeff[5] * coeff[8] - coeff[0] * coeff[7] * coeff[6] - coeff[5] * coeff[2] * coeff[3] -

+                     coeff[1] * coeff[2] * coeff[8] + coeff[6] * coeff[2] * coeff[2] + coeff[1] * coeff[3] * coeff[7])

+                     / det,

+                 (-coeff[8] * coeff[0] * coeff[4] + coeff[8] * coeff[1] * coeff[1] + coeff[2] * coeff[3] * coeff[4] +

+                     coeff[5] * coeff[0] * coeff[6] - coeff[5] * coeff[1] * coeff[3] - coeff[1] * coeff[2] * coeff[6])

+                     / det

+    });

+  }

+

+  /**

+   * returns the point that minimizes the quadric.

+   * It inverses the quadric if its determinant is higher that a given threshold .

+   * If the determinant is lower than this value the returned value is uninitialized.

+   */

+  boost::optional<Point> min_cost(double scale = 1) const {

+    // const double min_determinant = 1e-4 * scale*scale;

+    const double min_determinant = 1e-5;

+    boost::optional<Point> pt_res;

+    double det = grad_determinant();

+    if (std::abs(det) > min_determinant)

+      pt_res = solve_linear_gradient(det);

+    return pt_res;

+  }

+

+  friend std::ostream& operator<<(std::ostream& stream, const Error_quadric& quadric) {

+    stream << "\n[ " << quadric.coeff[0] << "," << quadric.coeff[1] << "," << quadric.coeff[2] << "," <<

+        quadric.coeff[3] << ";\n";

+    stream << " " << quadric.coeff[1] << "," << quadric.coeff[4] << "," << quadric.coeff[5] << "," <<

+        quadric.coeff[6] << ";\n";

+    stream << " " << quadric.coeff[2] << "," << quadric.coeff[5] << "," << quadric.coeff[7] << "," <<

+        quadric.coeff[8] << ";\n";

+    stream << " " << quadric.coeff[3] << "," << quadric.coeff[6] << "," << quadric.coeff[8] << "," <<

+        quadric.coeff[9] << "]";

+    return stream;

+  }

 };

 

-

-

-

-#endif /* ERROR_QUADRIC_H_ */

-

+#endif  // ERROR_QUADRIC_H_

diff --git a/src/Contraction/example/Rips_contraction.cpp b/src/Contraction/example/Rips_contraction.cpp
index bd0a8b8c..d21246ed 100644
--- a/src/Contraction/example/Rips_contraction.cpp
+++ b/src/Contraction/example/Rips_contraction.cpp
@@ -19,24 +19,23 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+#include <gudhi/Edge_contraction.h>
+#include <gudhi/Skeleton_blocker.h>
+#include <gudhi/Off_reader.h>
+#include <gudhi/Point.h>
+
 #include <boost/timer/timer.hpp>
 #include <iostream>
-#include "gudhi/Edge_contraction.h"
-#include "gudhi/Skeleton_blocker.h"
-#include "gudhi/Off_reader.h"
-#include "gudhi/Point.h"
 
 using namespace std;
 using namespace Gudhi;
 using namespace skbl;
 using namespace contraction;
 
-
-struct Geometry_trait{
-	typedef Point_d Point;
+struct Geometry_trait {
+  typedef Point_d Point;
 };
 
-
 typedef Geometry_trait::Point Point;
 typedef Skeleton_blocker_simple_geometric_traits<Geometry_trait> Complex_geometric_traits;
 typedef Skeleton_blocker_geometric_complex< Complex_geometric_traits > Complex;
@@ -44,62 +43,62 @@ typedef Edge_profile<Complex> Profile;
 typedef Skeleton_blocker_contractor<Complex> Complex_contractor;
 
 template<typename ComplexType>
-void build_rips(ComplexType& complex, double offset){
-	if (offset<=0) return;
-	auto vertices = complex.vertex_range();
-	for (auto p = vertices.begin(); p != vertices.end(); ++p)
-		for (auto q = p; ++q != vertices.end(); /**/){
-			if ( squared_dist(complex.point(*p), complex.point(*q)) < 4 * offset * offset)
-				complex.add_edge(*p,*q);
-		}
+void build_rips(ComplexType& complex, double offset) {
+  if (offset <= 0) return;
+  auto vertices = complex.vertex_range();
+  for (auto p = vertices.begin(); p != vertices.end(); ++p)
+    for (auto q = p; ++q != vertices.end(); /**/) {
+      if (squared_dist(complex.point(*p), complex.point(*q)) < 4 * offset * offset)
+        complex.add_edge(*p, *q);
+    }
 }
 
-int main (int argc, char *argv[])
-{
-	if (argc!=3){
-		std::cerr << "Usage "<<argv[0]<<" ../../../data/meshes/SO3_10000.off 0.3 to load the file ../../data/SO3_10000.off and contract the Rips complex built with paremeter 0.3.\n";
-		return -1;
-	}
+int main(int argc, char *argv[]) {
+  if (argc != 3) {
+    std::cerr << "Usage " << argv[0] << " ../../../data/meshes/SO3_10000.off 0.3 to load the file " <<
+        "../../data/SO3_10000.off and contract the Rips complex built with paremeter 0.3.\n";
+    return -1;
+  }
 
-	Complex complex;
+  Complex complex;
 
-	// load only the points
-	Skeleton_blocker_off_reader<Complex> off_reader(argv[1],complex,true);
-	if(!off_reader.is_valid()){
-		std::cerr << "Unable to read file:"<<argv[1]<<std::endl;
-		return EXIT_FAILURE;
-	}
+  // load only the points
+  Skeleton_blocker_off_reader<Complex> off_reader(argv[1], complex, true);
+  if (!off_reader.is_valid()) {
+    std::cerr << "Unable to read file:" << argv[1] << std::endl;
+    return EXIT_FAILURE;
+  }
 
-	std::cout << "Build the Rips complex with "<<complex.num_vertices()<<" vertices"<<std::endl;
+  std::cout << "Build the Rips complex with " << complex.num_vertices() << " vertices" << std::endl;
 
-	build_rips(complex,atof(argv[2]));
+  build_rips(complex, atof(argv[2]));
 
-	boost::timer::auto_cpu_timer t;
+  boost::timer::auto_cpu_timer t;
 
-	std::cout << "Initial complex has "<<
-			complex.num_vertices()<<" vertices and "<<
-			complex.num_edges()<<" edges"<<std::endl;
+  std::cout << "Initial complex has " <<
+      complex.num_vertices() << " vertices and " <<
+      complex.num_edges() << " edges" << std::endl;
 
-	Complex_contractor contractor(complex,
-			new Edge_length_cost<Profile>,
-			contraction::make_first_vertex_placement<Profile>(),
-			contraction::make_link_valid_contraction<Profile>(),
-			contraction::make_remove_popable_blockers_visitor<Profile>());
-	contractor.contract_edges();
+  Complex_contractor contractor(complex,
+                                new Edge_length_cost<Profile>,
+                                contraction::make_first_vertex_placement<Profile>(),
+                                contraction::make_link_valid_contraction<Profile>(),
+                                contraction::make_remove_popable_blockers_visitor<Profile>());
+  contractor.contract_edges();
 
-	std::cout << "Counting final number of simplices \n";
-	unsigned num_simplices = std::distance(complex.simplex_range().begin(),complex.simplex_range().end());
+  std::cout << "Counting final number of simplices \n";
+  unsigned num_simplices = std::distance(complex.simplex_range().begin(), complex.simplex_range().end());
 
-	std::cout << "Final complex has "<<
-			complex.num_vertices()<<" vertices, "<<
-			complex.num_edges()<<" edges, "<<
-			complex.num_blockers()<<" blockers and "<<
-			num_simplices<<" simplices"<<std::endl;
+  std::cout << "Final complex has " <<
+      complex.num_vertices() << " vertices, " <<
+      complex.num_edges() << " edges, " <<
+      complex.num_blockers() << " blockers and " <<
+      num_simplices << " simplices" << std::endl;
 
 
-	std::cout << "Time to simplify and enumerate simplices:\n";
+  std::cout << "Time to simplify and enumerate simplices:\n";
 
-	return EXIT_SUCCESS;
+  return EXIT_SUCCESS;
 }
 
 
diff --git a/src/Persistent_cohomology/example/CMakeLists.txt b/src/Persistent_cohomology/example/CMakeLists.txt
index 3276989d..435d2f58 100644
--- a/src/Persistent_cohomology/example/CMakeLists.txt
+++ b/src/Persistent_cohomology/example/CMakeLists.txt
@@ -5,6 +5,7 @@ project(GUDHIExPersCohom)
 if (NOT MSVC)
    add_executable(persistence_from_simple_simplex_tree persistence_from_simple_simplex_tree.cpp)
    target_link_libraries(persistence_from_simple_simplex_tree ${Boost_SYSTEM_LIBRARY})
+   add_test(persistence_from_simple_simplex_tree ${CMAKE_CURRENT_BINARY_DIR}/persistence_from_simple_simplex_tree 1 0)
 
    add_executable(rips_persistence rips_persistence.cpp)
    target_link_libraries(rips_persistence ${Boost_SYSTEM_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY})
diff --git a/src/Persistent_cohomology/example/alpha_shapes_persistence.cpp b/src/Persistent_cohomology/example/alpha_shapes_persistence.cpp
index 1e907040..6d5eebcf 100644
--- a/src/Persistent_cohomology/example/alpha_shapes_persistence.cpp
+++ b/src/Persistent_cohomology/example/alpha_shapes_persistence.cpp
@@ -1,24 +1,29 @@
- /*    This file is part of the Gudhi Library. The Gudhi library
-  *    (Geometric Understanding in Higher Dimensions) is a generic C++
-  *    library for computational topology.
-  *
-  *    Author(s):       Vincent Rouvreau
-  *
-  *    Copyright (C) 2014  INRIA Saclay (France)
-  *
-  *    This program is free software: you can redistribute it and/or modify
-  *    it under the terms of the GNU General Public License as published by
-  *    the Free Software Foundation, either version 3 of the License, or
-  *    (at your option) any later version.
-  *
-  *    This program is distributed in the hope that it will be useful,
-  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
-  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  *    GNU General Public License for more details.
-  *
-  *    You should have received a copy of the GNU General Public License
-  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-  */
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
+ *
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2014  INRIA Saclay (France)
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gudhi/graph_simplicial_complex.h>
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Persistent_cohomology.h>
+#include <boost/variant.hpp>
 
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/Delaunay_triangulation_3.h>
@@ -27,36 +32,37 @@
 
 #include <fstream>
 #include <cmath>
-
-#include "gudhi/graph_simplicial_complex.h"
-#include "gudhi/Simplex_tree.h"
-#include "gudhi/Persistent_cohomology.h"
-#include <boost/variant.hpp>
+#include <string>
+#include <tuple>
+#include <map>
+#include <utility>
+#include <list>
+#include <vector>
 
 using namespace Gudhi;
 using namespace Gudhi::persistent_cohomology;
 
 // Alpha_shape_3 templates type definitions
 typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
-typedef CGAL::Alpha_shape_vertex_base_3<Kernel>             Vb;
-typedef CGAL::Alpha_shape_cell_base_3<Kernel>               Fb;
-typedef CGAL::Triangulation_data_structure_3<Vb,Fb>         Tds;
-typedef CGAL::Delaunay_triangulation_3<Kernel,Tds>          Triangulation_3;
-typedef CGAL::Alpha_shape_3<Triangulation_3>                Alpha_shape_3;
+typedef CGAL::Alpha_shape_vertex_base_3<Kernel> Vb;
+typedef CGAL::Alpha_shape_cell_base_3<Kernel> Fb;
+typedef CGAL::Triangulation_data_structure_3<Vb, Fb> Tds;
+typedef CGAL::Delaunay_triangulation_3<Kernel, Tds> Triangulation_3;
+typedef CGAL::Alpha_shape_3<Triangulation_3> Alpha_shape_3;
 
 // From file type definition
-typedef Kernel::Point_3                                     Point_3;
+typedef Kernel::Point_3 Point_3;
 
 // filtration with alpha values needed type definition
 typedef Alpha_shape_3::FT Alpha_value_type;
-typedef CGAL::Object      Object;
+typedef CGAL::Object Object;
 typedef CGAL::Dispatch_output_iterator<
-  CGAL::cpp11::tuple<Object, Alpha_value_type>,
-  CGAL::cpp11::tuple<std::back_insert_iterator< std::vector<Object> >, std::back_insert_iterator< std::vector<Alpha_value_type> >
-                     > > Dispatch;
-typedef Alpha_shape_3::Cell_handle   Cell_handle;
-typedef Alpha_shape_3::Facet         Facet;
-typedef Alpha_shape_3::Edge          Edge_3;
+CGAL::cpp11::tuple<Object, Alpha_value_type>,
+CGAL::cpp11::tuple<std::back_insert_iterator< std::vector<Object> >,
+    std::back_insert_iterator< std::vector<Alpha_value_type> > > > Dispatch;
+typedef Alpha_shape_3::Cell_handle Cell_handle;
+typedef Alpha_shape_3::Facet Facet;
+typedef Alpha_shape_3::Edge Edge_3;
 typedef std::list<Alpha_shape_3::Vertex_handle> Vertex_list;
 
 // gudhi type definition
@@ -65,70 +71,60 @@ typedef std::map<Alpha_shape_3::Vertex_handle, Simplex_tree_vertex > Alpha_shape
 typedef std::pair<Alpha_shape_3::Vertex_handle, Simplex_tree_vertex> Alpha_shape_simplex_tree_pair;
 typedef std::vector< Simplex_tree_vertex > Simplex_tree_vector_vertex;
 
-//#define DEBUG_TRACES
-
-Vertex_list from (const Cell_handle& ch)
-{
+Vertex_list from(const Cell_handle& ch) {
   Vertex_list the_list;
-  for (auto i = 0; i < 4; i++)
-  {
+  for (auto i = 0; i < 4; i++) {
 #ifdef DEBUG_TRACES
     std::cout << "from cell[" << i << "]=" << ch->vertex(i)->point() << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
     the_list.push_back(ch->vertex(i));
   }
   return the_list;
 }
-Vertex_list from (const Facet& fct)
-{
+
+Vertex_list from(const Facet& fct) {
   Vertex_list the_list;
-  for (auto i = 0; i < 4; i++)
-  {
-    if (fct.second != i)
-    {
+  for (auto i = 0; i < 4; i++) {
+    if (fct.second != i) {
 #ifdef DEBUG_TRACES
       std::cout << "from facet=[" << i << "]" << fct.first->vertex(i)->point() << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
       the_list.push_back(fct.first->vertex(i));
     }
   }
   return the_list;
 }
-Vertex_list from (const Edge_3& edg)
-{
+
+Vertex_list from(const Edge_3& edg) {
   Vertex_list the_list;
-  for (auto i = 0; i < 4; i++)
-  {
-    if ((edg.second == i) ||(edg.third == i))
-    {
+  for (auto i = 0; i < 4; i++) {
+    if ((edg.second == i) || (edg.third == i)) {
 #ifdef DEBUG_TRACES
       std::cout << "from edge[" << i << "]=" << edg.first->vertex(i)->point() << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
       the_list.push_back(edg.first->vertex(i));
     }
   }
   return the_list;
 }
-Vertex_list from (const Alpha_shape_3::Vertex_handle& vh)
-{
+
+Vertex_list from(const Alpha_shape_3::Vertex_handle& vh) {
   Vertex_list the_list;
 #ifdef DEBUG_TRACES
   std::cout << "from vertex=" << vh->point() << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
   the_list.push_back(vh);
   return the_list;
 }
 
-void usage(char * const progName)
-{
-  std::cerr << "Usage: " << progName << " path_to_file_graph coeff_field_characteristic[integer > 0] min_persistence[float >= -1.0]\n";
-  exit(-1); // ----- >>
+void usage(char * const progName) {
+  std::cerr << "Usage: " << progName <<
+      " path_to_file_graph coeff_field_characteristic[integer > 0] min_persistence[float >= -1.0]\n";
+  exit(-1);
 }
 
-int main (int argc, char * const argv[])
-{
-
-  int coeff_field_characteristic=0;
+int main(int argc, char * const argv[]) {
+  int coeff_field_characteristic = 0;
   int returnedScanValue = sscanf(argv[2], "%d", &coeff_field_characteristic);
   if ((returnedScanValue == EOF) || (coeff_field_characteristic <= 0)) {
     std::cerr << "Error: " << argv[2] << " is not correct\n";
@@ -149,102 +145,96 @@ int main (int argc, char * const argv[])
   }
 
   // Read points from file
-  std::string filegraph   = argv[1];
+  std::string filegraph = argv[1];
   std::list<Point_3> lp;
   std::ifstream is(filegraph.c_str());
   int n;
   is >> n;
 #ifdef DEBUG_TRACES
   std::cout << "Reading " << n << " points " << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
   Point_3 p;
-  for( ; n>0 ; n--)    {
+  for (; n > 0; n--) {
     is >> p;
     lp.push_back(p);
   }
 
   // alpha shape construction from points. CGAL has a strange behavior in REGULARIZED mode.
-  Alpha_shape_3 as(lp.begin(),lp.end(),0,Alpha_shape_3::GENERAL);
+  Alpha_shape_3 as(lp.begin(), lp.end(), 0, Alpha_shape_3::GENERAL);
 #ifdef DEBUG_TRACES
   std::cout << "Alpha shape computed in GENERAL mode" << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
 
   // filtration with alpha values from alpha shape
   std::vector<Object> the_objects;
   std::vector<Alpha_value_type> the_alpha_values;
 
-  Dispatch disp = CGAL::dispatch_output<Object, Alpha_value_type>( std::back_inserter(the_objects), std::back_inserter(the_alpha_values));
+  Dispatch disp = CGAL::dispatch_output<Object, Alpha_value_type>(std::back_inserter(the_objects),
+                                                                  std::back_inserter(the_alpha_values));
 
   as.filtration_with_alpha_values(disp);
 #ifdef DEBUG_TRACES
   std::cout << "filtration_with_alpha_values returns : " << the_objects.size() << " objects" << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
 
   Alpha_shape_3::size_type count_vertices = 0;
-  Alpha_shape_3::size_type count_edges    = 0;
-  Alpha_shape_3::size_type count_facets   = 0;
-  Alpha_shape_3::size_type count_cells    = 0;
+  Alpha_shape_3::size_type count_edges = 0;
+  Alpha_shape_3::size_type count_facets = 0;
+  Alpha_shape_3::size_type count_cells = 0;
 
   // Loop on objects vector
   Vertex_list vertex_list;
   Simplex_tree<> simplex_tree;
   Alpha_shape_simplex_tree_map map_cgal_simplex_tree;
   std::vector<Alpha_value_type>::iterator the_alpha_value_iterator = the_alpha_values.begin();
-  int dim_max=0;
-  Filtration_value filtration_max=0.0;
-  for(auto object_iterator: the_objects)
-  {
+  int dim_max = 0;
+  Filtration_value filtration_max = 0.0;
+  for (auto object_iterator : the_objects) {
     // Retrieve Alpha shape vertex list from object
-    if (const Cell_handle* cell = CGAL::object_cast<Cell_handle>(&object_iterator))
-    {
+    if (const Cell_handle * cell = CGAL::object_cast<Cell_handle>(&object_iterator)) {
       vertex_list = from(*cell);
       count_cells++;
       if (dim_max < 3) {
-        dim_max=3; // Cell is of dim 3
+        // Cell is of dim 3
+        dim_max = 3;
       }
-    }
-    else if (const Facet* facet = CGAL::object_cast<Facet>(&object_iterator))
-    {
+    } else if (const Facet * facet = CGAL::object_cast<Facet>(&object_iterator)) {
       vertex_list = from(*facet);
       count_facets++;
       if (dim_max < 2) {
-        dim_max=2; // Facet is of dim 2
+        // Facet is of dim 2
+        dim_max = 2;
       }
-    }
-    else if (const Edge_3* edge = CGAL::object_cast<Edge_3>(&object_iterator))
-    {
+    } else if (const Edge_3 * edge = CGAL::object_cast<Edge_3>(&object_iterator)) {
       vertex_list = from(*edge);
       count_edges++;
       if (dim_max < 1) {
-        dim_max=1; // Edge_3 is of dim 1
+        // Edge_3 is of dim 1
+        dim_max = 1;
       }
-    }
-    else if (const Alpha_shape_3::Vertex_handle* vertex = CGAL::object_cast<Alpha_shape_3::Vertex_handle>(&object_iterator))
-    {
+    } else if (const Alpha_shape_3::Vertex_handle * vertex =
+               CGAL::object_cast<Alpha_shape_3::Vertex_handle>(&object_iterator)) {
       count_vertices++;
       vertex_list = from(*vertex);
     }
     // Construction of the vector of simplex_tree vertex from list of alpha_shapes vertex
     Simplex_tree_vector_vertex the_simplex_tree;
-    for (auto the_alpha_shape_vertex:vertex_list)
-    {
+    for (auto the_alpha_shape_vertex : vertex_list) {
       Alpha_shape_simplex_tree_map::iterator the_map_iterator = map_cgal_simplex_tree.find(the_alpha_shape_vertex);
-      if (the_map_iterator == map_cgal_simplex_tree.end())
-      {
+      if (the_map_iterator == map_cgal_simplex_tree.end()) {
         // alpha shape not found
         Simplex_tree_vertex vertex = map_cgal_simplex_tree.size();
 #ifdef DEBUG_TRACES
         std::cout << "vertex [" << the_alpha_shape_vertex->point() << "] not found - insert " << vertex << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
         the_simplex_tree.push_back(vertex);
-        map_cgal_simplex_tree.insert(Alpha_shape_simplex_tree_pair(the_alpha_shape_vertex,vertex));
-      } else
-      {
+        map_cgal_simplex_tree.insert(Alpha_shape_simplex_tree_pair(the_alpha_shape_vertex, vertex));
+      } else {
         // alpha shape found
         Simplex_tree_vertex vertex = the_map_iterator->second;
 #ifdef DEBUG_TRACES
         std::cout << "vertex [" << the_alpha_shape_vertex->point() << "] found in " << vertex << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
         the_simplex_tree.push_back(vertex);
       }
     }
@@ -252,7 +242,7 @@ int main (int argc, char * const argv[])
     Filtration_value filtr = std::sqrt(*the_alpha_value_iterator);
 #ifdef DEBUG_TRACES
     std::cout << "filtration = " << filtr << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
     if (filtr > filtration_max) {
       filtration_max = filtr;
     }
@@ -267,9 +257,9 @@ int main (int argc, char * const argv[])
 
 #ifdef DEBUG_TRACES
   std::cout << "vertices \t\t" << count_vertices << std::endl;
-  std::cout << "edges \t\t"    << count_edges << std::endl;
-  std::cout << "facets \t\t"   << count_facets << std::endl;
-  std::cout << "cells \t\t"    << count_cells << std::endl;
+  std::cout << "edges \t\t" << count_edges << std::endl;
+  std::cout << "facets \t\t" << count_facets << std::endl;
+  std::cout << "cells \t\t" << count_cells << std::endl;
 
 
   std::cout << "Information of the Simplex Tree: " << std::endl;
@@ -277,23 +267,25 @@ int main (int argc, char * const argv[])
   std::cout << "  Number of simplices = " << simplex_tree.num_simplices() << std::endl << std::endl;
   std::cout << "  Dimension = " << simplex_tree.dimension() << " ";
   std::cout << "  filtration = " << simplex_tree.filtration() << std::endl << std::endl;
-#endif // DEBUG_TRACES
+#endif  // DEBUG_TRACES
 
 #ifdef DEBUG_TRACES
   std::cout << "Iterator on vertices: " << std::endl;
-  for( auto vertex : simplex_tree.complex_vertex_range() )
-  { std::cout << vertex << " "; }
-#endif // DEBUG_TRACES
+  for (auto vertex : simplex_tree.complex_vertex_range()) {
+    std::cout << vertex << " ";
+  }
+#endif  // DEBUG_TRACES
 
   // Sort the simplices in the order of the filtration
   simplex_tree.initialize_filtration();
 
   std::cout << "Simplex_tree dim: " << simplex_tree.dimension() << std::endl;
   // Compute the persistence diagram of the complex
-  Persistent_cohomology< Simplex_tree<>, Field_Zp > pcoh( simplex_tree );
-  pcoh.init_coefficients( coeff_field_characteristic ); //initializes the coefficient field for homology
+  Persistent_cohomology< Simplex_tree<>, Field_Zp > pcoh(simplex_tree);
+  // initializes the coefficient field for homology
+  pcoh.init_coefficients(coeff_field_characteristic);
 
-  pcoh.compute_persistent_cohomology( min_persistence );
+  pcoh.compute_persistent_cohomology(min_persistence);
 
   pcoh.output_diagram();
 
diff --git a/src/Persistent_cohomology/example/performance_rips_persistence.cpp b/src/Persistent_cohomology/example/performance_rips_persistence.cpp
index 077c2b07..0e912d57 100644
--- a/src/Persistent_cohomology/example/performance_rips_persistence.cpp
+++ b/src/Persistent_cohomology/example/performance_rips_persistence.cpp
@@ -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):       Clément Maria
-  *
-  *    Copyright (C) 2014  INRIA Sophia Antipolis-Méditerranée (France)
-  *
-  *    This program is free software: you can redistribute it and/or modify
-  *    it under the terms of the GNU General Public License as published by
-  *    the Free Software Foundation, either version 3 of the License, or
-  *    (at your option) any later version.
-  *
-  *    This program is distributed in the hope that it will be useful,
-  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
-  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  *    GNU General Public License for more details.
-  *
-  *    You should have received a copy of the GNU General Public License
-  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-  */
-
-#include "gudhi/reader_utils.h"
-#include "gudhi/graph_simplicial_complex.h"
-#include "gudhi/distance_functions.h"
-#include "gudhi/Simplex_tree.h"
-#include "gudhi/Persistent_cohomology.h"
-#include "gudhi/Persistent_cohomology/Multi_field.h"
-#include "gudhi/Hasse_complex.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/>.
+ */
+
+#include <gudhi/reader_utils.h>
+#include <gudhi/graph_simplicial_complex.h>
+#include <gudhi/distance_functions.h>
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Persistent_cohomology.h>
+#include <gudhi/Persistent_cohomology/Multi_field.h>
+#include <gudhi/Hasse_complex.h>
 
 #include <chrono>
+#include <string>
+#include <vector>
 
 using namespace Gudhi;
 using namespace Gudhi::persistent_cohomology;
 
 /* Compute the persistent homology of the complex cpx with coefficients in Z/pZ. */
 template< typename FilteredComplex>
-void timing_persistence( FilteredComplex & cpx
-                       , int               p );
+void timing_persistence(FilteredComplex & cpx
+                        , int p);
 
 /* Compute multi-field persistent homology of the complex cpx with coefficients in
  * Z/rZ for all prime number r in [p;q].*/
 template< typename FilteredComplex>
-void timing_persistence( FilteredComplex & cpx
-                       , int               p 
-                       , int               q );
+void timing_persistence(FilteredComplex & cpx
+                        , int p
+                        , int q);
 
 /* Timings for the computation of persistent homology with different 
  * representations of a Rips complex and different coefficient fields. The 
@@ -59,111 +61,111 @@ void timing_persistence( FilteredComplex & cpx
  * We present also timings for the computation of multi-field persistent 
  * homology in all fields Z/rZ for r prime between 2 and 1223.
  */
-int main (int argc, char * argv[]) 
-{
+int main(int argc, char * argv[]) {
   std::chrono::time_point<std::chrono::system_clock> start, end;
   int enlapsed_sec;
 
-  std::string      filepoints      = "../examples/Kl.txt";
-  Filtration_value threshold       = 0.3;
-  int              dim_max         = 3;
-  int              p               = 2;
-  int              q               = 1223;
+  std::string filepoints = "../examples/Kl.txt";
+  Filtration_value threshold = 0.3;
+  int dim_max = 3;
+  int p = 2;
+  int q = 1223;
 
-// Extract the points from the file filepoints
+  // Extract the points from the file filepoints
   typedef std::vector<double> Point_t;
   std::vector< Point_t > points;
-  read_points( filepoints, points );
+  read_points(filepoints, points);
 
-// Compute the proximity graph of the points
+  // Compute the proximity graph of the points
   start = std::chrono::system_clock::now();
-  Graph_t prox_graph = compute_proximity_graph( points, threshold
-                                              , euclidean_distance<Point_t> );
+  Graph_t prox_graph = compute_proximity_graph(points, threshold
+                                               , euclidean_distance<Point_t>);
   end = std::chrono::system_clock::now();
-  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end-start).count();
+  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end - start).count();
   std::cout << "Compute Rips graph in " << enlapsed_sec << " sec.\n";
 
-// Construct the Rips complex in a Simplex Tree
-  Simplex_tree<> st;        
+  // Construct the Rips complex in a Simplex Tree
+  Simplex_tree<> st;
   start = std::chrono::system_clock::now();
 
-  st.insert_graph(prox_graph); // insert the proximity graph in the simplex tree
-  st.expansion( dim_max ); // expand the graph until dimension dim_max
+  // insert the proximity graph in the simplex tree
+  st.insert_graph(prox_graph);
+  // expand the graph until dimension dim_max
+  st.expansion(dim_max);
 
   end = std::chrono::system_clock::now();
-  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end-start).count();
+  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end - start).count();
   std::cout << "Compute Rips complex in " << enlapsed_sec << " sec.\n";
   std::cout << "  - dimension           = " << st.dimension() << std::endl;
   std::cout << "  - number of simplices = " << st.num_simplices() << std::endl;
 
-// Sort the simplices in the order of the filtration
+  // Sort the simplices in the order of the filtration
   start = std::chrono::system_clock::now();
   st.initialize_filtration();
   end = std::chrono::system_clock::now();
-  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end-start).count();
+  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end - start).count();
   std::cout << "Order the simplices of the filtration in " << enlapsed_sec << " sec.\n";
 
-// Convert the simplex tree into a hasse diagram
+  // Convert the simplex tree into a hasse diagram
   start = std::chrono::system_clock::now();
   Hasse_complex<> hcpx(st);
   end = std::chrono::system_clock::now();
-  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end-start).count();
+  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end - start).count();
   std::cout << "Convert the simplex tree into a Hasse diagram in " << enlapsed_sec << " sec.\n";
 
 
   std::cout << "Timings when using a simplex tree: \n";
-  timing_persistence(st,p);
-  timing_persistence(st,q);
-  timing_persistence(st,p,q);
+  timing_persistence(st, p);
+  timing_persistence(st, q);
+  timing_persistence(st, p, q);
 
   std::cout << "Timings when using a Hasse complex: \n";
-  timing_persistence(hcpx,p);
-  timing_persistence(hcpx,q);
-  timing_persistence(hcpx,p,q);
+  timing_persistence(hcpx, p);
+  timing_persistence(hcpx, q);
+  timing_persistence(hcpx, p, q);
 
   return 0;
 }
 
-
 template< typename FilteredComplex>
 void
-timing_persistence( FilteredComplex & cpx
-                  , int               p )
-{
+timing_persistence(FilteredComplex & cpx
+                   , int p) {
   std::chrono::time_point<std::chrono::system_clock> start, end;
   int enlapsed_sec;
 
-  Persistent_cohomology< FilteredComplex, Field_Zp > pcoh (cpx);
-  pcoh.init_coefficients( p ); //initilizes the coefficient field for homology
-  
+  Persistent_cohomology< FilteredComplex, Field_Zp > pcoh(cpx);
+  // initializes the coefficient field for homology
+  pcoh.init_coefficients(p);
+
   start = std::chrono::system_clock::now();
- 
-  pcoh.compute_persistent_cohomology( INFINITY );
- 
+
+  pcoh.compute_persistent_cohomology(INFINITY);
+
   end = std::chrono::system_clock::now();
-  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end-start).count();
-  std::cout << "  Compute persistent homology in Z/"<<p<<"Z in " << enlapsed_sec << " sec.\n";
+  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end - start).count();
+  std::cout << "  Compute persistent homology in Z/" << p << "Z in " << enlapsed_sec << " sec.\n";
 }
 
 template< typename FilteredComplex>
 void
-timing_persistence( FilteredComplex & cpx
-                  , int               p 
-                  , int               q )
-{
+timing_persistence(FilteredComplex & cpx
+                   , int p
+                   , int q) {
   std::chrono::time_point<std::chrono::system_clock> start, end;
   int enlapsed_sec;
 
-  Persistent_cohomology< FilteredComplex, Multi_field > pcoh (cpx);
-  pcoh.init_coefficients( p, q ); //initilizes the coefficient field for homology
+  Persistent_cohomology< FilteredComplex, Multi_field > pcoh(cpx);
+  // initializes the coefficient field for homology
+  pcoh.init_coefficients(p, q);
   // compute persistent homology, disgarding persistent features of life shorter than min_persistence
 
   start = std::chrono::system_clock::now();
 
-  pcoh.compute_persistent_cohomology( INFINITY );
+  pcoh.compute_persistent_cohomology(INFINITY);
 
   end = std::chrono::system_clock::now();
-  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end-start).count();
+  enlapsed_sec = std::chrono::duration_cast<std::chrono::seconds>(end - start).count();
   std::cout << "  Compute multi-field persistent homology in all coefficient fields Z/pZ "
-            << "with p in ["<<p<<";"<<q<<"] in " << enlapsed_sec << " sec.\n";
+      << "with p in [" << p << ";" << q << "] in " << enlapsed_sec << " sec.\n";
 }
diff --git a/src/Persistent_cohomology/example/persistence_from_file.cpp b/src/Persistent_cohomology/example/persistence_from_file.cpp
index e886aea7..8eb8d0f3 100644
--- a/src/Persistent_cohomology/example/persistence_from_file.cpp
+++ b/src/Persistent_cohomology/example/persistence_from_file.cpp
@@ -1,141 +1,144 @@
- /*    This file is part of the Gudhi Library. The Gudhi library 
-  *    (Geometric Understanding in Higher Dimensions) is a generic C++ 
-  *    library for computational topology.
-  *
-  *    Author(s):       Vincent Rouvreau
-  *
-  *    Copyright (C) 2014  INRIA Saclay (France)
-  *
-  *    This program is free software: you can redistribute it and/or modify
-  *    it under the terms of the GNU General Public License as published by
-  *    the Free Software Foundation, either version 3 of the License, or
-  *    (at your option) any later version.
-  *
-  *    This program is distributed in the hope that it will be useful,
-  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
-  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  *    GNU General Public License for more details.
-  *
-  *    You should have received a copy of the GNU General Public License
-  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-  */
-
-#include "gudhi/reader_utils.h"
-#include "gudhi/graph_simplicial_complex.h"
-#include "gudhi/distance_functions.h"
-#include "gudhi/Simplex_tree.h"
-#include "gudhi/Persistent_cohomology.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):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2014  INRIA Saclay (France)
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gudhi/reader_utils.h>
+#include <gudhi/graph_simplicial_complex.h>
+#include <gudhi/distance_functions.h>
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Persistent_cohomology.h>
 
 #include <boost/program_options.hpp>
 
+#include <string>
+
 using namespace Gudhi;
 using namespace Gudhi::persistent_cohomology;
 
-typedef int        Vertex_handle;
-typedef double     Filtration_value;
-
-void program_options( int argc, char *   argv[] 
-                    , std::string      & simplex_tree_file
-                    , std::string      & output_file
-                    , int              & p
-                    , Filtration_value & min_persistence );
-
-int main (int argc, char * argv[]) 
-{
-	std::string      simplex_tree_file;
-	std::string      output_file  ;
-	int              p         ;
-	Filtration_value min_persistence;
-
-	program_options(argc,argv,simplex_tree_file,output_file,p,min_persistence);
-
-	std::cout << "Simplex_tree from file=" << simplex_tree_file.c_str() << " - output_file=" << output_file.c_str() << std::endl;
-	std::cout << "     - p=" << p << " - min_persistence=" << min_persistence << std::endl;
-
-	// Construct the Rips complex in a Simplex Tree
-	Simplex_tree<> simplex_tree;
-
-	std::ifstream simplex_tree_stream(simplex_tree_file);
-	simplex_tree_stream >> simplex_tree;
-
-	std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices" << std::endl;
-	std::cout << "   - dimension " << simplex_tree.dimension() << "   - filtration " << simplex_tree.filtration() << std::endl;
-
-	/*
-	std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
-	for( auto f_simplex : simplex_tree.filtration_simplex_range() )
-	{ std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
-	for( auto vertex : simplex_tree.simplex_vertex_range(f_simplex) )
-	{ std::cout << vertex << " "; }
-	std::cout << std::endl;
-	}*/
-
-	// Sort the simplices in the order of the filtration
-	simplex_tree.initialize_filtration();
-
-	// Compute the persistence diagram of the complex
-	Persistent_cohomology< Simplex_tree<>, Field_Zp > pcoh( simplex_tree );
-	pcoh.init_coefficients( p ); //initilizes the coefficient field for homology
-
-	pcoh.compute_persistent_cohomology( min_persistence );
-
-	// Output the diagram in output_file
-	if(output_file.empty()) {  pcoh.output_diagram(); }
-	else {
-		std::ofstream out(output_file);
-		pcoh.output_diagram(out);
-		out.close(); }
+typedef int Vertex_handle;
+typedef double Filtration_value;
+
+void program_options(int argc, char * argv[]
+                     , std::string & simplex_tree_file
+                     , std::string & output_file
+                     , int & p
+                     , Filtration_value & min_persistence);
+
+int main(int argc, char * argv[]) {
+  std::string simplex_tree_file;
+  std::string output_file;
+  int p;
+  Filtration_value min_persistence;
+
+  program_options(argc, argv, simplex_tree_file, output_file, p, min_persistence);
+
+  std::cout << "Simplex_tree from file=" << simplex_tree_file.c_str() << " - output_file=" << output_file.c_str()
+      << std::endl;
+  std::cout << "     - p=" << p << " - min_persistence=" << min_persistence << std::endl;
+
+  // Construct the Rips complex in a Simplex Tree
+  Simplex_tree<> simplex_tree;
+
+  std::ifstream simplex_tree_stream(simplex_tree_file);
+  simplex_tree_stream >> simplex_tree;
+
+  std::cout << "The complex contains " << simplex_tree.num_simplices() << " simplices" << std::endl;
+  std::cout << "   - dimension " << simplex_tree.dimension() << "   - filtration " << simplex_tree.filtration()
+      << std::endl;
+
+  /*
+  std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+  for( auto f_simplex : simplex_tree.filtration_simplex_range() )
+  { std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+  for( auto vertex : simplex_tree.simplex_vertex_range(f_simplex) )
+  { std::cout << vertex << " "; }
+  std::cout << std::endl;
+  }*/
+
+  // Sort the simplices in the order of the filtration
+  simplex_tree.initialize_filtration();
+
+  // Compute the persistence diagram of the complex
+  Persistent_cohomology< Simplex_tree<>, Field_Zp > pcoh(simplex_tree);
+  // initializes the coefficient field for homology
+  pcoh.init_coefficients(p);
+
+  pcoh.compute_persistent_cohomology(min_persistence);
+
+  // Output the diagram in output_file
+  if (output_file.empty()) {
+    pcoh.output_diagram();
+  } else {
+    std::ofstream out(output_file);
+    pcoh.output_diagram(out);
+    out.close();
+  }
 
-	return 0;
+  return 0;
 }
 
-
-
-void program_options( int argc, char *   argv[] 
-                    , std::string      & simplex_tree_file
-                    , std::string      & output_file
-                    , int              & p
-                    , Filtration_value & min_persistence )
-{
+void program_options(int argc, char * argv[]
+                     , std::string & simplex_tree_file
+                     , std::string & output_file
+                     , int & p
+                     , Filtration_value & min_persistence) {
   namespace po = boost::program_options;
-  po::options_description     hidden("Hidden options");
+  po::options_description hidden("Hidden options");
   hidden.add_options()
-        ("input-file",  po::value<std::string>(&simplex_tree_file),
-          "Name of file containing a simplex set. Format is one simplex per line (cf. reader_utils.h - read_simplex):   Dim1 X11 X12 ... X1d Fil1  ");
-    
+      ("input-file", po::value<std::string>(&simplex_tree_file),
+       "Name of file containing a simplex set. Format is one simplex per line (cf. reader_utils.h - read_simplex): Dim1 X11 X12 ... X1d Fil1  ");
+
   po::options_description visible("Allowed options", 100);
   visible.add_options()
-        ("help,h",          "produce help message")
-        ("output-file,o", po::value<std::string>(&output_file)->default_value(std::string()),
-                   "Name of file in which the persistence diagram is written. Default print in std::cout")
-        ("field-charac,p", po::value<int>(&p)->default_value(11),                  
-                  "Characteristic p of the coefficient field Z/pZ for computing homology.")
-        ("min-persistence,m", po::value<Filtration_value>(&min_persistence), 
-                  "Minimal lifetime of homology feature to be recorded. Default is 0");
+      ("help,h", "produce help message")
+      ("output-file,o", po::value<std::string>(&output_file)->default_value(std::string()),
+       "Name of file in which the persistence diagram is written. Default print in std::cout")
+      ("field-charac,p", po::value<int>(&p)->default_value(11),
+       "Characteristic p of the coefficient field Z/pZ for computing homology.")
+      ("min-persistence,m", po::value<Filtration_value>(&min_persistence),
+       "Minimal lifetime of homology feature to be recorded. Default is 0");
 
   po::positional_options_description pos;
   pos.add("input-file", 1);
-  
-  po::options_description all; all.add(visible).add(hidden);
+
+  po::options_description all;
+  all.add(visible).add(hidden);
 
   po::variables_map vm;
   po::store(po::command_line_parser(argc, argv).
-                options(all).positional(pos).run(), vm);
+            options(all).positional(pos).run(), vm);
   po::notify(vm);
 
-  if (vm.count("help") || !vm.count("input-file"))
-  { 
-      std::cout << std::endl;
-      std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-      std::cout << "of a Rips complex defined on a set of input points.\n \n";
-      std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-      std::cout << "   p   dim b d \n";
-      std::cout << "where dim is the dimension of the homological feature,\n";
-      std::cout << "b and d are respectively the birth and death of the feature and \n";
-      std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-      std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-      std::cout << visible << std::endl; 
-      std::abort();
+  if (vm.count("help") || !vm.count("input-file")) {
+    std::cout << std::endl;
+    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::cout << "of a Rips complex defined on a set of input points.\n \n";
+    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
+    std::cout << "   p   dim b d \n";
+    std::cout << "where dim is the dimension of the homological feature,\n";
+    std::cout << "b and d are respectively the birth and death of the feature and \n";
+    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
+
+    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
+    std::cout << visible << std::endl;
+    std::abort();
   }
 }
diff --git a/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp b/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp
index ba82e4e6..ba772f04 100644
--- a/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp
+++ b/src/Persistent_cohomology/example/persistence_from_simple_simplex_tree.cpp
@@ -20,11 +20,14 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <gudhi/graph_simplicial_complex.h>
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Persistent_cohomology.h>
+
 #include <iostream>
 #include <ctime>
-#include "gudhi/graph_simplicial_complex.h"
-#include "gudhi/Simplex_tree.h"
-#include "gudhi/Persistent_cohomology.h"
+#include <utility>
+#include <vector>
 
 using namespace Gudhi;
 using namespace Gudhi::persistent_cohomology;
@@ -34,15 +37,19 @@ typedef std::pair<typeVectorVertex, Filtration_value> typeSimplex;
 typedef std::pair< Simplex_tree<>::Simplex_handle, bool > typePairSimplexBool;
 typedef Simplex_tree<> typeST;
 
-void usage(char * const progName)
-{
+void usage(char * const progName) {
   std::cerr << "Usage: " << progName << " coeff_field_characteristic[integer > 0] min_persistence[float >= -1.0]\n";
-  exit(-1); // ----- >>
+  exit(-1);
 }
 
-int main (int argc, char * const argv[])
-{
-  int coeff_field_characteristic=0;
+int main(int argc, char * const argv[]) {
+  // program args management
+  if (argc != 3) {
+    std::cerr << "Error: Number of arguments (" << argc << ") is not correct\n";
+    usage(argv[0]);
+  }
+
+  int coeff_field_characteristic = 0;
   int returnedScanValue = sscanf(argv[1], "%d", &coeff_field_characteristic);
   if ((returnedScanValue == EOF) || (coeff_field_characteristic <= 0)) {
     std::cerr << "Error: " << argv[1] << " is not correct\n";
@@ -56,101 +63,65 @@ int main (int argc, char * const argv[])
     usage(argv[0]);
   }
 
-  // program args management
-  if (argc != 3) {
-    std::cerr << "Error: Number of arguments (" << argc << ") is not correct\n";
-    usage(argv[0]);
-  }
-
   // 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);
+  std::cout << "   - INSERT (0,1,2)" << std::endl;
+  typeVectorVertex SimplexVector = {0, 1, 2};
+  st.insert_simplex_and_subfaces(SimplexVector, 0.3);
 
   // ++ SECOND
   std::cout << "   - INSERT 3" << std::endl;
-  typeVectorVertex SimplexVector2;
-  SimplexVector2.push_back(3);
-  st.insert_simplex_and_subfaces ( SimplexVector2, 0.1);
+  SimplexVector = {3};
+  st.insert_simplex_and_subfaces(SimplexVector, 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);
+  SimplexVector = {0, 3};
+  st.insert_simplex_and_subfaces(SimplexVector, 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);
+  std::cout << "   - INSERT (0,1) (already inserted)" << std::endl;
+  SimplexVector = {0, 1};
+  st.insert_simplex_and_subfaces(SimplexVector, 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);
+  SimplexVector = {3, 4, 5};
+  st.insert_simplex_and_subfaces(SimplexVector, 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);
+  SimplexVector = {0, 1, 6, 7};
+  st.insert_simplex_and_subfaces(SimplexVector, 0.4);
 
   // ++ SEVENTH
   std::cout << "   - INSERT (4,5,8,9)" << std::endl;
-  typeVectorVertex SimplexVector7;
-  SimplexVector7.push_back(4);
-  SimplexVector7.push_back(5);
-  SimplexVector7.push_back(8);
-  SimplexVector7.push_back(9);
-  st.insert_simplex_and_subfaces ( SimplexVector7, 0.4);
+  SimplexVector = {4, 5, 8, 9};
+  st.insert_simplex_and_subfaces(SimplexVector, 0.4);
 
   // ++ EIGHTH
   std::cout << "   - INSERT (9,10,11)" << std::endl;
-  typeVectorVertex SimplexVector8;
-  SimplexVector8.push_back(9);
-  SimplexVector8.push_back(10);
-  SimplexVector8.push_back(11);
-  st.insert_simplex_and_subfaces ( SimplexVector8, 0.3);
-  
+  SimplexVector = {9, 10, 11};
+  st.insert_simplex_and_subfaces(SimplexVector, 0.3);
+
   // ++ NINETH
   std::cout << "   - INSERT (2,10,12)" << std::endl;
-  typeVectorVertex SimplexVector9;
-  SimplexVector9.push_back(2);
-  SimplexVector9.push_back(10);
-  SimplexVector9.push_back(12);
-  st.insert_simplex_and_subfaces ( SimplexVector9, 0.3);
-  
+  SimplexVector = {2, 10, 12};
+  st.insert_simplex_and_subfaces(SimplexVector, 0.3);
+
   // ++ TENTH
   std::cout << "   - INSERT (11,6)" << std::endl;
-  typeVectorVertex SimplexVector10;
-  SimplexVector10.push_back(11);
-  SimplexVector10.push_back(6);
-  st.insert_simplex_and_subfaces ( SimplexVector10, 0.2);
+  SimplexVector = {6, 11};
+  st.insert_simplex_and_subfaces(SimplexVector, 0.2);
 
   // ++ ELEVENTH
   std::cout << "   - INSERT (13,14,15)" << std::endl;
-  typeVectorVertex SimplexVector11;
-  SimplexVector11.push_back(13);
-  SimplexVector11.push_back(14);
-  SimplexVector11.push_back(15);
-  st.insert_simplex_and_subfaces ( SimplexVector11, 0.25);
+  SimplexVector = {13, 14, 15};
+  st.insert_simplex_and_subfaces(SimplexVector, 0.25);
 
   /* Inserted simplex:         */
   /*    1   6                  */
@@ -175,33 +146,31 @@ int main (int argc, char * const argv[])
   st.set_dimension(2);
   st.set_filtration(0.4);
 
-  std::cout << "The complex contains " << st.num_simplices() << " simplices - " << st.num_vertices() << " vertices " << std::endl;
+  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 << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:"
+      << std::endl;
   std::cout << "**************************************************************" << std::endl;
   std::cout << "strict graph G { " << std::endl;
 
-  for( auto f_simplex : st.filtration_simplex_range() )
-  {
+  for (auto f_simplex : st.filtration_simplex_range()) {
     std::cout << "   " << "[" << st.filtration(f_simplex) << "] ";
-    for( auto vertex : st.simplex_vertex_range(f_simplex) )
-    {
-      std::cout << (int)vertex << " -- ";
+    for (auto vertex : st.simplex_vertex_range(f_simplex)) {
+      std::cout << static_cast<int>(vertex) << " -- ";
     }
     std::cout << ";" << std::endl;
   }
 
   std::cout << "}" << std::endl;
-  //std::cout << "**************************************************************" << std::endl;
-  //st.print_hasse(std::cout);
   std::cout << "**************************************************************" << std::endl;
 
-
   // Compute the persistence diagram of the complex
   persistent_cohomology::Persistent_cohomology< Simplex_tree<>, Field_Zp > pcoh(st);
-  pcoh.init_coefficients( coeff_field_characteristic ); //initiliazes the coefficient field for homology
+  // initializes the coefficient field for homology
+  pcoh.init_coefficients(coeff_field_characteristic);
 
-  pcoh.compute_persistent_cohomology( min_persistence );
+  pcoh.compute_persistent_cohomology(min_persistence);
 
   // Output the diagram in filediag
   pcoh.output_diagram();
diff --git a/src/Persistent_cohomology/example/rips_multifield_persistence.cpp b/src/Persistent_cohomology/example/rips_multifield_persistence.cpp
index 297a8f98..5277bf7a 100644
--- a/src/Persistent_cohomology/example/rips_multifield_persistence.cpp
+++ b/src/Persistent_cohomology/example/rips_multifield_persistence.cpp
@@ -1,153 +1,157 @@
- /*    This file is part of the Gudhi Library. The Gudhi library 
-  *    (Geometric Understanding in Higher Dimensions) is a generic C++ 
-  *    library for computational topology.
-  *
-  *    Author(s):       Clément Maria
-  *
-  *    Copyright (C) 2014  INRIA Sophia Antipolis-Méditerranée (France)
-  *
-  *    This program is free software: you can redistribute it and/or modify
-  *    it under the terms of the GNU General Public License as published by
-  *    the Free Software Foundation, either version 3 of the License, or
-  *    (at your option) any later version.
-  *
-  *    This program is distributed in the hope that it will be useful,
-  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
-  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  *    GNU General Public License for more details.
-  *
-  *    You should have received a copy of the GNU General Public License
-  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-  */
-
-#include "gudhi/reader_utils.h"
-#include "gudhi/graph_simplicial_complex.h"
-#include "gudhi/distance_functions.h"
-#include "gudhi/Simplex_tree.h"
-#include "gudhi/Persistent_cohomology.h"
-#include "gudhi/Persistent_cohomology/Multi_field.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/>.
+ */
+
+#include <gudhi/reader_utils.h>
+#include <gudhi/graph_simplicial_complex.h>
+#include <gudhi/distance_functions.h>
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Persistent_cohomology.h>
+#include <gudhi/Persistent_cohomology/Multi_field.h>
 
 #include <boost/program_options.hpp>
 
+#include <string>
+#include <vector>
+
 using namespace Gudhi;
 using namespace Gudhi::persistent_cohomology;
 
-typedef int    Vertex_handle;
+typedef int Vertex_handle;
 typedef double Filtration_value;
 
-void program_options( int argc, char *   argv[] 
-                    , std::string      & filepoints
-                    , std::string      & filediag
-                    , Filtration_value & threshold
-                    , int              & dim_max
-                    , int              & min_p
-                    , int              & max_p
-                    , Filtration_value & min_persistence );
-
-int main (int argc, char * argv[]) 
-{
-  std::string      filepoints;
-  std::string      filediag;
+void program_options(int argc, char * argv[]
+                     , std::string & filepoints
+                     , std::string & filediag
+                     , Filtration_value & threshold
+                     , int & dim_max
+                     , int & min_p
+                     , int & max_p
+                     , Filtration_value & min_persistence);
+
+int main(int argc, char * argv[]) {
+  std::string filepoints;
+  std::string filediag;
   Filtration_value threshold;
-  int              dim_max;
-  int              min_p;
-  int              max_p;
+  int dim_max;
+  int min_p;
+  int max_p;
   Filtration_value min_persistence;
 
-  program_options(argc,argv,filepoints,filediag,threshold,dim_max,min_p,max_p,min_persistence);
+  program_options(argc, argv, filepoints, filediag, threshold, dim_max, min_p, max_p, min_persistence);
 
-// Extract the points from the file filepoints
+  // Extract the points from the file filepoints
   typedef std::vector<double> Point_t;
   std::vector< Point_t > points;
-  read_points( filepoints, points );
+  read_points(filepoints, points);
 
-// Compute the proximity graph of the points
-  Graph_t prox_graph = compute_proximity_graph( points, threshold
-                                              , euclidean_distance<Point_t> );
+  // Compute the proximity graph of the points
+  Graph_t prox_graph = compute_proximity_graph(points, threshold
+                                               , euclidean_distance<Point_t>);
 
-// Construct the Rips complex in a Simplex Tree
-  Simplex_tree<> st;        
-  st.insert_graph(prox_graph); // insert the proximity graph in the simplex tree
-  st.expansion( dim_max ); // expand the graph until dimension dim_max
+  // Construct the Rips complex in a Simplex Tree
+  Simplex_tree<> st;
+  // insert the proximity graph in the simplex tree
+  st.insert_graph(prox_graph);
+  // expand the graph until dimension dim_max
+  st.expansion(dim_max);
 
-// Sort the simplices in the order of the filtration
+  // Sort the simplices in the order of the filtration
   st.initialize_filtration();
 
-// Compute the persistence diagram of the complex
-  Persistent_cohomology< Simplex_tree<>, Multi_field > pcoh( st );
-  pcoh.init_coefficients( min_p, max_p ); //initilizes the coefficient field for homology
+  // Compute the persistence diagram of the complex
+  Persistent_cohomology< Simplex_tree<>, Multi_field > pcoh(st);
+  // initializes the coefficient field for homology
+  pcoh.init_coefficients(min_p, max_p);
   // compute persistent homology, disgarding persistent features of life shorter than min_persistence
-  pcoh.compute_persistent_cohomology( min_persistence );
-
-// Output the diagram in filediag
-  if(filediag.empty()) {  pcoh.output_diagram(); }
-  else {
-   std::ofstream out(filediag);
-   pcoh.output_diagram(out);
-   out.close(); }
+  pcoh.compute_persistent_cohomology(min_persistence);
+
+  // Output the diagram in filediag
+  if (filediag.empty()) {
+    pcoh.output_diagram();
+  } else {
+    std::ofstream out(filediag);
+    pcoh.output_diagram(out);
+    out.close();
+  }
 
   return 0;
 }
 
-
-
-void program_options( int argc, char *   argv[] 
-                    , std::string      & filepoints
-                    , std::string      & filediag
-                    , Filtration_value & threshold
-                    , int              & dim_max
-                    , int              & min_p
-                    , int              & max_p
-                    , Filtration_value & min_persistence )
-{
+void program_options(int argc, char * argv[]
+                     , std::string & filepoints
+                     , std::string & filediag
+                     , Filtration_value & threshold
+                     , int & dim_max
+                     , int & min_p
+                     , int & max_p
+                     , Filtration_value & min_persistence) {
   namespace po = boost::program_options;
-  po::options_description     hidden("Hidden options");
+  po::options_description hidden("Hidden options");
   hidden.add_options()
-        ("input-file",  po::value<std::string>(&filepoints), 
-          "Name of file containing a point set. Format is one point per line:   X1 ... Xd \n");
-    
+      ("input-file", po::value<std::string>(&filepoints),
+       "Name of file containing a point set. Format is one point per line:   X1 ... Xd \n");
+
   po::options_description visible("Allowed options");
   visible.add_options()
-        ("help,h",          "produce help message")
-        ("output-file,o", po::value<std::string>(&filediag)->default_value(std::string()), 
-                   "Name of file in which the persistence diagram is written. Default print in std::cout")
-        ("max-edge-length,r", po::value<Filtration_value>(&threshold)->default_value(0), 
-                   "Maximal length of an edge for the Rips complex construction.")
-        ("cpx-dimension,d", po::value<int>(&dim_max)->default_value(1),        
-                  "Maximal dimension of the Rips complex we want to compute.")
-        ("min-field-charac,p", po::value<int>(&min_p)->default_value(2),                  
-                  "Minimal characteristic p of the coefficient field Z/pZ.")
-        ("max-field-charac,q", po::value<int>(&max_p)->default_value(1223),                  
-                  "Minimial characteristic q of the coefficient field Z/pZ.")
-        ("min-persistence,m", po::value<Filtration_value>(&min_persistence), 
-                  "Minimal lifetime of homology feature to be recorded. Default is 0");
+      ("help,h", "produce help message")
+      ("output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
+       "Name of file in which the persistence diagram is written. Default print in std::cout")
+      ("max-edge-length,r", po::value<Filtration_value>(&threshold)->default_value(0),
+       "Maximal length of an edge for the Rips complex construction.")
+      ("cpx-dimension,d", po::value<int>(&dim_max)->default_value(1),
+       "Maximal dimension of the Rips complex we want to compute.")
+      ("min-field-charac,p", po::value<int>(&min_p)->default_value(2),
+       "Minimal characteristic p of the coefficient field Z/pZ.")
+      ("max-field-charac,q", po::value<int>(&max_p)->default_value(1223),
+       "Minimial characteristic q of the coefficient field Z/pZ.")
+      ("min-persistence,m", po::value<Filtration_value>(&min_persistence),
+       "Minimal lifetime of homology feature to be recorded. Default is 0");
 
   po::positional_options_description pos;
   pos.add("input-file", 1);
-  
-  po::options_description all; all.add(visible).add(hidden);
+
+  po::options_description all;
+  all.add(visible).add(hidden);
 
   po::variables_map vm;
   po::store(po::command_line_parser(argc, argv).
-                options(all).positional(pos).run(), vm);
+            options(all).positional(pos).run(), vm);
   po::notify(vm);
 
-  if (vm.count("help") || !vm.count("input-file"))
-  { 
-      std::cout << std::endl;
-      std::cout << "Compute the persistent homology with various coefficient fields \n";
-      std::cout << "of a Rips complex defined on a set of input points. The coefficient \n";
-      std::cout << "fields are all the Z/rZ for a prime number r contained in the \n";
-      std::cout << "specified range [p,q]\n \n";
-      std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-      std::cout << "   p1*...*pr   dim b d \n";
-      std::cout << "where dim is the dimension of the homological feature,\n";
-      std::cout << "b and d are respectively the birth and death of the feature and \n";
-      std::cout << "p1*...*pr is the product of prime numbers pi such that the homology \n";
-      std::cout << "feature exists in homology with Z/piZ coefficients."<< std::endl << std::endl;
-
-      std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-      std::cout << visible << std::endl; 
-      std::abort();
+  if (vm.count("help") || !vm.count("input-file")) {
+    std::cout << std::endl;
+    std::cout << "Compute the persistent homology with various coefficient fields \n";
+    std::cout << "of a Rips complex defined on a set of input points. The coefficient \n";
+    std::cout << "fields are all the Z/rZ for a prime number r contained in the \n";
+    std::cout << "specified range [p,q]\n \n";
+    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
+    std::cout << "   p1*...*pr   dim b d \n";
+    std::cout << "where dim is the dimension of the homological feature,\n";
+    std::cout << "b and d are respectively the birth and death of the feature and \n";
+    std::cout << "p1*...*pr is the product of prime numbers pi such that the homology \n";
+    std::cout << "feature exists in homology with Z/piZ coefficients." << std::endl << std::endl;
+
+    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
+    std::cout << visible << std::endl;
+    std::abort();
   }
 }
diff --git a/src/Persistent_cohomology/example/rips_persistence.cpp b/src/Persistent_cohomology/example/rips_persistence.cpp
index 4253def9..9b1ef42f 100644
--- a/src/Persistent_cohomology/example/rips_persistence.cpp
+++ b/src/Persistent_cohomology/example/rips_persistence.cpp
@@ -1,147 +1,151 @@
- /*    This file is part of the Gudhi Library. The Gudhi library 
-  *    (Geometric Understanding in Higher Dimensions) is a generic C++ 
-  *    library for computational topology.
-  *
-  *    Author(s):       Clément Maria
-  *
-  *    Copyright (C) 2014  INRIA Sophia Antipolis-Méditerranée (France)
-  *
-  *    This program is free software: you can redistribute it and/or modify
-  *    it under the terms of the GNU General Public License as published by
-  *    the Free Software Foundation, either version 3 of the License, or
-  *    (at your option) any later version.
-  *
-  *    This program is distributed in the hope that it will be useful,
-  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
-  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  *    GNU General Public License for more details.
-  *
-  *    You should have received a copy of the GNU General Public License
-  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-  */
-
-#include "gudhi/reader_utils.h"
-#include "gudhi/graph_simplicial_complex.h"
-#include "gudhi/distance_functions.h"
-#include "gudhi/Simplex_tree.h"
-#include "gudhi/Persistent_cohomology.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/>.
+ */
+
+#include <gudhi/reader_utils.h>
+#include <gudhi/graph_simplicial_complex.h>
+#include <gudhi/distance_functions.h>
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Persistent_cohomology.h>
 
 #include <boost/program_options.hpp>
 
+#include <string>
+#include <vector>
+
 using namespace Gudhi;
 using namespace Gudhi::persistent_cohomology;
 
-typedef int        Vertex_handle;
-typedef double     Filtration_value;
-
-void program_options( int argc, char *   argv[] 
-                    , std::string      & filepoints
-                    , std::string      & filediag
-                    , Filtration_value & threshold
-                    , int              & dim_max
-                    , int              & p
-                    , Filtration_value & min_persistence );
-
-int main (int argc, char * argv[]) 
-{
-  std::string      filepoints;
-  std::string      filediag  ;
-  Filtration_value threshold ;
-  int              dim_max   ;
-  int              p         ;
+typedef int Vertex_handle;
+typedef double Filtration_value;
+
+void program_options(int argc, char * argv[]
+                     , std::string & filepoints
+                     , std::string & filediag
+                     , Filtration_value & threshold
+                     , int & dim_max
+                     , int & p
+                     , Filtration_value & min_persistence);
+
+int main(int argc, char * argv[]) {
+  std::string filepoints;
+  std::string filediag;
+  Filtration_value threshold;
+  int dim_max;
+  int p;
   Filtration_value min_persistence;
 
-  program_options(argc,argv,filepoints,filediag,threshold,dim_max,p,min_persistence);
+  program_options(argc, argv, filepoints, filediag, threshold, dim_max, p, min_persistence);
 
-// Extract the points from the file filepoints
+  // Extract the points from the file filepoints
   typedef std::vector<double> Point_t;
   std::vector< Point_t > points;
-  read_points( filepoints, points );
+  read_points(filepoints, points);
 
-// Compute the proximity graph of the points
-  Graph_t prox_graph = compute_proximity_graph( points, threshold
-                                              , euclidean_distance<Point_t> );
+  // Compute the proximity graph of the points
+  Graph_t prox_graph = compute_proximity_graph(points, threshold
+                                               , euclidean_distance<Point_t>);
 
-// Construct the Rips complex in a Simplex Tree
-  Simplex_tree<> st;        
-  st.insert_graph(prox_graph); // insert the proximity graph in the simplex tree
-  st.expansion( dim_max ); // expand the graph until dimension dim_max
+  // Construct the Rips complex in a Simplex Tree
+  Simplex_tree<> st;
+  // insert the proximity graph in the simplex tree
+  st.insert_graph(prox_graph);
+  // expand the graph until dimension dim_max
+  st.expansion(dim_max);
 
   std::cout << "The complex contains " << st.num_simplices() << " simplices \n";
   std::cout << "   and has dimension " << st.dimension() << " \n";
 
-// Sort the simplices in the order of the filtration
+  // Sort the simplices in the order of the filtration
   st.initialize_filtration();
 
-// Compute the persistence diagram of the complex
+  // Compute the persistence diagram of the complex
   persistent_cohomology::Persistent_cohomology< Simplex_tree<>, Field_Zp > pcoh(st);
-  pcoh.init_coefficients( p ); //initilizes the coefficient field for homology
-  
-  pcoh.compute_persistent_cohomology( min_persistence );
-
-// Output the diagram in filediag
-  if(filediag.empty()) {  pcoh.output_diagram(); }
-  else {
-   std::ofstream out(filediag);
-   pcoh.output_diagram(out);
-   out.close(); }
+  // initializes the coefficient field for homology
+  pcoh.init_coefficients(p);
+
+  pcoh.compute_persistent_cohomology(min_persistence);
+
+  // Output the diagram in filediag
+  if (filediag.empty()) {
+    pcoh.output_diagram();
+  } else {
+    std::ofstream out(filediag);
+    pcoh.output_diagram(out);
+    out.close();
+  }
 
   return 0;
 }
 
-
-
-void program_options( int argc, char *   argv[] 
-                    , std::string      & filepoints
-                    , std::string      & filediag
-                    , Filtration_value & threshold
-                    , int              & dim_max
-                    , int              & p
-                    , Filtration_value & min_persistence )
-{
+void program_options(int argc, char * argv[]
+                     , std::string & filepoints
+                     , std::string & filediag
+                     , Filtration_value & threshold
+                     , int & dim_max
+                     , int & p
+                     , Filtration_value & min_persistence) {
   namespace po = boost::program_options;
-  po::options_description     hidden("Hidden options");
+  po::options_description hidden("Hidden options");
   hidden.add_options()
-        ("input-file",  po::value<std::string>(&filepoints), 
-          "Name of file containing a point set. Format is one point per line:   X1 ... Xd ");
-    
+      ("input-file", po::value<std::string>(&filepoints),
+       "Name of file containing a point set. Format is one point per line:   X1 ... Xd ");
+
   po::options_description visible("Allowed options", 100);
   visible.add_options()
-        ("help,h",          "produce help message")
-        ("output-file,o", po::value<std::string>(&filediag)->default_value(std::string()), 
-                   "Name of file in which the persistence diagram is written. Default print in std::cout")
-        ("max-edge-length,r", po::value<Filtration_value>(&threshold)->default_value(0), 
-                   "Maximal length of an edge for the Rips complex construction.")
-        ("cpx-dimension,d", po::value<int>(&dim_max)->default_value(1),        
-                  "Maximal dimension of the Rips complex we want to compute.")
-        ("field-charac,p", po::value<int>(&p)->default_value(11),                  
-                  "Characteristic p of the coefficient field Z/pZ for computing homology.")
-        ("min-persistence,m", po::value<Filtration_value>(&min_persistence), 
-                  "Minimal lifetime of homology feature to be recorded. Default is 0. Enter a negative value to see zero length intervals");
+      ("help,h", "produce help message")
+      ("output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
+       "Name of file in which the persistence diagram is written. Default print in std::cout")
+      ("max-edge-length,r", po::value<Filtration_value>(&threshold)->default_value(0),
+       "Maximal length of an edge for the Rips complex construction.")
+      ("cpx-dimension,d", po::value<int>(&dim_max)->default_value(1),
+       "Maximal dimension of the Rips complex we want to compute.")
+      ("field-charac,p", po::value<int>(&p)->default_value(11),
+       "Characteristic p of the coefficient field Z/pZ for computing homology.")
+      ("min-persistence,m", po::value<Filtration_value>(&min_persistence),
+       "Minimal lifetime of homology feature to be recorded. Default is 0. Enter a negative value to see zero length intervals");
 
   po::positional_options_description pos;
   pos.add("input-file", 1);
-  
-  po::options_description all; all.add(visible).add(hidden);
+
+  po::options_description all;
+  all.add(visible).add(hidden);
 
   po::variables_map vm;
   po::store(po::command_line_parser(argc, argv).
-                options(all).positional(pos).run(), vm);
+            options(all).positional(pos).run(), vm);
   po::notify(vm);
 
-  if (vm.count("help") || !vm.count("input-file"))
-  { 
-      std::cout << std::endl;
-      std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
-      std::cout << "of a Rips complex defined on a set of input points.\n \n";
-      std::cout << "The output diagram contains one bar per line, written with the convention: \n";
-      std::cout << "   p   dim b d \n";
-      std::cout << "where dim is the dimension of the homological feature,\n";
-      std::cout << "b and d are respectively the birth and death of the feature and \n";
-      std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
-
-      std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-      std::cout << visible << std::endl; 
-      std::abort();
+  if (vm.count("help") || !vm.count("input-file")) {
+    std::cout << std::endl;
+    std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
+    std::cout << "of a Rips complex defined on a set of input points.\n \n";
+    std::cout << "The output diagram contains one bar per line, written with the convention: \n";
+    std::cout << "   p   dim b d \n";
+    std::cout << "where dim is the dimension of the homological feature,\n";
+    std::cout << "b and d are respectively the birth and death of the feature and \n";
+    std::cout << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
+
+    std::cout << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
+    std::cout << visible << std::endl;
+    std::abort();
   }
 }
diff --git a/src/Skeleton_blocker/example/CMakeLists.txt b/src/Skeleton_blocker/example/CMakeLists.txt
index d1228526..de0c7bba 100644
--- a/src/Skeleton_blocker/example/CMakeLists.txt
+++ b/src/Skeleton_blocker/example/CMakeLists.txt
@@ -1,10 +1,12 @@
 cmake_minimum_required(VERSION 2.6)
 project(GUDHIskbl)
 
-
 add_executable(SkeletonBlockerFromSimplices Skeleton_blocker_from_simplices.cpp)
 add_executable(SkeletonBlockerIteration Skeleton_blocker_iteration.cpp)
 add_executable(SkeletonBlockerLink Skeleton_blocker_link.cpp)
 
+target_link_libraries(SkeletonBlockerIteration ${Boost_TIMER_LIBRARY} ${Boost_SYSTEM_LIBRARY})
 
-target_link_libraries(SkeletonBlockerIteration ${Boost_TIMER_LIBRARY} ${Boost_SYSTEM_LIBRARY})	
+add_test(SkeletonBlockerFromSimplices ${CMAKE_CURRENT_BINARY_DIR}/SkeletonBlockerFromSimplices)
+add_test(SkeletonBlockerIteration ${CMAKE_CURRENT_BINARY_DIR}/SkeletonBlockerIteration)
+add_test(SkeletonBlockerLink ${CMAKE_CURRENT_BINARY_DIR}/SkeletonBlockerLink)
diff --git a/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp b/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp
index 9f9b3d52..2738c01c 100644
--- a/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp
+++ b/src/Skeleton_blocker/example/Skeleton_blocker_from_simplices.cpp
@@ -1,34 +1,33 @@
- /*    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 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/>.
+ */
+
+#include <gudhi/Skeleton_blocker.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 #include <fstream>
 #include <sstream>
-
-
-#include "gudhi/Skeleton_blocker.h"
+#include <vector>
 
 using namespace std;
 using namespace Gudhi;
@@ -39,45 +38,44 @@ typedef Complex::Vertex_handle Vertex_handle;
 typedef Complex::Simplex_handle Simplex_handle;
 typedef Complex::Simplex_handle Simplex;
 
-int main (int argc, char *argv[]){
-	std::vector<Simplex_handle> simplices;
+int main(int argc, char *argv[]) {
+  std::vector<Simplex_handle> simplices;
 
-	//add 4 triangles of a tetrahedron 0123
-	simplices.push_back(Simplex_handle(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2)));
-	simplices.push_back(Simplex_handle(Vertex_handle(1),Vertex_handle(2),Vertex_handle(3)));
-	simplices.push_back(Simplex_handle(Vertex_handle(3),Vertex_handle(0),Vertex_handle(2)));
-	simplices.push_back(Simplex_handle(Vertex_handle(3),Vertex_handle(0),Vertex_handle(1)));
+  // add 4 triangles of a tetrahedron 0123
+  simplices.push_back(Simplex_handle(Vertex_handle(0), Vertex_handle(1), Vertex_handle(2)));
+  simplices.push_back(Simplex_handle(Vertex_handle(1), Vertex_handle(2), Vertex_handle(3)));
+  simplices.push_back(Simplex_handle(Vertex_handle(3), Vertex_handle(0), Vertex_handle(2)));
+  simplices.push_back(Simplex_handle(Vertex_handle(3), Vertex_handle(0), Vertex_handle(1)));
 
-	//get complex from top faces
-	Complex complex(make_complex_from_top_faces<Complex>(simplices.begin(),simplices.end()));
+  // get complex from top faces
+  Complex complex(make_complex_from_top_faces<Complex>(simplices.begin(), simplices.end()));
 
 
-	std::cout << "Simplices:"<<std::endl;
-	for(const Simplex & s : complex.simplex_range())
-		std::cout << s << " ";
-	std::cout << std::endl;
+  std::cout << "Simplices:" << std::endl;
+  for (const Simplex & s : complex.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;
+  // 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_handle(Vertex_handle(0)));
-	simplices.push_back(Simplex_handle(Vertex_handle(1)));
-	simplices.push_back(Simplex_handle(Vertex_handle(2)));
-	simplices.push_back(Simplex_handle(Vertex_handle(0),Vertex_handle(1)));
-	simplices.push_back(Simplex_handle(Vertex_handle(1),Vertex_handle(2)));
-	simplices.push_back(Simplex_handle(Vertex_handle(2),Vertex_handle(0)));
-	complex = Complex(simplices.begin(),simplices.end());
+  // now build a complex from its full list of simplices
+  simplices.clear();
+  simplices.push_back(Simplex_handle(Vertex_handle(0)));
+  simplices.push_back(Simplex_handle(Vertex_handle(1)));
+  simplices.push_back(Simplex_handle(Vertex_handle(2)));
+  simplices.push_back(Simplex_handle(Vertex_handle(0), Vertex_handle(1)));
+  simplices.push_back(Simplex_handle(Vertex_handle(1), Vertex_handle(2)));
+  simplices.push_back(Simplex_handle(Vertex_handle(2), Vertex_handle(0)));
+  complex = Complex(simplices.begin(), simplices.end());
 
-	std::cout << "Simplices:"<<std::endl;
-	for(const Simplex & s : complex.simplex_range())
-		std::cout << s << " ";
-	std::cout << std::endl;
+  std::cout << "Simplices:" << std::endl;
+  for (const Simplex & s : complex.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;
+  // 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;
 
-	return EXIT_SUCCESS;
+  return EXIT_SUCCESS;
 }
-
diff --git a/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp b/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp
index 126e32ec..69557694 100644
--- a/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp
+++ b/src/Skeleton_blocker/example/Skeleton_blocker_iteration.cpp
@@ -1,24 +1,26 @@
- /*    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 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/>.
+ */
+
+#include <gudhi/Skeleton_blocker.h>
 
 #include <boost/timer/timer.hpp>
 
@@ -29,8 +31,6 @@
 #include <sstream>
 
 
-#include "gudhi/Skeleton_blocker.h"
-
 using namespace std;
 using namespace Gudhi;
 using namespace skbl;
@@ -39,54 +39,53 @@ typedef Skeleton_blocker_complex<Skeleton_blocker_simple_traits> Complex;
 typedef Complex::Vertex_handle Vertex_handle;
 typedef Complex::Simplex_handle Simplex;
 
-
-Complex build_complete_complex(int n){
-	// build a full complex with n 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++)
-				//note that add_edge, add the edge and all its cofaces
-				complex.add_edge(Vertex_handle(i),Vertex_handle(j));
-		return complex;
+Complex build_complete_complex(int n) {
+  // build a full complex with n 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++)
+      // note that add_edge, add the edge and all its cofaces
+      complex.add_edge(Vertex_handle(i), Vertex_handle(j));
+  return complex;
 }
 
-int main (int argc, char *argv[]){
-	boost::timer::auto_cpu_timer t;
+int main(int argc, char *argv[]) {
+  boost::timer::auto_cpu_timer t;
 
-	const int n = 15;
+  const int n = 15;
 
-	// build a full complex with n vertices and 2^n-1 simplices
-	Complex complex(build_complete_complex(n));
+  // build a full complex with n vertices and 2^n-1 simplices
+  Complex complex(build_complete_complex(n));
 
-	// 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()) {
-	  std::cout << "Vertex " << v <<std::endl;
-	  ++num_vertices;
-        }
+  // 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()) {
+    std::cout << "Vertex " << v << std::endl;
+    ++num_vertices;
+  }
 
-	// such loop can also be done directly with distance as iterators are STL compliant
-	auto edges = complex.edge_range();
-	unsigned num_edges = std::distance(edges.begin(), edges.end());
+  // such loop can also be done directly with distance as iterators are STL compliant
+  auto edges = complex.edge_range();
+  unsigned num_edges = std::distance(edges.begin(), edges.end());
 
-	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.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;
-	return EXIT_SUCCESS;
+  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.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;
+  return EXIT_SUCCESS;
 }
-
diff --git a/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp b/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp
index 0987cc89..002cbc49 100644
--- a/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp
+++ b/src/Skeleton_blocker/example/Skeleton_blocker_link.cpp
@@ -1,25 +1,26 @@
- /*    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 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/>.
+ */
 
+#include <gudhi/Skeleton_blocker.h>
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -27,9 +28,6 @@
 #include <fstream>
 #include <sstream>
 
-
-#include "gudhi/Skeleton_blocker.h"
-
 using namespace std;
 using namespace Gudhi;
 using namespace skbl;
@@ -39,33 +37,31 @@ typedef Complex::Vertex_handle Vertex_handle;
 typedef Complex::Root_vertex_handle Root_vertex_handle;
 typedef Complex::Simplex_handle Simplex;
 
+int main(int argc, char *argv[]) {
+  // build a full complex with 4 vertices and 2^4-1 simplices
+  // Initial vertices are (0,1,2,3,4)
+  Simplex tetrahedron(Vertex_handle(0), Vertex_handle(1), Vertex_handle(2), Vertex_handle(3));
+  Complex complex;
+  complex.add_simplex(tetrahedron);
 
-int main (int argc, char *argv[]){
-	// build a full complex with 4 vertices and 2^4-1 simplices
-	// Initial vertices are (0,1,2,3,4)
-	Simplex tetrahedron(Vertex_handle(0),Vertex_handle(1),Vertex_handle(2),Vertex_handle(3));
-	Complex complex;
-	complex.add_simplex(tetrahedron);
+  cout << "complex:" << complex.to_string() << endl;
 
-	cout<<"complex:"<<complex.to_string()<<endl;
+  // build the link of vertex 1, eg a triangle {0,2,3}
+  auto link = complex.link(Vertex_handle(1));
+  cout << "link:" << link.to_string() << endl;
 
-	//build the link of vertex 1, eg a triangle {0,2,3}
-	auto link = complex.link(Vertex_handle(1));
-	cout<<"link:"<<link.to_string()<<endl;
+  // Internally link is a subcomplex of 'complex' and its vertices are stored in a vector.
+  // They can be accessed via Vertex_handle(x) where x is an index of the vector.
+  // In that example, link has three vertices and thus it contains only
+  // Vertex_handle(0),Vertex_handle(1) and Vertex_handle(2) are).
+  for (int i = 0; i < 5; ++i)
+    cout << "link.contains_vertex(Vertex_handle(" << i << ")):" << link.contains_vertex(Vertex_handle(i)) << endl;
+  cout << endl;
 
-	//Internally link is a subcomplex of 'complex' and its vertices are stored in a vector.
-	//They can be accessed via Vertex_handle(x) where x is an index of the vector.
-	//In that example, link has three vertices and thus it contains only
-	// Vertex_handle(0),Vertex_handle(1) and Vertex_handle(2) are).
-	for(int i = 0; i<5; ++i)
-		cout << "link.contains_vertex(Vertex_handle("<<i<<")):"<<link.contains_vertex(Vertex_handle(i))<<endl;
-	cout<<endl;
+  // To access to the initial vertices eg (0,1,2,3,4),  Root_vertex_handle must be used.
+  // 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;
 
-	//To access to the initial vertices eg (0,1,2,3,4),  Root_vertex_handle must be used.
-	//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;
-
-	return EXIT_SUCCESS;
+  return EXIT_SUCCESS;
 }
-
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 10d552ec..0d2de767 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
@@ -179,4 +179,4 @@ struct Skeleton_blocker_simple_traits {
 
 }  // namespace Gudhi
 
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_TRAITS_H_
+#endif  // SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_TRAITS_H_