Fix formatting.

bindings/Python/detail/tracking/performance_tracker.cpp

@@ -8,8 +8,8 @@
 
 #include "plssvm/detail/tracking/performance_tracker.hpp"  // plssvm::detail::tracking::{global_tracker, tracking_entry}
 
-#include "plssvm/detail/tracking/events.hpp"            // plssvm::detail::tracking::events
-#include "plssvm/parameter.hpp"                         // plssvm::parameter
+#include "plssvm/detail/tracking/events.hpp"  // plssvm::detail::tracking::events
+#include "plssvm/parameter.hpp"               // plssvm::parameter
 
 #include "pybind11/chrono.h"    // automatic bindings for std::chrono::milliseconds
 #include "pybind11/pybind11.h"  // py::module_

bindings/Python/sklearn.cpp

@@ -66,10 +66,10 @@ void parse_provided_params(svc &self, const py::kwargs &args) {
             kernel = plssvm::kernel_function_type::rbf;
         } else if (kernel_str == "sigmoid") {
             kernel = plssvm::kernel_function_type::sigmoid;
-	} else if (kernel_str == "laplacian") {
-	    kernel = plssvm::kernel_function_type::laplacian;
-	} else if (kernel_str == "chi_squared") {
-	    kernel = plssvm::kernel_function_type::chi_squared;
+        } else if (kernel_str == "laplacian") {
+            kernel = plssvm::kernel_function_type::laplacian;
+        } else if (kernel_str == "chi_squared") {
+            kernel = plssvm::kernel_function_type::chi_squared;
         } else if (kernel_str == "precomputed") {
             throw py::attribute_error{ R"(The "kernel = 'precomputed'" parameter for a call to the 'SVC' constructor is not implemented yet!)" };
         } else {

include/plssvm/backends/HIP/kernel/detail/fill_kernel.hip.hpp

@@ -38,4 +38,4 @@ __global__ void fill_array(value_type *data, const value_type value, const size_
 
 }  // namespace plssvm::hip::detail
 
-#endif  // PLSSVM_BACKENDS_HIP_DETAIL_FILL_KERNEL_HPP_
+#endif  // PLSSVM_BACKENDS_HIP_DETAIL_FILL_KERNEL_HPP_

include/plssvm/backends/OpenCL/detail/pinned_memory.hpp

@@ -88,6 +88,6 @@ class [[nodiscard]] pinned_memory final : public ::plssvm::detail::host_pinned_m
 extern template class pinned_memory<float>;
 extern template class pinned_memory<double>;
 
-}  // namespace plssvm::adaptivecpp::detail
+}  // namespace plssvm::opencl::detail
 
 #endif  // PLSSVM_BACKENDS_OPENCL_DETAIL_PINNED_MEMORY_HPP_

include/plssvm/backends/SYCL/DPCPP/detail/pinned_memory.hpp

@@ -88,6 +88,6 @@ class [[nodiscard]] pinned_memory final : public ::plssvm::detail::host_pinned_m
 extern template class pinned_memory<float>;
 extern template class pinned_memory<double>;
 
-}  // namespace plssvm::adaptivecpp::detail
+}  // namespace plssvm::dpcpp::detail
 
 #endif  // PLSSVM_BACKENDS_SYCL_DPCPP_DETAIL_PINNED_MEMORY_HPP_

include/plssvm/backends/execution_range.hpp

