clang-format files

6 files changed, 84 insertions, 100 deletions

diff --git a/src/Coxeter_triangulation/test/cell_complex_test.cpp b/src/Coxeter_triangulation/test/cell_complex_test.cpp
index 486c4981..88b6142b 100644
--- a/src/Coxeter_triangulation/test/cell_complex_test.cpp
+++ b/src/Coxeter_triangulation/test/cell_complex_test.cpp
@@ -27,34 +27,33 @@
 using namespace Gudhi::coxeter_triangulation;
 
 BOOST_AUTO_TEST_CASE(cell_complex) {
-
   double radius = 1.1111;
-  Function_torus_in_R3 fun_torus(radius, 3*radius);
+  Function_torus_in_R3 fun_torus(radius, 3 * radius);
   Eigen::VectorXd seed = fun_torus.seed();
-  Function_Sm_in_Rd fun_bound(2.5*radius, 2, seed);
-    
+  Function_Sm_in_Rd fun_bound(2.5 * radius, 2, seed);
+
   auto oracle = make_oracle(fun_torus, fun_bound);
   double lambda = 0.2;
   Coxeter_triangulation<> cox_tr(oracle.amb_d());
   cox_tr.change_offset(Eigen::VectorXd::Random(oracle.amb_d()));
   cox_tr.change_matrix(lambda * cox_tr.matrix());
-  
+
   using MT = Manifold_tracing<Coxeter_triangulation<> >;
   using Out_simplex_map = typename MT::Out_simplex_map;
   std::vector<Eigen::VectorXd> seed_points(1, seed);
   Out_simplex_map interior_simplex_map, boundary_simplex_map;
   manifold_tracing_algorithm(seed_points, cox_tr, oracle, interior_simplex_map, boundary_simplex_map);
-  
+
   std::size_t intr_d = oracle.amb_d() - oracle.cod_d();
   Cell_complex<Out_simplex_map> cell_complex(intr_d);
   cell_complex.construct_complex(interior_simplex_map, boundary_simplex_map);
-  
+
   std::size_t interior_sc_map_size0 = cell_complex.interior_simplex_cell_map(0).size();
   std::size_t interior_sc_map_size1 = cell_complex.interior_simplex_cell_map(1).size();
   std::size_t interior_sc_map_size2 = cell_complex.interior_simplex_cell_map(2).size();
   std::size_t boundary_sc_map_size0 = cell_complex.boundary_simplex_cell_map(0).size();
   std::size_t boundary_sc_map_size1 = cell_complex.boundary_simplex_cell_map(1).size();
-  BOOST_CHECK (interior_simplex_map.size() == interior_sc_map_size0 );
-  BOOST_CHECK ( boundary_sc_map_size0 - boundary_sc_map_size1 == 0 );
-  BOOST_CHECK ( interior_sc_map_size0 - interior_sc_map_size1 + interior_sc_map_size2 == 0 );
+  BOOST_CHECK(interior_simplex_map.size() == interior_sc_map_size0);
+  BOOST_CHECK(boundary_sc_map_size0 - boundary_sc_map_size1 == 0);
+  BOOST_CHECK(interior_sc_map_size0 - interior_sc_map_size1 + interior_sc_map_size2 == 0);
 }
