chore : formatted cpp files

include/aidge/backend/cpu.hpp

@@ -19,13 +19,12 @@
 
 #include "aidge/backend/cpu/operator/ArgMaxImpl.hpp"
 #include "aidge/backend/cpu/operator/AvgPoolingImpl.hpp"
-#include "aidge/backend/cpu/operator/MaxPoolingImpl.hpp"
 #include "aidge/backend/cpu/operator/BatchNormImpl.hpp"
 #include "aidge/backend/cpu/operator/BitShiftImpl.hpp"
 #include "aidge/backend/cpu/operator/ClipImpl.hpp"
+#include "aidge/backend/cpu/operator/ConstantOfShapeImpl.hpp"
 #include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp"
 #include "aidge/backend/cpu/operator/ConvImpl.hpp"
-#include "aidge/backend/cpu/operator/ConstantOfShapeImpl.hpp"
 #include "aidge/backend/cpu/operator/DivImpl.hpp"
 #include "aidge/backend/cpu/operator/ErfImpl.hpp"
 #include "aidge/backend/cpu/operator/FCImpl.hpp"
@@ -34,21 +33,21 @@
 #include "aidge/backend/cpu/operator/LeakyReLUImpl.hpp"
 #include "aidge/backend/cpu/operator/LnImpl.hpp"
 #include "aidge/backend/cpu/operator/MatMulImpl.hpp"
+#include "aidge/backend/cpu/operator/MaxPoolingImpl.hpp"
 #include "aidge/backend/cpu/operator/MulImpl.hpp"
 #include "aidge/backend/cpu/operator/PadImpl.hpp"
 #include "aidge/backend/cpu/operator/PowImpl.hpp"
+#include "aidge/backend/cpu/operator/ReLUImpl.hpp"
 #include "aidge/backend/cpu/operator/ReduceMeanImpl.hpp"
 #include "aidge/backend/cpu/operator/ReduceSumImpl.hpp"
-#include "aidge/backend/cpu/operator/ReLUImpl.hpp"
 #include "aidge/backend/cpu/operator/ScalingImpl.hpp"
 #include "aidge/backend/cpu/operator/SigmoidImpl.hpp"
-#include "aidge/backend/cpu/operator/SqrtImpl.hpp"
 #include "aidge/backend/cpu/operator/SliceImpl.hpp"
 #include "aidge/backend/cpu/operator/SoftmaxImpl.hpp"
+#include "aidge/backend/cpu/operator/SqrtImpl.hpp"
 #include "aidge/backend/cpu/operator/SubImpl.hpp"
 #include "aidge/backend/cpu/operator/TanhImpl.hpp"
 
 #include "aidge/backend/cpu/data/TensorImpl.hpp"
 
 #endif /* AIDGE_CPU_IMPORTS_H_ */
-

include/aidge/backend/cpu/data/Broadcasting.hpp

@@ -16,33 +16,43 @@
 
 namespace Aidge {
 
-// Function to broadCast an input dims vector into the same size as an outputDims vector
-
-    /**
-     * @brief  Broadcast an input dims vector into the same size as an outputDims vector
-     * @details The missing dimensions would be completed by 1
-     * @param outputDims The vector of dimensions to follow 
-     * @param dimsToBroadcast The vecotr of dimensions to braodcast
-     * @return std::vector<std::size_t> a broadcasted vector by addding 1 on the missing dimensions.
-     */
-    std::vector<std::size_t> getBroadcastedDims(const std::vector<std::size_t>& outputDims, const std::vector<std::size_t>& dimsToBroadcast);
-
-    /**
-     * @brief Get a vector of indexes along the dimensions vector from a flattened index
-     * @param dimensions The vector of dimensions we want the indexes on
-     * @param idx The flattened index
-     * @return std::vector<std::size_t> vector of indexes along dimensions.
-     */
-    std::vector<std::size_t> getMultiDimIndices(const std::vector<std::size_t>& dimensions, std::size_t idx);
-
-    // Function to get a flattened index from multi-dimensional indices
-    /**
-     * @brief Get a flattened index the dimensions vector from a given vector of indices on a broadcasted vector
-     * @param dimensions The vector of dimensions we want the flattened index on
-     * @param indices The vector of indices we want to flatten
-     * @return std::size_t The flattened index on the dimensions vector
-     */
-    std::size_t getFlattenedIndex(const std::vector<std::size_t>& dimensions, const std::vector<std::size_t>& indices);
+// Function to broadCast an input dims vector into the same size as an
+// outputDims vector
+
+/**
+ * @brief  Broadcast an input dims vector into the same size as an outputDims
+ * vector
+ * @details The missing dimensions would be completed by 1
+ * @param outputDims The vector of dimensions to follow
+ * @param dimsToBroadcast The vecotr of dimensions to braodcast
+ * @return std::vector<std::size_t> a broadcasted vector by addding 1 on the
+ * missing dimensions.
+ */
+std::vector<std::size_t>
+getBroadcastedDims(const std::vector<std::size_t> &outputDims,
+                   const std::vector<std::size_t> &dimsToBroadcast);
+
+/**
+ * @brief Get a vector of indexes along the dimensions vector from a flattened
+ * index
+ * @param dimensions The vector of dimensions we want the indexes on
+ * @param idx The flattened index
+ * @return std::vector<std::size_t> vector of indexes along dimensions.
+ */
+std::vector<std::size_t>
+getMultiDimIndices(const std::vector<std::size_t> &dimensions,
+                   std::size_t idx);
+
+// Function to get a flattened index from multi-dimensional indices
+/**
+ * @brief Get a flattened index the dimensions vector from a given vector of
+ * indices on a broadcasted vector
+ * @param dimensions The vector of dimensions we want the flattened index on
+ * @param indices The vector of indices we want to flatten
+ * @return std::size_t The flattened index on the dimensions vector
+ */
+std::size_t getFlattenedIndex(const std::vector<std::size_t> &dimensions,
+                              const std::vector<std::size_t> &indices);
 
 } // namespace Aidge
 

include/aidge/backend/cpu/operator/AbsImpl.hpp

@@ -21,11 +21,11 @@
 
 namespace Aidge {
 // Operator implementation entry point for the backend
-using AbsImpl_cpu = OperatorImpl_cpu<Abs_Op,
-    void(const std::size_t, const void*, void*)>;
+using AbsImpl_cpu =
+    OperatorImpl_cpu<Abs_Op, void(const std::size_t, const void *, void *)>;
 
 // Implementation entry point registration to Operator
 REGISTRAR(Abs_Op, "cpu", Aidge::AbsImpl_cpu::create);
-}  // namespace Aidge
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_ABSIMPL_H_ */

include/aidge/backend/cpu/operator/AbsImpl_kernels.hpp

