Fix cpplint

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

Former-commit-id: e1cc797f8c24015168a1f84430666e8a156ababa

3 files changed, 91 insertions, 118 deletions

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;
   }