diff --git a/src/Coxeter_triangulation/test/freud_triang_test.cpp b/src/Coxeter_triangulation/test/freud_triang_test.cpp
index 69729975..9e06acc9 100644
--- a/src/Coxeter_triangulation/test/freud_triang_test.cpp
+++ b/src/Coxeter_triangulation/test/freud_triang_test.cpp
@@ -17,13 +17,12 @@
 #include <gudhi/Coxeter_triangulation.h>
 
 BOOST_AUTO_TEST_CASE(freudenthal_triangulation) {
-  
   // Point location check
   typedef std::vector<double> Point;
   typedef Gudhi::coxeter_triangulation::Freudenthal_triangulation<> FK_triangulation;
   typedef typename FK_triangulation::Simplex_handle Simplex_handle;
   typedef typename FK_triangulation::Vertex_handle Vertex_handle;
-  typedef typename Simplex_handle::OrderedSetPartition Ordered_set_partition; 
+  typedef typename Simplex_handle::OrderedSetPartition Ordered_set_partition;
   typedef typename Ordered_set_partition::value_type Part;
 
   FK_triangulation tr(3);
@@ -32,48 +31,47 @@ BOOST_AUTO_TEST_CASE(freudenthal_triangulation) {
   {
     Point point({3, -1, 0});
     Simplex_handle s = tr.locate_point(point);
-    BOOST_CHECK( s.vertex() == Vertex_handle({3, -1, 0}) );
-    BOOST_CHECK( s.partition() == Ordered_set_partition({Part({0, 1, 2, 3})}) );
+    BOOST_CHECK(s.vertex() == Vertex_handle({3, -1, 0}));
+    BOOST_CHECK(s.partition() == Ordered_set_partition({Part({0, 1, 2, 3})}));
   }
 
   {
     Point point({3.5, -1.5, 0.5});
     Simplex_handle s = tr.locate_point(point);
-    BOOST_CHECK( s.vertex() == Vertex_handle({3, -2, 0}) );
-    BOOST_CHECK( s.partition() == Ordered_set_partition({Part({0, 1, 2}), Part({3})}) );
+    BOOST_CHECK(s.vertex() == Vertex_handle({3, -2, 0}));
+    BOOST_CHECK(s.partition() == Ordered_set_partition({Part({0, 1, 2}), Part({3})}));
   }
 
   {
     Point point({3.5, -1.8, 0.5});
     Simplex_handle s = tr.locate_point(point);
-    BOOST_CHECK( s.vertex() == Vertex_handle({3, -2, 0}) );
-    BOOST_CHECK( s.partition() == Ordered_set_partition({Part({0, 2}), Part({1}), Part({3})}) );
+    BOOST_CHECK(s.vertex() == Vertex_handle({3, -2, 0}));
+    BOOST_CHECK(s.partition() == Ordered_set_partition({Part({0, 2}), Part({1}), Part({3})}));
   }
 
   {
     Point point({3.5, -1.8, 0.3});
     Simplex_handle s = tr.locate_point(point);
-    BOOST_CHECK( s.vertex() == Vertex_handle({3, -2, 0}) );
-    BOOST_CHECK( s.partition() == Ordered_set_partition({Part({0}), Part({2}), Part({1}), Part({3})}) );
+    BOOST_CHECK(s.vertex() == Vertex_handle({3, -2, 0}));
+    BOOST_CHECK(s.partition() == Ordered_set_partition({Part({0}), Part({2}), Part({1}), Part({3})}));
   }
 
   // Dimension check
-  BOOST_CHECK( tr.dimension() == 3 );
+  BOOST_CHECK(tr.dimension() == 3);
   // Matrix check
-  Eigen::MatrixXd default_matrix = Eigen::MatrixXd::Identity(3, 3);  
-  BOOST_CHECK( tr.matrix() == default_matrix );
+  Eigen::MatrixXd default_matrix = Eigen::MatrixXd::Identity(3, 3);
+  BOOST_CHECK(tr.matrix() == default_matrix);
   // Vector check
-  Eigen::MatrixXd default_offset = Eigen::VectorXd::Zero(3);  
-  BOOST_CHECK( tr.offset() == default_offset );
+  Eigen::MatrixXd default_offset = Eigen::VectorXd::Zero(3);
+  BOOST_CHECK(tr.offset() == default_offset);
 
   // Barycenter check
   Point point({3.5, -1.8, 0.3});
   Simplex_handle s = tr.locate_point(point);
   Eigen::Vector3d barycenter_cart = Eigen::Vector3d::Zero();
-  for (auto v: s.vertex_range())
-    for (std::size_t i = 0; i < v.size(); i++)
-      barycenter_cart(i) += v[i];
-  barycenter_cart /= 4.; // simplex is three-dimensional
+  for (auto v : s.vertex_range())
+    for (std::size_t i = 0; i < v.size(); i++) barycenter_cart(i) += v[i];
+  barycenter_cart /= 4.;  // simplex is three-dimensional
   Eigen::Vector3d barycenter = tr.barycenter(s);
   for (std::size_t i = 0; (long int)i < barycenter.size(); i++)
     GUDHI_TEST_FLOAT_EQUALITY_CHECK(barycenter(i), barycenter_cart(i), 1e-7);
@@ -81,22 +79,21 @@ BOOST_AUTO_TEST_CASE(freudenthal_triangulation) {
   // Barycenter check for twice the scale
   s = tr.locate_point(point, 2);
   barycenter_cart = Eigen::Vector3d::Zero();
-  for (auto v: s.vertex_range())
-    for (std::size_t i = 0; i < v.size(); i++)
-      barycenter_cart(i) += v[i];
-  barycenter_cart /= 3.; // simplex is now a two-dimensional face
-  barycenter_cart /= 2.; // scale
+  for (auto v : s.vertex_range())
+    for (std::size_t i = 0; i < v.size(); i++) barycenter_cart(i) += v[i];
+  barycenter_cart /= 3.;  // simplex is now a two-dimensional face
+  barycenter_cart /= 2.;  // scale
   barycenter = tr.barycenter(s, 2);
   for (std::size_t i = 0; (long int)i < barycenter.size(); i++)
     GUDHI_TEST_FLOAT_EQUALITY_CHECK(barycenter(i), barycenter_cart(i), 1e-7);
-  
+
   // Matrix and offset change check
-  Eigen::MatrixXd new_matrix(3,3);
+  Eigen::MatrixXd new_matrix(3, 3);
   new_matrix << 1, 0, 0, -1, 1, 0, -1, 0, 1;
   Eigen::Vector3d new_offset(1.5, 1, 0.5);
   tr.change_matrix(new_matrix);
   tr.change_offset(new_offset);
-  
-  BOOST_CHECK( tr.matrix() == new_matrix );
-  BOOST_CHECK( tr.offset() == new_offset );
+
+  BOOST_CHECK(tr.matrix() == new_matrix);
+  BOOST_CHECK(tr.offset() == new_offset);
 }
diff --git a/src/Coxeter_triangulation/test/function_test.cpp b/src/Coxeter_triangulation/test/function_test.cpp
index c9c3f55b..d3c8d46c 100644
--- a/src/Coxeter_triangulation/test/function_test.cpp
+++ b/src/Coxeter_triangulation/test/function_test.cpp
@@ -11,7 +11,7 @@
 // workaround for the annoying boost message in boost 1.69
 #define BOOST_PENDING_INTEGER_LOG2_HPP
 #include <boost/integer/integer_log2.hpp>
-// end workaround 
+// end workaround
 
 #define BOOST_TEST_DYN_LINK
 #define BOOST_TEST_MODULE "function"
@@ -48,18 +48,17 @@ template <class Function>
 void test_function(const Function& fun) {
   Eigen::VectorXd seed = fun.seed();
   Eigen::VectorXd res_seed = fun(fun.seed());
-  BOOST_CHECK( seed.size() == (long int)fun.amb_d() );
-  BOOST_CHECK( res_seed.size() == (long int)fun.cod_d() );
-  for (std::size_t i = 0; i < fun.cod_d(); i++)
-    GUDHI_TEST_FLOAT_EQUALITY_CHECK(res_seed(i), 0., 1e-10);
+  BOOST_CHECK(seed.size() == (long int)fun.amb_d());
+  BOOST_CHECK(res_seed.size() == (long int)fun.cod_d());
+  for (std::size_t i = 0; i < fun.cod_d(); i++) GUDHI_TEST_FLOAT_EQUALITY_CHECK(res_seed(i), 0., 1e-10);
 }
 
 BOOST_AUTO_TEST_CASE(function) {
-
   {
     // the sphere testing part
     std::size_t m = 3, d = 5;
-    Eigen::VectorXd center(d); center << 2, 1.5, -0.5, 4.5, -1;
+    Eigen::VectorXd center(d);
+    center << 2, 1.5, -0.5, 4.5, -1;
     double radius = 5;
     typedef Function_Sm_in_Rd Function_sphere;
     Function_sphere fun_sphere(radius, m, d, center);
@@ -68,9 +67,8 @@ BOOST_AUTO_TEST_CASE(function) {
   {
     // the affine plane testing part
     std::size_t m = 0, d = 5;
-    Eigen::MatrixXd normal_matrix = Eigen::MatrixXd::Zero(d, d-m);
-    for (std::size_t i = 0; i < d-m; ++i)
-      normal_matrix(i,i) = 1;
+    Eigen::MatrixXd normal_matrix = Eigen::MatrixXd::Zero(d, d - m);
+    for (std::size_t i = 0; i < d - m; ++i) normal_matrix(i, i) = 1;
     typedef Function_affine_plane_in_Rd Function_plane;
     Function_plane fun_plane(normal_matrix);
     test_function(fun_plane);
@@ -81,8 +79,7 @@ BOOST_AUTO_TEST_CASE(function) {
     auto x = Eigen::VectorXd::Constant(k, 1);
     Constant_function fun_const(d, k, x);
     Eigen::VectorXd res_zero = fun_const(Eigen::VectorXd::Zero(d));
-    for (std::size_t i = 0; i < k; ++i)
-      GUDHI_TEST_FLOAT_EQUALITY_CHECK(res_zero(i), x(i), 1e-10);
+    for (std::size_t i = 0; i < k; ++i) GUDHI_TEST_FLOAT_EQUALITY_CHECK(res_zero(i), x(i), 1e-10);
   }
   {
     // the chair function
@@ -119,10 +116,10 @@ BOOST_AUTO_TEST_CASE(function) {
     Eigen::MatrixXd id_matrix = matrix.transpose() * matrix;
     for (std::size_t i = 0; i < 5; ++i)
       for (std::size_t j = 0; j < 5; ++j)
-	if (i == j)
-	  GUDHI_TEST_FLOAT_EQUALITY_CHECK(id_matrix(i,j), 1.0, 1e-10);
-	else
-	  GUDHI_TEST_FLOAT_EQUALITY_CHECK(id_matrix(i,j), 0.0, 1e-10);
+        if (i == j)
+          GUDHI_TEST_FLOAT_EQUALITY_CHECK(id_matrix(i, j), 1.0, 1e-10);
+        else
+          GUDHI_TEST_FLOAT_EQUALITY_CHECK(id_matrix(i, j), 0.0, 1e-10);
   }
   {
     // function embedding
@@ -137,7 +134,7 @@ BOOST_AUTO_TEST_CASE(function) {
 
     // function linear transformation
     Eigen::MatrixXd matrix = Eigen::MatrixXd::Random(5, 5);
-    BOOST_CHECK( matrix.determinant() != 0. );
+    BOOST_CHECK(matrix.determinant() != 0.);
     auto fun_lin = make_linear_transformation(fun_trans, matrix);
     test_function(fun_lin);
 
@@ -150,7 +147,7 @@ BOOST_AUTO_TEST_CASE(function) {
     Function_sphere fun_sphere(1, 1);
     auto fun_prod = make_product_function(fun_sphere, fun_sphere, fun_sphere);
     test_function(fun_prod);
-    
+
     // function PL approximation
     Coxeter_triangulation<> cox_tr(6);
     typedef Coxeter_triangulation<>::Vertex_handle Vertex_handle;
@@ -159,17 +156,15 @@ BOOST_AUTO_TEST_CASE(function) {
     Eigen::VectorXd x0 = cox_tr.cartesian_coordinates(v0);
     Eigen::VectorXd value0 = fun_prod(x0);
     Eigen::VectorXd pl_value0 = fun_pl(x0);
-    for (std::size_t i = 0; i < fun_pl.cod_d(); i++)
-      GUDHI_TEST_FLOAT_EQUALITY_CHECK(value0(i), pl_value0(i), 1e-10);
+    for (std::size_t i = 0; i < fun_pl.cod_d(); i++) GUDHI_TEST_FLOAT_EQUALITY_CHECK(value0(i), pl_value0(i), 1e-10);
     Vertex_handle v1 = v0;
     v1[0] += 1;
     Eigen::VectorXd x1 = cox_tr.cartesian_coordinates(v1);
     Eigen::VectorXd value1 = fun_prod(x1);
     Eigen::VectorXd pl_value1 = fun_pl(x1);
+    for (std::size_t i = 0; i < fun_pl.cod_d(); i++) GUDHI_TEST_FLOAT_EQUALITY_CHECK(value1(i), pl_value1(i), 1e-10);
+    Eigen::VectorXd pl_value_mid = fun_pl(0.5 * x0 + 0.5 * x1);
     for (std::size_t i = 0; i < fun_pl.cod_d(); i++)
-      GUDHI_TEST_FLOAT_EQUALITY_CHECK(value1(i), pl_value1(i), 1e-10);
-    Eigen::VectorXd pl_value_mid = fun_pl(0.5*x0 + 0.5*x1);
-    for (std::size_t i = 0; i < fun_pl.cod_d(); i++)
-      GUDHI_TEST_FLOAT_EQUALITY_CHECK(0.5*value0(i) + 0.5*value1(i), pl_value_mid(i), 1e-10);
+      GUDHI_TEST_FLOAT_EQUALITY_CHECK(0.5 * value0(i) + 0.5 * value1(i), pl_value_mid(i), 1e-10);
   }
 }
diff --git a/src/Coxeter_triangulation/test/manifold_tracing_test.cpp b/src/Coxeter_triangulation/test/manifold_tracing_test.cpp
index 0113f8b5..68b79487 100644
--- a/src/Coxeter_triangulation/test/manifold_tracing_test.cpp
+++ b/src/Coxeter_triangulation/test/manifold_tracing_test.cpp
@@ -28,37 +28,35 @@ BOOST_AUTO_TEST_CASE(manifold_tracing) {
   auto oracle = make_oracle(fun_sph);
   Coxeter_triangulation<> cox_tr(oracle.amb_d());
   // cox_tr.change_offset(Eigen::VectorXd::Random(oracle.amb_d()));
-  
+
   using MT = Manifold_tracing<Coxeter_triangulation<> >;
   Eigen::VectorXd seed = fun_sph.seed();
   std::vector<Eigen::VectorXd> seed_points(1, seed);
   typename MT::Out_simplex_map out_simplex_map;
   manifold_tracing_algorithm(seed_points, cox_tr, oracle, out_simplex_map);
 
-  for (auto si_pair: out_simplex_map) {
-    BOOST_CHECK ( si_pair.first.dimension() == oracle.function().cod_d() );
-    BOOST_CHECK ( si_pair.second.size() == (long int)oracle.function().amb_d() );
+  for (auto si_pair : out_simplex_map) {
+    BOOST_CHECK(si_pair.first.dimension() == oracle.function().cod_d());
+    BOOST_CHECK(si_pair.second.size() == (long int)oracle.function().amb_d());
   }
   std::cout << "out_simplex_map.size() = " << out_simplex_map.size() << "\n";
-  BOOST_CHECK ( out_simplex_map.size() == 1140 );
-  
+  BOOST_CHECK(out_simplex_map.size() == 1140);
 
   // manifold with boundary
   Function_Sm_in_Rd fun_boundary(3.0, 2, fun_sph.seed());
   auto oracle_with_boundary = make_oracle(fun_sph, fun_boundary);
   typename MT::Out_simplex_map interior_simplex_map, boundary_simplex_map;
   manifold_tracing_algorithm(seed_points, cox_tr, oracle_with_boundary, interior_simplex_map, boundary_simplex_map);
-  for (auto si_pair: interior_simplex_map) {
-    BOOST_CHECK ( si_pair.first.dimension() == oracle.function().cod_d() );
-    BOOST_CHECK ( si_pair.second.size() == (long int)oracle.function().amb_d() );
+  for (auto si_pair : interior_simplex_map) {
+    BOOST_CHECK(si_pair.first.dimension() == oracle.function().cod_d());
+    BOOST_CHECK(si_pair.second.size() == (long int)oracle.function().amb_d());
   }
   std::cout << "interior_simplex_map.size() = " << interior_simplex_map.size() << "\n";
-  BOOST_CHECK ( interior_simplex_map.size() == 96 );
-  for (auto si_pair: boundary_simplex_map) {
-    BOOST_CHECK ( si_pair.first.dimension() == oracle.function().cod_d()+1 );
-    BOOST_CHECK ( si_pair.second.size() == (long int)oracle.function().amb_d() );
+  BOOST_CHECK(interior_simplex_map.size() == 96);
+  for (auto si_pair : boundary_simplex_map) {
+    BOOST_CHECK(si_pair.first.dimension() == oracle.function().cod_d() + 1);
+    BOOST_CHECK(si_pair.second.size() == (long int)oracle.function().amb_d());
   }
   std::cout << "boundary_simplex_map.size() = " << boundary_simplex_map.size() << "\n";
-  BOOST_CHECK ( boundary_simplex_map.size() == 55 );
-  
+  BOOST_CHECK(boundary_simplex_map.size() == 55);
 }
diff --git a/src/Coxeter_triangulation/test/oracle_test.cpp b/src/Coxeter_triangulation/test/oracle_test.cpp
index dfa19293..ed2042f5 100644
--- a/src/Coxeter_triangulation/test/oracle_test.cpp
+++ b/src/Coxeter_triangulation/test/oracle_test.cpp
@@ -28,31 +28,29 @@
 using namespace Gudhi::coxeter_triangulation;
 
 BOOST_AUTO_TEST_CASE(oracle) {
-
   Function_Sm_in_Rd fun_sph(5.1111, 2);
   auto oracle = make_oracle(fun_sph);
   Coxeter_triangulation<> cox_tr(oracle.amb_d());
   // cox_tr.change_offset(Eigen::VectorXd::Random(oracle.amb_d()));
-  
+
   Eigen::VectorXd seed = fun_sph.seed();
   auto s = cox_tr.locate_point(seed);
 
   std::size_t num_intersected_edges = 0;
-  for (auto f: s.face_range(oracle.cod_d())) {
+  for (auto f : s.face_range(oracle.cod_d())) {
     auto qr = oracle.intersects(f, cox_tr);
-    if (qr.success)
-      num_intersected_edges++;
+    if (qr.success) num_intersected_edges++;
     auto vertex_it = f.vertex_range().begin();
     Eigen::Vector3d p1 = cox_tr.cartesian_coordinates(*vertex_it++);
     Eigen::Vector3d p2 = cox_tr.cartesian_coordinates(*vertex_it++);
-    BOOST_CHECK( vertex_it == f.vertex_range().end() );
-    Eigen::MatrixXd m(3,3);
-    if (qr.success) {      
+    BOOST_CHECK(vertex_it == f.vertex_range().end());
+    Eigen::MatrixXd m(3, 3);
+    if (qr.success) {
       m.col(0) = qr.intersection;
       m.col(1) = p1;
       m.col(2) = p2;
       GUDHI_TEST_FLOAT_EQUALITY_CHECK(m.determinant(), 0.0, 1e-10);
     }
   }
-  BOOST_CHECK( num_intersected_edges == 3 || num_intersected_edges == 4 );
+  BOOST_CHECK(num_intersected_edges == 3 || num_intersected_edges == 4);
 }
diff --git a/src/Coxeter_triangulation/test/perm_rep_test.cpp b/src/Coxeter_triangulation/test/perm_rep_test.cpp
index 2376c88a..a668fc66 100644
--- a/src/Coxeter_triangulation/test/perm_rep_test.cpp
+++ b/src/Coxeter_triangulation/test/perm_rep_test.cpp
@@ -20,7 +20,7 @@ BOOST_AUTO_TEST_CASE(permutahedral_representation) {
   typedef std::vector<Part> Partition;
   typedef Gudhi::coxeter_triangulation::Permutahedral_representation<Vertex, Partition> Simplex_handle;
   Vertex v0(10, 0);
-  Partition omega = {Part({5}), Part({2}), Part({3,7}), Part({4,9}), Part({0,6,8}), Part({1,10})};
+  Partition omega = {Part({5}), Part({2}), Part({3, 7}), Part({4, 9}), Part({0, 6, 8}), Part({1, 10})};
   Simplex_handle s(v0, omega);
 
   // Dimension check
@@ -28,34 +28,31 @@ BOOST_AUTO_TEST_CASE(permutahedral_representation) {
 
   // Vertex number check
   std::vector<Vertex> vertices;
-  for (auto& v: s.vertex_range())
-    vertices.push_back(v);
+  for (auto& v : s.vertex_range()) vertices.push_back(v);
   BOOST_CHECK(vertices.size() == 6);
-  
+
   // Facet number check
   std::vector<Simplex_handle> facets;
-  for (auto& f: s.facet_range())
-    facets.push_back(f);
+  for (auto& f : s.facet_range()) facets.push_back(f);
   BOOST_CHECK(facets.size() == 6);
 
   // Face of dim 3 number check
   std::vector<Simplex_handle> faces3;
-  for (auto& f: s.face_range(3))
-    faces3.push_back(f);
+  for (auto& f : s.face_range(3)) faces3.push_back(f);
   BOOST_CHECK(faces3.size() == 15);
 
   // Cofacet number check
   std::vector<Simplex_handle> cofacets;
-  for (auto& f: s.cofacet_range())
-    cofacets.push_back(f);
+  for (auto& f : s.cofacet_range()) cofacets.push_back(f);
   BOOST_CHECK(cofacets.size() == 12);
 
   // Is face check
   Vertex v1(10, 0);
-  Partition omega1 = {Part({5}), Part({0,1,2,3,4,6,7,8,9,10})};
+  Partition omega1 = {Part({5}), Part({0, 1, 2, 3, 4, 6, 7, 8, 9, 10})};
   Simplex_handle s1(v1, omega1);
-  Vertex v2(10, 0); v2[1] = -1;
-  Partition omega2 = {Part({1}), Part({5}), Part({2}), Part({3,7}), Part({4,9}), Part({0,6,8}), Part({10})};
+  Vertex v2(10, 0);
+  v2[1] = -1;
+  Partition omega2 = {Part({1}), Part({5}), Part({2}), Part({3, 7}), Part({4, 9}), Part({0, 6, 8}), Part({10})};
   Simplex_handle s2(v2, omega2);
   BOOST_CHECK(s.is_face_of(s));
   BOOST_CHECK(s1.is_face_of(s));