@@ -21,11 +21,11 @@
 namespace Aidge {
 template <class I, class O>
 void AbsImpl_cpu_forward_kernel(std::size_t inputLenght,
-                                     const void* input_,
-                                     void* output_) {
+                                const void *input_,
+                                void *output_) {
 
-    const I* input = static_cast<const I*>(input_);
-    O* output = static_cast<O*>(output_);
+    const I *input = static_cast<const I *>(input_);
+    O *output = static_cast<O *>(output_);
 
     for (std::size_t i = 0; i < inputLenght; ++i) {
         output[i] = std::abs(input[i]);
@@ -34,14 +34,20 @@ void AbsImpl_cpu_forward_kernel(std::size_t inputLenght,
 
 // Kernels registration to implementation entry point
 REGISTRAR(AbsImpl_cpu,
-    {DataType::Float32},
-    {ProdConso::inPlaceModel, Aidge::AbsImpl_cpu_forward_kernel<float, float>, nullptr});
+          {DataType::Float32},
+          {ProdConso::inPlaceModel,
+           Aidge::AbsImpl_cpu_forward_kernel<float, float>,
+           nullptr});
 REGISTRAR(AbsImpl_cpu,
-    {DataType::Float64},
-    {ProdConso::inPlaceModel, Aidge::AbsImpl_cpu_forward_kernel<double, double>, nullptr});
+          {DataType::Float64},
+          {ProdConso::inPlaceModel,
+           Aidge::AbsImpl_cpu_forward_kernel<double, double>,
+           nullptr});
 REGISTRAR(AbsImpl_cpu,
-    {DataType::Int32},
-    {ProdConso::inPlaceModel, Aidge::AbsImpl_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr});
-}  // namespace Aidge
+          {DataType::Int32},
+          {ProdConso::inPlaceModel,
+           Aidge::AbsImpl_cpu_forward_kernel<std::int32_t, std::int32_t>,
+           nullptr});
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_ABSIMPL_KERNELS_H_ */

include/aidge/backend/cpu/operator/AddImpl.hpp

@@ -12,8 +12,8 @@
 #ifndef AIDGE_CPU_OPERATOR_ADDIMPL_H_
 #define AIDGE_CPU_OPERATOR_ADDIMPL_H_
 
-#include <cstddef>  // std::size_t
-#include <memory>   // std::unique_ptr, std::make_unique
+#include <cstddef> // std::size_t
+#include <memory>  // std::unique_ptr, std::make_unique
 #include <string>
 #include <vector>
 
@@ -24,11 +24,16 @@
 
 namespace Aidge {
 // Operator implementation entry point for the backend
-using AddImpl_cpu = OperatorImpl_cpu<Add_Op,
-    void(const std::vector<const void*>, const std::vector<std::vector<std::size_t>>&, const std::size_t, const std::vector<std::size_t>&, void*)>;
+using AddImpl_cpu =
+    OperatorImpl_cpu<Add_Op,
+                     void(const std::vector<const void *>,
+                          const std::vector<std::vector<std::size_t>> &,
+                          const std::size_t,
+                          const std::vector<std::size_t> &,
+                          void *)>;
 
 // Implementation entry point registration to Operator
 REGISTRAR(Add_Op, "cpu", Aidge::AddImpl_cpu::create);
-}  // namespace Aidge
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_ADDIMPL_H_ */

include/aidge/backend/cpu/operator/AddImpl_kernels.hpp

@@ -14,7 +14,7 @@
 
 #include "aidge/utils/Registrar.hpp"
 
-#include <cstdint>     // std::int32_t, std::int64_t
+#include <cstdint> // std::int32_t, std::int64_t
 
 #include "aidge/backend/cpu/data/Broadcasting.hpp"
 #include "aidge/backend/cpu/operator/AddImpl.hpp"
@@ -22,38 +22,52 @@
 namespace Aidge {
 
 template <class I, class O>
-void AddImpl_cpu_forward_kernel(const std::vector<const void*> inputs_, const std::vector<std::vector<std::size_t>>& inputDims, const std::size_t outputLength, const std::vector<std::size_t>& outDims, void* output_) {
+void AddImpl_cpu_forward_kernel(
+    const std::vector<const void *> inputs_,
+    const std::vector<std::vector<std::size_t>> &inputDims,
+    const std::size_t outputLength,
+    const std::vector<std::size_t> &outDims,
+    void *output_) {
     // FIXME: missing Add attributes as arguments
-    std::vector<const I*> inputs;
-    for (const auto& input_ : inputs_) {
-        inputs.push_back(static_cast<const I*>(input_));
+    std::vector<const I *> inputs;
+    for (const auto &input_ : inputs_) {
+        inputs.push_back(static_cast<const I *>(input_));
     }
-    O* output = static_cast<O*>(output_);
+    O *output = static_cast<O *>(output_);
 
-	for (std::size_t oIndex = 0; oIndex < outputLength; ++oIndex)
-	{
+    for (std::size_t oIndex = 0; oIndex < outputLength; ++oIndex) {
         output[oIndex] = 0;
-		std::vector<size_t> indexes = getMultiDimIndices(outDims, oIndex);
-		for(std::size_t iIndex = 0; iIndex < inputs.size(); ++iIndex) {
-			std::size_t idx = getFlattenedIndex(inputDims[iIndex], indexes);
+        std::vector<size_t> indexes = getMultiDimIndices(outDims, oIndex);
+        for (std::size_t iIndex = 0; iIndex < inputs.size(); ++iIndex) {
+            std::size_t idx = getFlattenedIndex(inputDims[iIndex], indexes);
             output[oIndex] += inputs[iIndex][idx];
-		}
-	}
+        }
+    }
 }
 
 // Kernels registration to implementation entry point
 REGISTRAR(AddImpl_cpu,
-    {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Float32}},
-    {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<float, float>, nullptr});
+          {ImplSpec::IOSpec{DataType::Any},
+           ImplSpec::IOSpec{DataType::Float32}},
+          {ProdConso::inPlaceModel,
+           Aidge::AddImpl_cpu_forward_kernel<float, float>,
+           nullptr});
 REGISTRAR(AddImpl_cpu,
-    {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Float64}},
-    {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<double, double>, nullptr});
+          {ImplSpec::IOSpec{DataType::Any},
+           ImplSpec::IOSpec{DataType::Float64}},
+          {ProdConso::inPlaceModel,
+           Aidge::AddImpl_cpu_forward_kernel<double, double>,
+           nullptr});
 REGISTRAR(AddImpl_cpu,
-    {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Int32}},
-    {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr});
+          {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Int32}},
+          {ProdConso::inPlaceModel,
+           Aidge::AddImpl_cpu_forward_kernel<std::int32_t, std::int32_t>,
+           nullptr});
 REGISTRAR(AddImpl_cpu,
-    {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Int64}},
-    {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<std::int64_t, std::int64_t>, nullptr});
-}  // namespace Aidge
+          {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Int64}},
+          {ProdConso::inPlaceModel,
+           Aidge::AddImpl_cpu_forward_kernel<std::int64_t, std::int64_t>,
+           nullptr});
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_ADDIMPL_CPU_KERNELS_H_ */
\ No newline at end of file

include/aidge/backend/cpu/operator/AndImpl.hpp

@@ -12,21 +12,26 @@
 #ifndef AIDGE_CPU_OPERATOR_ANDIMPL_H_
 #define AIDGE_CPU_OPERATOR_ANDIMPL_H_
 
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
 #include "aidge/operator/And.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include <memory>
 #include <vector>
 
 namespace Aidge {
 // Operator implementation entry point for the backend
 using AndImpl_cpu = OperatorImpl_cpu<And_Op,
-    void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)>;
+                                     void(const std::vector<std::size_t> &,
+                                          const std::vector<std::size_t> &,
+                                          const std::vector<std::size_t> &,
+                                          const void *,
+                                          const void *,
+                                          void *)>;
 
 // Implementation entry point registration to Operator
 REGISTRAR(And_Op, "cpu", Aidge::AndImpl_cpu::create);
