clang-format files

1 files changed, 25 insertions, 34 deletions

diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/PL_approximation.h b/src/Coxeter_triangulation/include/gudhi/Functions/PL_approximation.h
index ab2b9294..3d1f3564 100644
--- a/src/Coxeter_triangulation/include/gudhi/Functions/PL_approximation.h
+++ b/src/Coxeter_triangulation/include/gudhi/Functions/PL_approximation.h
@@ -21,23 +21,21 @@ namespace Gudhi {
 
 namespace coxeter_triangulation {
 
-/** 
+/**
  * \class PL_approximation
  * \brief Constructs a piecewise-linear approximation of a function induced by
  * an ambient triangulation.
  *
- * \tparam Function The function template parameter. Should be a model of 
+ * \tparam Function The function template parameter. Should be a model of
  * the concept FunctionForImplicitManifold.
  * \tparam Triangulation The triangulation template parameter. Should be a model of
  * the concept TriangulationForManifoldTracing.
  *
  * \ingroup coxeter_triangulation
  */
-template <class Function_,
-	  class Triangulation_>
+template <class Function_, class Triangulation_>
 struct PL_approximation : public Function {
-  
-  /** 
+  /**
    * \brief Value of the function at a specified point.
    * @param[in] p The input point. The dimension needs to coincide with the ambient dimension.
    */
@@ -47,33 +45,29 @@ struct PL_approximation : public Function {
     auto s = tr_.locate_point(p);
     Eigen::MatrixXd matrix(cod_d, s.dimension() + 1);
     Eigen::MatrixXd vertex_matrix(amb_d + 1, s.dimension() + 1);
-    for (std::size_t i = 0; i < s.dimension() + 1; ++i)
-      vertex_matrix(0, i) = 1;
+    for (std::size_t i = 0; i < s.dimension() + 1; ++i) vertex_matrix(0, i) = 1;
     std::size_t j = 0;
-    for (auto v: s.vertex_range()) {
+    for (auto v : s.vertex_range()) {
       Eigen::VectorXd pt_v = tr_.cartesian_coordinates(v);
       Eigen::VectorXd fun_v = fun_(pt_v);
-      for (std::size_t i = 1; i < amb_d + 1; ++i)
-	vertex_matrix(i, j) = pt_v(i-1); 
-      for (std::size_t i = 0; i < cod_d; ++i)
-	matrix(i, j) = fun_v(i);
+      for (std::size_t i = 1; i < amb_d + 1; ++i) vertex_matrix(i, j) = pt_v(i - 1);
+      for (std::size_t i = 0; i < cod_d; ++i) matrix(i, j) = fun_v(i);
       j++;
     }
-    assert(j == s.dimension()+1);
+    assert(j == s.dimension() + 1);
     Eigen::VectorXd z(amb_d + 1);
     z(0) = 1;
-    for (std::size_t i = 1; i < amb_d + 1; ++i)
-      z(i) = p(i-1);
-    Eigen::VectorXd lambda = vertex_matrix.colPivHouseholderQr().solve(z);    
+    for (std::size_t i = 1; i < amb_d + 1; ++i) z(i) = p(i - 1);
+    Eigen::VectorXd lambda = vertex_matrix.colPivHouseholderQr().solve(z);
     Eigen::VectorXd result = matrix * lambda;
     return result;
   }
 
   /** \brief Returns the domain (ambient) dimension. */
-  virtual std::size_t amb_d() const override {return fun_.amb_d();}
+  virtual std::size_t amb_d() const override { return fun_.amb_d(); }
 
   /** \brief Returns the codomain dimension. */
-  virtual std::size_t cod_d() const override {return fun_.cod_d();}
+  virtual std::size_t cod_d() const override { return fun_.cod_d(); }
 
   /** \brief Returns a point on the zero-set. */
   virtual Eigen::VectorXd seed() const override {
@@ -81,44 +75,41 @@ struct PL_approximation : public Function {
     return Eigen::VectorXd(amb_d());
   }
 
-  /** 
-   * \brief Constructor of the piecewise-linear approximation of a function 
+  /**
+   * \brief Constructor of the piecewise-linear approximation of a function
    * induced by an ambient triangulation.
    *
    * @param[in] function The function.
    * @param[in] triangulation The ambient triangulation.
    */
   PL_approximation(const Function_& function, const Triangulation_& triangulation)
-    : fun_(function), tr_(triangulation) {}
+      : fun_(function), tr_(triangulation) {}
 
- private:  
+ private:
   Function_ fun_;
   Triangulation_ tr_;
 };
 
-
-/** 
- * \brief Static constructor of the piecewise-linear approximation of a function 
+/**
+ * \brief Static constructor of the piecewise-linear approximation of a function
  * induced by an ambient triangulation.
  *
  * @param[in] function The function.
  * @param[in] triangulation The ambient triangulation.
  *
- * \tparam Function_ The function template parameter. Should be a model of 
+ * \tparam Function_ The function template parameter. Should be a model of
  * the concept FunctionForImplicitManifold.
  *
  * \ingroup coxeter_triangulation
  */
-template <class Function_,
-	  class Triangulation_>
-PL_approximation<Function_, Triangulation_>
-make_pl_approximation(const Function_& function,
-		      const Triangulation_& triangulation) {
+template <class Function_, class Triangulation_>
+PL_approximation<Function_, Triangulation_> make_pl_approximation(const Function_& function,
+                                                                  const Triangulation_& triangulation) {
   return PL_approximation<Function_, Triangulation_>(function, triangulation);
 }
 
-} // namespace coxeter_triangulation
+}  // namespace coxeter_triangulation
 
-} // namespace Gudhi
+}  // namespace Gudhi
 
 #endif