diff --git a/include/stichwort/parameter.hpp b/include/stichwort/parameter.hpp
index 96dc8dd..5844eba 100644
--- a/include/stichwort/parameter.hpp
+++ b/include/stichwort/parameter.hpp
@@ -110,7 +110,8 @@ class Parameter
         }
     }
 
-    void throwIfInvalid() {
+    void throwIfInvalid()
+    {
         if (!valid)
         {
             throw wrong_parameter_error(invalidity_reasons);
@@ -200,8 +201,7 @@ class CheckedParameter
         return parameter.is<T>(v);
     }
 
-    template <template <class> class F, class Q>
-    inline const CheckedParameter& satisfies(const F<Q>& cond) const
+    template <template <class> class F, class Q> inline const CheckedParameter& satisfies(const F<Q>& cond) const
     {
         if (!parameter.isCondition(cond))
             parameter.invalidate(cond.failureMessage(parameter));
@@ -271,15 +271,21 @@ class ParametersSet
     }
     void merge(const ParametersSet& pg)
     {
-        typedef ParametersMap::const_iterator MapIter;
-        for (MapIter iter = pg.pmap.begin(); iter != pg.pmap.end(); ++iter)
+        for (auto each : pg.pmap)
         {
-            if (!pmap.count(iter->first))
+            if (!pmap.count(each.first))
             {
-                pmap[iter->first] = iter->second;
+                pmap[each.first] = each.second;
             }
         }
     }
+    void visit(std::function<void(const Parameter&)> visitor)
+    {
+        for (auto each : pmap)
+        {
+            visitor(each.second);
+        }
+    }
     Parameter operator[](const std::string& name) const
     {
         ParametersMap::const_iterator it = pmap.find(name);
diff --git a/include/tapkee/embed.hpp b/include/tapkee/embed.hpp
index c018273..2660e21 100644
--- a/include/tapkee/embed.hpp
+++ b/include/tapkee/embed.hpp
@@ -103,6 +103,9 @@ TapkeeOutput embed(RandomAccessIterator begin, RandomAccessIterator end, KernelC
     {
         parameters.check();
         parameters.merge(tapkee_internal::defaults);
+        parameters.visit([] (const stichwort::Parameter& p) {
+            tapkee::LoggingSingleton::instance().message_debug(fmt::format("Parameter {} = [{}]", p.name(), p.repr()));
+        });
 
         DimensionReductionMethod selected_method = parameters[method];
 
diff --git a/include/tapkee/methods.hpp b/include/tapkee/methods.hpp
index 3cab8e8..2ab538a 100644
--- a/include/tapkee/methods.hpp
+++ b/include/tapkee/methods.hpp
@@ -6,11 +6,11 @@
 
 /* Tapkee includes */
 #include <tapkee/defines.hpp>
-#include <tapkee/predicates.hpp>
 #include <tapkee/external/barnes_hut_sne/tsne.hpp>
 #include <tapkee/neighbors/neighbors.hpp>
 #include <tapkee/parameters/context.hpp>
 #include <tapkee/parameters/defaults.hpp>
+#include <tapkee/predicates.hpp>
 #include <tapkee/routines/diffusion_maps.hpp>
 #include <tapkee/routines/eigendecomposition.hpp>
 #include <tapkee/routines/fa.hpp>
@@ -35,7 +35,6 @@ namespace tapkee
 namespace tapkee_internal
 {
 
-
 template <class RandomAccessIterator, class KernelCallback, class DistanceCallback, class FeaturesCallback>
 class ImplementationBase
 {
@@ -44,8 +43,8 @@ class ImplementationBase
                        FeaturesCallback f, ParametersSet& pmap, const Context& ctx)
         : parameters(pmap), context(ctx), kernel(k), distance(d), features(f),
           plain_distance(PlainDistance<RandomAccessIterator, DistanceCallback>(distance)),
-          kernel_distance(KernelDistance<RandomAccessIterator, KernelCallback>(kernel)), begin(b), end(e),
-          n_vectors(0), current_dimension(0)
+          kernel_distance(KernelDistance<RandomAccessIterator, KernelCallback>(kernel)), begin(b), end(e), n_vectors(0),
+          current_dimension(0)
     {
         n_vectors = (end - begin);
 
@@ -141,7 +140,8 @@ class ImplementationBase
     template <class Distance> Neighbors findNeighborsWith(Distance d)
     {
         parameters[num_neighbors].checked().satisfies(InRange<IndexType>(3, n_vectors)).orThrow();
-        return find_neighbors(parameters[neighbors_method], begin, end, d, parameters[num_neighbors], parameters[check_connectivity]);
+        return find_neighbors(parameters[neighbors_method], begin, end, d, parameters[num_neighbors],
+                              parameters[check_connectivity]);
     }
 
     static tapkee::ProjectingFunction unimplementedProjectingFunction()
@@ -154,8 +154,8 @@ class ImplementationBase
         Neighbors neighbors = findNeighborsWith(kernel_distance);
         SparseWeightMatrix weight_matrix =
             linear_weight_matrix(begin, end, neighbors, kernel, parameters[nullspace_shift], parameters[klle_shift]);
-        DenseMatrix embedding = eigendecomposition(parameters[eigen_method], parameters[computation_strategy], SmallestEigenvalues,
-                                                   weight_matrix, parameters[target_dimension])
+        DenseMatrix embedding = eigendecomposition(parameters[eigen_method], parameters[computation_strategy],
+                                                   SmallestEigenvalues, weight_matrix, parameters[target_dimension])
                                     .first;
 
         return TapkeeOutput(embedding, unimplementedProjectingFunction());
@@ -164,10 +164,10 @@ class ImplementationBase
     TapkeeOutput embedKernelLocalTangentSpaceAlignment()
     {
         Neighbors neighbors = findNeighborsWith(kernel_distance);
-        SparseWeightMatrix weight_matrix =
-            tangent_weight_matrix(begin, end, neighbors, kernel, parameters[target_dimension], parameters[nullspace_shift]);
-        DenseMatrix embedding = eigendecomposition(parameters[eigen_method], parameters[computation_strategy], SmallestEigenvalues,
-                                                   weight_matrix, parameters[target_dimension])
+        SparseWeightMatrix weight_matrix = tangent_weight_matrix(
+            begin, end, neighbors, kernel, parameters[target_dimension], parameters[nullspace_shift]);
+        DenseMatrix embedding = eigendecomposition(parameters[eigen_method], parameters[computation_strategy],
+                                                   SmallestEigenvalues, weight_matrix, parameters[target_dimension])
                                     .first;
 
         return TapkeeOutput(embedding, unimplementedProjectingFunction());
@@ -177,13 +177,16 @@ class ImplementationBase
     {
         IndexType target_dimension_value = static_cast<IndexType>(parameters[target_dimension]);
         Parameter target_dimension_add = Parameter::create("target_dimension", target_dimension_value + 1);
-        DenseSymmetricMatrix diffusion_matrix = compute_diffusion_matrix(begin, end, distance, parameters[gaussian_kernel_width]);
-        EigendecompositionResult decomposition_result = eigendecomposition(
-            parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues, diffusion_matrix, target_dimension_add);
+        DenseSymmetricMatrix diffusion_matrix =
+            compute_diffusion_matrix(begin, end, distance, parameters[gaussian_kernel_width]);
+        EigendecompositionResult decomposition_result =
+            eigendecomposition(parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues,
+                               diffusion_matrix, target_dimension_add);
         DenseMatrix embedding = (decomposition_result.first).leftCols(target_dimension_value);
         // scaling with lambda_i^t
         for (IndexType i = 0; i < target_dimension_value; i++)
-            embedding.col(i).array() *= pow(decomposition_result.second(i), static_cast<IndexType>(parameters[diffusion_map_timesteps]));
+            embedding.col(i).array() *=
+                pow(decomposition_result.second(i), static_cast<IndexType>(parameters[diffusion_map_timesteps]));
         // scaling by eigenvector to largest eigenvalue 1
         for (IndexType i = 0; i < target_dimension_value; i++)
             embedding.col(i).array() /= decomposition_result.first.col(target_dimension_value).array();
@@ -195,8 +198,9 @@ class ImplementationBase
         DenseSymmetricMatrix distance_matrix = compute_distance_matrix(begin, end, distance);
         centerMatrix(distance_matrix);
         distance_matrix.array() *= -0.5;
-        EigendecompositionResult embedding = eigendecomposition(
-            parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues, distance_matrix, parameters[target_dimension]);
+        EigendecompositionResult embedding =
+            eigendecomposition(parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues,
+                               distance_matrix, parameters[target_dimension]);
 
         for (IndexType i = 0; i < static_cast<IndexType>(parameters[target_dimension]); i++)
             embedding.first.col(i).array() *= sqrt(embedding.second(i));
@@ -212,8 +216,9 @@ class ImplementationBase
         DenseVector landmark_distances_squared = distance_matrix.colwise().mean();
         centerMatrix(distance_matrix);
         distance_matrix.array() *= -0.5;
-        EigendecompositionResult landmarks_embedding = eigendecomposition(
-            parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues, distance_matrix, parameters[target_dimension]);
+        EigendecompositionResult landmarks_embedding =
+            eigendecomposition(parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues,
+                               distance_matrix, parameters[target_dimension]);
         for (IndexType i = 0; i < static_cast<IndexType>(parameters[target_dimension]); i++)
             landmarks_embedding.first.col(i).array() *= sqrt(landmarks_embedding.second(i));
         return TapkeeOutput(triangulate(begin, end, distance, landmarks, landmark_distances_squared,
@@ -230,8 +235,9 @@ class ImplementationBase
         centerMatrix(shortest_distances_matrix);
         shortest_distances_matrix.array() *= -0.5;
 
-        EigendecompositionResult embedding = eigendecomposition(
-            parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues, shortest_distances_matrix, parameters[target_dimension]);
+        EigendecompositionResult embedding =
+            eigendecomposition(parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues,
+                               shortest_distances_matrix, parameters[target_dimension]);
 
         for (IndexType i = 0; i < static_cast<IndexType>(parameters[target_dimension]); i++)
             embedding.first.col(i).array() *= sqrt(embedding.second(i));
@@ -261,13 +267,15 @@ class ImplementationBase
         if (parameters[eigen_method].is(Dense))
         {
             DenseMatrix distance_matrix_sym = distance_matrix * distance_matrix.transpose();
-            landmarks_embedding = eigendecomposition(parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues,
-                                                     distance_matrix_sym, parameters[target_dimension]);
+            landmarks_embedding =
+                eigendecomposition(parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues,
+                                   distance_matrix_sym, parameters[target_dimension]);
         }
         else
         {
-            landmarks_embedding = eigendecomposition(parameters[eigen_method], parameters[computation_strategy], SquaredLargestEigenvalues,
-                                                     distance_matrix, parameters[target_dimension]);
+            landmarks_embedding =
+                eigendecomposition(parameters[eigen_method], parameters[computation_strategy],
+                                   SquaredLargestEigenvalues, distance_matrix, parameters[target_dimension]);
         }
 
         DenseMatrix embedding = distance_matrix.transpose() * landmarks_embedding.first;
@@ -284,9 +292,9 @@ class ImplementationBase
             linear_weight_matrix(begin, end, neighbors, kernel, parameters[nullspace_shift], parameters[klle_shift]);
         DenseSymmetricMatrixPair eig_matrices =
             construct_neighborhood_preserving_eigenproblem(weight_matrix, begin, end, features, current_dimension);
-        EigendecompositionResult projection_result =
-            generalized_eigendecomposition(parameters[eigen_method], parameters[computation_strategy], SmallestEigenvalues,
-                                           eig_matrices.first, eig_matrices.second, parameters[target_dimension]);
+        EigendecompositionResult projection_result = generalized_eigendecomposition(
+            parameters[eigen_method], parameters[computation_strategy], SmallestEigenvalues, eig_matrices.first,
+            eig_matrices.second, parameters[target_dimension]);
         DenseVector mean_vector = compute_mean(begin, end, features, current_dimension);
         tapkee::ProjectingFunction projecting_function(
             new tapkee::MatrixProjectionImplementation(projection_result.first, mean_vector));
@@ -297,9 +305,10 @@ class ImplementationBase
     TapkeeOutput embedHessianLocallyLinearEmbedding()
     {
         Neighbors neighbors = findNeighborsWith(kernel_distance);
-        SparseWeightMatrix weight_matrix = hessian_weight_matrix(begin, end, neighbors, kernel, parameters[target_dimension]);
-        return TapkeeOutput(eigendecomposition(parameters[eigen_method], parameters[computation_strategy], SmallestEigenvalues,
-                                               weight_matrix, parameters[target_dimension])
+        SparseWeightMatrix weight_matrix =
+            hessian_weight_matrix(begin, end, neighbors, kernel, parameters[target_dimension]);
+        return TapkeeOutput(eigendecomposition(parameters[eigen_method], parameters[computation_strategy],
+                                               SmallestEigenvalues, weight_matrix, parameters[target_dimension])
                                 .first,
                             unimplementedProjectingFunction());
     }
@@ -308,8 +317,9 @@ class ImplementationBase
     {
         Neighbors neighbors = findNeighborsWith(plain_distance);
         Laplacian laplacian = compute_laplacian(begin, end, neighbors, distance, parameters[gaussian_kernel_width]);
-        return TapkeeOutput(generalized_eigendecomposition(parameters[eigen_method], parameters[computation_strategy], SmallestEigenvalues,
-                                                           laplacian.first, laplacian.second, parameters[target_dimension])
+        return TapkeeOutput(generalized_eigendecomposition(parameters[eigen_method], parameters[computation_strategy],
+                                                           SmallestEigenvalues, laplacian.first, laplacian.second,
+                                                           parameters[target_dimension])
                                 .first,
                             unimplementedProjectingFunction());
     }
@@ -321,8 +331,8 @@ class ImplementationBase
         DenseSymmetricMatrixPair eigenproblem_matrices = construct_locality_preserving_eigenproblem(
             laplacian.first, laplacian.second, begin, end, features, current_dimension);
         EigendecompositionResult projection_result = generalized_eigendecomposition(
-            parameters[eigen_method], parameters[computation_strategy], SmallestEigenvalues, eigenproblem_matrices.first,
-            eigenproblem_matrices.second, parameters[target_dimension]);
+            parameters[eigen_method], parameters[computation_strategy], SmallestEigenvalues,
+            eigenproblem_matrices.first, eigenproblem_matrices.second, parameters[target_dimension]);
         DenseVector mean_vector = compute_mean(begin, end, features, current_dimension);
         tapkee::ProjectingFunction projecting_function(
             new tapkee::MatrixProjectionImplementation(projection_result.first, mean_vector));
@@ -335,8 +345,9 @@ class ImplementationBase
         DenseVector mean_vector = compute_mean(begin, end, features, current_dimension);
         DenseSymmetricMatrix centered_covariance_matrix =
             compute_covariance_matrix(begin, end, mean_vector, features, current_dimension);
-        EigendecompositionResult projection_result = eigendecomposition(
-            parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues, centered_covariance_matrix, parameters[target_dimension]);
+        EigendecompositionResult projection_result =
+            eigendecomposition(parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues,
+                               centered_covariance_matrix, parameters[target_dimension]);
         tapkee::ProjectingFunction projecting_function(
             new tapkee::MatrixProjectionImplementation(projection_result.first, mean_vector));
         return TapkeeOutput(project(projection_result.first, mean_vector, begin, end, features, current_dimension),
@@ -357,8 +368,9 @@ class ImplementationBase
     TapkeeOutput embedKernelPCA()
     {
         DenseSymmetricMatrix centered_kernel_matrix = compute_centered_kernel_matrix(begin, end, kernel);
-        EigendecompositionResult embedding = eigendecomposition(
-            parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues, centered_kernel_matrix, parameters[target_dimension]);
+        EigendecompositionResult embedding =
+            eigendecomposition(parameters[eigen_method], parameters[computation_strategy], LargestEigenvalues,
+                               centered_kernel_matrix, parameters[target_dimension]);
         for (IndexType i = 0; i < static_cast<IndexType>(parameters[target_dimension]); i++)
             embedding.first.col(i).array() *= sqrt(embedding.second(i));
         return TapkeeOutput(embedding.first, unimplementedProjectingFunction());
@@ -367,13 +379,13 @@ class ImplementationBase
     TapkeeOutput embedLinearLocalTangentSpaceAlignment()
     {
         Neighbors neighbors = findNeighborsWith(kernel_distance);
-        SparseWeightMatrix weight_matrix =
-            tangent_weight_matrix(begin, end, neighbors, kernel, parameters[target_dimension], parameters[nullspace_shift]);
+        SparseWeightMatrix weight_matrix = tangent_weight_matrix(
+            begin, end, neighbors, kernel, parameters[target_dimension], parameters[nullspace_shift]);
         DenseSymmetricMatrixPair eig_matrices =
             construct_lltsa_eigenproblem(weight_matrix, begin, end, features, current_dimension);
-        EigendecompositionResult projection_result =
-            generalized_eigendecomposition(parameters[eigen_method], parameters[computation_strategy], SmallestEigenvalues,
-                                           eig_matrices.first, eig_matrices.second, parameters[target_dimension]);
+        EigendecompositionResult projection_result = generalized_eigendecomposition(
+            parameters[eigen_method], parameters[computation_strategy], SmallestEigenvalues, eig_matrices.first,
+            eig_matrices.second, parameters[target_dimension]);
         DenseVector mean_vector = compute_mean(begin, end, features, current_dimension);
         tapkee::ProjectingFunction projecting_function(
             new tapkee::MatrixProjectionImplementation(projection_result.first, mean_vector));
@@ -389,8 +401,9 @@ class ImplementationBase
             neighbors = findNeighborsWith(plain_distance);
         }
 
-        return TapkeeOutput(spe_embedding(begin, end, distance, neighbors, parameters[target_dimension], parameters[spe_global_strategy],
-                                          parameters[spe_tolerance], parameters[spe_num_updates], parameters[max_iteration]),
+        return TapkeeOutput(spe_embedding(begin, end, distance, neighbors, parameters[target_dimension],
+                                          parameters[spe_global_strategy], parameters[spe_tolerance],
+                                          parameters[spe_num_updates], parameters[max_iteration]),
                             unimplementedProjectingFunction());
     }
 
@@ -403,8 +416,8 @@ class ImplementationBase
     TapkeeOutput embedFactorAnalysis()
     {
         DenseVector mean_vector = compute_mean(begin, end, features, current_dimension);
-        return TapkeeOutput(project(begin, end, features, current_dimension, parameters[max_iteration], parameters[fa_epsilon],
-                                    parameters[target_dimension], mean_vector),
+        return TapkeeOutput(project(begin, end, features, current_dimension, parameters[max_iteration],
+                                    parameters[fa_epsilon], parameters[target_dimension], mean_vector),
                             unimplementedProjectingFunction());
     }
 
@@ -416,7 +429,8 @@ class ImplementationBase
 
         DenseMatrix embedding(static_cast<IndexType>(parameters[target_dimension]), n_vectors);
         tsne::TSNE tsne;
-        tsne.run(data, data.cols(), data.rows(), embedding.data(), parameters[target_dimension], parameters[sne_perplexity], parameters[sne_theta]);
+        tsne.run(data, data.cols(), data.rows(), embedding.data(), parameters[target_dimension],
+                 parameters[sne_perplexity], parameters[sne_theta]);
 
         return TapkeeOutput(embedding.transpose(), unimplementedProjectingFunction());
     }
@@ -429,8 +443,8 @@ class ImplementationBase
 
         Neighbors neighbors = findNeighborsWith(plain_distance);
 
-        manifold_sculpting_embed(begin, end, embedding, parameters[target_dimension], neighbors, distance, parameters[max_iteration],
-                                 parameters[squishing_rate]);
+        manifold_sculpting_embed(begin, end, embedding, parameters[target_dimension], neighbors, distance,
+                                 parameters[max_iteration], parameters[squishing_rate]);
 
         return TapkeeOutput(embedding, unimplementedProjectingFunction());
     }
diff --git a/include/tapkee/neighbors/covertree.hpp b/include/tapkee/neighbors/covertree.hpp
index 3f4da9b..62e9c53 100644
--- a/include/tapkee/neighbors/covertree.hpp
+++ b/include/tapkee/neighbors/covertree.hpp
@@ -9,8 +9,8 @@
 #pragma once
 
 /* Tapkee includes */
-#include <tapkee/neighbors/covertree_point.hpp>
 #include <tapkee/neighbors/covertree/structures.hpp>
+#include <tapkee/neighbors/covertree_point.hpp>
 /* End of Tapkee includes */
 
 #include <assert.h>
@@ -27,107 +27,97 @@ namespace tapkee
 namespace tapkee_internal
 {
 
-template <class P, class DistanceCallback>
-class CoverTreeWrapper
+template <class P, class DistanceCallback> class CoverTreeWrapper
 {
-    public:
-        CoverTreeWrapper() :
-            base(COVERTREE_BASE),
-            il2(1. / log(base)),
-            internal_k(1)
-        {
-
-        }
+  public:
+    CoverTreeWrapper() : base(COVERTREE_BASE), il2(1. / log(base)), internal_k(1)
+    {
+    }
 
-        void split(v_array<ds_node<P>>& point_set, v_array<ds_node<P>>& far_set, int max_scale);
+    void split(v_array<ds_node<P>>& point_set, v_array<ds_node<P>>& far_set, int max_scale);
 
-        void dist_split(DistanceCallback& dcb, v_array<ds_node<P>>& point_set, v_array<ds_node<P>>& new_point_set, P new_point, int max_scale);
+    void dist_split(DistanceCallback& dcb, v_array<ds_node<P>>& point_set, v_array<ds_node<P>>& new_point_set,
+                    P new_point, int max_scale);
 
-        node<P> batch_insert(DistanceCallback& dcb, const P& p, int max_scale, int top_scale, v_array<ds_node<P>>& point_set,
-                     v_array<ds_node<P>>& consumed_set, v_array<v_array<ds_node<P>>>& stack);
+    node<P> batch_insert(DistanceCallback& dcb, const P& p, int max_scale, int top_scale,
+                         v_array<ds_node<P>>& point_set, v_array<ds_node<P>>& consumed_set,
+                         v_array<v_array<ds_node<P>>>& stack);
 
-        node<P> batch_create(DistanceCallback& dcb, v_array<P> points);
+    node<P> batch_create(DistanceCallback& dcb, v_array<P> points);
 
-        void k_nearest_neighbor(DistanceCallback& dcb, const node<P>& top_node, const node<P>& query, v_array<v_array<P>>& results, int k);
+    void k_nearest_neighbor(DistanceCallback& dcb, const node<P>& top_node, const node<P>& query,
+                            v_array<v_array<P>>& results, int k);
 
-        void batch_nearest_neighbor(DistanceCallback& dcb, const node<P>& top_node, const node<P>& query, v_array<v_array<P>>& results);
+    void batch_nearest_neighbor(DistanceCallback& dcb, const node<P>& top_node, const node<P>& query,
+                                v_array<v_array<P>>& results);
 
-        void internal_batch_nearest_neighbor(
-            DistanceCallback& dcb, const node<P>* query,
-            v_array<v_array<d_node<P>>>& cover_sets, v_array<d_node<P>>& zero_set,
-            int current_scale, int max_scale, std::vector<ScalarType>& upper_bound,
-            v_array<v_array<P>>& results,
-            v_array<v_array<v_array<d_node<P>>>>& spare_cover_sets,
-            v_array<v_array<d_node<P>>>& spare_zero_sets
-        );
+    void internal_batch_nearest_neighbor(DistanceCallback& dcb, const node<P>* query,
+                                         v_array<v_array<d_node<P>>>& cover_sets, v_array<d_node<P>>& zero_set,
+                                         int current_scale, int max_scale, std::vector<ScalarType>& upper_bound,
+                                         v_array<v_array<P>>& results,
+                                         v_array<v_array<v_array<d_node<P>>>>& spare_cover_sets,
+                                         v_array<v_array<d_node<P>>>& spare_zero_sets);
 
-        void brute_nearest(
-            DistanceCallback& dcb, const node<P>* query, v_array<d_node<P>> zero_set, std::vector<ScalarType>& upper_bound,
-            v_array<v_array<P>>& results, v_array<v_array<d_node<P>>>& spare_zero_sets
-        );
+    void brute_nearest(DistanceCallback& dcb, const node<P>* query, v_array<d_node<P>> zero_set,
+                       std::vector<ScalarType>& upper_bound, v_array<v_array<P>>& results,
+                       v_array<v_array<d_node<P>>>& spare_zero_sets);
 
-        void descend(
-            DistanceCallback& dcb, const node<P>* query, std::vector<ScalarType>& upper_bound, int current_scale,
-            int& max_scale, v_array<v_array<d_node<P>>>& cover_sets, v_array<d_node<P>>& zero_set
-        );
+    void descend(DistanceCallback& dcb, const node<P>* query, std::vector<ScalarType>& upper_bound, int current_scale,
+                 int& max_scale, v_array<v_array<d_node<P>>>& cover_sets, v_array<d_node<P>>& zero_set);
 
-        void copy_cover_sets(
-            DistanceCallback& dcb, const node<P>* query_chi, std::vector<ScalarType>& new_upper_bound,
-            v_array<v_array<d_node<P>>>& cover_sets, v_array<v_array<d_node<P>>>& new_cover_sets,
-            int current_scale, int max_scale
-        );
+    void copy_cover_sets(DistanceCallback& dcb, const node<P>* query_chi, std::vector<ScalarType>& new_upper_bound,
+                         v_array<v_array<d_node<P>>>& cover_sets, v_array<v_array<d_node<P>>>& new_cover_sets,
+                         int current_scale, int max_scale);
 
-        void copy_zero_set(
-            DistanceCallback& dcb, const node<P>* query_chi, std::vector<ScalarType>& new_upper_bound,
-            v_array<d_node<P>>& zero_set, v_array<d_node<P>>& new_zero_set
-        );
+    void copy_zero_set(DistanceCallback& dcb, const node<P>* query_chi, std::vector<ScalarType>& new_upper_bound,
+                       v_array<d_node<P>>& zero_set, v_array<d_node<P>>& new_zero_set);
 
-        v_array<v_array<d_node<P>>> get_cover_sets(v_array<v_array<v_array<d_node<P>>>>& spare_cover_sets);
+    v_array<v_array<d_node<P>>> get_cover_sets(v_array<v_array<v_array<d_node<P>>>>& spare_cover_sets);
 
-        inline ScalarType dist_of_scale(int s)
-        {
-            return pow(base, s);
-        }
+    inline ScalarType dist_of_scale(int s)
+    {
+        return pow(base, s);
+    }
 
-        inline int get_scale(ScalarType d)
-        {
-            return (int)ceil(il2 * log(d));
-        }
+    inline int get_scale(ScalarType d)
+    {
+        return (int)ceil(il2 * log(d));
+    }
 
-        void update(std::vector<ScalarType>& k_upper_bound, ScalarType upper_bound)
+    void update(std::vector<ScalarType>& k_upper_bound, ScalarType upper_bound)
+    {
+        auto end = k_upper_bound.begin() + internal_k - 1;
+        auto begin = k_upper_bound.begin();
+        for (; end != begin; begin++)
         {
-            auto end = k_upper_bound.begin() + internal_k - 1;
-            auto begin = k_upper_bound.begin();
-            for (; end != begin; begin++)
+            if (upper_bound < *(begin + 1))
+                *begin = *(begin + 1);
+            else
             {
-                if (upper_bound < *(begin + 1))
-                    *begin = *(begin + 1);
-                else
-                {
-                    *begin = upper_bound;
-                    break;
-                }
-            }
-            if (end == begin)
                 *begin = upper_bound;
+                break;
+            }
         }
+        if (end == begin)
+            *begin = upper_bound;
+    }
 
-        void setter(std::vector<ScalarType>& vector, ScalarType max)
-        {
-            auto begin = vector.begin();
-            for (auto end = begin + internal_k; end != begin; begin++)
-                *begin = max;
-        }
+    void setter(std::vector<ScalarType>& vector, ScalarType max)
+    {
+        auto begin = vector.begin();
+        for (auto end = begin + internal_k; end != begin; begin++)
+            *begin = max;
+    }
 
-        std::vector<ScalarType> alloc_upper()
-        {
-            return std::vector<ScalarType>(internal_k);
-        }
+    std::vector<ScalarType> alloc_upper()
+    {
+        return std::vector<ScalarType>(internal_k);
+    }
 
-    private:
-        ScalarType base;
-        ScalarType il2;
-        int internal_k;
+  private:
+    ScalarType base;
+    ScalarType il2;
+    int internal_k;
 };
 
 template <class P> ScalarType max_set(v_array<ds_node<P>>& v)
@@ -157,9 +147,8 @@ void CoverTreeWrapper<P, D>::split(v_array<ds_node<P>>& point_set, v_array<ds_no
 }
 
 template <class P, class DistanceCallback>
-void CoverTreeWrapper<P, DistanceCallback>::dist_split(
-    DistanceCallback& dcb, v_array<ds_node<P>>& point_set, v_array<ds_node<P>>& new_point_set, P new_point, int max_scale
-)
+void CoverTreeWrapper<P, DistanceCallback>::dist_split(DistanceCallback& dcb, v_array<ds_node<P>>& point_set,
+                                                       v_array<ds_node<P>>& new_point_set, P new_point, int max_scale)
 {
     IndexType new_index = 0;
     ScalarType fmax = dist_of_scale(max_scale);
@@ -183,10 +172,10 @@ void CoverTreeWrapper<P, DistanceCallback>::dist_split(
    point_set contains points which are 2*max_scale or less away.
    */
 template <class P, class DistanceCallback>
-node<P> CoverTreeWrapper<P, DistanceCallback>::batch_insert(
-    DistanceCallback& dcb, const P& p, int max_scale, int top_scale, v_array<ds_node<P>>& point_set,
-    v_array<ds_node<P>>& consumed_set, v_array<v_array<ds_node<P>>>& stack
-)
+node<P> CoverTreeWrapper<P, DistanceCallback>::batch_insert(DistanceCallback& dcb, const P& p, int max_scale,
+                                                            int top_scale, v_array<ds_node<P>>& point_set,
+                                                            v_array<ds_node<P>>& consumed_set,
+                                                            v_array<v_array<ds_node<P>>>& stack)
 {
     if (size(point_set) == 0)
         return new_leaf(p);
@@ -412,7 +401,8 @@ template <class P> void halfsort(v_array<d_node<P>> cover_set)
 }
 
 template <class P, class D>
-v_array<v_array<d_node<P>>> CoverTreeWrapper<P, D>::get_cover_sets(v_array<v_array<v_array<d_node<P>>>>& spare_cover_sets)
+v_array<v_array<d_node<P>>> CoverTreeWrapper<P, D>::get_cover_sets(
+    v_array<v_array<v_array<d_node<P>>>>& spare_cover_sets)
 {
     v_array<v_array<d_node<P>>> ret = pop(spare_cover_sets);
     while (size(ret) < 101)
@@ -430,10 +420,10 @@ inline bool shell(ScalarType parent_query_dist, ScalarType child_parent_dist, Sc
 }
 
 template <class P, class DistanceCallback>
-void CoverTreeWrapper<P, DistanceCallback>::copy_zero_set(
-    DistanceCallback& dcb, const node<P>* query_chi, std::vector<ScalarType>& new_upper_bound,
-    v_array<d_node<P>>& zero_set, v_array<d_node<P>>& new_zero_set
-)
+void CoverTreeWrapper<P, DistanceCallback>::copy_zero_set(DistanceCallback& dcb, const node<P>* query_chi,
+                                                          std::vector<ScalarType>& new_upper_bound,
+                                                          v_array<d_node<P>>& zero_set,
+                                                          v_array<d_node<P>>& new_zero_set)
 {
     resize(new_zero_set, 0);
     auto end = begin(zero_set) + size(zero_set);
@@ -456,11 +446,11 @@ void CoverTreeWrapper<P, DistanceCallback>::copy_zero_set(
 }
 
 template <class P, class DistanceCallback>
-void CoverTreeWrapper<P, DistanceCallback>::copy_cover_sets(
-    DistanceCallback& dcb, const node<P>* query_chi, std::vector<ScalarType>& new_upper_bound,
-    v_array<v_array<d_node<P>>>& cover_sets, v_array<v_array<d_node<P>>>& new_cover_sets,
-    int current_scale, int max_scale
-)
+void CoverTreeWrapper<P, DistanceCallback>::copy_cover_sets(DistanceCallback& dcb, const node<P>* query_chi,
+                                                            std::vector<ScalarType>& new_upper_bound,
+                                                            v_array<v_array<d_node<P>>>& cover_sets,
+                                                            v_array<v_array<d_node<P>>>& new_cover_sets,
+                                                            int current_scale, int max_scale)
 {
     for (; current_scale <= max_scale; current_scale++)
     {
@@ -497,10 +487,10 @@ void CoverTreeWrapper<P, DistanceCallback>::copy_cover_sets(
    Compute distances in the presence of the tighter upper bound.
    */
 template <class P, class DistanceCallback>
-void CoverTreeWrapper<P, DistanceCallback>::descend(
-    DistanceCallback& dcb, const node<P>* query, std::vector<ScalarType>& upper_bound, int current_scale,
-    int& max_scale, v_array<v_array<d_node<P>>>& cover_sets, v_array<d_node<P>>& zero_set
-)
+void CoverTreeWrapper<P, DistanceCallback>::descend(DistanceCallback& dcb, const node<P>* query,
+                                                    std::vector<ScalarType>& upper_bound, int current_scale,
+                                                    int& max_scale, v_array<v_array<d_node<P>>>& cover_sets,
+                                                    v_array<d_node<P>>& zero_set)
 {
     auto end = begin(cover_sets[current_scale]) + size(cover_sets[current_scale]);
     for (auto parent = begin(cover_sets[current_scale]); parent != end; parent++)
@@ -556,10 +546,11 @@ void CoverTreeWrapper<P, DistanceCallback>::descend(
 }
 
 template <class P, class DistanceCallback>
-void CoverTreeWrapper<P, DistanceCallback>::brute_nearest(
-    DistanceCallback& dcb, const node<P>* query, v_array<d_node<P>> zero_set, std::vector<ScalarType>& upper_bound,
-    v_array<v_array<P>>& results, v_array<v_array<d_node<P>>>& spare_zero_sets
-)
+void CoverTreeWrapper<P, DistanceCallback>::brute_nearest(DistanceCallback& dcb, const node<P>* query,
+                                                          v_array<d_node<P>> zero_set,
+                                                          std::vector<ScalarType>& upper_bound,
+                                                          v_array<v_array<P>>& results,
+                                                          v_array<v_array<d_node<P>>>& spare_zero_sets)
 {
     if (query->num_children > 0)
     {
@@ -592,13 +583,9 @@ void CoverTreeWrapper<P, DistanceCallback>::brute_nearest(
 
 template <class P, class DistanceCallback>
 void CoverTreeWrapper<P, DistanceCallback>::internal_batch_nearest_neighbor(
-    DistanceCallback& dcb, const node<P>* query,
-    v_array<v_array<d_node<P>>>& cover_sets, v_array<d_node<P>>& zero_set,
-    int current_scale, int max_scale, std::vector<ScalarType>& upper_bound,
-    v_array<v_array<P>>& results,
-    v_array<v_array<v_array<d_node<P>>>>& spare_cover_sets,
-    v_array<v_array<d_node<P>>>& spare_zero_sets
-)
+    DistanceCallback& dcb, const node<P>* query, v_array<v_array<d_node<P>>>& cover_sets, v_array<d_node<P>>& zero_set,
+    int current_scale, int max_scale, std::vector<ScalarType>& upper_bound, v_array<v_array<P>>& results,
+    v_array<v_array<v_array<d_node<P>>>>& spare_cover_sets, v_array<v_array<d_node<P>>>& spare_zero_sets)
 {
     if (current_scale > max_scale) // All remaining points are in the zero set.
         brute_nearest(dcb, query, zero_set, upper_bound, results, spare_zero_sets);
@@ -636,9 +623,8 @@ void CoverTreeWrapper<P, DistanceCallback>::internal_batch_nearest_neighbor(
 }
 
 template <class P, class DistanceCallback>
-void CoverTreeWrapper<P, DistanceCallback>::batch_nearest_neighbor(
-    DistanceCallback& dcb, const node<P>& top_node, const node<P>& query, v_array<v_array<P>>& results
-)
+void CoverTreeWrapper<P, DistanceCallback>::batch_nearest_neighbor(DistanceCallback& dcb, const node<P>& top_node,
+                                                                   const node<P>& query, v_array<v_array<P>>& results)
 {
     v_array<v_array<v_array<d_node<P>>>> spare_cover_sets;
     v_array<v_array<d_node<P>>> spare_zero_sets;
@@ -669,9 +655,9 @@ void CoverTreeWrapper<P, DistanceCallback>::batch_nearest_neighbor(
 }
 
 template <class P, class DistanceCallback>
-void CoverTreeWrapper<P, DistanceCallback>::k_nearest_neighbor(
-    DistanceCallback& dcb, const node<P>& top_node, const node<P>& query, v_array<v_array<P>>& results, int k
-)
+void CoverTreeWrapper<P, DistanceCallback>::k_nearest_neighbor(DistanceCallback& dcb, const node<P>& top_node,
+                                                               const node<P>& query, v_array<v_array<P>>& results,
+                                                               int k)
 {
     internal_k = k;
     batch_nearest_neighbor(dcb, top_node, query, results);
diff --git a/include/tapkee/neighbors/covertree/structures.hpp b/include/tapkee/neighbors/covertree/structures.hpp
index 7b4ce47..3e8064f 100644
--- a/include/tapkee/neighbors/covertree/structures.hpp
+++ b/include/tapkee/neighbors/covertree/structures.hpp
@@ -31,8 +31,8 @@ template <class P> struct node
     {
     }
 
-    node(P _p, ScalarType _max_dist, ScalarType _parent_dist, std::vector<node<P>> _children, unsigned short int _num_children,
-         short int _scale)
+    node(P _p, ScalarType _max_dist, ScalarType _parent_dist, std::vector<node<P>> _children,
+         unsigned short int _num_children, short int _scale)
         : p(_p), max_dist(_max_dist), parent_dist(_parent_dist), children(_children), num_children(_num_children),
           scale(_scale)
     {
@@ -104,5 +104,5 @@ template <class P> node<P> new_leaf(const P& p)
     return new_leaf;
 }
 
-}
-}
+} // namespace tapkee_internal
+} // namespace tapkee
diff --git a/include/tapkee/neighbors/neighbors.hpp b/include/tapkee/neighbors/neighbors.hpp
index 5077e31..5883ecc 100644
--- a/include/tapkee/neighbors/neighbors.hpp
+++ b/include/tapkee/neighbors/neighbors.hpp
@@ -196,14 +196,16 @@ Neighbors find_neighbors(NeighborsMethod method, const RandomAccessIterator& beg
     {
         const std::string message = fmt::format("The neighborhood graph with {} neighbors "
                                                 "is not connected. Recomputing with a "
-                                                "larger number of neighbors {}.", k, 2 *k);
+                                                "larger number of neighbors {}.",
+                                                k, 2 * k);
         LoggingSingleton::instance().message_warning(message);
         neighbors = find_neighbors(method, begin, end, callback, 2 * k, check_connectivity);
     }
     else
     {
         const std::string message = fmt::format("The neighborhood graph with {} neighbors "
-                                                "is connected.", k);
+                                                "is connected.",
+                                                k);
         LoggingSingleton::instance().message_info(message);
     }
     return neighbors;
diff --git a/include/tapkee/predicates.hpp b/include/tapkee/predicates.hpp
index 9f8cd66..bb9ad0c 100644
--- a/include/tapkee/predicates.hpp
+++ b/include/tapkee/predicates.hpp
@@ -71,5 +71,5 @@ template <typename T> struct InClosedRange
     }
 };
 
-}
-}
+} // namespace tapkee_internal
+} // namespace tapkee