-}  // namespace Aidge
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_ANDIMPL_H_ */

include/aidge/backend/cpu/operator/AndImpl_kernels.hpp

@@ -18,28 +18,27 @@
 
 namespace Aidge {
 template <class I1, class I2, class O>
-void AndImpl_cpu_forward_kernel(const std::vector<std::size_t>& input1Dims,
-                                const std::vector<std::size_t>& input2Dims,
-                                const std::vector<std::size_t>& outputDims,
-                                const void* input1_,
-                                const void* input2_,
-                                void* output_) {
+void AndImpl_cpu_forward_kernel(const std::vector<std::size_t> &input1Dims,
+                                const std::vector<std::size_t> &input2Dims,
+                                const std::vector<std::size_t> &outputDims,
+                                const void *input1_,
+                                const void *input2_,
+                                void *output_) {
 
-    const I1* input_1 = static_cast<const I1*>(input1_);
-    const I2* input_2 = static_cast<const I2*>(input2_);
-    O* output = static_cast<O*>(output_);
+    const I1 *input_1 = static_cast<const I1 *>(input1_);
+    const I2 *input_2 = static_cast<const I2 *>(input2_);
+    O *output = static_cast<O *>(output_);
 
     size_t totalElements = 1;
     for (size_t dimSize : outputDims) {
         totalElements *= dimSize;
     }
 
-	for (std::size_t oIndex = 0; oIndex < totalElements; ++oIndex)
-	{
-		std::vector<size_t> indexes = getMultiDimIndices(outputDims, oIndex);
+    for (std::size_t oIndex = 0; oIndex < totalElements; ++oIndex) {
+        std::vector<size_t> indexes = getMultiDimIndices(outputDims, oIndex);
 
-		std::size_t idx1 = getFlattenedIndex(input1Dims, indexes);
-		std::size_t idx2 = getFlattenedIndex(input2Dims, indexes);
+        std::size_t idx1 = getFlattenedIndex(input1Dims, indexes);
+        std::size_t idx2 = getFlattenedIndex(input2Dims, indexes);
 
         output[oIndex] = static_cast<O>(input_1[idx1] == input_2[idx2]);
     }
@@ -47,17 +46,29 @@ void AndImpl_cpu_forward_kernel(const std::vector<std::size_t>& input1Dims,
 
 // Kernels registration to implementation entry point
 REGISTRAR(AndImpl_cpu,
-    {DataType::Float32},
-    {ProdConso::inPlaceModel, Aidge::AndImpl_cpu_forward_kernel<float, float, float>, nullptr});
+          {DataType::Float32},
+          {ProdConso::inPlaceModel,
+           Aidge::AndImpl_cpu_forward_kernel<float, float, float>,
+           nullptr});
 REGISTRAR(AndImpl_cpu,
-    {DataType::Float64},
-    {ProdConso::inPlaceModel, Aidge::AndImpl_cpu_forward_kernel<double, double, double>, nullptr});
+          {DataType::Float64},
+          {ProdConso::inPlaceModel,
+           Aidge::AndImpl_cpu_forward_kernel<double, double, double>,
+           nullptr});
 REGISTRAR(AndImpl_cpu,
-    {DataType::Int32},
-    {ProdConso::inPlaceModel, Aidge::AndImpl_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t>, nullptr});
+          {DataType::Int32},
+          {ProdConso::inPlaceModel,
+           Aidge::AndImpl_cpu_forward_kernel<std::int32_t,
+                                             std::int32_t,
+                                             std::int32_t>,
+           nullptr});
 REGISTRAR(AndImpl_cpu,
-    {DataType::Int64},
-    {ProdConso::inPlaceModel, Aidge::AndImpl_cpu_forward_kernel<std::int64_t, std::int64_t, std::int64_t>, nullptr});
-}  // namespace Aidge
+          {DataType::Int64},
+          {ProdConso::inPlaceModel,
+           Aidge::AndImpl_cpu_forward_kernel<std::int64_t,
+                                             std::int64_t,
+                                             std::int64_t>,
+           nullptr});
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_ANDIMPL_KERNELS_H_ */

include/aidge/backend/cpu/operator/ArgMaxImpl.hpp

@@ -25,14 +25,14 @@
 namespace Aidge {
 // Operator implementation entry point for the backend
 using ArgMaxImpl_cpu = OperatorImpl_cpu<ArgMax_Op,
-    void(std::int32_t,
-        DimSize_t,
-        const std::vector<DimSize_t>&,
-        const void *,
-        void *)>;
+                                        void(std::int32_t,
+                                             DimSize_t,
+                                             const std::vector<DimSize_t> &,
+                                             const void *,
+                                             void *)>;
 
 // Implementation entry point registration to Operator
 REGISTRAR(ArgMax_Op, "cpu", Aidge::ArgMaxImpl_cpu::create);
-}  // namespace Aidge
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_ARGMAXIMPL_H_ */

include/aidge/backend/cpu/operator/ArgMaxImpl_kernels.hpp

@@ -12,13 +12,13 @@
 #ifndef AIDGE_CPU_OPERATOR_ARGMAXIMPL_KERNELS_H_
 #define AIDGE_CPU_OPERATOR_ARGMAXIMPL_KERNELS_H_
 
-#include <algorithm>   // std::for_each
-#include <cstddef>     // std::size_t
-#include <cstdint>     // std::int32_t
-#include <functional>  //std::multiplies
-#include <numeric>     //std::accumulate
-#include <vector>
+#include <algorithm>  // std::for_each
+#include <cstddef>    // std::size_t
+#include <cstdint>    // std::int32_t
+#include <functional> //std::multiplies
 #include <limits>
+#include <numeric>    //std::accumulate
+#include <vector>
 
 #include "aidge/backend/cpu/operator/ArgMaxImpl.hpp"
 #include "aidge/data/Data.hpp"
