diff --git a/.clang-format b/.clang-format
index b3961d1f9..6182f4559 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,3 +1,7 @@
 Language: Cpp
+Standard: c++20
 BasedOnStyle: Google
 ColumnLimit: 120
+UseTab: Never
+QualifierAlignment: Left
+PointerAlignment: Right
diff --git a/modules/ref/average_of_vector_elements/func_tests/ref_tests.cpp b/modules/ref/average_of_vector_elements/func_tests/ref_tests.cpp
index 73ed0f7d3..ac173edc9 100644
--- a/modules/ref/average_of_vector_elements/func_tests/ref_tests.cpp
+++ b/modules/ref/average_of_vector_elements/func_tests/ref_tests.cpp
@@ -14,9 +14,9 @@ TEST(average_of_vector_elements, check_int32_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -36,9 +36,9 @@ TEST(average_of_vector_elements, check_validate_func) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -54,9 +54,9 @@ TEST(average_of_vector_elements, check_double) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -76,9 +76,9 @@ TEST(average_of_vector_elements, check_uint8_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -98,9 +98,9 @@ TEST(average_of_vector_elements, check_int64_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -120,9 +120,9 @@ TEST(average_of_vector_elements, check_float) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
diff --git a/modules/ref/average_of_vector_elements/include/ref_task.hpp b/modules/ref/average_of_vector_elements/include/ref_task.hpp
index 40e2282da..92ef54f06 100644
--- a/modules/ref/average_of_vector_elements/include/ref_task.hpp
+++ b/modules/ref/average_of_vector_elements/include/ref_task.hpp
@@ -16,7 +16,7 @@ class AverageOfVectorElements : public ppc::core::Task {
   bool PreProcessingImpl() override {
     // Init vectors
     input_ = std::vector<InType>(task_data->inputs_count[0]);
-    auto tmp_ptr = reinterpret_cast<InType*>(task_data->inputs[0]);
+    auto tmp_ptr = reinterpret_cast<InType *>(task_data->inputs[0]);
     for (unsigned i = 0; i < task_data->inputs_count[0]; i++) {
       input_[i] = tmp_ptr[i];
     }
@@ -37,7 +37,7 @@ class AverageOfVectorElements : public ppc::core::Task {
   }
 
   bool PostProcessingImpl() override {
-    reinterpret_cast<OutType*>(task_data->outputs[0])[0] = average_;
+    reinterpret_cast<OutType *>(task_data->outputs[0])[0] = average_;
     return true;
   }
 
diff --git a/modules/ref/max_of_vector_elements/func_tests/ref_tests.cpp b/modules/ref/max_of_vector_elements/func_tests/ref_tests.cpp
index 06f34dc50..af1b4fd25 100644
--- a/modules/ref/max_of_vector_elements/func_tests/ref_tests.cpp
+++ b/modules/ref/max_of_vector_elements/func_tests/ref_tests.cpp
@@ -16,11 +16,11 @@ TEST(max_of_vector_elements, check_int32_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -42,11 +42,11 @@ TEST(max_of_vector_elements, check_validate_func_1) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -63,11 +63,11 @@ TEST(max_of_vector_elements, check_validate_func_2) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -85,11 +85,11 @@ TEST(max_of_vector_elements, check_double) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -111,11 +111,11 @@ TEST(max_of_vector_elements, check_uint8_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -138,11 +138,11 @@ TEST(max_of_vector_elements, check_int64_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -165,11 +165,11 @@ TEST(max_of_vector_elements, check_float) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
diff --git a/modules/ref/max_of_vector_elements/include/ref_task.hpp b/modules/ref/max_of_vector_elements/include/ref_task.hpp
index eeb5b4e2a..2a29fb437 100644
--- a/modules/ref/max_of_vector_elements/include/ref_task.hpp
+++ b/modules/ref/max_of_vector_elements/include/ref_task.hpp
@@ -16,7 +16,7 @@ class MaxOfVectorElements : public ppc::core::Task {
   bool PreProcessingImpl() override {
     // Init vectors
     input_ = std::vector<InOutType>(task_data->inputs_count[0]);
-    auto tmp_ptr = reinterpret_cast<InOutType*>(task_data->inputs[0]);
+    auto tmp_ptr = reinterpret_cast<InOutType *>(task_data->inputs[0]);
     for (unsigned i = 0; i < task_data->inputs_count[0]; i++) {
       input_[i] = tmp_ptr[i];
     }
@@ -44,8 +44,8 @@ class MaxOfVectorElements : public ppc::core::Task {
   }
 
   bool PostProcessingImpl() override {
-    reinterpret_cast<InOutType*>(task_data->outputs[0])[0] = max_;
-    reinterpret_cast<IndexType*>(task_data->outputs[1])[0] = max_index_;
+    reinterpret_cast<InOutType *>(task_data->outputs[0])[0] = max_;
+    reinterpret_cast<IndexType *>(task_data->outputs[1])[0] = max_index_;
     return true;
   }
 
diff --git a/modules/ref/min_of_vector_elements/func_tests/ref_tests.cpp b/modules/ref/min_of_vector_elements/func_tests/ref_tests.cpp
index ec884943c..59b25f648 100644
--- a/modules/ref/min_of_vector_elements/func_tests/ref_tests.cpp
+++ b/modules/ref/min_of_vector_elements/func_tests/ref_tests.cpp
@@ -16,11 +16,11 @@ TEST(min_of_vector_elements, check_int32_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -42,11 +42,11 @@ TEST(min_of_vector_elements, check_validate_func_1) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -63,11 +63,11 @@ TEST(min_of_vector_elements, check_validate_func_2) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -85,11 +85,11 @@ TEST(min_of_vector_elements, check_double) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -111,11 +111,11 @@ TEST(min_of_vector_elements, check_uint8_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -138,11 +138,11 @@ TEST(min_of_vector_elements, check_int64_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -165,11 +165,11 @@ TEST(min_of_vector_elements, check_float) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
diff --git a/modules/ref/min_of_vector_elements/include/ref_task.hpp b/modules/ref/min_of_vector_elements/include/ref_task.hpp
index 38632a055..6c2752c4d 100644
--- a/modules/ref/min_of_vector_elements/include/ref_task.hpp
+++ b/modules/ref/min_of_vector_elements/include/ref_task.hpp
@@ -16,7 +16,7 @@ class MinOfVectorElements : public ppc::core::Task {
   bool PreProcessingImpl() override {
     // Init vectors
     input_ = std::vector<InOutType>(task_data->inputs_count[0]);
-    auto tmp_ptr = reinterpret_cast<InOutType*>(task_data->inputs[0]);
+    auto tmp_ptr = reinterpret_cast<InOutType *>(task_data->inputs[0]);
     for (unsigned i = 0; i < task_data->inputs_count[0]; i++) {
       input_[i] = tmp_ptr[i];
     }
@@ -44,8 +44,8 @@ class MinOfVectorElements : public ppc::core::Task {
   }
 
   bool PostProcessingImpl() override {
-    reinterpret_cast<InOutType*>(task_data->outputs[0])[0] = min_;
-    reinterpret_cast<IndexType*>(task_data->outputs[1])[0] = min_index_;
+    reinterpret_cast<InOutType *>(task_data->outputs[0])[0] = min_;
+    reinterpret_cast<IndexType *>(task_data->outputs[1])[0] = min_index_;
     return true;
   }
 
diff --git a/modules/ref/most_different_neighbor_elements/func_tests/ref_tests.cpp b/modules/ref/most_different_neighbor_elements/func_tests/ref_tests.cpp
index 1abdcb6d2..af25da2b3 100644
--- a/modules/ref/most_different_neighbor_elements/func_tests/ref_tests.cpp
+++ b/modules/ref/most_different_neighbor_elements/func_tests/ref_tests.cpp
@@ -21,11 +21,11 @@ TEST(most_different_neighbor_elements, check_int32_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -49,11 +49,11 @@ TEST(most_different_neighbor_elements, check_validate_func) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -75,11 +75,11 @@ TEST(most_different_neighbor_elements, check_double) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -112,11 +112,11 @@ TEST(most_different_neighbor_elements, check_int8_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -151,11 +151,11 @@ TEST(most_different_neighbor_elements, check_int64_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -184,11 +184,11 @@ TEST(most_different_neighbor_elements, check_float) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
diff --git a/modules/ref/most_different_neighbor_elements/include/ref_task.hpp b/modules/ref/most_different_neighbor_elements/include/ref_task.hpp
index 350fb84a9..04afd28a5 100644
--- a/modules/ref/most_different_neighbor_elements/include/ref_task.hpp
+++ b/modules/ref/most_different_neighbor_elements/include/ref_task.hpp
@@ -16,7 +16,7 @@ class MostDifferentNeighborElements : public ppc::core::Task {
   bool PreProcessingImpl() override {
     // Init vectors
     input_ = std::vector<InOutType>(task_data->inputs_count[0]);
-    auto tmp_ptr = reinterpret_cast<InOutType*>(task_data->inputs[0]);
+    auto tmp_ptr = reinterpret_cast<InOutType *>(task_data->inputs[0]);
     for (unsigned i = 0; i < task_data->inputs_count[0]; i++) {
       input_[i] = tmp_ptr[i];
     }
@@ -50,10 +50,10 @@ class MostDifferentNeighborElements : public ppc::core::Task {
   }
 
   bool PostProcessingImpl() override {
-    reinterpret_cast<InOutType*>(task_data->outputs[0])[0] = l_elem_;
-    reinterpret_cast<InOutType*>(task_data->outputs[0])[1] = r_elem_;
-    reinterpret_cast<IndexType*>(task_data->outputs[1])[0] = l_elem_index_;
-    reinterpret_cast<IndexType*>(task_data->outputs[1])[1] = r_elem_index_;
+    reinterpret_cast<InOutType *>(task_data->outputs[0])[0] = l_elem_;
+    reinterpret_cast<InOutType *>(task_data->outputs[0])[1] = r_elem_;
+    reinterpret_cast<IndexType *>(task_data->outputs[1])[0] = l_elem_index_;
+    reinterpret_cast<IndexType *>(task_data->outputs[1])[1] = r_elem_index_;
     return true;
   }
 
diff --git a/modules/ref/nearest_neighbor_elements/func_tests/ref_tests.cpp b/modules/ref/nearest_neighbor_elements/func_tests/ref_tests.cpp
index 4dd435782..f6d88ebc2 100644
--- a/modules/ref/nearest_neighbor_elements/func_tests/ref_tests.cpp
+++ b/modules/ref/nearest_neighbor_elements/func_tests/ref_tests.cpp
@@ -21,11 +21,11 @@ TEST(nearest_neighbor_elements, check_int32_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -49,11 +49,11 @@ TEST(nearest_neighbor_elements, check_validate_func) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -75,11 +75,11 @@ TEST(nearest_neighbor_elements, check_double) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -112,11 +112,11 @@ TEST(nearest_neighbor_elements, check_int8_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -151,11 +151,11 @@ TEST(nearest_neighbor_elements, check_int64_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
@@ -184,11 +184,11 @@ TEST(nearest_neighbor_elements, check_float) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out_index.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out_index.data()));
   task_data->outputs_count.emplace_back(out_index.size());
 
   // Create Task
diff --git a/modules/ref/nearest_neighbor_elements/include/ref_task.hpp b/modules/ref/nearest_neighbor_elements/include/ref_task.hpp
index 566bf5233..17a28ea89 100644
--- a/modules/ref/nearest_neighbor_elements/include/ref_task.hpp
+++ b/modules/ref/nearest_neighbor_elements/include/ref_task.hpp
@@ -16,7 +16,7 @@ class NearestNeighborElements : public ppc::core::Task {
   bool PreProcessingImpl() override {
     // Init vectors
     input_ = std::vector<InOutType>(task_data->inputs_count[0]);
-    auto tmp_ptr = reinterpret_cast<InOutType*>(task_data->inputs[0]);
+    auto tmp_ptr = reinterpret_cast<InOutType *>(task_data->inputs[0]);
     for (unsigned i = 0; i < task_data->inputs_count[0]; i++) {
       input_[i] = tmp_ptr[i];
     }
@@ -50,10 +50,10 @@ class NearestNeighborElements : public ppc::core::Task {
   }
 
   bool PostProcessingImpl() override {
-    reinterpret_cast<InOutType*>(task_data->outputs[0])[0] = l_elem_;
-    reinterpret_cast<InOutType*>(task_data->outputs[0])[1] = r_elem_;
-    reinterpret_cast<IndexType*>(task_data->outputs[1])[0] = l_elem_index_;
-    reinterpret_cast<IndexType*>(task_data->outputs[1])[1] = r_elem_index_;
+    reinterpret_cast<InOutType *>(task_data->outputs[0])[0] = l_elem_;
+    reinterpret_cast<InOutType *>(task_data->outputs[0])[1] = r_elem_;
+    reinterpret_cast<IndexType *>(task_data->outputs[1])[0] = l_elem_index_;
+    reinterpret_cast<IndexType *>(task_data->outputs[1])[1] = r_elem_index_;
     return true;
   }
 
diff --git a/modules/ref/num_of_alternations_signs/func_tests/ref_tests.cpp b/modules/ref/num_of_alternations_signs/func_tests/ref_tests.cpp
index 4fdd5c87b..ad311c4d7 100644
--- a/modules/ref/num_of_alternations_signs/func_tests/ref_tests.cpp
+++ b/modules/ref/num_of_alternations_signs/func_tests/ref_tests.cpp
@@ -20,9 +20,9 @@ TEST(num_of_alternations_signs, check_int32_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -41,9 +41,9 @@ TEST(num_of_alternations_signs, check_validate_func) {
   std::vector<int32_t> out(2, 0);
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
   // Create Task
   ppc::reference::NumOfAlternationsSigns<int32_t, uint64_t> test_task(task_data);
@@ -61,9 +61,9 @@ TEST(num_of_alternations_signs, check_double) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -83,9 +83,9 @@ TEST(num_of_alternations_signs, check_int8_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -108,9 +108,9 @@ TEST(num_of_alternations_signs, check_int64_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -131,9 +131,9 @@ TEST(num_of_alternations_signs, check_float) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
diff --git a/modules/ref/num_of_alternations_signs/include/ref_task.hpp b/modules/ref/num_of_alternations_signs/include/ref_task.hpp
index 85c7b7077..0599a6a06 100644
--- a/modules/ref/num_of_alternations_signs/include/ref_task.hpp
+++ b/modules/ref/num_of_alternations_signs/include/ref_task.hpp
@@ -17,7 +17,7 @@ class NumOfAlternationsSigns : public ppc::core::Task {
   bool PreProcessingImpl() override {
     // Init vectors
     input_ = std::vector<InOutType>(task_data->inputs_count[0]);
-    auto tmp_ptr = reinterpret_cast<InOutType*>(task_data->inputs[0]);
+    auto tmp_ptr = reinterpret_cast<InOutType *>(task_data->inputs[0]);
     for (unsigned i = 0; i < task_data->inputs_count[0]; i++) {
       input_[i] = tmp_ptr[i];
     }
@@ -44,7 +44,7 @@ class NumOfAlternationsSigns : public ppc::core::Task {
   }
 
   bool PostProcessingImpl() override {
-    reinterpret_cast<CountType*>(task_data->outputs[0])[0] = num_;
+    reinterpret_cast<CountType *>(task_data->outputs[0])[0] = num_;
     return true;
   }
 
diff --git a/modules/ref/num_of_orderly_violations/func_tests/ref_tests.cpp b/modules/ref/num_of_orderly_violations/func_tests/ref_tests.cpp
index bf9591959..a18d1c866 100644
--- a/modules/ref/num_of_orderly_violations/func_tests/ref_tests.cpp
+++ b/modules/ref/num_of_orderly_violations/func_tests/ref_tests.cpp
@@ -20,9 +20,9 @@ TEST(num_of_orderly_violations, check_int32_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -41,9 +41,9 @@ TEST(num_of_orderly_violations, check_validate_func) {
   std::vector<int32_t> out(2, 0);
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
   // Create Task
   ppc::reference::NumOfOrderlyViolations<int32_t, uint64_t> test_task(task_data);
@@ -61,9 +61,9 @@ TEST(num_of_orderly_violations, check_double) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -83,9 +83,9 @@ TEST(num_of_orderly_violations, check_int8_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -108,9 +108,9 @@ TEST(num_of_orderly_violations, check_int64_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -131,9 +131,9 @@ TEST(num_of_orderly_violations, check_float) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
diff --git a/modules/ref/num_of_orderly_violations/include/ref_task.hpp b/modules/ref/num_of_orderly_violations/include/ref_task.hpp
index 6301c5d4e..261f260c4 100644
--- a/modules/ref/num_of_orderly_violations/include/ref_task.hpp
+++ b/modules/ref/num_of_orderly_violations/include/ref_task.hpp
@@ -16,7 +16,7 @@ class NumOfOrderlyViolations : public ppc::core::Task {
   bool PreProcessingImpl() override {
     // Init vectors
     input_ = std::vector<InOutType>(task_data->inputs_count[0]);
-    auto tmp_ptr = reinterpret_cast<InOutType*>(task_data->inputs[0]);
+    auto tmp_ptr = reinterpret_cast<InOutType *>(task_data->inputs[0]);
     for (unsigned i = 0; i < task_data->inputs_count[0]; i++) {
       input_[i] = tmp_ptr[i];
     }
@@ -44,7 +44,7 @@ class NumOfOrderlyViolations : public ppc::core::Task {
   }
 
   bool PostProcessingImpl() override {
-    reinterpret_cast<CountType*>(task_data->outputs[0])[0] = num_;
+    reinterpret_cast<CountType *>(task_data->outputs[0])[0] = num_;
     return true;
   }
 
diff --git a/modules/ref/sum_of_vector_elements/func_tests/ref_tests.cpp b/modules/ref/sum_of_vector_elements/func_tests/ref_tests.cpp
index fa24db952..6375cda41 100644
--- a/modules/ref/sum_of_vector_elements/func_tests/ref_tests.cpp
+++ b/modules/ref/sum_of_vector_elements/func_tests/ref_tests.cpp
@@ -13,9 +13,9 @@ TEST(sum_of_vector_elements, check_int32_t) {
   std::vector<int32_t> out(1, 0);
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
   // Create Task
   ppc::reference::SumOfVectorElements<int32_t> test_task(task_data);
@@ -33,9 +33,9 @@ TEST(sum_of_vector_elements, check_validate_func) {
   std::vector<int32_t> out(2, 0);
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
   // Create Task
   ppc::reference::SumOfVectorElements<int32_t> test_task(task_data);
@@ -49,9 +49,9 @@ TEST(sum_of_vector_elements, check_double) {
   std::vector<double> out(1, 0);
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
   // Create Task
   ppc::reference::SumOfVectorElements<double> test_task(task_data);
@@ -69,9 +69,9 @@ TEST(sum_of_vector_elements, check_uint8_t) {
   std::vector<uint8_t> out(1, 0);
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
   // Create Task
   ppc::reference::SumOfVectorElements<uint8_t> test_task(task_data);
@@ -89,9 +89,9 @@ TEST(sum_of_vector_elements, check_int64_t) {
   std::vector<int64_t> out(1, 0);
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
   // Create Task
   ppc::reference::SumOfVectorElements<int64_t> test_task(task_data);
@@ -109,9 +109,9 @@ TEST(sum_of_vector_elements, check_float) {
   std::vector<float> out(1, 0.F);
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
   // Create Task
   ppc::reference::SumOfVectorElements<float> test_task(task_data);
diff --git a/modules/ref/sum_of_vector_elements/include/ref_task.hpp b/modules/ref/sum_of_vector_elements/include/ref_task.hpp
index de612dda1..6fa890657 100644
--- a/modules/ref/sum_of_vector_elements/include/ref_task.hpp
+++ b/modules/ref/sum_of_vector_elements/include/ref_task.hpp
@@ -15,7 +15,7 @@ class SumOfVectorElements : public ppc::core::Task {
   bool PreProcessingImpl() override {
     // Init vectors
     input_ = std::vector<InOutType>(task_data->inputs_count[0]);
-    auto tmp_ptr = reinterpret_cast<InOutType*>(task_data->inputs[0]);
+    auto tmp_ptr = reinterpret_cast<InOutType *>(task_data->inputs[0]);
     for (unsigned i = 0; i < task_data->inputs_count[0]; i++) {
       input_[i] = tmp_ptr[i];
     }
@@ -35,7 +35,7 @@ class SumOfVectorElements : public ppc::core::Task {
   }
 
   bool PostProcessingImpl() override {
-    reinterpret_cast<InOutType*>(task_data->outputs[0])[0] = sum_;
+    reinterpret_cast<InOutType *>(task_data->outputs[0])[0] = sum_;
     return true;
   }
 
diff --git a/modules/ref/sum_values_by_rows_matrix/func_tests/ref_tests.cpp b/modules/ref/sum_values_by_rows_matrix/func_tests/ref_tests.cpp
index 70d3337e2..df01adda4 100644
--- a/modules/ref/sum_values_by_rows_matrix/func_tests/ref_tests.cpp
+++ b/modules/ref/sum_values_by_rows_matrix/func_tests/ref_tests.cpp
@@ -16,11 +16,11 @@ TEST(sum_values_by_rows_matrix, check_int32_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in_index.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in_index.data()));
   task_data->inputs_count.emplace_back(in_index.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -43,11 +43,11 @@ TEST(sum_values_by_rows_matrix, check_validate_func1) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in_index.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in_index.data()));
   task_data->inputs_count.emplace_back(in_index.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -64,11 +64,11 @@ TEST(sum_values_by_rows_matrix, check_validate_func2) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in_index.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in_index.data()));
   task_data->inputs_count.emplace_back(in_index.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -85,11 +85,11 @@ TEST(sum_values_by_rows_matrix, check_double) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in_index.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in_index.data()));
   task_data->inputs_count.emplace_back(in_index.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -115,11 +115,11 @@ TEST(sum_values_by_rows_matrix, check_int8_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in_index.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in_index.data()));
   task_data->inputs_count.emplace_back(in_index.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -145,11 +145,11 @@ TEST(sum_values_by_rows_matrix, check_int64_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in_index.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in_index.data()));
   task_data->inputs_count.emplace_back(in_index.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -176,11 +176,11 @@ TEST(sum_values_by_rows_matrix, check_float) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   task_data->inputs_count.emplace_back(in.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in_index.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in_index.data()));
   task_data->inputs_count.emplace_back(in_index.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
diff --git a/modules/ref/sum_values_by_rows_matrix/include/ref_task.hpp b/modules/ref/sum_values_by_rows_matrix/include/ref_task.hpp
index 5175e66b5..ab7412037 100644
--- a/modules/ref/sum_values_by_rows_matrix/include/ref_task.hpp
+++ b/modules/ref/sum_values_by_rows_matrix/include/ref_task.hpp
@@ -17,12 +17,12 @@ class SumValuesByRowsMatrix : public ppc::core::Task {
   bool PreProcessingImpl() override {
     // Init vectors
     input_ = std::vector<InOutType>(task_data->inputs_count[0]);
-    auto tmp_ptr = reinterpret_cast<InOutType*>(task_data->inputs[0]);
+    auto tmp_ptr = reinterpret_cast<InOutType *>(task_data->inputs[0]);
     for (unsigned i = 0; i < task_data->inputs_count[0]; i++) {
       input_[i] = tmp_ptr[i];
     }
-    rows_ = reinterpret_cast<IndexType*>(task_data->inputs[1])[0];
-    cols_ = reinterpret_cast<IndexType*>(task_data->inputs[1])[1];
+    rows_ = reinterpret_cast<IndexType *>(task_data->inputs[1])[0];
+    cols_ = reinterpret_cast<IndexType *>(task_data->inputs[1])[1];
 
     // Init value for output
     sum_ = std::vector<InOutType>(cols_, 0.F);
@@ -32,7 +32,7 @@ class SumValuesByRowsMatrix : public ppc::core::Task {
   bool ValidationImpl() override {
     // Check count elements of output
     return static_cast<bool>(task_data->inputs_count[1] == 2 &&
-                             task_data->outputs_count[0] == reinterpret_cast<IndexType*>(task_data->inputs[1])[0]);
+                             task_data->outputs_count[0] == reinterpret_cast<IndexType *>(task_data->inputs[1])[0]);
   }
 
   bool RunImpl() override {
@@ -44,7 +44,7 @@ class SumValuesByRowsMatrix : public ppc::core::Task {
 
   bool PostProcessingImpl() override {
     for (IndexType i = 0; i < rows_; i++) {
-      reinterpret_cast<InOutType*>(task_data->outputs[0])[i] = sum_[i];
+      reinterpret_cast<InOutType *>(task_data->outputs[0])[i] = sum_[i];
     }
     return true;
   }
diff --git a/modules/ref/vector_dot_product/func_tests/ref_tests.cpp b/modules/ref/vector_dot_product/func_tests/ref_tests.cpp
index a09f7fe43..64d10d7a0 100644
--- a/modules/ref/vector_dot_product/func_tests/ref_tests.cpp
+++ b/modules/ref/vector_dot_product/func_tests/ref_tests.cpp
@@ -21,11 +21,11 @@ TEST(vector_dot_product, check_int32_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in1.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in1.data()));
   task_data->inputs_count.emplace_back(in1.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in2.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in2.data()));
   task_data->inputs_count.emplace_back(in2.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -46,11 +46,11 @@ TEST(vector_dot_product, check_validate_func) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in1.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in1.data()));
   task_data->inputs_count.emplace_back(in1.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in2.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in2.data()));
   task_data->inputs_count.emplace_back(in2.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -67,11 +67,11 @@ TEST(vector_dot_product, check_validate_func_2) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in1.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in1.data()));
   task_data->inputs_count.emplace_back(in1.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in2.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in2.data()));
   task_data->inputs_count.emplace_back(in2.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -88,11 +88,11 @@ TEST(vector_dot_product, check_double) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in1.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in1.data()));
   task_data->inputs_count.emplace_back(in1.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in2.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in2.data()));
   task_data->inputs_count.emplace_back(in2.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -116,11 +116,11 @@ TEST(vector_dot_product, check_int8_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in1.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in1.data()));
   task_data->inputs_count.emplace_back(in1.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in2.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in2.data()));
   task_data->inputs_count.emplace_back(in2.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -146,11 +146,11 @@ TEST(vector_dot_product, check_int64_t) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in1.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in1.data()));
   task_data->inputs_count.emplace_back(in1.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in2.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in2.data()));
   task_data->inputs_count.emplace_back(in2.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
@@ -171,11 +171,11 @@ TEST(vector_dot_product, check_float) {
 
   // Create task_data
   auto task_data = std::make_shared<ppc::core::TaskData>();
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in1.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in1.data()));
   task_data->inputs_count.emplace_back(in1.size());
-  task_data->inputs.emplace_back(reinterpret_cast<uint8_t*>(in2.data()));
+  task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in2.data()));
   task_data->inputs_count.emplace_back(in2.size());
-  task_data->outputs.emplace_back(reinterpret_cast<uint8_t*>(out.data()));
+  task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
   task_data->outputs_count.emplace_back(out.size());
 
   // Create Task
diff --git a/modules/ref/vector_dot_product/include/ref_task.hpp b/modules/ref/vector_dot_product/include/ref_task.hpp
index 03a69d9e2..e4a4559fd 100644
--- a/modules/ref/vector_dot_product/include/ref_task.hpp
+++ b/modules/ref/vector_dot_product/include/ref_task.hpp
@@ -16,10 +16,10 @@ class VectorDotProduct : public ppc::core::Task {
   explicit VectorDotProduct(ppc::core::TaskDataPtr task_data) : Task(task_data) {}
   bool PreProcessingImpl() override {
     // Init vectors
-    input_ = std::vector<std::vector<InOutType> >(2);
+    input_ = std::vector<std::vector<InOutType>>(2);
     for (size_t i = 0; i < input_.size(); i++) {
       input_[i] = std::vector<InOutType>(task_data->inputs_count[i]);
-      auto tmp_ptr = reinterpret_cast<InOutType*>(task_data->inputs[i]);
+      auto tmp_ptr = reinterpret_cast<InOutType *>(task_data->inputs[i]);
       for (unsigned j = 0; j < task_data->inputs_count[i]; j++) {
         input_[i][j] = tmp_ptr[j];
       }
@@ -41,12 +41,12 @@ class VectorDotProduct : public ppc::core::Task {
   }
 
   bool PostProcessingImpl() override {
-    reinterpret_cast<InOutType*>(task_data->outputs[0])[0] = dor_product_;
+    reinterpret_cast<InOutType *>(task_data->outputs[0])[0] = dor_product_;
     return true;
   }
 
  private:
-  std::vector<std::vector<InOutType> > input_;
+  std::vector<std::vector<InOutType>> input_;
   InOutType dor_product_;
 };