@@ -161,7 +161,6 @@ struct execution_range {
     /// The grids. Multiple grids are used, if the grid sizes would exceed the maximum allowed number. Also stores the offsets for the respective grids used in the kernels.
     /// Note: no default initialization due to a linker error occurring with NVIDIA's nvhpc!
     std::vector<grid_type> grids;
-
 };
 
 /**

include/plssvm/backends/gpu_device_ptr.hpp

@@ -32,7 +32,7 @@ template <typename T, typename queue_t, typename device_pointer_t, typename deri
 class gpu_device_ptr {
     // make sure only valid template types are used
     static_assert(detail::tuple_contains_v<T, detail::supported_real_types>,
-        "Illegal real type provided! See the 'real_type_list' in the type_list.hpp header for a list of the allowed types.");
+                  "Illegal real type provided! See the 'real_type_list' in the type_list.hpp header for a list of the allowed types.");
 
   public:
     /// The type of the values used in the device_ptr.
@@ -370,7 +370,6 @@ class gpu_device_ptr {
     device_pointer_type data_{};
 };
 
-
 template <typename T, typename queue_t, typename device_pointer_t, typename derived_gpu_device_ptr>
 gpu_device_ptr<T, queue_t, device_pointer_t, derived_gpu_device_ptr>::gpu_device_ptr(const size_type size, const queue_type queue) :
     queue_{ queue },

include/plssvm/backends/stdpar/csvm.hpp

@@ -119,7 +119,7 @@ class csvm : public ::plssvm::csvm {
      */
     [[nodiscard]] implementation_type get_implementation_type() const noexcept;
 
-    protected:
+  protected:
     /**
      * @copydoc plssvm::csvm::get_device_memory
      */

include/plssvm/backends/stdpar/kernel/kernel_functions.hpp

@@ -16,8 +16,8 @@
 #include "plssvm/constants.hpp"              // plssvm::real_type
 #include "plssvm/kernel_function_types.hpp"  // plssvm::kernel_function_type
 
-#if defined(PLSSVM_STDPAR_BACKEND_HAS_INTEL_LLVM)   // TODO: remove after linker error is fixed on AMD GPUs
-    #include "sycl/sycl.hpp"  // override std::* math functions
+#if defined(PLSSVM_STDPAR_BACKEND_HAS_INTEL_LLVM)  // TODO: remove after linker error is fixed on AMD GPUs
+    #include "sycl/sycl.hpp"                       // override std::* math functions
 #endif
 
 #if defined(PLSSVM_STDPAR_BACKEND_HAS_HIPSTDPAR)

include/plssvm/csvm_factory.hpp

@@ -158,7 +158,7 @@ template <typename... Args>
  * @return the C-SVM (`[[nodiscard]]`)
  */
 template <typename... Args>