@@ -28,13 +28,13 @@
 namespace Aidge {
 template <class I, class O>
 void ArgMaxImpl_cpu_forward_kernel(std::int32_t axis_,
-                                    DimSize_t select_last_index,
-                                    const std::vector<DimSize_t>& inputDims,
-                                    const void* input_,
-                                    void* output_) {
+                                   DimSize_t select_last_index,
+                                   const std::vector<DimSize_t> &inputDims,
+                                   const void *input_,
+                                   void *output_) {
 
-    const I* input = static_cast<const I*>(input_);
-    O* output = static_cast<O*>(output_);
+    const I *input = static_cast<const I *>(input_);
+    O *output = static_cast<O *>(output_);
 
     const std::size_t axis = static_cast<std::size_t>(axis_);
 
@@ -53,14 +53,13 @@ void ArgMaxImpl_cpu_forward_kernel(std::int32_t axis_,
             const std::size_t idx_o = pre * stride_post + post;
             I max = std::numeric_limits<I>::min();
             for (std::size_t i = 0; i < dim_i; ++i) {
-                I curr_value = input[idx_i + i*stride_post];
+                I curr_value = input[idx_i + i * stride_post];
                 if (select_last_index) {
-                    if (curr_value>=max) {
+                    if (curr_value >= max) {
                         output[idx_o] = i;
                         max = curr_value;
                     }
-                }
-                else {
+                } else {
                     if (curr_value > max) {
                         output[idx_o] = i;
                         max = curr_value;
@@ -69,19 +68,24 @@ void ArgMaxImpl_cpu_forward_kernel(std::int32_t axis_,
             }
         }
     }
-
 }
 
 // Kernels registration to implementation entry point
 REGISTRAR(ArgMaxImpl_cpu,
-    {DataType::Float32},
-    {ProdConso::defaultModel, Aidge::ArgMaxImpl_cpu_forward_kernel<float, float>, nullptr});
+          {DataType::Float32},
+          {ProdConso::defaultModel,
+           Aidge::ArgMaxImpl_cpu_forward_kernel<float, float>,
+           nullptr});
 REGISTRAR(ArgMaxImpl_cpu,
-    {DataType::Float64},
-    {ProdConso::defaultModel, Aidge::ArgMaxImpl_cpu_forward_kernel<double, double>, nullptr});
+          {DataType::Float64},
+          {ProdConso::defaultModel,
+           Aidge::ArgMaxImpl_cpu_forward_kernel<double, double>,
+           nullptr});
 REGISTRAR(ArgMaxImpl_cpu,
-    {DataType::Int32},
-    {ProdConso::defaultModel, Aidge::ArgMaxImpl_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr});
-}  // namespace Aidge
+          {DataType::Int32},
+          {ProdConso::defaultModel,
+           Aidge::ArgMaxImpl_cpu_forward_kernel<std::int32_t, std::int32_t>,
+           nullptr});
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_ARGMAXIMPL_KERNELS_H_ */

include/aidge/backend/cpu/operator/AtanImpl.hpp

@@ -12,22 +12,23 @@
 #ifndef AIDGE_CPU_OPERATOR_ATAN_H_
 #define AIDGE_CPU_OPERATOR_ATAN_H_
 
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
 #include "aidge/operator/Atan.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include <memory>
 #include <vector>
 
 namespace Aidge {
 // Operator implementation entry point for the backend
-using AtanImpl_cpu = OperatorImpl_cpu<Atan_Op,
-    void(const std::size_t, const void*, void*),
-    void(const std::size_t, const void*, const void*, void*)>;
+using AtanImpl_cpu = OperatorImpl_cpu<
+    Atan_Op,
+    void(const std::size_t, const void *, void *),
+    void(const std::size_t, const void *, const void *, void *)>;
 
 // Implementation entry point registration to Operator
 REGISTRAR(Atan_Op, "cpu", Aidge::AtanImpl_cpu::create);
-}  // namespace Aidge
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_ATAN_H_ */

include/aidge/backend/cpu/operator/AtanImpl_kernels.hpp

@@ -15,46 +15,49 @@
 #include "aidge/utils/Registrar.hpp"
 
 #include "aidge/backend/cpu/operator/AtanImpl.hpp"
-#include <cmath>  // For atan()
-
+#include <cmath> // For atan()
 
 namespace Aidge {
 template <class I, class O>
 void AtanImpl_cpu_forward_kernel(std::size_t inputLenght,
-                                    const void* input_,
-                                    void* output_) {
-    const I* input = static_cast<const I*>(input_);
-    O* output = static_cast<O*>(output_);
+                                 const void *input_,
+                                 void *output_) {
+    const I *input = static_cast<const I *>(input_);
+    O *output = static_cast<O *>(output_);
 
     for (size_t i = 0; i < inputLenght; ++i) {
         output[i] = static_cast<O>(atan(input[i]));
     }
-
 }
 
 template <class O, class GI, class GO>
 void AtanImpl_cpu_backward_kernel(const std::size_t inputLenght,
-                                     const void* output_, const void* grad_output_,
-				     void* grad_input_) {
-    const O* output = static_cast<const O*>(output_);
-    const GO* grad_output = static_cast<const GO*>(grad_output_);
-    GI* grad_input = static_cast<GI*>(grad_input_);
+                                  const void *output_,
+                                  const void *grad_output_,
+                                  void *grad_input_) {
+    const O *output = static_cast<const O *>(output_);
+    const GO *grad_output = static_cast<const GO *>(grad_output_);
+    GI *grad_input = static_cast<GI *>(grad_input_);
 
     // Apply the derivative of atan for each element in the input array
     for (size_t i = 0; i < inputLenght; ++i) {
         // dx = dy * (1 / (1 + x^2))
-        grad_input[i] = grad_output[i] * static_cast<O>(1.0 / (1.0 + output[i] * output[i]));
+        grad_input[i] = grad_output[i] *
+                        static_cast<O>(1.0 / (1.0 + output[i] * output[i]));
     }
 }
 
-
 // Kernels registration to implementation entry point
 REGISTRAR(AtanImpl_cpu,
-    {DataType::Float32},
-    {ProdConso::inPlaceModel, Aidge::AtanImpl_cpu_forward_kernel<float, float>, Aidge::AtanImpl_cpu_backward_kernel<float, float, float>});
+          {DataType::Float32},
+          {ProdConso::inPlaceModel,
+           Aidge::AtanImpl_cpu_forward_kernel<float, float>,
+           Aidge::AtanImpl_cpu_backward_kernel<float, float, float>});
 REGISTRAR(AtanImpl_cpu,
-    {DataType::Float64},
-    {ProdConso::inPlaceModel, Aidge::AtanImpl_cpu_forward_kernel<double, double>, Aidge::AtanImpl_cpu_backward_kernel<double, double, double>});
-}  // namespace Aidge
+          {DataType::Float64},
+          {ProdConso::inPlaceModel,
+           Aidge::AtanImpl_cpu_forward_kernel<double, double>,
+           Aidge::AtanImpl_cpu_backward_kernel<double, double, double>});
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_ATANIMPL_KERNELS_H_ */

include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp

@@ -17,24 +17,25 @@
 #include <tuple>
 #include <vector>
 
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
 #include "aidge/operator/AvgPooling.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
 
 namespace Aidge {
 // Operator implementation entry point for the backend
 using AvgPooling2D_Op = AvgPooling_Op<2>;
-using AvgPoolingImpl2D_cpu = OperatorImpl_cpu<AvgPooling_Op<2>,
-    void(const std::array<DimSize_t, 2>&,
-        const std::array<DimSize_t, 2>&,
-        const std::array<DimSize_t, 4>&,
-        const void *,
-        void *)>;
+using AvgPoolingImpl2D_cpu =
+    OperatorImpl_cpu<AvgPooling_Op<2>,
+                     void(const std::array<DimSize_t, 2> &,
+                          const std::array<DimSize_t, 2> &,
+                          const std::array<DimSize_t, 4> &,
+                          const void *,
+                          void *)>;
 
 // Implementation entry point registration to Operator
 REGISTRAR(AvgPooling2D_Op, "cpu", Aidge::AvgPoolingImpl2D_cpu::create);
-}  // namespace Aidge
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_H_ */

include/aidge/backend/cpu/operator/AvgPoolingImpl_kernels.hpp

@@ -13,8 +13,8 @@
 #define AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_KERNELS_H_
 
 #include <array>
-#include <tuple>
 #include <cmath>
