Fix cpplint

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

Former-commit-id: e1cc797f8c24015168a1f84430666e8a156ababa

14 files changed, 223 insertions, 315 deletions

diff --git a/src/Bottleneck_distance/include/gudhi/Bottleneck.h b/src/Bottleneck_distance/include/gudhi/Bottleneck.h
index 8c97dce9..7aee07bb 100644
--- a/src/Bottleneck_distance/include/gudhi/Bottleneck.h
+++ b/src/Bottleneck_distance/include/gudhi/Bottleneck.h
@@ -46,7 +46,7 @@ double bottleneck_distance_approx(Persistence_graph& g, double e) {
     if (step <= b_lower_bound || step >= b_upper_bound)  // Avoid precision problem
       break;
     m.set_r(step);
-    while (m.multi_augment()) {};  // compute a maximum matching (in the graph corresponding to the current r)
+    while (m.multi_augment()) {}  // compute a maximum matching (in the graph corresponding to the current r)
     if (m.perfect()) {
       m = biggest_unperfect;
       b_upper_bound = step;
@@ -68,7 +68,7 @@ double bottleneck_distance_exact(Persistence_graph& g) {
   while (lower_bound_i != upper_bound_i) {
     long step = lower_bound_i + static_cast<long> ((upper_bound_i - lower_bound_i - 1) / alpha);
     m.set_r(sd.at(step));
-    while (m.multi_augment()) {};  // compute a maximum matching (in the graph corresponding to the current r)
+    while (m.multi_augment()) {}  // compute a maximum matching (in the graph corresponding to the current r)
     if (m.perfect()) {
       m = biggest_unperfect;
       upper_bound_i = step;
diff --git a/src/Bottleneck_distance/include/gudhi/Neighbors_finder.h b/src/Bottleneck_distance/include/gudhi/Neighbors_finder.h
index dc804630..87c7cee5 100644
--- a/src/Bottleneck_distance/include/gudhi/Neighbors_finder.h
+++ b/src/Bottleneck_distance/include/gudhi/Neighbors_finder.h
@@ -32,6 +32,7 @@
 
 #include <unordered_set>
 #include <vector>
+#include <algorithm>  // for std::max
 
 namespace Gudhi {
 
diff --git a/src/Persistence_representations/include/gudhi/read_persistence_from_file.h b/src/Persistence_representations/include/gudhi/read_persistence_from_file.h
index 450c223c..83b89d0e 100644
--- a/src/Persistence_representations/include/gudhi/read_persistence_from_file.h
+++ b/src/Persistence_representations/include/gudhi/read_persistence_from_file.h
@@ -23,6 +23,8 @@
 #ifndef READ_PERSISTENCE_FROM_FILE_H_
 #define READ_PERSISTENCE_FROM_FILE_H_
 
+#include <gudhi/reader_utils.h>
+
 #include <iostream>
 #include <fstream>
 #include <sstream>
@@ -30,7 +32,7 @@
 #include <algorithm>
 #include <string>
 #include <utility>
-#include <gudhi/reader_utils.h>
+#include <limits>  // for std::numeric_limits<>
 
 namespace Gudhi {
 namespace Persistence_representations {
@@ -72,16 +74,9 @@ std::vector<std::pair<double, double> > read_persistence_intervals_in_one_dimens
       std::cout << "COnsidering interval : " << barcode_initial[i].first << " " << barcode_initial[i].second
                 << std::endl;
     }
-    // if ( barcode_initial[i].first == barcode_initial[i].second )
-    //{
-    //		if ( dbg )std::cout << "It has zero length \n";
-    //		continue;//zero length intervals are not relevant, so we skip all of them.
-    //}
 
-    if (barcode_initial[i].first >
-        barcode_initial[i]
-            .second)  // note that in this case barcode_initial[i].second != std::numeric_limits<double>::infinity()
-    {
+    if (barcode_initial[i].first > barcode_initial[i].second) {
+      // note that in this case barcode_initial[i].second != std::numeric_limits<double>::infinity()
       if (dbg) std::cout << "Swap and enter \n";
       // swap them to make sure that birth < death
       final_barcode.push_back(std::pair<double, double>(barcode_initial[i].second, barcode_initial[i].first));
diff --git a/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp b/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp
index d38808c7..ca3c0327 100644
--- a/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp
+++ b/src/Rips_complex/utilities/rips_distance_matrix_persistence.cpp
@@ -1,5 +1,5 @@
-/*    This file is part of the Gudhi Library. The Gudhi library 
- *    (Geometric Understanding in Higher Dimensions) is a generic C++ 
+/*    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):       Pawel Dlotko, Vincent Rouvreau
@@ -36,18 +36,13 @@ using Simplex_tree = Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_fast_persis
 using Filtration_value = Simplex_tree::Filtration_value;
 using Rips_complex = Gudhi::rips_complex::Rips_complex<Filtration_value>;
 using Field_Zp = Gudhi::persistent_cohomology::Field_Zp;
-using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<Simplex_tree, Field_Zp >;
+using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<Simplex_tree, Field_Zp>;
 using Distance_matrix = std::vector<std::vector<Filtration_value>>;
 
-void program_options(int argc, char * argv[]
-                     , std::string & csv_matrix_file
-                     , std::string & filediag
-                     , Filtration_value & threshold
-                     , int & dim_max
-                     , int & p
-                     , Filtration_value & min_persistence);
+void program_options(int argc, char* argv[], std::string& csv_matrix_file, std::string& filediag,
+                     Filtration_value& threshold, int& dim_max, int& p, Filtration_value& min_persistence);
 
-int main(int argc, char * argv[]) {
+int main(int argc, char* argv[]) {
   std::string csv_matrix_file;
   std::string filediag;
   Filtration_value threshold;
@@ -88,33 +83,28 @@ int main(int argc, char * argv[]) {
   return 0;
 }
 
-void program_options(int argc, char * argv[]
-                     , std::string & csv_matrix_file
-                     , std::string & filediag
-                     , Filtration_value & threshold
-                     , int & dim_max
-                     , int & p
-                     , Filtration_value & min_persistence) {
+void program_options(int argc, char* argv[], std::string& csv_matrix_file, 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");
-  hidden.add_options()
-      ("input-file", po::value<std::string>(&csv_matrix_file),
-       "Name of file containing a distance matrix. Can be square or lower triangular matrix. Separator is ';'.");
+  hidden.add_options()(
+      "input-file", po::value<std::string>(&csv_matrix_file),
+      "Name of file containing a distance matrix. Can be square or lower triangular matrix. Separator is ';'.");
 
   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(std::numeric_limits<Filtration_value>::infinity()),
-       "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");
+  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(std::numeric_limits<Filtration_value>::infinity()),
+      "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);
@@ -123,8 +113,7 @@ void program_options(int argc, char * argv[]
   all.add(visible).add(hidden);
 
   po::variables_map vm;
-  po::store(po::command_line_parser(argc, argv).
-            options(all).positional(pos).run(), vm);
+  po::store(po::command_line_parser(argc, argv).options(all).positional(pos).run(), vm);
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
diff --git a/src/Rips_complex/utilities/rips_persistence.cpp b/src/Rips_complex/utilities/rips_persistence.cpp
index d504798b..8405c014 100644
--- a/src/Rips_complex/utilities/rips_persistence.cpp
+++ b/src/Rips_complex/utilities/rips_persistence.cpp
@@ -1,5 +1,5 @@
-/*    This file is part of the Gudhi Library. The Gudhi library 
- *    (Geometric Understanding in Higher Dimensions) is a generic C++ 
+/*    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
@@ -37,19 +37,14 @@ using Simplex_tree = Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_fast_persis
 using Filtration_value = Simplex_tree::Filtration_value;
 using Rips_complex = Gudhi::rips_complex::Rips_complex<Filtration_value>;
 using Field_Zp = Gudhi::persistent_cohomology::Field_Zp;
-using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<Simplex_tree, Field_Zp >;
+using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<Simplex_tree, Field_Zp>;
 using Point = std::vector<double>;
 using Points_off_reader = Gudhi::Points_off_reader<Point>;
 
-void program_options(int argc, char * argv[]
-                     , std::string & off_file_points
-                     , std::string & filediag
-                     , Filtration_value & threshold
-                     , int & dim_max
-                     , int & p
-                     , Filtration_value & min_persistence);
+void program_options(int argc, char* argv[], std::string& off_file_points, std::string& filediag,
+                     Filtration_value& threshold, int& dim_max, int& p, Filtration_value& min_persistence);
 
-int main(int argc, char * argv[]) {
+int main(int argc, char* argv[]) {
   std::string off_file_points;
   std::string filediag;
   Filtration_value threshold;
@@ -91,33 +86,27 @@ int main(int argc, char * argv[]) {
   return 0;
 }
 
-void program_options(int argc, char * argv[]
-                     , std::string & off_file_points
-                     , std::string & filediag
-                     , Filtration_value & threshold
-                     , int & dim_max
-                     , int & p
-                     , Filtration_value & min_persistence) {
+void program_options(int argc, char* argv[], std::string& off_file_points, 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");
-  hidden.add_options()
-      ("input-file", po::value<std::string>(&off_file_points),
-       "Name of an OFF file containing a point set.\n");
+  hidden.add_options()("input-file", po::value<std::string>(&off_file_points),
+                       "Name of an OFF file containing a point set.\n");
 
   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(std::numeric_limits<Filtration_value>::infinity()),
-       "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");
+  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(std::numeric_limits<Filtration_value>::infinity()),
+      "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);
@@ -126,8 +115,7 @@ void program_options(int argc, char * argv[]
   all.add(visible).add(hidden);
 
   po::variables_map vm;
-  po::store(po::command_line_parser(argc, argv).
-            options(all).positional(pos).run(), vm);
+  po::store(po::command_line_parser(argc, argv).options(all).positional(pos).run(), vm);
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
diff --git a/src/Simplex_tree/example/cech_complex_cgal_mini_sphere_3d.cpp b/src/Simplex_tree/example/cech_complex_cgal_mini_sphere_3d.cpp
index 217e251f..9bd51106 100644
--- a/src/Simplex_tree/example/cech_complex_cgal_mini_sphere_3d.cpp
+++ b/src/Simplex_tree/example/cech_complex_cgal_mini_sphere_3d.cpp
@@ -1,5 +1,5 @@
-/*    This file is part of the Gudhi Library. The Gudhi library 
- *    (Geometric Understanding in Higher Dimensions) is a generic C++ 
+/*    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
@@ -33,7 +33,7 @@
 
 #include <string>
 #include <vector>
-#include <limits>  // infinity
+#include <limits>   // infinity
 #include <utility>  // for pair
 #include <map>
 
@@ -50,15 +50,14 @@ using Vertex_handle = Simplex_tree::Vertex_handle;
 using Simplex_handle = Simplex_tree::Simplex_handle;
 using Filtration_value = Simplex_tree::Filtration_value;
 using Siblings = Simplex_tree::Siblings;
-using Graph_t = boost::adjacency_list < boost::vecS, boost::vecS, boost::undirectedS
-, boost::property < Gudhi::vertex_filtration_t, Filtration_value >
-, boost::property < Gudhi::edge_filtration_t, Filtration_value >
->;
-using Edge_t = std::pair< Vertex_handle, Vertex_handle >;
+using Graph_t = boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,
+                                      boost::property<Gudhi::vertex_filtration_t, Filtration_value>,
+                                      boost::property<Gudhi::edge_filtration_t, Filtration_value> >;
+using Edge_t = std::pair<Vertex_handle, Vertex_handle>;
 
-using Kernel = CGAL::Epick_d< CGAL::Dimension_tag<3> >;
+using Kernel = CGAL::Epick_d<CGAL::Dimension_tag<3> >;
 using Point = Kernel::Point_d;
-using Traits = CGAL::Min_sphere_of_points_d_traits_d<Kernel,Filtration_value,3>;
+using Traits = CGAL::Min_sphere_of_points_d_traits_d<Kernel, Filtration_value, 3>;
 using Min_sphere = CGAL::Min_sphere_of_spheres_d<Traits>;
 
 using Points_off_reader = Gudhi::Points_off_reader<Point>;
@@ -76,7 +75,7 @@ class Cech_blocker {
       std::cout << vertex << ", ";
 #endif  // DEBUG_TRACES
     }
-    Min_sphere ms(points.begin(),points.end());
+    Min_sphere ms(points.begin(), points.end());
     Filtration_value radius = ms.radius();
 #if DEBUG_TRACES
     std::cout << "] - radius = " << radius << " - returns " << (radius > threshold_) << std::endl;
@@ -85,24 +84,20 @@ class Cech_blocker {
     return (radius > threshold_);
   }
   Cech_blocker(Simplex_tree& simplex_tree, Filtration_value threshold, const std::vector<Point>& point_cloud)
-    : simplex_tree_(simplex_tree),
-      threshold_(threshold),
-      point_cloud_(point_cloud) { }
+      : simplex_tree_(simplex_tree), threshold_(threshold), point_cloud_(point_cloud) {}
+
  private:
   Simplex_tree simplex_tree_;
   Filtration_value threshold_;
   std::vector<Point> point_cloud_;
 };
 
-template< typename InputPointRange>
-Graph_t compute_proximity_graph(InputPointRange &points, Filtration_value threshold);
+template <typename InputPointRange>
+Graph_t compute_proximity_graph(InputPointRange& points, Filtration_value threshold);
 
-void program_options(int argc, char * argv[]
-                     , std::string & off_file_points
-                     , Filtration_value & threshold
-                     , int & dim_max);
+void program_options(int argc, char* argv[], std::string& off_file_points, Filtration_value& threshold, int& dim_max);
 
-int main(int argc, char * argv[]) {
+int main(int argc, char* argv[]) {
   std::string off_file_points;
   Filtration_value threshold;
   int dim_max;
@@ -115,7 +110,7 @@ int main(int argc, char * argv[]) {
   // Compute the proximity graph of the points
   Graph_t prox_graph = compute_proximity_graph(off_reader.get_point_cloud(), threshold);
 
-  //Min_sphere sph1(off_reader.get_point_cloud()[0], off_reader.get_point_cloud()[1], off_reader.get_point_cloud()[2]);
+  // Min_sphere sph1(off_reader.get_point_cloud()[0], off_reader.get_point_cloud()[1], off_reader.get_point_cloud()[2]);
   // Construct the Rips complex in a Simplex Tree
   Simplex_tree st;
   // insert the proximity graph in the simplex tree
@@ -135,7 +130,8 @@ int main(int argc, char * argv[]) {
   std::cout << "* The complex contains " << st.num_simplices() << " simplices - dimension=" << st.dimension() << "\n";
   std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
   for (auto f_simplex : st.filtration_simplex_range()) {
-    std::cout << "   " << "[" << st.filtration(f_simplex) << "] ";
+    std::cout << "   "
+              << "[" << st.filtration(f_simplex) << "] ";
     for (auto vertex : st.simplex_vertex_range(f_simplex)) {
       std::cout << static_cast<int>(vertex) << " ";
     }
@@ -145,24 +141,19 @@ int main(int argc, char * argv[]) {
   return 0;
 }
 
-void program_options(int argc, char * argv[]
-                     , std::string & off_file_points
-                     , Filtration_value & threshold
-                     , int & dim_max) {
+void program_options(int argc, char* argv[], std::string& off_file_points, Filtration_value& threshold, int& dim_max) {
   namespace po = boost::program_options;
   po::options_description hidden("Hidden options");
-  hidden.add_options()
-      ("input-file", po::value<std::string>(&off_file_points),
-       "Name of an OFF file containing a 3d point set.\n");
+  hidden.add_options()("input-file", po::value<std::string>(&off_file_points),
+                       "Name of an OFF file containing a 3d point set.\n");
 
   po::options_description visible("Allowed options", 100);
-  visible.add_options()
-      ("help,h", "produce help message")
-      ("max-edge-length,r",
-       po::value<Filtration_value>(&threshold)->default_value(std::numeric_limits<Filtration_value>::infinity()),
-       "Maximal length of an edge for the Cech complex construction.")
-      ("cpx-dimension,d", po::value<int>(&dim_max)->default_value(1),
-       "Maximal dimension of the Cech complex we want to compute.");
+  visible.add_options()("help,h", "produce help message")(
+      "max-edge-length,r",
+      po::value<Filtration_value>(&threshold)->default_value(std::numeric_limits<Filtration_value>::infinity()),
+      "Maximal length of an edge for the Cech complex construction.")(
+      "cpx-dimension,d", po::value<int>(&dim_max)->default_value(1),
+      "Maximal dimension of the Cech complex we want to compute.");
 
   po::positional_options_description pos;
   pos.add("input-file", 1);
@@ -171,8 +162,7 @@ void program_options(int argc, char * argv[]
   all.add(visible).add(hidden);
 
   po::variables_map vm;
-  po::store(po::command_line_parser(argc, argv).
-            options(all).positional(pos).run(), vm);
+  po::store(po::command_line_parser(argc, argv).options(all).positional(pos).run(), vm);
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
@@ -194,10 +184,10 @@ void program_options(int argc, char * argv[]
  * The type PointCloud furnishes .begin() and .end() methods, that return
  * iterators with value_type Point.
  */
-template< typename InputPointRange>
-Graph_t compute_proximity_graph(InputPointRange &points, Filtration_value threshold) {
-  std::vector< Edge_t > edges;
-  std::vector< Filtration_value > edges_fil;
+template <typename InputPointRange>
+Graph_t compute_proximity_graph(InputPointRange& points, Filtration_value threshold) {
+  std::vector<Edge_t> edges;
+  std::vector<Filtration_value> edges_fil;
 
   Kernel k;
   Vertex_handle idx_u, idx_v;
@@ -217,16 +207,13 @@ Graph_t compute_proximity_graph(InputPointRange &points, Filtration_value thresh
     ++idx_u;
   }
 
-  Graph_t skel_graph(edges.begin()
-                     , edges.end()
-                     , edges_fil.begin()
-                     , idx_u);  // number of points labeled from 0 to idx_u-1
+  Graph_t skel_graph(edges.begin(), edges.end(), edges_fil.begin(),
+                     idx_u);  // number of points labeled from 0 to idx_u-1
 
   auto vertex_prop = boost::get(Gudhi::vertex_filtration_t(), skel_graph);
 
   boost::graph_traits<Graph_t>::vertex_iterator vi, vi_end;
-  for (std::tie(vi, vi_end) = boost::vertices(skel_graph);
-       vi != vi_end; ++vi) {
+  for (std::tie(vi, vi_end) = boost::vertices(skel_graph); vi != vi_end; ++vi) {
     boost::put(vertex_prop, *vi, 0.);
   }
 
diff --git a/src/Simplex_tree/example/graph_expansion_with_blocker.cpp b/src/Simplex_tree/example/graph_expansion_with_blocker.cpp
index 86bfb8cb..0d458cbd 100644
--- a/src/Simplex_tree/example/graph_expansion_with_blocker.cpp
+++ b/src/Simplex_tree/example/graph_expansion_with_blocker.cpp
@@ -27,8 +27,7 @@
 using Simplex_tree = Gudhi::Simplex_tree<>;
 using Simplex_handle = Simplex_tree::Simplex_handle;
 
-int main(int argc, char * const argv[]) {
-
+int main(int argc, char* const argv[]) {
   // Construct the Simplex Tree with a 1-skeleton graph example
   Simplex_tree simplexTree;
 
@@ -45,33 +44,32 @@ int main(int argc, char * const argv[]) {
   simplexTree.insert_simplex({5, 6}, 10.);
   simplexTree.insert_simplex({6}, 10.);
 
-  simplexTree.expansion_with_blockers(3, [&](Simplex_handle sh){
-      bool result = false;
-      std::cout << "Blocker on [";
-      // User can loop on the vertices from the given simplex_handle i.e.
-      for (auto vertex : simplexTree.simplex_vertex_range(sh)) {
-        // We block the expansion, if the vertex '6' is in the given list of vertices
-        if (vertex == 6)
-          result = true;
-        std::cout << vertex << ", ";
-      }
-      std::cout << "] ( " << simplexTree.filtration(sh);
-      // User can re-assign a new filtration value directly in the blocker (default is the maximal value of boudaries)
-      simplexTree.assign_filtration(sh, simplexTree.filtration(sh) + 1.);
+  simplexTree.expansion_with_blockers(3, [&](Simplex_handle sh) {
+    bool result = false;
+    std::cout << "Blocker on [";
+    // User can loop on the vertices from the given simplex_handle i.e.
+    for (auto vertex : simplexTree.simplex_vertex_range(sh)) {
+      // We block the expansion, if the vertex '6' is in the given list of vertices
+      if (vertex == 6) result = true;
+      std::cout << vertex << ", ";
+    }
+    std::cout << "] ( " << simplexTree.filtration(sh);
+    // User can re-assign a new filtration value directly in the blocker (default is the maximal value of boudaries)
+    simplexTree.assign_filtration(sh, simplexTree.filtration(sh) + 1.);
 
-      std::cout << " + 1. ) = " << result << std::endl;
+    std::cout << " + 1. ) = " << result << std::endl;
 
-      return result;
-    });
+    return result;
+  });
 
   std::cout << "********************************************************************\n";
   std::cout << "* The complex contains " << simplexTree.num_simplices() << " simplices";
   std::cout << "   - dimension " << simplexTree.dimension() << "\n";
   std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
   for (auto f_simplex : simplexTree.filtration_simplex_range()) {
-    std::cout << "   " << "[" << simplexTree.filtration(f_simplex) << "] ";
-    for (auto vertex : simplexTree.simplex_vertex_range(f_simplex))
-      std::cout << "(" << vertex << ")";
+    std::cout << "   "
+              << "[" << simplexTree.filtration(f_simplex) << "] ";
+    for (auto vertex : simplexTree.simplex_vertex_range(f_simplex)) std::cout << "(" << vertex << ")";
     std::cout << std::endl;
   }
 
diff --git a/src/Simplex_tree/example/simple_simplex_tree.cpp b/src/Simplex_tree/example/simple_simplex_tree.cpp
index b6b65b88..828977c2 100644
--- a/src/Simplex_tree/example/simple_simplex_tree.cpp
+++ b/src/Simplex_tree/example/simple_simplex_tree.cpp
@@ -30,10 +30,10 @@
 using Simplex_tree = Gudhi::Simplex_tree<>;
 using Vertex_handle = Simplex_tree::Vertex_handle;
 using Filtration_value = Simplex_tree::Filtration_value;
-using typeVectorVertex = std::vector< Vertex_handle >;
-using typePairSimplexBool = std::pair< Simplex_tree::Simplex_handle, bool >;
+using typeVectorVertex = std::vector<Vertex_handle>;
+using typePairSimplexBool = std::pair<Simplex_tree::Simplex_handle, bool>;
 
-int main(int argc, char * const argv[]) {
+int main(int argc, char* const argv[]) {
   const Filtration_value FIRST_FILTRATION_VALUE = 0.1;
   const Filtration_value SECOND_FILTRATION_VALUE = 0.2;
   const Filtration_value THIRD_FILTRATION_VALUE = 0.3;
@@ -54,7 +54,7 @@ int main(int argc, char * const argv[]) {
 
   // ++ FIRST
   std::cout << "   * INSERT 0" << std::endl;
-  typeVectorVertex firstSimplexVector = { 0 };
+  typeVectorVertex firstSimplexVector = {0};
   typePairSimplexBool returnValue =
       simplexTree.insert_simplex(firstSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
@@ -66,9 +66,8 @@ int main(int argc, char * const argv[]) {
 
   // ++ SECOND
   std::cout << "   * INSERT 1" << std::endl;
-  typeVectorVertex secondSimplexVector = { 1 };
-  returnValue =
-      simplexTree.insert_simplex(secondSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+  typeVectorVertex secondSimplexVector = {1};
+  returnValue = simplexTree.insert_simplex(secondSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + 1 INSERTED" << std::endl;
@@ -78,9 +77,8 @@ int main(int argc, char * const argv[]) {
 
   // ++ THIRD
   std::cout << "   * INSERT (0,1)" << std::endl;
-  typeVectorVertex thirdSimplexVector = { 0, 1 };
-  returnValue =
-      simplexTree.insert_simplex(thirdSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+  typeVectorVertex thirdSimplexVector = {0, 1};
+  returnValue = simplexTree.insert_simplex(thirdSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (0,1) INSERTED" << std::endl;
@@ -90,9 +88,8 @@ int main(int argc, char * const argv[]) {
 
   // ++ FOURTH
   std::cout << "   * INSERT 2" << std::endl;
-  typeVectorVertex fourthSimplexVector = { 2 };
-  returnValue =
-      simplexTree.insert_simplex(fourthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+  typeVectorVertex fourthSimplexVector = {2};
+  returnValue = simplexTree.insert_simplex(fourthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + 2 INSERTED" << std::endl;
@@ -102,9 +99,8 @@ int main(int argc, char * const argv[]) {
 
   // ++ FIFTH
   std::cout << "   * INSERT (2,0)" << std::endl;
-  typeVectorVertex fifthSimplexVector = { 2, 0 };
-  returnValue =
-      simplexTree.insert_simplex(fifthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+  typeVectorVertex fifthSimplexVector = {2, 0};
+  returnValue = simplexTree.insert_simplex(fifthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (2,0) INSERTED" << std::endl;
@@ -114,9 +110,8 @@ int main(int argc, char * const argv[]) {
 
   // ++ SIXTH
   std::cout << "   * INSERT (2,1)" << std::endl;
-  typeVectorVertex sixthSimplexVector = { 2, 1 };
-  returnValue =
-      simplexTree.insert_simplex(sixthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+  typeVectorVertex sixthSimplexVector = {2, 1};
+  returnValue = simplexTree.insert_simplex(sixthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (2,1) INSERTED" << std::endl;
@@ -126,9 +121,8 @@ int main(int argc, char * const argv[]) {
 
   // ++ SEVENTH
   std::cout << "   * INSERT (2,1,0)" << std::endl;
-  typeVectorVertex seventhSimplexVector = { 2, 1, 0 };
-  returnValue =
-      simplexTree.insert_simplex(seventhSimplexVector, Filtration_value(THIRD_FILTRATION_VALUE));
+  typeVectorVertex seventhSimplexVector = {2, 1, 0};
+  returnValue = simplexTree.insert_simplex(seventhSimplexVector, Filtration_value(THIRD_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (2,1,0) INSERTED" << std::endl;
@@ -138,9 +132,8 @@ int main(int argc, char * const argv[]) {
 
   // ++ EIGHTH
   std::cout << "   * INSERT 3" << std::endl;
-  typeVectorVertex eighthSimplexVector = { 3 };
-  returnValue =
-      simplexTree.insert_simplex(eighthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+  typeVectorVertex eighthSimplexVector = {3};
+  returnValue = simplexTree.insert_simplex(eighthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + 3 INSERTED" << std::endl;
@@ -150,9 +143,8 @@ int main(int argc, char * const argv[]) {
 
   // ++ NINETH
   std::cout << "   * INSERT (3,0)" << std::endl;
-  typeVectorVertex ninethSimplexVector = { 3, 0 };
-  returnValue =
-      simplexTree.insert_simplex(ninethSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+  typeVectorVertex ninethSimplexVector = {3, 0};
+  returnValue = simplexTree.insert_simplex(ninethSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (3,0) INSERTED" << std::endl;
@@ -162,7 +154,7 @@ int main(int argc, char * const argv[]) {
 
   // ++ TENTH
   std::cout << "   * INSERT 0 (already inserted)" << std::endl;
-  typeVectorVertex tenthSimplexVector = { 0 };
+  typeVectorVertex tenthSimplexVector = {0};
   // With a different filtration value
   returnValue = simplexTree.insert_simplex(tenthSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
 
@@ -174,9 +166,8 @@ int main(int argc, char * const argv[]) {
 
   // ++ ELEVENTH
   std::cout << "   * INSERT (2,1,0) (already inserted)" << std::endl;
-  typeVectorVertex eleventhSimplexVector = { 2, 1, 0 };
-  returnValue =
-      simplexTree.insert_simplex(eleventhSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
+  typeVectorVertex eleventhSimplexVector = {2, 1, 0};
+  returnValue = simplexTree.insert_simplex(eleventhSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
 
   if (returnValue.second == true) {
     std::cout << "   + (2,1,0) INSERTED" << std::endl;
@@ -192,9 +183,9 @@ int main(int argc, char * const argv[]) {
   std::cout << "   - dimension " << simplexTree.dimension() << "\n";
   std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
   for (auto f_simplex : simplexTree.filtration_simplex_range()) {
-    std::cout << "   " << "[" << simplexTree.filtration(f_simplex) << "] ";
-    for (auto vertex : simplexTree.simplex_vertex_range(f_simplex))
-      std::cout << "(" << vertex << ")";
+    std::cout << "   "
+              << "[" << simplexTree.filtration(f_simplex) << "] ";
+    for (auto vertex : simplexTree.simplex_vertex_range(f_simplex)) std::cout << "(" << vertex << ")";
     std::cout << std::endl;
   }
   //   [0.1] 0
@@ -217,7 +208,7 @@ int main(int argc, char * const argv[]) {
   else
     std::cout << "***- NO IT ISN'T\n";
 
-  typeVectorVertex unknownSimplexVector = { 15 };
+  typeVectorVertex unknownSimplexVector = {15};
   simplexFound = simplexTree.find(unknownSimplexVector);
   std::cout << "**************IS THE SIMPLEX {15} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
@@ -232,7 +223,7 @@ int main(int argc, char * const argv[]) {
   else
     std::cout << "***- NO IT ISN'T\n";
 
-  typeVectorVertex otherSimplexVector = { 1, 15 };
+  typeVectorVertex otherSimplexVector = {1, 15};
   simplexFound = simplexTree.find(otherSimplexVector);
   std::cout << "**************IS THE SIMPLEX {15,1} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
@@ -240,7 +231,7 @@ int main(int argc, char * const argv[]) {
   else
     std::cout << "***- NO IT ISN'T\n";
 
-  typeVectorVertex invSimplexVector = { 1, 2, 0 };
+  typeVectorVertex invSimplexVector = {1, 2, 0};
   simplexFound = simplexTree.find(invSimplexVector);
   std::cout << "**************IS THE SIMPLEX {1,2,0} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
@@ -248,7 +239,7 @@ int main(int argc, char * const argv[]) {
   else
     std::cout << "***- NO IT ISN'T\n";
 
-  simplexFound = simplexTree.find({ 0, 1 });
+  simplexFound = simplexTree.find({0, 1});
   std::cout << "**************IS THE SIMPLEX {0,1} IN THE SIMPLEX TREE ?\n";
   if (simplexFound != simplexTree.null_simplex())
     std::cout << "***+ YES IT IS!\n";
@@ -256,23 +247,20 @@ int main(int argc, char * const argv[]) {
     std::cout << "***- NO IT ISN'T\n";
 
   std::cout << "**************COFACES OF {0,1} IN CODIMENSION 1 ARE\n";
-  for (auto& simplex : simplexTree.cofaces_simplex_range(simplexTree.find({0,1}), 1)) {
-    for (auto vertex : simplexTree.simplex_vertex_range(simplex))
-      std::cout << "(" << vertex << ")";
+  for (auto& simplex : simplexTree.cofaces_simplex_range(simplexTree.find({0, 1}), 1)) {
+    for (auto vertex : simplexTree.simplex_vertex_range(simplex)) std::cout << "(" << vertex << ")";
     std::cout << std::endl;
   }
 
   std::cout << "**************STARS OF {0,1} ARE\n";
-  for (auto& simplex : simplexTree.star_simplex_range(simplexTree.find({0,1}))) {
-    for (auto vertex : simplexTree.simplex_vertex_range(simplex))
-      std::cout << "(" << vertex << ")";
+  for (auto& simplex : simplexTree.star_simplex_range(simplexTree.find({0, 1}))) {
+    for (auto vertex : simplexTree.simplex_vertex_range(simplex)) std::cout << "(" << vertex << ")";
     std::cout << std::endl;
   }
 
   std::cout << "**************BOUNDARIES OF {0,1,2} ARE\n";
-  for (auto& simplex : simplexTree.boundary_simplex_range(simplexTree.find({0,1,2}))) {
-    for (auto vertex : simplexTree.simplex_vertex_range(simplex))
-      std::cout << "(" << vertex << ")";
+  for (auto& simplex : simplexTree.boundary_simplex_range(simplexTree.find({0, 1, 2}))) {
+    for (auto vertex : simplexTree.simplex_vertex_range(simplex)) std::cout << "(" << vertex << ")";
     std::cout << std::endl;
   }
 
diff --git a/src/Spatial_searching/include/gudhi/Kd_tree_search.h b/src/Spatial_searching/include/gudhi/Kd_tree_search.h
index ef428002..96bbeb36 100644
--- a/src/Spatial_searching/include/gudhi/Kd_tree_search.h
+++ b/src/Spatial_searching/include/gudhi/Kd_tree_search.h
@@ -271,8 +271,7 @@ class Kd_tree_search {
     m_tree.search(it, Fuzzy_sphere(p, radius, eps, m_tree.traits()));
   }
 
-  int tree_depth() const
-  {
+  int tree_depth() const {
     return m_tree.root()->depth();
   }
 
diff --git a/src/Witness_complex/example/example_strong_witness_complex_off.cpp b/src/Witness_complex/example/example_strong_witness_complex_off.cpp
index bc069654..346bef6d 100644
--- a/src/Witness_complex/example/example_strong_witness_complex_off.cpp
+++ b/src/Witness_complex/example/example_strong_witness_complex_off.cpp
@@ -39,10 +39,9 @@ using Point_d = typename K::Point_d;
 using Witness_complex = Gudhi::witness_complex::Euclidean_strong_witness_complex<K>;
 using Point_vector = std::vector<Point_d>;
 
-int main(int argc, char * const argv[]) {
+int main(int argc, char* const argv[]) {
   if (argc != 5) {
-    std::cerr << "Usage: " << argv[0]
-        << " path_to_point_file number_of_landmarks max_squared_alpha limit_dimension\n";
+    std::cerr << "Usage: " << argv[0] << " path_to_point_file number_of_landmarks max_squared_alpha limit_dimension\n";
     return 0;
   }
 
@@ -56,9 +55,9 @@ int main(int argc, char * const argv[]) {
   Point_vector point_vector, landmarks;
   Gudhi::Points_off_reader<Point_d> off_reader(file_name);
   if (!off_reader.is_valid()) {
-      std::cerr << "Strong witness complex - Unable to read file " << file_name << "\n";
-      exit(-1);  // ----- >>
-    }
+    std::cerr << "Strong witness complex - Unable to read file " << file_name << "\n";
+    exit(-1);  // ----- >>
+  }
   point_vector = Point_vector(off_reader.get_point_cloud());
 
   std::cout << "Successfully read " << point_vector.size() << " points.\n";
@@ -66,16 +65,15 @@ int main(int argc, char * const argv[]) {
 
   // Choose landmarks (decomment one of the following two lines)
   // Gudhi::subsampling::pick_n_random_points(point_vector, nbL, std::back_inserter(landmarks));
-  Gudhi::subsampling::choose_n_farthest_points(K(), point_vector, nbL, Gudhi::subsampling::random_starting_point, std::back_inserter(landmarks));
-  
+  Gudhi::subsampling::choose_n_farthest_points(K(), point_vector, nbL, Gudhi::subsampling::random_starting_point,
+                                               std::back_inserter(landmarks));
+
   // Compute witness complex
   start = clock();
-  Witness_complex witness_complex(landmarks,
-                                  point_vector);
+  Witness_complex witness_complex(landmarks, point_vector);
 
   witness_complex.create_complex(simplex_tree, alpha2, lim_dim);
   end = clock();
-  std::cout << "Strong witness complex took "
-      << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
+  std::cout << "Strong witness complex took " << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
   std::cout << "Number of simplices is: " << simplex_tree.num_simplices() << "\n";
 }
diff --git a/src/Witness_complex/example/example_witness_complex_sphere.cpp b/src/Witness_complex/example/example_witness_complex_sphere.cpp
index a66da3f9..a6e9b11a 100644
--- a/src/Witness_complex/example/example_witness_complex_sphere.cpp
+++ b/src/Witness_complex/example/example_witness_complex_sphere.cpp
@@ -42,27 +42,25 @@
 /** Write a gnuplot readable file.
  *  Data range is a random access range of pairs (arg, value)
  */
-template < typename Data_range >
-void write_data(Data_range & data, std::string filename) {
+template <typename Data_range>
+void write_data(Data_range& data, std::string filename) {
   std::ofstream ofs(filename, std::ofstream::out);
-  for (auto entry : data)
-    ofs << entry.first << ", " << entry.second << "\n";
+  for (auto entry : data) ofs << entry.first << ", " << entry.second << "\n";
   ofs.close();
 }
 
-int main(int argc, char * const argv[]) {
+int main(int argc, char* const argv[]) {
   using Kernel = CGAL::Epick_d<CGAL::Dynamic_dimension_tag>;
   using Witness_complex = Gudhi::witness_complex::Euclidean_witness_complex<Kernel>;
 
   if (argc != 2) {
-    std::cerr << "Usage: " << argv[0]
-        << " number_of_landmarks \n";
+    std::cerr << "Usage: " << argv[0] << " number_of_landmarks \n";
     return 0;
   }
 
   int number_of_landmarks = atoi(argv[1]);
 
-  std::vector< std::pair<int, double> > l_time;
+  std::vector<std::pair<int, double> > l_time;
 
   // Generate points
   for (int nbP = 500; nbP < 10000; nbP += 500) {
@@ -77,16 +75,16 @@ int main(int argc, char * const argv[]) {
     // Choose landmarks
     start = clock();
     // Gudhi::subsampling::pick_n_random_points(point_vector, number_of_landmarks, std::back_inserter(landmarks));
-    Gudhi::subsampling::choose_n_farthest_points(K(), point_vector, number_of_landmarks, Gudhi::subsampling::random_starting_point, std::back_inserter(landmarks));
+    Gudhi::subsampling::choose_n_farthest_points(K(), point_vector, number_of_landmarks,
+                                                 Gudhi::subsampling::random_starting_point,
+                                                 std::back_inserter(landmarks));
 
     // Compute witness complex
-    Witness_complex witness_complex(landmarks,
-                                    point_vector);
+    Witness_complex witness_complex(landmarks, point_vector);
     witness_complex.create_complex(simplex_tree, 0);
     end = clock();
     double time = static_cast<double>(end - start) / CLOCKS_PER_SEC;
-    std::cout << "Witness complex for " << number_of_landmarks << " landmarks took "
-        << time << " s. \n";
+    std::cout << "Witness complex for " << number_of_landmarks << " landmarks took " << time << " s. \n";
     std::cout << "Number of simplices is: " << simplex_tree.num_simplices() << "\n";
     l_time.push_back(std::make_pair(nbP, time));
   }
diff --git a/src/Witness_complex/utilities/strong_witness_persistence.cpp b/src/Witness_complex/utilities/strong_witness_persistence.cpp
index e3e0c1ee..2fba631b 100644
--- a/src/Witness_complex/utilities/strong_witness_persistence.cpp
+++ b/src/Witness_complex/utilities/strong_witness_persistence.cpp
@@ -47,16 +47,10 @@ using Filtration_value = SimplexTree::Filtration_value;
 using Field_Zp = Gudhi::persistent_cohomology::Field_Zp;
 using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<SimplexTree, Field_Zp>;
 
-void program_options(int argc, char * argv[]
-                     , int & nbL
-                     , std::string & file_name
-                     , std::string & filediag
-                     , Filtration_value & max_squared_alpha
-                     , int & p
-                     , int & dim_max
-                     , Filtration_value & min_persistence);
-
-int main(int argc, char * argv[]) {
+void program_options(int argc, char* argv[], int& nbL, std::string& file_name, std::string& filediag,
+                     Filtration_value& max_squared_alpha, int& p, int& dim_max, Filtration_value& min_persistence);
+
+int main(int argc, char* argv[]) {
   std::string file_name;
   std::string filediag;
   Filtration_value max_squared_alpha;
@@ -70,8 +64,8 @@ int main(int argc, char * argv[]) {
   Point_vector witnesses, landmarks;
   Gudhi::Points_off_reader<Point_d> off_reader(file_name);
   if (!off_reader.is_valid()) {
-      std::cerr << "Witness complex - Unable to read file " << file_name << "\n";
-      exit(-1);  // ----- >>
+    std::cerr << "Witness complex - Unable to read file " << file_name << "\n";
+    exit(-1);  // ----- >>
   }
   witnesses = Point_vector(off_reader.get_point_cloud());
   std::cout << "Successfully read " << witnesses.size() << " points.\n";
@@ -79,11 +73,11 @@ int main(int argc, char * argv[]) {
 
   // Choose landmarks (decomment one of the following two lines)
   // Gudhi::subsampling::pick_n_random_points(point_vector, nbL, std::back_inserter(landmarks));
-  Gudhi::subsampling::choose_n_farthest_points(K(), witnesses, nbL, Gudhi::subsampling::random_starting_point, std::back_inserter(landmarks));
+  Gudhi::subsampling::choose_n_farthest_points(K(), witnesses, nbL, Gudhi::subsampling::random_starting_point,
+                                               std::back_inserter(landmarks));
 
   // Compute witness complex
-  Strong_witness_complex strong_witness_complex(landmarks,
-                                                witnesses);
+  Strong_witness_complex strong_witness_complex(landmarks, witnesses);
 
   strong_witness_complex.create_complex(simplex_tree, max_squared_alpha, lim_d);
 
@@ -112,37 +106,28 @@ int main(int argc, char * argv[]) {
   return 0;
 }
 
-void program_options(int argc, char * argv[]
-                     , int & nbL
-                     , std::string & file_name
-                     , std::string & filediag
-                     , Filtration_value & max_squared_alpha
-                     , int & p
-                     , int & dim_max
-                     , Filtration_value & min_persistence) {
+void program_options(int argc, char* argv[], int& nbL, std::string& file_name, std::string& filediag,
+                     Filtration_value& max_squared_alpha, int& p, int& dim_max, Filtration_value& min_persistence) {
   namespace po = boost::program_options;
 
   po::options_description hidden("Hidden options");
-  hidden.add_options()
-      ("input-file", po::value<std::string>(&file_name),
-      "Name of file containing a point set in off format.");
+  hidden.add_options()("input-file", po::value<std::string>(&file_name),
+                       "Name of file containing a point set in off format.");
 
   po::options_description visible("Allowed options", 100);
   Filtration_value default_alpha = std::numeric_limits<Filtration_value>::infinity();
-  visible.add_options()
-      ("help,h", "produce help message")
-      ("landmarks,l", po::value<int>(&nbL),
-       "Number of landmarks to choose from the point cloud.")
-      ("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-sq-alpha,a", po::value<Filtration_value>(&max_squared_alpha)->default_value(default_alpha),
-       "Maximal squared relaxation parameter.")
-      ("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)->default_value(0),
-       "Minimal lifetime of homology feature to be recorded. Default is 0. Enter a negative value to see zero length intervals")
-      ("cpx-dimension,d", po::value<int>(&dim_max)->default_value(std::numeric_limits<int>::max()),
-       "Maximal dimension of the strong witness complex we want to compute.");
+  visible.add_options()("help,h", "produce help message")("landmarks,l", po::value<int>(&nbL),
+                                                          "Number of landmarks to choose from the point cloud.")(
+      "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-sq-alpha,a", po::value<Filtration_value>(&max_squared_alpha)->default_value(default_alpha),
+      "Maximal squared relaxation parameter.")(
+      "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)->default_value(0),
+      "Minimal lifetime of homology feature to be recorded. Default is 0. Enter a negative value to see zero length "
+      "intervals")("cpx-dimension,d", po::value<int>(&dim_max)->default_value(std::numeric_limits<int>::max()),
+                   "Maximal dimension of the strong witness complex we want to compute.");
 
   po::positional_options_description pos;
   pos.add("input-file", 1);
@@ -151,8 +136,7 @@ void program_options(int argc, char * argv[]
   all.add(visible).add(hidden);
   po::variables_map vm;
 
-  po::store(po::command_line_parser(argc, argv).
-            options(all).positional(pos).run(), vm);
+  po::store(po::command_line_parser(argc, argv).options(all).positional(pos).run(), vm);
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
@@ -170,4 +154,3 @@ void program_options(int argc, char * argv[]
     std::abort();
   }
 }
-
diff --git a/src/Witness_complex/utilities/weak_witness_persistence.cpp b/src/Witness_complex/utilities/weak_witness_persistence.cpp
index a63b0837..23fa93aa 100644
--- a/src/Witness_complex/utilities/weak_witness_persistence.cpp
+++ b/src/Witness_complex/utilities/weak_witness_persistence.cpp
@@ -47,16 +47,10 @@ using Filtration_value = SimplexTree::Filtration_value;
 using Field_Zp = Gudhi::persistent_cohomology::Field_Zp;
 using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<SimplexTree, Field_Zp>;
 
-void program_options(int argc, char * argv[]
-                     , int & nbL
-                     , std::string & file_name
-                     , std::string & filediag
-                     , Filtration_value & max_squared_alpha
-                     , int & p
-                     , int & dim_max
-                     , Filtration_value & min_persistence);
-
-int main(int argc, char * argv[]) {
+void program_options(int argc, char* argv[], int& nbL, std::string& file_name, std::string& filediag,
+                     Filtration_value& max_squared_alpha, int& p, int& dim_max, Filtration_value& min_persistence);
+
+int main(int argc, char* argv[]) {
   std::string file_name;
   std::string filediag;
   Filtration_value max_squared_alpha;
@@ -70,8 +64,8 @@ int main(int argc, char * argv[]) {
   Point_vector witnesses, landmarks;
   Gudhi::Points_off_reader<Point_d> off_reader(file_name);
   if (!off_reader.is_valid()) {
-      std::cerr << "Witness complex - Unable to read file " << file_name << "\n";
-      exit(-1);  // ----- >>
+    std::cerr << "Witness complex - Unable to read file " << file_name << "\n";
+    exit(-1);  // ----- >>
   }
   witnesses = Point_vector(off_reader.get_point_cloud());
   std::cout << "Successfully read " << witnesses.size() << " points.\n";
@@ -79,11 +73,11 @@ int main(int argc, char * argv[]) {
 
   // Choose landmarks (decomment one of the following two lines)
   // Gudhi::subsampling::pick_n_random_points(point_vector, nbL, std::back_inserter(landmarks));
-  Gudhi::subsampling::choose_n_farthest_points(K(), witnesses, nbL, Gudhi::subsampling::random_starting_point, std::back_inserter(landmarks));
+  Gudhi::subsampling::choose_n_farthest_points(K(), witnesses, nbL, Gudhi::subsampling::random_starting_point,
+                                               std::back_inserter(landmarks));
 
   // Compute witness complex
-  Witness_complex witness_complex(landmarks,
-                                  witnesses);
+  Witness_complex witness_complex(landmarks, witnesses);
 
   witness_complex.create_complex(simplex_tree, max_squared_alpha, lim_d);
 
@@ -112,38 +106,28 @@ int main(int argc, char * argv[]) {
   return 0;
 }
 
-
-void program_options(int argc, char * argv[]
-                     , int & nbL
-                     , std::string & file_name
-                     , std::string & filediag
-                     , Filtration_value & max_squared_alpha
-                     , int & p
-                     , int & dim_max
-                     , Filtration_value & min_persistence) {
+void program_options(int argc, char* argv[], int& nbL, std::string& file_name, std::string& filediag,
+                     Filtration_value& max_squared_alpha, int& p, int& dim_max, Filtration_value& min_persistence) {
   namespace po = boost::program_options;
 
   po::options_description hidden("Hidden options");
-  hidden.add_options()
-      ("input-file", po::value<std::string>(&file_name),
-      "Name of file containing a point set in off format.");
+  hidden.add_options()("input-file", po::value<std::string>(&file_name),
+                       "Name of file containing a point set in off format.");
 
   Filtration_value default_alpha = std::numeric_limits<Filtration_value>::infinity();
   po::options_description visible("Allowed options", 100);
-  visible.add_options()
-      ("help,h", "produce help message")
-      ("landmarks,l", po::value<int>(&nbL),
-       "Number of landmarks to choose from the point cloud.")
-      ("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-sq-alpha,a", po::value<Filtration_value>(&max_squared_alpha)->default_value(default_alpha),
-       "Maximal squared relaxation parameter.")
-      ("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)->default_value(0),
-       "Minimal lifetime of homology feature to be recorded. Default is 0. Enter a negative value to see zero length intervals")
-      ("cpx-dimension,d", po::value<int>(&dim_max)->default_value(std::numeric_limits<int>::max()),
-       "Maximal dimension of the weak witness complex we want to compute.");
+  visible.add_options()("help,h", "produce help message")("landmarks,l", po::value<int>(&nbL),
+                                                          "Number of landmarks to choose from the point cloud.")(
+      "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-sq-alpha,a", po::value<Filtration_value>(&max_squared_alpha)->default_value(default_alpha),
+      "Maximal squared relaxation parameter.")(
+      "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)->default_value(0),
+      "Minimal lifetime of homology feature to be recorded. Default is 0. Enter a negative value to see zero length "
+      "intervals")("cpx-dimension,d", po::value<int>(&dim_max)->default_value(std::numeric_limits<int>::max()),
+                   "Maximal dimension of the weak witness complex we want to compute.");
 
   po::positional_options_description pos;
   pos.add("input-file", 1);
@@ -152,8 +136,7 @@ void program_options(int argc, char * argv[]
   all.add(visible).add(hidden);
   po::variables_map vm;
 
-  po::store(po::command_line_parser(argc, argv).
-            options(all).positional(pos).run(), vm);
+  po::store(po::command_line_parser(argc, argv).options(all).positional(pos).run(), vm);
   po::notify(vm);
 
   if (vm.count("help") || !vm.count("input-file")) {
diff --git a/src/common/include/gudhi/Unitary_tests_utils.h b/src/common/include/gudhi/Unitary_tests_utils.h
index 7ae5d356..8394a062 100644
--- a/src/common/include/gudhi/Unitary_tests_utils.h
+++ b/src/common/include/gudhi/Unitary_tests_utils.h
@@ -25,6 +25,7 @@
 #include <boost/test/unit_test.hpp>
 
 #include <iostream>
+#include <limits>  // for std::numeric_limits<>
 
 template<typename FloatingType >
 void GUDHI_TEST_FLOAT_EQUALITY_CHECK(FloatingType a, FloatingType b,