-[[nodiscard]] inline std::unique_ptr<csvm> make_csvm(const backend_type backend, Args ...args) {
+[[nodiscard]] inline std::unique_ptr<csvm> make_csvm(const backend_type backend, Args... args) {
     return detail::make_csvm_impl(backend, args...);
 }
 
@@ -170,7 +170,7 @@ template <typename... Args>
  * @return the C-SVM (`[[nodiscard]]`)
  */
 template <typename... Args>
-[[nodiscard]] inline std::unique_ptr<csvm> make_csvm(Args ...args) {
+[[nodiscard]] inline std::unique_ptr<csvm> make_csvm(Args... args) {
     return detail::make_csvm_impl(backend_type::automatic, args...);
 }
 

include/plssvm/detail/io/scaling_factors_parsing.hpp

@@ -22,7 +22,7 @@
 #include "plssvm/exceptions/exceptions.hpp"     // plssvm::invalid_file_format_exception
 
 #include "fmt/format.h"  // fmt::format
-#include "fmt/os.h"    // fmt::ostream, fmt::output_file
+#include "fmt/os.h"      // fmt::ostream, fmt::output_file
 
 #include <exception>    // std::exception_ptr, std::exception, std::current_exception, std::rethrow_exception
 #include <string>       // std::string

src/main_scale.cpp

@@ -17,7 +17,7 @@
 #include "plssvm/detail/utility.hpp"                       // PLSSVM_IS_DEFINED
 
 #if defined(PLSSVM_HARDWARE_SAMPLING_ENABLED)
-    #include "hws/system_hardware_sampler.hpp" // hws::system_hardware_sampler
+    #include "hws/system_hardware_sampler.hpp"  // hws::system_hardware_sampler
 #endif
 
 #include <algorithm>   // std::for_each

src/plssvm/backends/OpenCL/detail/command_queue.cpp

@@ -16,8 +16,8 @@
 
 #include "CL/cl.h"  // cl_context, cl_command_queue, cl_device_id, clCreateCommandQueueWithProperties, clCreateCommandQueue, clReleaseCommandQueue
 
-#include <exception>  // std::terminate
-#include <iostream>   // std::cerr, std::endl
+#include <exception>    // std::terminate
+#include <iostream>     // std::cerr, std::endl
 #include <memory>       // std::addressof
 #include <type_traits>  // std::is_same_v
 #include <utility>      // std::exchange, std::move

src/plssvm/backends/OpenCL/detail/context.cpp

@@ -26,7 +26,7 @@ context::context(context &&other) noexcept :
     platform{ std::exchange(other.platform, nullptr) },
     devices{ std::move(other.devices) } { }
 
-context &context::operator=(context &&other)noexcept {
+context &context::operator=(context &&other) noexcept {
     if (this != std::addressof(other)) {
         other.device_context = std::exchange(other.device_context, nullptr);
         platform = std::exchange(other.platform, nullptr);

src/plssvm/backends/stdpar/detail/utility.cpp

@@ -51,16 +51,16 @@ std::string get_stdpar_version() {
 #if defined(PLSSVM_STDPAR_BACKEND_HAS_ACPP)
     return plssvm::adaptivecpp::detail::get_adaptivecpp_version_short();
 #elif defined(PLSSVM_STDPAR_BACKEND_HAS_NVHPC)
-#if defined(PLSSVM_STDPAR_BACKEND_NVHPC_GPU)
+    #if defined(PLSSVM_STDPAR_BACKEND_NVHPC_GPU)
     int runtime_version{};
     cudaRuntimeGetVersion(&runtime_version);
     // parse it to a more useful string
     int major_version = runtime_version / 1000;
     int minor_version = runtime_version % 1000 / 10;
     return fmt::format("{}.{}.{}; {}.{}", __NVCOMPILER_MAJOR__, __NVCOMPILER_MINOR__, __NVCOMPILER_PATCHLEVEL__, major_version, minor_version);
-#else
+    #else
     return fmt::format("{}.{}.{}", __NVCOMPILER_MAJOR__, __NVCOMPILER_MINOR__, __NVCOMPILER_PATCHLEVEL__);
-#endif
+    #endif
 #elif defined(PLSSVM_STDPAR_BACKEND_HAS_INTEL_LLVM)
     return fmt::format("{}", __VERSION__);
 #elif defined(PLSSVM_STDPAR_BACKEND_HAS_GNU_TBB)

src/plssvm/detail/cmd/parser_predict.cpp

@@ -17,8 +17,8 @@
 #include "plssvm/verbosity_levels.hpp"                             // plssvm::verbosity, plssvm::verbosity_level
 #include "plssvm/version/version.hpp"                              // plssvm::version::detail::get_version_info
 
-#include "cxxopts.hpp"    // cxxopts::{Options, value, ParseResult}
-#include "fmt/color.h"    // fmt::fg, fmt::color::orange
+#include "cxxopts.hpp"   // cxxopts::{Options, value, ParseResult}
+#include "fmt/color.h"   // fmt::fg, fmt::color::orange
 #include "fmt/format.h"  // fmt::format
 #include "fmt/ranges.h"  // fmt::join
 

src/plssvm/detail/cmd/parser_scale.cpp

@@ -13,8 +13,8 @@
 #include "plssvm/verbosity_levels.hpp"                             // plssvm::verbosity, plssvm::verbosity_level
 #include "plssvm/version/version.hpp"                              // plssvm::version::detail::get_version_info
 
-#include "cxxopts.hpp"    // cxxopts::{Options, value, ParseResult}
-#include "fmt/color.h"    // fmt::fg, fmt::color::red
+#include "cxxopts.hpp"   // cxxopts::{Options, value, ParseResult}
+#include "fmt/color.h"   // fmt::fg, fmt::color::red
 #include "fmt/format.h"  // fmt::format
 #include "fmt/ranges.h"  // fmt::join
 

tests/backends/CUDA/cuda_csvm.cpp

@@ -159,4 +159,4 @@ using cuda_mock_kernel_function_type_gtest = util::combine_test_parameters_gtest
 
 // generic GPU CSVM tests - mocked grid sizes
 INSTANTIATE_TYPED_TEST_SUITE_P(CUDACSVMFakedGridSize, GenericGPUCSVM, cuda_mock_csvm_test_type_gtest, naming::test_parameter_to_name);
-INSTANTIATE_TYPED_TEST_SUITE_P(CUDACSVMFakedGridSize, GenericGPUCSVMKernelFunction, cuda_mock_kernel_function_type_gtest, naming::test_parameter_to_name);
+INSTANTIATE_TYPED_TEST_SUITE_P(CUDACSVMFakedGridSize, GenericGPUCSVMKernelFunction, cuda_mock_kernel_function_type_gtest, naming::test_parameter_to_name);

tests/backends/OpenCL/opencl_csvm.cpp

@@ -157,4 +157,4 @@ using opencl_mock_kernel_function_type_gtest = util::combine_test_parameters_gte
 
 // generic GPU CSVM tests - mocked grid sizes
 INSTANTIATE_TYPED_TEST_SUITE_P(OpenCLCSVMFakedGridSize, GenericGPUCSVM, opencl_mock_csvm_test_type_gtest, naming::test_parameter_to_name);
-INSTANTIATE_TYPED_TEST_SUITE_P(OpenCLCSVMFakedGridSize, GenericGPUCSVMKernelFunction, opencl_mock_kernel_function_type_gtest, naming::test_parameter_to_name);
+INSTANTIATE_TYPED_TEST_SUITE_P(OpenCLCSVMFakedGridSize, GenericGPUCSVMKernelFunction, opencl_mock_kernel_function_type_gtest, naming::test_parameter_to_name);

tests/backends/SYCL/DPCPP/mock_dpcpp_csvm.hpp

@@ -13,15 +13,14 @@
 #define PLSSVM_TESTS_BACKENDS_SYCL_DPCPP_MOCK_DPCPP_CSVM_HPP_
 #pragma once
 
-#include "plssvm/backends/SYCL/DPCPP/csvm.hpp"  // plssvm::dpcpp::csvm
 #include "plssvm/backends/execution_range.hpp"  // plssvm::detail::dim_type
+#include "plssvm/backends/SYCL/DPCPP/csvm.hpp"  // plssvm::dpcpp::csvm
 
 #include "gmock/gmock.h"  // MOCK_METHOD, ON_CALL, ::testing::Return
 
 #include <cstddef>  // std::size_t
 #include <utility>  // std::forward
 
-
 /**
  * @brief GTest mock class for the SYCL CSVM using DPC++ as SYCL implementation.
  * @tparam mock_grid_size `true` if the `plssvm::dpcpp::csvm::get_max_grid_size()` function should be mocked, otherwise `false`

tests/backends/ground_truth.cpp

@@ -17,11 +17,11 @@
 #include "plssvm/parameter.hpp"                 // plssvm::parameter
 #include "plssvm/shape.hpp"                     // plssvm::shape
 
-#include <cmath>      // std::pow, std::exp, std::fma
-#include <cstddef>    // std::size_t
-#include <utility>    // std::pair, std::make_pair, std::move
-#include <variant>    // std::get
-#include <vector>     // std::vector
+#include <cmath>    // std::pow, std::exp, std::fma
+#include <cstddef>  // std::size_t
+#include <utility>  // std::pair, std::make_pair, std::move
+#include <variant>  // std::get
+#include <vector>   // std::vector
 
 namespace ground_truth {
 
@@ -116,7 +116,6 @@ real_type chi_squared_kernel(const std::vector<real_type> &x, const std::vector<
 template float chi_squared_kernel(const std::vector<float> &, const std::vector<float> &, const float);
 template double chi_squared_kernel(const std::vector<double> &, const std::vector<double> &, const double);
 
-
 template <typename real_type, plssvm::layout_type layout>
 real_type linear_kernel(const plssvm::matrix<real_type, layout> &X, const std::size_t i, const plssvm::matrix<real_type, layout> &Y, const std::size_t j) {
     PLSSVM_ASSERT(X.num_cols() == Y.num_cols(), "Sizes mismatch!: {} != {}", X.num_cols(), Y.num_cols());
@@ -364,7 +363,6 @@ plssvm::aos_matrix<real_type> predict_values(const plssvm::parameter &params, co
 template plssvm::aos_matrix<float> predict_values(const plssvm::parameter &, const plssvm::soa_matrix<float> &, const plssvm::aos_matrix<float> &, const std::vector<float> &, const plssvm::soa_matrix<float> &, const plssvm::soa_matrix<float> &, const std::size_t, const std::size_t);
 template plssvm::aos_matrix<double> predict_values(const plssvm::parameter &, const plssvm::soa_matrix<double> &, const plssvm::aos_matrix<double> &, const std::vector<double> &, const plssvm::soa_matrix<double> &, const plssvm::soa_matrix<double> &, const std::size_t, const std::size_t);
 
-
 }  // namespace detail
 
 template <typename real_type>

tests/backends/ground_truth.hpp

@@ -185,7 +185,6 @@ template <typename real_type, plssvm::layout_type layout>
 template <typename real_type>
 [[nodiscard]] plssvm::aos_matrix<real_type> predict_values(const plssvm::parameter &params, const plssvm::soa_matrix<real_type> &w, const plssvm::aos_matrix<real_type> &weights, const std::vector<real_type> &rho, const plssvm::soa_matrix<real_type> &support_vectors, const plssvm::soa_matrix<real_type> &predict_points, std::size_t row_offset, std::size_t device_specific_num_rows);
 
-
 }  // namespace detail
 
 /**

tests/backends/stdpar/implementation_types.cpp

@@ -71,11 +71,11 @@ TEST(stdparImplementationType, from_string_unknown) {
 TEST(stdparImplementationType, minimal_available_stdpar_implementation_type) {
     const std::vector<plssvm::stdpar::implementation_type> implementation_type = plssvm::stdpar::list_available_stdpar_implementations();
 
-    #if defined(PLSSVM_HAS_STDPAR_BACKEND)
-        // at least one must be available!
-        EXPECT_GE(implementation_type.size(), 1);
-    #else
-        // stdpar not active -> no implementation type available
-        EXPECT_TRUE(implementation_type.empty());
-    #endif
+#if defined(PLSSVM_HAS_STDPAR_BACKEND)
+    // at least one must be available!
+    EXPECT_GE(implementation_type.size(), 1);
+#else
+    // stdpar not active -> no implementation type available
+    EXPECT_TRUE(implementation_type.empty());
+#endif
 }

tests/classification_report.cpp

@@ -87,17 +87,17 @@ TEST_F(ZeroDivisionBehavior, sanitize_nan_one) {
     EXPECT_EQ(plssvm::detail::sanitize_nan(42.0, 1.0, plssvm::classification_report::zero_division_behavior::one, "Foo"), 42.0);
 }
 
-//TEST_F(ZeroDivisionBehavior, sanitize_nan_nan) {
-//    // sanitize NaN using nan
-//#if !defined(PLSSVM_USE_FAST_MATH) || defined(_MSC_VER)
-//    // ATTENTION: MSVC doesn't optimize out the NaN check even if fast math is used
-//    EXPECT_TRUE(std::isnan(plssvm::detail::sanitize_nan(42.0, 0.0, plssvm::classification_report::zero_division_behavior::nan, "Foo")));
-//#else
-//    // ATTENTION: std::isnan will ALWAYS return false due to -ffast-math being enabled in release mode (in GCC and clang)
-//    EXPECT_FALSE(std::isnan(plssvm::detail::sanitize_nan(42.0, 0.0, plssvm::classification_report::zero_division_behavior::nan, "Foo")));
-//#endif
-//    EXPECT_EQ(plssvm::detail::sanitize_nan(42.0, 1.0, plssvm::classification_report::zero_division_behavior::nan, "Foo"), 42.0);
-//}
+// TEST_F(ZeroDivisionBehavior, sanitize_nan_nan) {
+//     // sanitize NaN using nan
+// #if !defined(PLSSVM_USE_FAST_MATH) || defined(_MSC_VER)
+//     // ATTENTION: MSVC doesn't optimize out the NaN check even if fast math is used
+//     EXPECT_TRUE(std::isnan(plssvm::detail::sanitize_nan(42.0, 0.0, plssvm::classification_report::zero_division_behavior::nan, "Foo")));
+// #else
+//     // ATTENTION: std::isnan will ALWAYS return false due to -ffast-math being enabled in release mode (in GCC and clang)
+//     EXPECT_FALSE(std::isnan(plssvm::detail::sanitize_nan(42.0, 0.0, plssvm::classification_report::zero_division_behavior::nan, "Foo")));
+// #endif
+//     EXPECT_EQ(plssvm::detail::sanitize_nan(42.0, 1.0, plssvm::classification_report::zero_division_behavior::nan, "Foo"), 42.0);
+// }
 
 //*************************************************************************************************************************************//
 //                                                               metrics                                                               //

tests/data_set/getter.cpp

@@ -18,7 +18,7 @@
 #include "tests/types_to_test.hpp"       // util::{label_type_gtest, test_parameter_type_at_t}
 #include "tests/utility.hpp"             // util::{redirect_output, scale}
 
-#include "gtest/gtest.h"           // TYPED_TEST, TYPED_TEST_SUITE, EXPECT_TRUE, EXPECT_FALSE, EXPECT_EQ, ASSERT_TRUE, ::testing::Test
+#include "gtest/gtest.h"  // TYPED_TEST, TYPED_TEST_SUITE, EXPECT_TRUE, EXPECT_FALSE, EXPECT_EQ, ASSERT_TRUE, ::testing::Test
 
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::get

tests/detail/operators.cpp

@@ -465,4 +465,4 @@ TYPED_TEST(VectorOperationsDeathTest, operator_manhattan_dist) {
     // try to calculate the Manhattan distance between two vectors with different distance
     EXPECT_DEATH(std::ignore = manhattan_dist(this->get_a(), this->get_b()), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(std::ignore = manhattan_dist(this->get_b(), this->get_a()), "Sizes mismatch!: 2 != 4");
-}
+}

tests/detail/tracking/performance_tracker.cpp

@@ -17,9 +17,9 @@
 #include "plssvm/detail/memory_size.hpp"         // plssvm::detail::memory_size (literals)
 #include "plssvm/detail/tracking/events.hpp"     // plssvm::detail::tracking::{events, event}
 
-#include "tests/naming.hpp"                                 // naming::test_parameter_to_name
-#include "tests/types_to_test.hpp"                          // util::{label_type_gtest, test_parameter_type_at_t}
-#include "tests/utility.hpp"                                // util::redirect_output
+#include "tests/naming.hpp"         // naming::test_parameter_to_name
+#include "tests/types_to_test.hpp"  // util::{label_type_gtest, test_parameter_type_at_t}
+#include "tests/utility.hpp"        // util::redirect_output
 
 #include "fmt/format.h"   // fmt::format
 #include "gmock/gmock.h"  // EXPECT_CALL, EXPECT_THAT, ::testing::{HasSubstr}

tests/kernel_function_types.cpp

@@ -10,7 +10,7 @@
 
 #include "plssvm/kernel_function_types.hpp"
 
-#include "tests/custom_test_macros.hpp"     // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING
+#include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING
 
 #include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_TRUE
 

tests/types_to_test.hpp

@@ -462,8 +462,7 @@ using combine_test_parameters_gtest_t = typename combine_test_parameters_gtest<T
 
 /// A list of all available kernel function types.
 constexpr std::array<plssvm::kernel_function_type, 6> kernel_functions_to_test{
-    plssvm::kernel_function_type::linear, plssvm::kernel_function_type::polynomial, plssvm::kernel_function_type::rbf,
-    plssvm::kernel_function_type::sigmoid, plssvm::kernel_function_type::laplacian, plssvm::kernel_function_type::chi_squared
+    plssvm::kernel_function_type::linear, plssvm::kernel_function_type::polynomial, plssvm::kernel_function_type::rbf, plssvm::kernel_function_type::sigmoid, plssvm::kernel_function_type::laplacian, plssvm::kernel_function_type::chi_squared
 };
 /// A list of all available layout types.
 constexpr std::array<plssvm::layout_type, 2> layout_types_to_test{