+#include <tuple>
 
 #include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include "aidge/backend/cpu/operator/AvgPoolingImpl.hpp"
@@ -33,24 +33,24 @@ namespace Aidge {
  * @param output_ Output Tensor.
  */
 template <class I, class O>
-void AvgPoolingImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims,
-                                        const std::array<DimSize_t, 2>& kernelDims,
-                                        const std::array<DimSize_t, 4> &dims,
-                                        const void *input_,
-                                        void *output_) {
+void AvgPoolingImpl2D_cpu_forward_kernel(
+    const std::array<DimSize_t, 2> &strideDims,
+    const std::array<DimSize_t, 2> &kernelDims,
+    const std::array<DimSize_t, 4> &dims,
+    const void *input_,
+    void *output_) {
     // FIXME: missing convolution attributes as arguments
     const I *input = static_cast<const I *>(input_);
     O *output = static_cast<O *>(output_);
 
-
     // output H size
-    const std::size_t oxSize =
-            static_cast<std::size_t>(std::floor(static_cast<float>(dims[2] - kernelDims[0] + strideDims[0]) /
-                                static_cast<float>(strideDims[0])));
+    const std::size_t oxSize = static_cast<std::size_t>(std::floor(
+        static_cast<float>(dims[2] - kernelDims[0] + strideDims[0]) /
+        static_cast<float>(strideDims[0])));
     // output W size
-    const std::size_t oySize =
-            static_cast<std::size_t>(std::floor(static_cast<float>(dims[3] - kernelDims[1] + strideDims[1]) /
-                                static_cast<float>(strideDims[1])));
+    const std::size_t oySize = static_cast<std::size_t>(std::floor(
+        static_cast<float>(dims[3] - kernelDims[1] + strideDims[1]) /
+        static_cast<float>(strideDims[1])));
 
     // TODO: kernel computation
     // output (batch, outCh, Xout, Yout)
@@ -60,40 +60,61 @@ void AvgPoolingImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideD
     using signedsize = std::make_signed<std::size_t>::type;
     for (std::size_t batch = 0; batch < dims[0]; ++batch) {
         for (std::size_t ch = 0; ch < dims[1]; ++ch) {
-            const std::size_t oIndex = (ch + batch*dims[1]) * oxSize * oySize;
-            const std::size_t iIndex = (ch + batch*dims[1]) * dims[2] * dims[3];
-            std::fill(output + oIndex, output+(oIndex+oxSize*oySize), 0);
+            const std::size_t oIndex =
+                (ch + batch * dims[1]) * oxSize * oySize;
+            const std::size_t iIndex =
+                (ch + batch * dims[1]) * dims[2] * dims[3];
+            std::fill(output + oIndex, output + (oIndex + oxSize * oySize), 0);
             for (std::size_t ox = 0; ox < oxSize; ++ox) {
-                const signedsize difx = static_cast<signedsize>(- ox * strideDims[0]);
-                const std::size_t sxMin = static_cast<std::size_t>(std::max(difx, signedsize(0)));
-                const std::size_t sxMax = (static_cast<signedsize>(dims[2]) + difx) < 0 ? 0 : ((dims[2] + difx) > kernelDims[0] ? kernelDims[0] : dims[2] + difx);
+                const signedsize difx =
+                    static_cast<signedsize>(-ox * strideDims[0]);
+                const std::size_t sxMin =
+                    static_cast<std::size_t>(std::max(difx, signedsize(0)));
+                const std::size_t sxMax =
+                    (static_cast<signedsize>(dims[2]) + difx) < 0
+                        ? 0
+                        : ((dims[2] + difx) > kernelDims[0] ? kernelDims[0]
+                                                            : dims[2] + difx);
                 for (std::size_t oy = 0; oy < oySize; ++oy) {
-                    const signedsize dify = static_cast<signedsize>(- oy * strideDims[1]);
-                    const std::size_t syMin = static_cast<std::size_t>(std::max(dify, signedsize(0)));
-                    const std::size_t syMax = (static_cast<signedsize>(dims[3]) + dify) < 0 ? 0 : ((dims[3] + dify) > kernelDims[1] ? kernelDims[1] : dims[3] + dify);
-                    const std::size_t oIndexFull = oIndex + ox*oySize + oy;
+                    const signedsize dify =
+                        static_cast<signedsize>(-oy * strideDims[1]);
+                    const std::size_t syMin = static_cast<std::size_t>(
+                        std::max(dify, signedsize(0)));
+                    const std::size_t syMax =
+                        (static_cast<signedsize>(dims[3]) + dify) < 0
+                            ? 0
+                            : ((dims[3] + dify) > kernelDims[1]
+                                   ? kernelDims[1]
+                                   : dims[3] + dify);
+                    const std::size_t oIndexFull = oIndex + ox * oySize + oy;
                     const std::size_t ix = ox * strideDims[0];
                     const std::size_t iy = oy * strideDims[1];
 
                     if (sxMin == 0 && syMin == 0 && sxMax == 3 && syMax == 3) {
-                        output[oIndexFull] += static_cast<O>(
-                                               input[iIndex + (ix+0)*dims[3] + (iy+0)] +
-                                               input[iIndex + (ix+0)*dims[3] + (iy+1)] +
-                                               input[iIndex + (ix+0)*dims[3] + (iy+2)] +
-                                               input[iIndex + (ix+1)*dims[3] + (iy+0)] +
-                                               input[iIndex + (ix+1)*dims[3] + (iy+1)] +
-                                               input[iIndex + (ix+1)*dims[3] + (iy+2)] +
-                                               input[iIndex + (ix+2)*dims[3] + (iy+0)] +
-                                               input[iIndex + (ix+2)*dims[3] + (iy+1)] +
-                                               input[iIndex + (ix+2)*dims[3] + (iy+2)]) / O(9);
+                        output[oIndexFull] +=
+                            static_cast<O>(
+                                input[iIndex + (ix + 0) * dims[3] + (iy + 0)] +
+                                input[iIndex + (ix + 0) * dims[3] + (iy + 1)] +
+                                input[iIndex + (ix + 0) * dims[3] + (iy + 2)] +
+                                input[iIndex + (ix + 1) * dims[3] + (iy + 0)] +
+                                input[iIndex + (ix + 1) * dims[3] + (iy + 1)] +
+                                input[iIndex + (ix + 1) * dims[3] + (iy + 2)] +
+                                input[iIndex + (ix + 2) * dims[3] + (iy + 0)] +
+                                input[iIndex + (ix + 2) * dims[3] + (iy + 1)] +
+                                input[iIndex + (ix + 2) * dims[3] +
+                                      (iy + 2)]) /
+                            O(9);
                     } else {
                         for (std::size_t sx = sxMin; sx < sxMax; ++sx) {
                             for (std::size_t sy = syMin; sy < syMax; ++sy) {
-                                output[oIndexFull] += input[iIndex + (ix+sx)*dims[3] + (iy+sy)];
+                                output[oIndexFull] +=
+                                    input[iIndex + (ix + sx) * dims[3] +
+                                          (iy + sy)];
                             }
                         }
                         // padding not used
-                        output[oIndexFull] /= (sxMax - sxMin) * (syMax - syMin);
+                        output[oIndexFull] /=
+                            (sxMax - sxMin) * (syMax - syMin);
                     }
                 }
             }
@@ -103,14 +124,23 @@ void AvgPoolingImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideD
 
 // Kernels registration to implementation entry point
 REGISTRAR(AvgPoolingImpl2D_cpu,
-    {{DataType::Float32, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},
-    {ProdConso::inPlaceModel, Aidge::AvgPoolingImpl2D_cpu_forward_kernel<float, float>, nullptr});
-REGISTRAR(AvgPoolingImpl2D_cpu,
+          {{DataType::Float32, DataFormat::NCHW},
+           {DataType::Float32, DataFormat::NCHW}},
+          {ProdConso::inPlaceModel,
+           Aidge::AvgPoolingImpl2D_cpu_forward_kernel<float, float>,
+           nullptr});
+REGISTRAR(
+    AvgPoolingImpl2D_cpu,
     {{DataType::Int32, DataFormat::NCHW}, {DataType::Int32, DataFormat::NCHW}},
-    {ProdConso::inPlaceModel, Aidge::AvgPoolingImpl2D_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr});
+    {ProdConso::inPlaceModel,
+     Aidge::AvgPoolingImpl2D_cpu_forward_kernel<std::int32_t, std::int32_t>,
+     nullptr});
 REGISTRAR(AvgPoolingImpl2D_cpu,
-    {{DataType::Float64, DataFormat::NCHW}, {DataType::Float64, DataFormat::NCHW}},
-    {ProdConso::inPlaceModel, Aidge::AvgPoolingImpl2D_cpu_forward_kernel<double, double>, nullptr});
-}  // namespace Aidge
+          {{DataType::Float64, DataFormat::NCHW},
+           {DataType::Float64, DataFormat::NCHW}},
+          {ProdConso::inPlaceModel,
+           Aidge::AvgPoolingImpl2D_cpu_forward_kernel<double, double>,
+           nullptr});
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_KERNELS_H_ */

include/aidge/backend/cpu/operator/BatchNormImpl.hpp

@@ -17,29 +17,30 @@
 #include <tuple>
 #include <vector>
 
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
 #include "aidge/operator/BatchNorm.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
 
 namespace Aidge {
 // Operator implementation entry point for the backend
 using BatchNorm2D_Op = BatchNorm_Op<2>;
-using BatchNormImpl2D_cpu = OperatorImpl_cpu<BatchNorm_Op<2>,
-    void(float,
-        float,
-        const std::array<DimSize_t, 4> &,
-        const void *,
-        const void *,
-        const void *,
-        void *,
-        void *,
-        void *,
-        const bool)>;
+using BatchNormImpl2D_cpu =
+    OperatorImpl_cpu<BatchNorm_Op<2>,
+                     void(float,
+                          float,
+                          const std::array<DimSize_t, 4> &,
+                          const void *,
+                          const void *,
+                          const void *,
+                          void *,
+                          void *,
+                          void *,
+                          const bool)>;
 
 // Implementation entry point registration to Operator
 REGISTRAR(BatchNorm2D_Op, "cpu", Aidge::BatchNormImpl2D_cpu::create);
-}  // namespace Aidge
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_BATCHNORMIMPL_H_ */

include/aidge/backend/cpu/operator/BatchNormImpl_kernels.hpp

@@ -14,12 +14,12 @@
 
 #include "aidge/utils/Registrar.hpp"
 
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include "aidge/backend/cpu/operator/BatchNormImpl.hpp"
 #include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
+#include <algorithm>
 #include <array>
 #include <cmath>
-#include <algorithm>
 
 namespace Aidge {
 /**
@@ -38,8 +38,16 @@ namespace Aidge {
  * @param output_ Output Tensor.
  */
 template <class I, class P, class O>
-void BatchNormImpl2D_cpu_forward_kernel(float epsilon, float momentum, const std::array<DimSize_t, 4> &dims,
-                                       const void *input_, const void *scale_, const void *shift_, void *batchMean_, void *batchVar_, void *output_, const bool freeze) {
+void BatchNormImpl2D_cpu_forward_kernel(float epsilon,
+                                        float momentum,
+                                        const std::array<DimSize_t, 4> &dims,
+                                        const void *input_,
+                                        const void *scale_,
+                                        const void *shift_,
+                                        void *batchMean_,
+                                        void *batchVar_,
+                                        void *output_,
+                                        const bool freeze) {
     // FIXME: missing convolution attributes as arguments
     const I *input = static_cast<const I *>(input_);
     const P *scale = static_cast<const P *>(scale_);
@@ -50,18 +58,24 @@ void BatchNormImpl2D_cpu_forward_kernel(float epsilon, float momentum, const std
 
     const DimSize_t nbBatch = dims[0];
     const DimSize_t nbChannels = dims[1];
-    const DimSize_t featureMapSize = dims[2]*dims[3];
-
+    const DimSize_t featureMapSize = dims[2] * dims[3];
 
     if ((freeze == true) || (momentum == 0.0f)) {
         for (std::size_t batch = 0; batch < nbBatch; ++batch) {
             for (std::size_t ch = 0; ch < nbChannels; ++ch) {
-                const std::size_t ioIndex = (ch + batch*nbChannels) * featureMapSize;
-                std::fill(output + ioIndex, output + ioIndex + featureMapSize, shift[ch]);
-                const P var = std::sqrt(batchVar[ch] + static_cast<P>(epsilon));
+                const std::size_t ioIndex =
+                    (ch + batch * nbChannels) * featureMapSize;
+                std::fill(output + ioIndex,
+                          output + ioIndex + featureMapSize,
+                          shift[ch]);
+                const P var =
+                    std::sqrt(batchVar[ch] + static_cast<P>(epsilon));
 
-                for (std::size_t feature = 0; feature<featureMapSize; ++feature) {
-                    output[ioIndex + feature] += scale[ch] * (input[ioIndex + feature]-batchMean[ch]) / var;
+                for (std::size_t feature = 0; feature < featureMapSize;
+                     ++feature) {
+                    output[ioIndex + feature] +=
+                        scale[ch] *
+                        (input[ioIndex + feature] - batchMean[ch]) / var;
                 }
             }
         }
@@ -71,25 +85,40 @@ void BatchNormImpl2D_cpu_forward_kernel(float epsilon, float momentum, const std
             I sum = I(0);
             I sumSquare = I(0);
             for (std::size_t batch = 0; batch < nbBatch; ++batch) {
-                const std::size_t ioIndex = (ch + batch*nbChannels) * featureMapSize;
-                std::fill(output + ioIndex, output + ioIndex + featureMapSize, shift[ch]);
+                const std::size_t ioIndex =
+                    (ch + batch * nbChannels) * featureMapSize;
+                std::fill(output + ioIndex,
+                          output + ioIndex + featureMapSize,
+                          shift[ch]);
 
-                for (std::size_t feature = 0; feature<featureMapSize; ++feature) {
+                for (std::size_t feature = 0; feature < featureMapSize;
+                     ++feature) {
                     sum += input[ioIndex + feature];
-                    sumSquare += input[ioIndex + feature] * input[ioIndex + feature];
+                    sumSquare +=
+                        input[ioIndex + feature] * input[ioIndex + feature];
                 }
             }
             const I inputMean = sum / static_cast<I>(nbDataPerChannel);
-            const I inputVar = sumSquare / static_cast<I>(nbDataPerChannel)  - inputMean*inputMean;
+            const I inputVar = sumSquare / static_cast<I>(nbDataPerChannel) -
+                               inputMean * inputMean;
 
-            batchMean[ch] = batchMean[ch]*(1-momentum) + inputMean*momentum;
-            batchVar[ch] = batchVar[ch]*(1-momentum) + inputVar*(static_cast<I>(nbDataPerChannel)/static_cast<I>(nbDataPerChannel-1))*momentum;
+            batchMean[ch] =
+                batchMean[ch] * (1 - momentum) + inputMean * momentum;
+            batchVar[ch] = batchVar[ch] * (1 - momentum) +
+                           inputVar *
+                               (static_cast<I>(nbDataPerChannel) /
+                                static_cast<I>(nbDataPerChannel - 1)) *
+                               momentum;
 
             const P var = std::sqrt(inputVar + static_cast<P>(epsilon));
             for (std::size_t batch = 0; batch < nbBatch; ++batch) {
-                const std::size_t ioIndex = (ch + batch*nbChannels) * featureMapSize;
-                for (std::size_t feature = 0; feature<featureMapSize; ++feature) {
-                    output[ioIndex + feature] += scale[ch] * (input[ioIndex + feature]-inputMean) / var;
+                const std::size_t ioIndex =
+                    (ch + batch * nbChannels) * featureMapSize;
+                for (std::size_t feature = 0; feature < featureMapSize;
+                     ++feature) {
+                    output[ioIndex + feature] +=
+                        scale[ch] * (input[ioIndex + feature] - inputMean) /
+                        var;
                 }
             }
         }
@@ -98,8 +127,11 @@ void BatchNormImpl2D_cpu_forward_kernel(float epsilon, float momentum, const std
 
 // Kernels registration to implementation entry point
 REGISTRAR(BatchNormImpl2D_cpu,
-    {{DataType::Float32, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},
-    {ProdConso::inPlaceModel, Aidge::BatchNormImpl2D_cpu_forward_kernel<float, float, float>, nullptr});
-}  // namespace Aidge
+          {{DataType::Float32, DataFormat::NCHW},
+           {DataType::Float32, DataFormat::NCHW}},
+          {ProdConso::inPlaceModel,
+           Aidge::BatchNormImpl2D_cpu_forward_kernel<float, float, float>,
+           nullptr});
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_BATCHNORMIMPL_KERNELS_H_ */

include/aidge/backend/cpu/operator/BitShiftImpl.hpp

@@ -12,27 +12,28 @@
 #ifndef AIDGE_CPU_OPERATOR_BITSHIFTIMPL_H_
 #define AIDGE_CPU_OPERATOR_BITSHIFTIMPL_H_
 
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
 #include "aidge/operator/BitShift.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include <memory>
 #include <vector>
 
 namespace Aidge {
 // Operator implementation entry point for the backend
-using BitShiftImpl_cpu = OperatorImpl_cpu<BitShift_Op,
-    void(const BitShift_Op::BitShiftDirection,
-    const std::vector<std::size_t>&, 
-    const std::vector<std::size_t>&, 
-    const std::vector<std::size_t>&, 
-    const void*, 
-    const void*,
-    void*)>;
-    
-    // Implementation entry point registration to Operator
-    REGISTRAR(BitShift_Op,"cpu",Aidge::BitShiftImpl_cpu::create);
-}  // namespace Aidge
+using BitShiftImpl_cpu =
+    OperatorImpl_cpu<BitShift_Op,
+                     void(const BitShift_Op::BitShiftDirection,
+                          const std::vector<std::size_t> &,
+                          const std::vector<std::size_t> &,
+                          const std::vector<std::size_t> &,
+                          const void *,
+                          const void *,
+                          void *)>;
+
+// Implementation entry point registration to Operator
+REGISTRAR(BitShift_Op, "cpu", Aidge::BitShiftImpl_cpu::create);
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_BITSHIFTIMPL_H_ */

include/aidge/backend/cpu/operator/BitShiftImpl_kernels.hpp

@@ -14,57 +14,62 @@
 
 #include "aidge/utils/Registrar.hpp"
 
-#include <cstdint>     // std::int32_t, std::int64_t
 #include "aidge/operator/BitShift.hpp"
+#include <cstdint> // std::int32_t, std::int64_t
 
 #include "aidge/backend/cpu/data/Broadcasting.hpp"
 #include "aidge/backend/cpu/operator/BitShiftImpl.hpp"
 
-
-
 namespace Aidge {
 template <class I1, class I2, class O>
 void BitShiftImpl_cpu_forward_kernel(
-                                const BitShift_Op::BitShiftDirection direction,
-                                const std::vector<std::size_t>& input1Dims,
-                                const std::vector<std::size_t>& input2Dims,
-                                const std::vector<std::size_t>& outputDims,
-                                const void* input1_,
-                                const void* input2_,
-                                void* output_
-                                ) {
+    const BitShift_Op::BitShiftDirection direction,
+    const std::vector<std::size_t> &input1Dims,
+    const std::vector<std::size_t> &input2Dims,
+    const std::vector<std::size_t> &outputDims,
+    const void *input1_,
+    const void *input2_,
+    void *output_) {
+
+    const I1 *input_1 = static_cast<const I1 *>(input1_);
+    const I2 *input_2 = static_cast<const I2 *>(input2_);
+    O *output = static_cast<O *>(output_);
 
-    const I1* input_1 = static_cast<const I1*>(input1_);
-    const I2* input_2 = static_cast<const I2*>(input2_);
-    O* output = static_cast<O*>(output_);
+    const size_t totalElements =
+        std::accumulate(outputDims.begin(),
+                        outputDims.end(),
+                        std::size_t(1),
+                        std::multiplies<std::size_t>());
 
-    const size_t totalElements = std::accumulate(outputDims.begin(), outputDims.end(), std::size_t(1), std::multiplies<std::size_t>());
-    
-    for (std::size_t oIndex = 0; oIndex < totalElements; ++oIndex)
-    {
+    for (std::size_t oIndex = 0; oIndex < totalElements; ++oIndex) {
         std::vector<size_t> indexes = getMultiDimIndices(outputDims, oIndex);
         std::size_t idx1 = getFlattenedIndex(input1Dims, indexes);
         std::size_t idx2 = getFlattenedIndex(input2Dims, indexes);
-        if(direction == BitShift_Op::BitShiftDirection::right)
+        if (direction == BitShift_Op::BitShiftDirection::right)
 
         {
-                output[oIndex]= input_1[idx1] >> input_2[idx2];
-        }
-        else
-        {
-                output[oIndex] = input_1[idx1] << input_2[idx2];
+            output[oIndex] = input_1[idx1] >> input_2[idx2];
+        } else {
+            output[oIndex] = input_1[idx1] << input_2[idx2];
         }
     }
 }
 
 REGISTRAR(BitShiftImpl_cpu,
-{DataType::Int32},
-{ProdConso::inPlaceModel,Aidge::BitShiftImpl_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t>,nullptr});
+          {DataType::Int32},
+          {ProdConso::inPlaceModel,
+           Aidge::BitShiftImpl_cpu_forward_kernel<std::int32_t,
+                                                  std::int32_t,
+                                                  std::int32_t>,
+           nullptr});
 REGISTRAR(BitShiftImpl_cpu,
-{DataType::Int64},
-{ProdConso::inPlaceModel,Aidge::BitShiftImpl_cpu_forward_kernel<std::int64_t, std::int64_t, std::int64_t>,nullptr});
-
+          {DataType::Int64},
+          {ProdConso::inPlaceModel,
+           Aidge::BitShiftImpl_cpu_forward_kernel<std::int64_t,
+                                                  std::int64_t,
+                                                  std::int64_t>,
+           nullptr});
 
-}  // namespace Aidge
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_BitShiftIMPL_KERNELS_H_ */
\ No newline at end of file

include/aidge/backend/cpu/operator/ClipImpl.hpp

@@ -12,35 +12,34 @@
 #ifndef AIDGE_CPU_OPERATOR_CLIPIMPL_H_
 #define AIDGE_CPU_OPERATOR_CLIPIMPL_H_
 
-#include <cstddef>  // std::size_t
+#include <algorithm>
+#include <cstddef> // std::size_t
 #include <memory>
-#include <tuple>    // std::tuple
+#include <tuple>   // std::tuple
 #include <vector>
-#include <algorithm>
 
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
 #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
 #include "aidge/operator/Clip.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
-
 
 namespace Aidge {
 // Operator implementation entry point for the backend
-    using ClipImpl_cpu = OperatorImpl_cpu<Clip_Op,
-    void(float, //Forward Types
-    float, 
-    const void*,
-    const std::size_t, 
-    void*),
-    void(float,//Backward Types
-    float, 
-    const std::size_t,
-    const void*, 
-    const void*,
-    void*)>;
+using ClipImpl_cpu = OperatorImpl_cpu<Clip_Op,
+                                      void(float, // Forward Types
+                                           float,
+                                           const void *,
+                                           const std::size_t,
+                                           void *),
+                                      void(float, // Backward Types
+                                           float,
+                                           const std::size_t,
+                                           const void *,
+                                           const void *,
+                                           void *)>;
 
-    REGISTRAR(Clip_Op,"cpu",Aidge::ClipImpl_cpu::create);
-}  // namespace Aidge
+REGISTRAR(Clip_Op, "cpu", Aidge::ClipImpl_cpu::create);
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_CLIPIMPL_H_ */

include/aidge/backend/cpu/operator/ClipImpl_kernels.hpp

@@ -13,65 +13,67 @@
 #ifndef AIDGE_CPU_OPERATOR_CLIPIMPL_KERNELS_H_
 #define AIDGE_CPU_OPERATOR_CLIPIMPL_KERNELS_H_
 
-#include "aidge/utils/Registrar.hpp"
 #include "aidge/backend/cpu/operator/ClipImpl.hpp"
+#include "aidge/utils/Registrar.hpp"
 
 namespace Aidge {
 template <class I, class O>
-void ClipImpl_cpu_forward_kernel(
-        float min_,
-        float max_,
-        const void* input_,
-        const std::size_t length,
-        void* output_) 
-{
-    const I* input = static_cast<const I*>(input_);
-    O* output = static_cast<O*>(output_);
+void ClipImpl_cpu_forward_kernel(float min_,
+                                 float max_,
+                                 const void *input_,
+                                 const std::size_t length,
+                                 void *output_) {
+    const I *input = static_cast<const I *>(input_);
+    O *output = static_cast<O *>(output_);
 
     for (std::size_t i = 0; i < length; ++i) {
-        output[i] = std::min(std::max(static_cast<float>(input[i]), min_), max_);
+        output[i] =
+            std::min(std::max(static_cast<float>(input[i]), min_), max_);
     }
 }
 
 template <class I, class GI, class GO>
-void ClipImpl_cpu_backward_kernel(
-        float min_,
-        float max_,
-        const std::size_t length,
-        const void* input_, 
-        const void* grad_output_,
-		void* grad_input_)           
-{
-    const I* input = static_cast<const I*>(input_);
-    const GO* grad_output = static_cast<const GO*>(grad_output_);
-    GI* grad_input = static_cast<GI*>(grad_input_);
+void ClipImpl_cpu_backward_kernel(float min_,
+                                  float max_,
+                                  const std::size_t length,
+                                  const void *input_,
+                                  const void *grad_output_,
+                                  void *grad_input_) {
+    const I *input = static_cast<const I *>(input_);
+    const GO *grad_output = static_cast<const GO *>(grad_output_);
+    GI *grad_input = static_cast<GI *>(grad_input_);
 
     for (std::size_t i = 0; i < length; ++i) {
-        grad_input[i] = ((input[i] > min_) && (input[i] < max_)) ? grad_output[i] : 0;
+        grad_input[i] =
+            ((input[i] > min_) && (input[i] < max_)) ? grad_output[i] : 0;
     }
 }
 
 REGISTRAR(ClipImpl_cpu,
-{DataType::Float32},
-{ProdConso::inPlaceModel,
-Aidge::ClipImpl_cpu_forward_kernel<float,float>,
-Aidge::ClipImpl_cpu_backward_kernel<float,float,float>});
+          {DataType::Float32},
+          {ProdConso::inPlaceModel,
+           Aidge::ClipImpl_cpu_forward_kernel<float, float>,
+           Aidge::ClipImpl_cpu_backward_kernel<float, float, float>});
 REGISTRAR(ClipImpl_cpu,
-{DataType::Float64},
-{ProdConso::inPlaceModel,
-Aidge::ClipImpl_cpu_forward_kernel<double,double>,
-Aidge::ClipImpl_cpu_backward_kernel<double,double,double>});
+          {DataType::Float64},
+          {ProdConso::inPlaceModel,
+           Aidge::ClipImpl_cpu_forward_kernel<double, double>,
+           Aidge::ClipImpl_cpu_backward_kernel<double, double, double>});
 REGISTRAR(ClipImpl_cpu,
-{DataType::Int32},
-{ProdConso::inPlaceModel,
-Aidge::ClipImpl_cpu_forward_kernel<std::int32_t,std::int32_t>,
-Aidge::ClipImpl_cpu_backward_kernel<std::int32_t,std::int32_t,std::int32_t>});
+          {DataType::Int32},
+          {ProdConso::inPlaceModel,
+           Aidge::ClipImpl_cpu_forward_kernel<std::int32_t, std::int32_t>,
+           Aidge::ClipImpl_cpu_backward_kernel<std::int32_t,
+                                               std::int32_t,
+                                               std::int32_t>});
 REGISTRAR(ClipImpl_cpu,
-{DataType::Int64},
-{ProdConso::inPlaceModel,
-Aidge::ClipImpl_cpu_forward_kernel<std::int64_t,std::int64_t>,
-Aidge::ClipImpl_cpu_backward_kernel<std::int64_t,std::int64_t,std::int64_t>});
+          {DataType::Int64},
+          {ProdConso::inPlaceModel,
+           Aidge::ClipImpl_cpu_forward_kernel<std::int64_t, std::int64_t>,
+           Aidge::ClipImpl_cpu_backward_kernel<std::int64_t,
+                                               std::int64_t,
+                                               std::int64_t>});
 
-}  // namespace Aidge
+} // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_CLIPIMPL_KERNELS_H_ */