diff --git a/.clang-format b/.clang-format
index ba886a47c..b1990c009 100644
--- a/.clang-format
+++ b/.clang-format
@@ -82,7 +82,7 @@ IncludeBlocks: Regroup
 IncludeCategories:
   - Regex: '^"plssvm/'
     Priority: 1
-  - Regex: '^"(cuda|hip|CL|sycl|omp|hpx|Kokkos)'
+  - Regex: '^"(cuda|driver_types|vector_types|hip|CL|sycl|omp|hpx|Kokkos)'
     Priority: 2
   - Regex: '^"(tests|bindings)/'
     Priority: 3
diff --git a/.clang-tidy b/.clang-tidy
index b8ef4aa69..872696e54 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,47 +1,58 @@
-# Generated from CLion Inspection settings
 ---
-Checks: '-*,
+Checks: '
+bugprone-*,
+-bugprone-branch-clone,
+-bugprone-easily-swappable-parameters,
+-bugprone-exception-escape,
+-bugprone-macro-parentheses,
+
 cert-*,
-misc-*,
-mpi-*,
+
+clang-analyzer-*,
+-clang-analyzer-optin.core.EnumCastOutOfRange,
+
 cppcoreguidelines-*,
--cppcoreguidelines-avoid-do-while,
--cppcoreguidelines-avoid-magic-numbers,
--cppcoreguidelines-pro-bounds-pointer-arithmetic,
+-cppcoreguidelines-macro-usage,
+-cppcoreguidelines-non-private-member-variables-in-classes,
 -cppcoreguidelines-pro-bounds-constant-array-index,
-google-default-arguments,
-google-runtime-operator,
-google-explicit-constructor,
-hicpp-multiway-paths-covered,
-hicpp-exception-baseclass,
+-cppcoreguidelines-pro-bounds-pointer-arithmetic,
+
+google-*,
+-google-readability-todo,
+-google-runtime-int,
+
+hicpp-*,
+-hicpp-uppercase-literal-suffix,
+
+misc-*,
+-misc-non-private-member-variables-in-classes,
+-misc-no-recursion,
+
 modernize-*,
 -modernize-use-trailing-return-type,
--modernize-avoid-c-arrays,
--modernize-use-using,
--modernize-use-default-member-init,
--modernize-macro-to-enum,
-portability-simd-intrinsics,
+-modernize-type-traits,
+
+mpi-*,
+
+openmp-*,
+-openmp-exception-escape,
+-openmp-use-default-none,
+
+performance-*,
+-performance-avoid-endl,
+-performance-enum-size,
+
+portability-*,
+-portability-avoid-pragma-once,
+
 readability-*,
--readability-redundant-preprocessor,
--readability-named-parameter,
--readability-function-size,
--readability-simplify-boolean-expr,
+-readability-convert-member-functions-to-static,
+-readability-function-cognitive-complexity,
 -readability-identifier-length,
--readability-duplicate-include,
--readability-magic-numbers,
--readability-braces-around-statements,
--readability-redundant-member-init,
+-readability-math-missing-parentheses,
 -readability-suspicious-call-argument,
--readability-qualified-auto,
--readability-isolate-declaration,
 -readability-uppercase-literal-suffix,
--readability-container-data-pointer,
--readability-else-after-return,
--readability-redundant-access-specifiers,
--readability-function-cognitive-complexity,
--readability-implicit-bool-conversion,
--readability-container-contains,
--readability-identifier-naming,
-bugprone-*'
+'
 
-CheckOptions: { misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic: true }
+UseColor: true
+HeaderFilterRegex: ".*(include\\/plssvm|bindings\\/Python|tests).*"
\ No newline at end of file
diff --git a/.github/workflows/clang_gcc_linux.yml b/.github/workflows/clang_gcc_linux.yml
index a57ed8b35..3d3db48d2 100644
--- a/.github/workflows/clang_gcc_linux.yml
+++ b/.github/workflows/clang_gcc_linux.yml
@@ -27,7 +27,7 @@ jobs:
       - name: "Install cmake 3.31.0"
         uses: lukka/get-cmake@v3.31.0
       - name: "Clone the PLSSVM repository into PLSSVM/"
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v6.0.1
         with:
           path: PLSSVM
       - name: "Install Python dependencies"
@@ -37,7 +37,7 @@ jobs:
       - name: "Configure PLSSVM using CMake"
         run: |
           cd PLSSVM
-          cmake --preset openmp_test -DCMAKE_CXX_COMPILER=${{ matrix.compiler }} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DPLSSVM_TARGET_PLATFORMS="cpu" -DPLSSVM_ENABLE_LANGUAGE_BINDINGS=ON -DPLSSVM_ENABLE_PERFORMANCE_TRACKING=ON -DPLSSVM_ENABLE_MPI=ON -DPLSSVM_TEST_FILE_NUM_DATA_POINTS=50 -DPLSSVM_TEST_FILE_NUM_FEATURES=20 -DPLSSVM_ENABLE_LTO=OFF
+          cmake --preset openmp_test -DCMAKE_CXX_COMPILER=${{ matrix.compiler }} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DPLSSVM_ENABLE_STL_DEBUG_MODE=${{ matrix.build_type == 'Debug' && 'ON' || 'OFF' }} -DPLSSVM_TARGET_PLATFORMS="cpu" -DPLSSVM_ENABLE_LANGUAGE_BINDINGS=ON -DPLSSVM_ENABLE_PERFORMANCE_TRACKING=ON -DPLSSVM_ENABLE_MPI=ON -DPLSSVM_TEST_FILE_NUM_DATA_POINTS=50 -DPLSSVM_TEST_FILE_NUM_FEATURES=20 -DPLSSVM_ENABLE_LTO=OFF
       - name: "Build PLSSVM"
         run: |
           cd PLSSVM
@@ -48,4 +48,4 @@ jobs:
           cd PLSSVM
           mkdir tmp
           export TMPDIR=$PWD/tmp
-          ctest --preset openmp_test -C ${{ matrix.build_type }} --parallel 2
\ No newline at end of file
+          ctest --preset openmp_test -C ${{ matrix.build_type }} --parallel 2 --output-on-failure
\ No newline at end of file
diff --git a/.github/workflows/clang_macos.yml b/.github/workflows/clang_macos.yml
index 6c3269609..7b2e882e4 100644
--- a/.github/workflows/clang_macos.yml
+++ b/.github/workflows/clang_macos.yml
@@ -7,51 +7,41 @@ on:
   workflow_dispatch:
 jobs:
   macOS-Test:
-    runs-on: macos-13
+    runs-on: macos-15-intel
     strategy:
       matrix:
         build_type: [Debug, Release]
     steps:
       - name: "Install cmake 3.31.0"
         uses: lukka/get-cmake@v3.31.0
-      - name: "Install LLVM and Clang"
-        uses: KyleMayes/install-llvm-action@v2
-        with:
-          version: "15.0"
       - name: "Install dependencies via brew"
         run: |
-          brew install python3
-          brew install numpy
           brew install libomp
+      - name: "Set up Python"
+        uses: actions/setup-python@v6.1.0
+        with:
+          python-version: "3.12"
       - name: "Install Python dependencies"
         run: |
-          python3 -m pip install -U pip
-          pip install argparse scikit-learn humanize --break-system-packages
-      - name: "Set PYTHONPATH"
-        run: |
-          export PYTHONPATH=$(python3 -c "import site; print(site.getsitepackages()[0])")
-          echo "PYTHONPATH=$PYTHONPATH" >> $GITHUB_ENV
+          pip install --upgrade pip setuptools wheel
+          pip install numpy scikit-learn humanize
       - name: "Clone the PLSSVM repository into PLSSVM/"
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v6.0.1
         with:
           path: PLSSVM
       - name: "Configure PLSSVM using CMake"
         run: |
           cd PLSSVM
-          export LDFLAGS="-L/opt/homebrew/opt/libomp/lib"
-          export CPPFLAGS="-I/opt/homebrew/opt/libomp/include"
-          cmake --preset openmp_test -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DPLSSVM_TARGET_PLATFORMS="cpu" -DPLSSVM_ENABLE_LANGUAGE_BINDINGS=ON -DPLSSVM_ENABLE_PERFORMANCE_TRACKING=ON -DPLSSVM_ENABLE_MPI=OFF -DPLSSVM_TEST_FILE_NUM_DATA_POINTS=50 -DPLSSVM_TEST_FILE_NUM_FEATURES=20 -DPLSSVM_ENABLE_LTO=OFF
+          cmake --preset openmp_test -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DPLSSVM_TARGET_PLATFORMS="cpu" -DPLSSVM_ENABLE_LANGUAGE_BINDINGS=ON -DPLSSVM_ENABLE_PERFORMANCE_TRACKING=ON -DPLSSVM_ENABLE_MPI=OFF -DPLSSVM_TEST_FILE_NUM_DATA_POINTS=50 -DPLSSVM_TEST_FILE_NUM_FEATURES=20 -DPLSSVM_ENABLE_LTO=OFF -DOpenMP_CXX_FLAGS="-Xpreprocessor -fopenmp" -DOpenMP_CXX_LIB_NAMES="omp" -DOpenMP_omp_LIBRARY="/usr/local/opt/libomp/lib/libomp.dylib" -DOpenMP_CXX_INCLUDE_DIRS="/usr/local/opt/libomp/include"
       - name: "Build PLSSVM"
         shell: bash
         run: |
           cd PLSSVM
-          export LDFLAGS="-L/opt/homebrew/opt/libomp/lib"
-          export CPPFLAGS="-I/opt/homebrew/opt/libomp/include"
+          export CPLUS_INCLUDE_PATH="/usr/local/opt/libomp/include":$CPLUS_INCLUDE_PATH
           cmake --build --preset openmp_test --config ${{ matrix.build_type }}
           echo "${GITHUB_WORKSPACE}/PLSSVM/build" >> $GITHUB_PATH
       - name: "Run tests"
         run: |
           cd PLSSVM
-          export LDFLAGS="-L/opt/homebrew/opt/libomp/lib"
-          export CPPFLAGS="-I/opt/homebrew/opt/libomp/include"
-          ctest --preset openmp_test -C ${{ matrix.build_type }} -E ".*executable.*" --parallel 2
+          export LD_LIBRARY_PATH="/usr/local/opt/libomp/lib":$LD_LIBRARY_PATH
+          ctest --preset openmp_test -C ${{ matrix.build_type }} -E ".*Executable.*" --parallel 2 --output-on-failure
diff --git a/.github/workflows/documentation.yml b/.github/workflows/documentation.yml
index 207971823..9c6dbf115 100644
--- a/.github/workflows/documentation.yml
+++ b/.github/workflows/documentation.yml
@@ -16,7 +16,7 @@ jobs:
     steps:
       # checkout repository
       - name: "Checkout PLSSVM"
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v6.0.1
         with:
           path: PLSSVM
       # install dependencies
@@ -25,8 +25,8 @@ jobs:
           sudo apt update
           sudo apt-get install -y doxygen graphviz
       # install new CMake version
-      - name: "Install cmake 3.31.0"
-        uses: lukka/get-cmake@v3.31.0
+      - name: "Install cmake 4.2.1"
+        uses: lukka/get-cmake@v4.2.1
       # configure project via CMake
       - name: "Configure"
         run: |
diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index 8632723be..d5ffaa027 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -13,7 +13,7 @@ jobs:
     steps:
       # checkout repository
       - name: "Checkout PLSSVM"
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v6.0.1
         with:
           path: PLSSVM
       # install dependencies
@@ -22,8 +22,8 @@ jobs:
           sudo apt install libomp-dev clang-format
           pip install "git+https://github.com/vancraar/cmake_format@master"
       # install new CMake version
-      - name: "Install cmake 3.31.0"
-        uses: lukka/get-cmake@v3.31.0
+      - name: "Install cmake 4.2.1"
+        uses: lukka/get-cmake@v4.2.1
       # configure project via CMake
       - name: "Configure"
         run: |
@@ -47,7 +47,7 @@ jobs:
       # upload the clang-format git patch, if available
       - name: "Upload clang-format patch"
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6.0.0
         with:
           name: clang-format-patch
           path: PLSSVM/clang-format-patch.txt
@@ -70,7 +70,7 @@ jobs:
       # upload the cmake-format git patch, if available
       - name: "Upload cmake-format patch"
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6.0.0
         with:
           name: cmake-format-patch
           path: PLSSVM/cmake-format-patch.txt
diff --git a/.github/workflows/msvc_windows.yml b/.github/workflows/msvc_windows.yml
index 537fb15de..46f1e0016 100644
--- a/.github/workflows/msvc_windows.yml
+++ b/.github/workflows/msvc_windows.yml
@@ -17,7 +17,7 @@ jobs:
       - name: "Install cmake 3.31.0"
         uses: lukka/get-cmake@v3.31.0
       - name: "Clone the PLSSVM repository into PLSSVM/"
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v6.0.1
         with:
           path: PLSSVM
       - name: "Install Python dependencies"
@@ -27,7 +27,7 @@ jobs:
       - name: "Configure PLSSVM using CMake"
         run: |
           cd PLSSVM
-          cmake --preset openmp_test -DCMAKE_CONFIGURATION_TYPES=${{ matrix.build_type }} -DPLSSVM_TARGET_PLATFORMS="cpu" -DPLSSVM_ENABLE_LANGUAGE_BINDINGS=ON -DPLSSVM_ENABLE_PERFORMANCE_TRACKING=ON -DPLSSVM_ENABLE_MPI=OFF -DPLSSVM_TEST_FILE_NUM_DATA_POINTS=50 -DPLSSVM_TEST_FILE_NUM_FEATURES=20
+          cmake --preset openmp_test -DCMAKE_CONFIGURATION_TYPES=${{ matrix.build_type }} -DPLSSVM_ENABLE_STL_DEBUG_MODE=${{ matrix.build_type == 'Debug' && 'ON' || 'OFF' }} -DPLSSVM_TARGET_PLATFORMS="cpu" -DPLSSVM_ENABLE_LANGUAGE_BINDINGS=ON -DPLSSVM_ENABLE_PERFORMANCE_TRACKING=ON -DPLSSVM_ENABLE_MPI=OFF -DPLSSVM_TEST_FILE_NUM_DATA_POINTS=50 -DPLSSVM_TEST_FILE_NUM_FEATURES=20
       - name: "Build PLSSVM"
         shell: bash
         run: |
@@ -37,4 +37,4 @@ jobs:
       - name: "Run tests"
         run: |
           cd PLSSVM
-          ctest --preset openmp_test -C ${{ matrix.build_type }} -E ".*executable.*" --parallel 2
+          ctest --preset openmp_test -C ${{ matrix.build_type }} -E ".*Executable.*" --parallel 2 --output-on-failure
diff --git a/.github/workflows/pip.yml b/.github/workflows/pip.yml
index 7ced58ffa..de092a843 100644
--- a/.github/workflows/pip.yml
+++ b/.github/workflows/pip.yml
@@ -21,11 +21,11 @@ jobs:
         run: |
           sudo apt install libopenmpi-dev
       - name: "Clone the PLSSVM repository into PLSSVM/"
-        uses: actions/checkout@v4.1.1
+        uses: actions/checkout@v6.0.1
         with:
           path: PLSSVM
       - name: "Set up Python"
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6.1.0
         with:
           python-version: "3.11"
       - name: "Create and activate virtual environment"
diff --git a/.gitignore b/.gitignore
index ec61ae3c9..3085db502 100644
--- a/.gitignore
+++ b/.gitignore
@@ -75,9 +75,10 @@ docs/*
 !docs/plssvm-scale.1.in
 
 # data in test folder
-!tests/data/
 tests/data/*
-!tests/data/model/
-!tests/data/libsvm/
-!tests/data/arff/
-!tests/data/predict/
\ No newline at end of file
+
+# model files
+*.model
+
+# auto-generated AdaptiveCpp directory for JIT related information
+.acpp-*
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8b5c16f86..a864d8f17 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,6 +13,9 @@ project(
     DESCRIPTION "A Least Squares Support Vector Machine implementation using different backends."
 )
 
+# generate a compile_commands.json file (used by clang-tidy and other tools)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE INTERNAL "Generate a compile_commands.json file." FORCE)
+
 # include some generally used utility scripts
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/add_coverage_build_type.cmake)
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/utility_macros.cmake)
@@ -78,14 +81,15 @@ endif ()
 # set base sources
 set(PLSSVM_BASE_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/backends/Kokkos/execution_space.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/backends/SYCL/data_parallel_kernels.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/backends/SYCL/implementation_types.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/backends/SYCL/kernel_invocation_types.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/backends/stdpar/implementation_types.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/backends/execution_range.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/data_set/min_max_scaler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/detail/cmd/parser_predict.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/detail/cmd/parser_scale.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/detail/cmd/parser_train.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/detail/cmd/utility.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/detail/io/file_reader.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/detail/data_distribution.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/detail/memory_size.cpp
@@ -298,7 +302,7 @@ list(
 ########################################################################################################################
 # coverage analysis only possible with the Coverage CMAKE_BUILD_TYPE
 if (uppercase_CMAKE_BUILD_TYPE MATCHES COVERAGE)
-    list(APPEND CMAKE_MESSAGE_INDENT "coverage:  ")
+    list(APPEND CMAKE_MESSAGE_INDENT "Coverage:  ")
     # must be linux
     if (WIN32 OR APPLE)
         message(FATAL_ERROR "Only Linux is supported for the coverage analysis.")
@@ -333,7 +337,7 @@ if (uppercase_CMAKE_BUILD_TYPE MATCHES COVERAGE)
         set(PLSSVM_DEMANGLE_USING_CPPFILT --demangle-cpp)
     endif ()
 
-    # Create the coverage target. Run coverage tests with 'ctest --build . --target coverage'
+    # Create the coverage target. Run coverage tests with 'cmake --build --preset XXX --target coverage'.
     set(PLSSVM_COVERAGE_REPORT_OUTPUT_DIRECTORY "coverage_report")
     add_custom_target(
         coverage
@@ -373,11 +377,11 @@ if (uppercase_CMAKE_BUILD_TYPE MATCHES COVERAGE)
     # add custom target `make clean_coverage` which calls `make clean` and also removes all generate *.gcda and *.gcno files
     add_custom_target(clean_coverage)
     add_custom_command(
-        DEPENDS clean
+        POST_BUILD TARGET clean_coverage
         COMMENT "remove all coverage files"
         COMMAND ${CMAKE_MAKE_PROGRAM} clean
         COMMAND ${CMAKE_COMMAND} -E remove -f coverage.info coverage_init.info coverage_tests.info ${PLSSVM_COVERAGE_REPORT_OUTPUT_DIRECTORY}
-        COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/delete_coverage_files.cmake" TARGET clean_coverage
+        COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/delete_coverage_files.cmake"
     )
     list(POP_BACK CMAKE_MESSAGE_INDENT)
 endif ()
@@ -638,6 +642,34 @@ if (PLSSVM_ENABLE_LTO)
     endif ()
 endif ()
 
+########################################################################################################################
+#                          enable the requested vectorization widths for the auto-vectorizers                          #
+########################################################################################################################
+# GCC and clang both do not automatically auto-vectorize for AVX-512 (only AVX2)
+# -> enable it if "cpu:avx512" was passed as PLSSVM_TARGET_PLATFORMS
+if (PLSSVM_NUM_CPU_TARGET_ARCHS EQUAL 1)
+    if (${PLSSVM_CPU_TARGET_ARCHS} STREQUAL "avx512")
+        message(STATUS "Enabling AVX512 support for the auto-vectorizers (-mprefer-vector-width=512).")
+        target_compile_options(
+            ${PLSSVM_BASE_LIBRARY_NAME} PUBLIC $<$<COMPILE_LANGUAGE:CXX>:$<$<CXX_COMPILER_ID:GNU,Clang,IntelLLVM>:-mprefer-vector-width=512>>
+        )
+    elseif (${PLSSVM_CPU_TARGET_ARCHS} STREQUAL "avx2" OR ${PLSSVM_CPU_TARGET_ARCHS} STREQUAL "avx")
+        message(STATUS "Enabling AVX/AVX2 support for the auto-vectorizers (-mprefer-vector-width=256).")
+        target_compile_options(
+            ${PLSSVM_BASE_LIBRARY_NAME} PUBLIC $<$<COMPILE_LANGUAGE:CXX>:$<$<CXX_COMPILER_ID:GNU,Clang,IntelLLVM>:-mprefer-vector-width=256>>
+        )
+    elseif (${PLSSVM_CPU_TARGET_ARCHS} MATCHES "^sse")
+        message(STATUS "Enabling SSE for the auto-vectorizers (-mprefer-vector-width=128).")
+        target_compile_options(
+            ${PLSSVM_BASE_LIBRARY_NAME} PUBLIC $<$<COMPILE_LANGUAGE:CXX>:$<$<CXX_COMPILER_ID:GNU,Clang,IntelLLVM>:-mprefer-vector-width=128>>
+        )
+    else ()
+        message(FATAL_ERROR "Unrecognized CPU target architecture \"${PLSSVM_CPU_TARGET_ARCHS}\". Allowed values are: avx512, avx2, avx, sse.")
+    endif ()
+else ()
+    # automatically use the "optimal" auto-vectorizer width
+endif ()
+
 ########################################################################################################################
 #                                     check for optional and necessary dependencies                                    #
 ########################################################################################################################
@@ -646,8 +678,8 @@ include(FetchContent)
 list(APPEND CMAKE_MESSAGE_INDENT "Dependencies:  ")
 
 # try finding cxxopts
-set(PLSSVM_cxxopts_VERSION v3.2.0)
-find_package(cxxopts 3.2.0 QUIET)
+set(PLSSVM_cxxopts_VERSION v3.3.1)
+find_package(cxxopts 3.3.1 QUIET)
 if (cxxopts_FOUND)
     message(STATUS "Found package cxxopts.")
     target_include_directories(${PLSSVM_BASE_LIBRARY_NAME} PUBLIC ${cxxopts_INCLUDE_DIR})
@@ -675,8 +707,8 @@ endif ()
 # ~~~
 set(PLSSVM_FAST_FLOAT_WRAPPER_LIBRARY_NAME plssvm-fast_float-wrapper)
 add_library(${PLSSVM_FAST_FLOAT_WRAPPER_LIBRARY_NAME} SHARED ${CMAKE_CURRENT_SOURCE_DIR}/src/plssvm/detail/fast_float_wrapper.cpp)
-set(PLSSVM_fast_float_VERSION v8.0.2)
-find_package(fast_float 8.0.0 QUIET)
+set(PLSSVM_fast_float_VERSION v8.1.0)
+find_package(fast_float 8.1.0 QUIET)
 if (fast_float_FOUND)
     message(STATUS "Found package fast_float.")
     target_include_directories(${PLSSVM_FAST_FLOAT_WRAPPER_LIBRARY_NAME} PUBLIC ${fast_float_INCLUDE_DIR})
@@ -715,7 +747,7 @@ target_link_libraries(${PLSSVM_BASE_LIBRARY_NAME} PUBLIC ${PLSSVM_FAST_FLOAT_WRA
 list(APPEND PLSSVM_TARGETS_TO_INSTALL "${PLSSVM_FAST_FLOAT_WRAPPER_LIBRARY_NAME}")
 
 # try finding igor
-set(PLSSVM_igor_VERSION a5224c60d266974d3f407191583fe266cbe1c93d)
+set(PLSSVM_igor_VERSION fef608b458ab2fca736ac8e415e4d4160a48745d) # can't use a newer commit since igor switch to mandatory C++20
 find_package(igor QUIET)
 if (igor_FOUND)
     message(STATUS "Found package igor.")
@@ -725,6 +757,8 @@ else ()
     target_compile_definitions(${PLSSVM_BASE_LIBRARY_NAME} PRIVATE PLSSVM_igor_VERSION="${PLSSVM_igor_VERSION}")
     # set options for igor
     set(IGOR_BUILD_TESTS OFF CACHE INTERNAL "" FORCE)
+    # disable additional compiler flags check (only warning flags) since for some reasons it takes ages with stdpar compilers
+    set(_YACMACompilerLinkerSettingsIncluded ON CACHE INTERNAL "" FORCE)
     # fetch named argument library igor
     FetchContent_Declare(
         igor
@@ -768,6 +802,7 @@ else ()
     )
     FetchContent_MakeAvailable(fmt)
     set_property(TARGET fmt PROPERTY POSITION_INDEPENDENT_CODE ON)
+    set_target_properties(fmt PROPERTIES CXX_CLANG_TIDY "")
     target_compile_definitions(fmt PRIVATE FMT_USE_FULL_CACHE_DRAGONBOX)
     if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "ppc64le")
         target_compile_definitions(fmt PUBLIC FMT_USE_FLOAT128=0)
@@ -808,6 +843,58 @@ if (PLSSVM_ENABLE_FORMATTING)
     list(POP_BACK CMAKE_MESSAGE_INDENT)
 endif ()
 
+########################################################################################################################
+#                                       enable clang-tidy static analyzer checks                                       #
+########################################################################################################################
+option(PLSSVM_ENABLE_CLANG_TIDY "Enable clang-tidy static code analysis." OFF)
+if (PLSSVM_ENABLE_CLANG_TIDY)
+    list(APPEND CMAKE_MESSAGE_INDENT "clang-tidy:  ")
+    message(CHECK_START "Checking for clang-tidy executable")
+
+    # check if the clang-tidy executable is available
+    find_program(PLSSVM_CLANG_TIDY_EXE clang-tidy) # usage as part of the compilation process (can't analyse headers)
+    find_program(PLSSVM_RUN_CLANG_TIDY_EXE run-clang-tidy) # usage as standalone target (can analyse headers)
+    if (NOT PLSSVM_CLANG_TIDY_EXE OR NOT PLSSVM_RUN_CLANG_TIDY_EXE)
+        # clang-tidy executable not found
+        message(CHECK_FAIL "not found")
+        message(SEND_ERROR "Cannot find requested clang-tidy/run-clang-tidy for static analysis!")
+    else ()
+        # clang-tidy executable found -> enable it
+        message(CHECK_PASS "found")
+
+        # clang-tidy support during compilation
+        message(STATUS "Enabling static analysis via clang-tidy during compilation.")
+        set(CMAKE_CXX_CLANG_TIDY "clang-tidy;-quiet")
+
+        # custom clang-tidy target that also supports headers
+        message(STATUS "Enabling custom clang-tidy-all target.")
+
+        # create a custom command that filters unwanted flags
+        add_custom_target(
+            filter_compile_commands
+            COMMAND ${CMAKE_COMMAND} -DPLSSVM_COMPILE_COMMANDS_JSON_FILE=${CMAKE_BINARY_DIR}/compile_commands.json -P
+                    ${CMAKE_SOURCE_DIR}/cmake/filter_compile_commands.cmake
+            COMMENT "Generating a sanitized compile_commands.json"
+            VERBATIM
+        )
+
+        # create the custom target
+        add_custom_target(
+            clang-tidy-all COMMAND ${PLSSVM_RUN_CLANG_TIDY_EXE} -p "${CMAKE_BINARY_DIR}" -quiet "${PROJECT_SOURCE_DIR}/src"
+                                   "${PROJECT_SOURCE_DIR}/bindings/Python" "${PROJECT_SOURCE_DIR}/tests" DEPENDS filter_compile_commands
+        )
+
+        # clang-tidy is not supported by all backends
+        message(
+            WARNING
+                "Since some backends use special compilers with custom compiler flags that are NOT understood by clang-tidy, the target may fail to correctly build! "
+                "Some precautions are taken to make the clang-tidy-all target more compatible with these special compilers, but it does not work in all cases!"
+        )
+    endif ()
+
+    list(POP_BACK CMAKE_MESSAGE_INDENT)
+endif ()
+
 ########################################################################################################################
 #                                     enable documentation generation via doxygen                                      #
 ########################################################################################################################
@@ -914,16 +1001,16 @@ if (TARGET ${PLSSVM_SYCL_BACKEND_LIBRARY_NAME})
 choose the SYCL implementation to be used in the SYCL backend: ${PLSSVM_SYCL_BACKEND_NAME_LIST} (default: automatic)
 "
     )
-    string(REPLACE ";" "|" PLSSVM_SYCL_KERNEL_INVOCATION_TYPE_NAME_LIST "${PLSSVM_SYCL_KERNEL_INVOCATION_TYPE_NAME_LIST}")
-    set(PLSSVM_SYCL_KERNEL_INVOCATION_TYPE_MANPAGE_ENTRY
+    string(REPLACE ";" "|" PLSSVM_SYCL_DATA_PARALLEL_KERNEL_NAME_LIST "${PLSSVM_SYCL_DATA_PARALLEL_KERNEL_NAME_LIST}")
+    set(PLSSVM_SYCL_DATA_PARALLEL_KERNEL_MANPAGE_ENTRY
         "
 .TP
-.B --sycl_kernel_invocation_type
-choose the kernel invocation type when using SYCL as backend: ${PLSSVM_SYCL_KERNEL_INVOCATION_TYPE_NAME_LIST} (default: automatic)
+.B --sycl_data_parallel_kernel
+choose the data parallel kernel when using SYCL as backend: ${PLSSVM_SYCL_DATA_PARALLEL_KERNEL_NAME_LIST} (default: automatic)
 "
     )
 endif ()
-set(PLSSVM_SYCL_MANPAGE_ENTRY "${PLSSVM_SYCL_KERNEL_INVOCATION_TYPE_MANPAGE_ENTRY}${PLSSVM_SYCL_IMPLEMENTATION_TYPE_MANPAGE_ENTRY}")
+set(PLSSVM_SYCL_MANPAGE_ENTRY "${PLSSVM_SYCL_DATA_PARALLEL_KERNEL_MANPAGE_ENTRY}${PLSSVM_SYCL_IMPLEMENTATION_TYPE_MANPAGE_ENTRY}")
 # assemble the Kokkos manpage entry
 if (TARGET ${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME})
     string(REPLACE ";" "|" PLSSVM_KOKKOS_BACKEND_AVAILABLE_EXECUTION_SPACES "${PLSSVM_KOKKOS_BACKEND_AVAILABLE_EXECUTION_SPACES}")
diff --git a/README.md b/README.md
index c764ed4d1..e6933d846 100644
--- a/README.md
+++ b/README.md
@@ -31,38 +31,41 @@
 A [Support Vector Machine (SVM)](https://en.wikipedia.org/wiki/Support-vector_machine) is a supervised machine learning model.
 In its basic form SVMs are used for binary classification tasks.
 Their fundamental idea is to learn a hyperplane which separates the two classes best, i.e., where the widest possible margin around its decision boundary is free of data.
-This is also the reason, why SVMs are also called "large margin classifiers".
+This is also the reason, why SVMs are also called "large margin classifiers."
 To predict to which class a new, unseen data point belongs, the SVM simply has to calculate on which side of the previously calculated hyperplane the data point lies.
-This is very efficient since it only involves a single scalar product of the size corresponding to the numer of features of the data set.
+This is very efficient since it only involves a single scalar product of the size corresponding to the numer of features per data point in the data set.
 
 <p align="center">
-  <img alt="Basic idea of an Support Vector Machine as classification model." src="https://github.com/SC-SGS/PLSSVM/raw/main/.figures/support_vector_machine.png" width="50%">
+  <img 
+    alt="Basic idea of an Support Vector Machine as classification model." 
+    src="https://github.com/SC-SGS/PLSSVM/raw/main/.figures/support_vector_machine.png" 
+    style="max-width:600px; width:50%; height:auto;">
 </p>
 
-However, normal SVMs suffer in their potential parallelizability.
+However, normal SVMs suffer from their potential parallelizability.
 Determining the hyperplane boils down to solving a convex quadratic problem.
 For this, most SVM implementations use Sequential Minimal Optimization (SMO), an inherently sequential algorithm.
 The basic idea of this algorithm is that it takes a pair of data points and calculates the hyperplane between them.
 Afterward, two new data points are selected and the existing hyperplane is adjusted accordingly.
-This procedure is repeat until a new adjustment would be smaller than some epsilon greater than zero.
+This procedure is repeated until a new adjustment would be smaller than some epsilon greater than zero.
 
 Some SVM implementations try to harness some parallelization potential by not drawing point pairs but group of points.
 In this case, the hyperplane calculation inside this group is parallelized.
-However, even then modern highly parallel hardware can not be utilized efficiently.
+However, even then, modern highly parallel hardware cannot be utilized efficiently.
 
 Therefore, we implemented a version of the original proposed SVM called [Least Squares Support Vector Machine (LS-SVM)](https://en.wikipedia.org/wiki/Least-squares_support-vector_machine).
 The LS-SVMs reformulated the original problem such that it boils down to solving a system of linear equations.
-For this kind of problem many highly parallel algorithms and implementations are known.
+For this kind of problem, many highly parallel algorithms and implementations are known.
 We decided to use the [Conjugate Gradient (CG)](https://en.wikipedia.org/wiki/Conjugate_gradient_method) to solve the system of linear equations.
 
 The main highlights of our SVM implementations are:
 1. Drop-in replacement for LIBSVM's `svm-train`, `svm-predict`, and `svm-scale` (some features currently not implemented).
-2. Support of multiple different programming frameworks for parallelization (also called backends in our PLSSVM implementation) which allows us to target GPUs and CPUs from different vendors like NVIDIA, AMD, or Intel:
+2. Support for multiple different programming frameworks for parallelization (also called backends in our PLSSVM implementation) which allows us to support GPUs and CPUs from different vendors like NVIDIA, AMD, or Intel:
    - [OpenMP](https://www.openmp.org/)
    - [HPX](https://hpx.stellar-group.org/) (tested with current master)
    - C++ 17's standard parallelism [stdpar](https://en.cppreference.com/w/cpp/algorithm):<br>
      **Note**: due to the nature of the used USM mechanics in the `stdpar` implementations, the `stdpar` backend **can't** be enabled together with **any** other backend! <br>
-     **Note**: since every translation units need to be compiled with the same flag, we currently globally set `CMAKE_CXX_FLAGS` although it's discouraged.
+     **Note**: since every translation unit needs to be compiled with the same flag, we currently globally set `CMAKE_CXX_FLAGS` although it's discouraged.
      - [nvc++](https://developer.nvidia.com/hpc-sdk) from NVIDIA's HPC SDK (tested with version [25.3](https://docs.nvidia.com/hpc-sdk/hpc-sdk-release-notes/index.html))
      - [roc-stdpar](https://github.com/ROCm/roc-stdpar) merged into upstream LLVM starting with version 18 (tested with version [18](https://releases.llvm.org/))
      - [icpx](https://www.intel.com/content/www/us/en/developer/tools/oneapi/dpc-compiler.html) as Intel's oneAPI compiler (tested with version [2025.0.0](https://www.intel.com/content/www/us/en/developer/articles/release-notes/oneapi-dpcpp/2025.html))
@@ -83,7 +86,7 @@ The main highlights of our SVM implementations are:
    - laplacian: $\exp(-\gamma$ $\cdot |$ $\vec{u}$ $-$ $\vec{v}$ $|_1)$
    - chi-squared (only well-defined for values > 0): $\exp(-\gamma \cdot \sum_i \frac{(x[i] - y[i])^2}{x[i] + y[i]})$
 4. Two different solver types for a trade-off between memory footprint and runtime:
-   - `cg_explicit`: large memory overhead but very fast
+   - `cg_explicit`: large memory overhead but fast
    - `cg_implicit`: slower but requires drastically less memory
 5. Multi-class classification available via one vs. all (also one vs. rest or OAA) and one vs. one (also OAO):
    - OAA: one huge classification task where our CG algorithm solves a system of linear equations with multiple right-hand sides. The resulting model file is **not** compatible with LIBSVM.
@@ -104,13 +107,13 @@ General dependencies:
 
 - a C++17 capable compiler (e.g. [`gcc`](https://gcc.gnu.org/) or [`clang`](https://clang.llvm.org/))
 - [CMake](https://cmake.org/) 3.25 or newer
-- [cxxopts ≥ v3.2.0](https://github.com/jarro2783/cxxopts), [fast_float ≥ v8.0.2](https://github.com/fastfloat/fast_float), [{fmt} ≥ v11.0.2](https://github.com/fmtlib/fmt), and [igor](https://github.com/bluescarni/igor) (all four are automatically build during the CMake configuration if they couldn't be found using the respective `find_package` call)
+- [cxxopts ≥ v3.3.1](https://github.com/jarro2783/cxxopts), [fast_float ≥ v8.1.0](https://github.com/fastfloat/fast_float), [{fmt} ≥ v12.0.0](https://github.com/fmtlib/fmt), and [igor](https://github.com/bluescarni/igor) (all four are automatically build during the CMake configuration if they couldn't be found using the respective `find_package` call)
 - [GoogleTest ≥ v1.16.0](https://github.com/google/googletest) if testing is enabled (automatically build during the CMake configuration if `find_package(GTest)` wasn't successful)
 - [doxygen](https://www.doxygen.nl/index.html) if documentation generation is enabled
-- [Pybind11 ≥ v2.13.6](https://github.com/pybind/pybind11) if Python bindings are enabled
+- [Pybind11 ≥ v3.0.1](https://github.com/pybind/pybind11) if Python bindings are enabled
 - [OpenMP](https://www.openmp.org/) 4.0 or newer (optional) to speed-up library utilities (like file parsing)
 - [MPI](https://www.mpi-forum.org/) if distributed memory systems should be supported; [mpi4py](https://mpi4py.readthedocs.io/en/stable/) to enable interoperability in our Python bindings
-- [Format.cmake](https://github.com/TheLartians/Format.cmake) if auto formatting via cmake-format and clang-format is enabled; also requires at least clang-format-18 and git, additionally, needs our custom [cmake-format fork](https://github.com/vancraar/cmake_format) incorporating some patches
+- [Format.cmake](https://github.com/TheLartians/Format.cmake) if auto formatting via cmake-format and clang-format is enabled; it also requires at least clang-format-18 and git, additionally, needs our custom [cmake-format fork](https://github.com/vancraar/cmake_format) incorporating some patches
 - multiple Python modules used in the utility scripts, to install all modules use `pip install --user -r install/python_requirements.txt`
 
 Additional dependencies for the OpenMP backend:
@@ -297,8 +300,15 @@ The `[optional_options]` can be one or multiple of:
 - `PLSSVM_ENABLE_FAST_MATH=ON|OFF` (default depending on `CMAKE_BUILD_TYPE`: `ON` for Release or RelWithDebInfo, `OFF` otherwise): enable `fast-math` compiler flags for all backends
 - `PLSSVM_ENABLE_ASSERTS=ON|OFF` (default: `OFF`): enables custom assertions
 - `PLSSVM_USE_FLOAT_AS_REAL_TYPE=ON|OFF` (default: `OFF`): use `float` as real_type instead of `double`
-- `PLSSVM_THREAD_BLOCK_SIZE` (default: `8`): set a specific thread block size used in the GPU kernels (for fine-tuning optimizations)
-- `PLSSVM_INTERNAL_BLOCK_SIZE` (default: `4`): set a specific internal block size used in the GPU kernels (for fine-tuning optimizations)
+- `PLSSVM_THREAD_BLOCK_SIZE` (default: `8`): set a specific thread block size used in the kernels (for fine-tuning optimizations) <br>
+   **Note**: for the different execution spaces in the Kokkos backend, the maximum value of the `PLSSVM_THREAD_BLOCK_SIZE` is not as straight forward as one may wish:
+  - CUDA, HIP, and SYCL: the maximum value depends on the underlying backend (in practice $\sqrt{1024}$ = 32)
+  - HPX and Serial: must **exactly** be 1
+  - OpenMP: must be 1 or 2 (most likely only 1 will work)
+  - Threads: must be 1; however, note that Kokkos itself **must** be built with hwloc support (via `-DKokkos_ENABLE_HWLOC=ON`), otherwise the Kokkos::Threads execution space will always only use a single core
+  - OpenMPTarget: $\sqrt{256}$ = 16
+  - OpenACC: $\lfloor\sqrt{512}\rfloor$ = 22
+- `PLSSVM_INTERNAL_BLOCK_SIZE` (default: `4`): set a specific internal block size used in the kernels (for fine-tuning optimizations)
 - `PLSSVM_ENABLE_LTO=ON|OFF` (default: `OFF`): enable interprocedural optimization (IPO/LTO) if supported by the compiler
 - `PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE=ON|OFF` (default: `ON`): enforce the maximum (device) memory allocation size for the plssvm::solver_type::automatic solver
 - `PLSSVM_ENABLE_PINNED_MEMORY=ON|OFF` (default: `OFF`): use host pinned memory for the input matrix when assembling the kernel matrix, if available
@@ -347,7 +357,7 @@ If the SYCL backend is available, additional options can be set.
   - `AUTO`: check for DPC++/icpx as implementation for the SYCL backend but **do not** fail if not available
   - `OFF`: do not check for DPC++/icpx as implementation for the SYCL backend
 
-- `PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS` (default: `ON`): enable SYCL's `hierarchical` and AdaptiveCpp's `scoped` kernel invocation types
+- `PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS` (default: `ON`): enable SYCL's `hierarchical` data parallel kernel and AdaptiveCpp's `scoped` parallelism 
 
 To use DPC++/icpx for SYCL, simply set the `CMAKE_CXX_COMPILER` to the respective DPC++/icpx clang executable during CMake invocation.
 
@@ -355,7 +365,7 @@ If the SYCL implementation is DPC++/icpx the following additional options are av
 
 - `PLSSVM_SYCL_BACKEND_DPCPP_USE_LEVEL_ZERO` (default: `ON`): use DPC++/icpx's Level-Zero backend instead of its OpenCL backend **(only available if a CPU or Intel GPU is targeted)**
 
-If the SYCL implementation is AdaptiveCpp the following additional option is available:
+If the SYCL implementation is AdaptiveCpp, the following additional option is available:
 
 - `PLSSVM_SYCL_BACKEND_ADAPTIVECPP_USE_GENERIC_SSCP` (default: `ON`): use AdaptiveCpp's new SSCP compilation flow
 
@@ -366,7 +376,7 @@ If more than one SYCL implementation is available the environment variables `PLS
 
 If the Kokkos backend is available, an additional option can be set.
 
-- `PLSSVM_KOKKOS_BACKEND_SYCL_ENABLE_MULTI_GPU` (default: `OFF`): enable multi-GPU support for the Kokkos::SYCL execution space; broken in Kokkos as of version 4.6.00!
+- `PLSSVM_KOKKOS_BACKEND_SYCL_ENABLE_MULTI_GPU` (default: `OFF`): enable multi-GPU support for the Kokkos::SYCL execution space; broken in Kokkos as of version 4.6.01!
 
 If the stdpar backend is available, an additional option can be set.
 
@@ -455,6 +465,19 @@ However, these additional options can be enabled using normal CMake options.
 
 **Note**: the only difference between the dpcpp and icpx presets is the automatically set `CMAKE_CXX_COMPILER`. Internally, both presets use the same SYCL implementation.
 
+#### HPX and including the hpx_main.hpp header
+
+HPX defines some command line options to change its runtime behavior, e.g., `--hpx:threads`.
+However, it also defines some shortcuts for these command line options like `-t`.
+The problem is that these shortcut command line options are likely to collide with other command line options. 
+In the example above the HPX `-t` option to set the number of used threads collides with PLSSVM's `-t` option to determine the kernel function leading to unwanted behavior.
+The only way to disable HPX's shortcut command line options is by including `"hpx/hpx_main.hpp"` which is automatically done in our `"plssvm/environment.hpp"` header.
+However, the [HPX documentation](https://hpx-docs.stellar-group.org/latest/html/manual/starting_the_hpx_runtime.html) states that this header should only be included in the main executable or otherwise linker errors wil occur.
+If the `"plssvm/environment.hpp"` header is included in another file, like in our case the custom GoogleTest main implementation, the `"hpx/hpx_main.cpp"` should not be included.
+This can be achieved by specifying `PLSSVM_HPX_DO_NOT_INCLUDE_HPX_MAIN` before including our header.
+
+All of this also applies to the Kokkos::HPX execution space.
+
 ### Running the Tests
 
 To run the tests after building the library (with `PLSSVM_ENABLE_TESTING` set to `ON`) use:
@@ -497,7 +520,7 @@ Our `cmake-format` can be installed via:
 pip install "git+https://github.com/vancraar/cmake_format@master"
 ```
 
-To check whether formatting changes must be applied use: 
+To check whether formatting changes must be applied, one can use: 
 
 ```bash
 cmake --build . --target check-cmake-format
@@ -519,7 +542,7 @@ If doxygen is installed and `PLSSVM_ENABLE_DOCUMENTATION` is set to `ON` the doc
 cmake --build . -- doc
 ```
 
-The documentation of the current state of the main branch can be found [here](https://sc-sgs.github.io/PLSSVM/).
+The documentation of the current main branch can be found [here](https://sc-sgs.github.io/PLSSVM/).
 
 ### Installing
 
@@ -528,7 +551,7 @@ The documentation of the current state of the main branch can be found [here](ht
 The library supports the `install` target:
 
 ```bash
-cmake --build . -- install
+cmake --build . --target install
 ```
 
 Afterward, the necessary exports should be performed:
@@ -550,13 +573,13 @@ export PYTHONPATH=${CMAKE_INSTALL_PREFIX}/lib:${CMAKE_INSTALL_PREFIX}/lib64:${PY
 
 #### Install via pip
 
-We also support a pip packages that can be used to install our library: 
+We also support a pip package that can be used to install our library: 
 
 ```bash
 pip install plssvm
 ```
 
-This pip install behaves **as if** the CMake `all_python` preset is used. 
+This pip installation behaves **as if** the CMake `all_python` preset is used. 
 This means that the `PLSSVM_TARGET_PLATFORMS` are automatically determined and PLSSVM is build with all supported 
 backends that available on the target machine at the point of the `pip install plssvm` invocation. 
 To check the installation, including, e.g., the installed backends, we provide the `plssvm-install-check` command after 
@@ -588,13 +611,17 @@ Issues: https://github.com/SC-SGS/PLSSVM/issues
 
 PLSSVM provides three executables: `plssvm-train`, `plssvm-predict`, and `plssvm-scale`.
 In addition, PLSSVM can also be used as a library in third-party code.
-For more information, see the respective `man` pages which are installed via `cmake --build . -- install`.
+For more information, see the respective `man` pages which are installed via `cmake --build . -- install`. 
+
+We support the command line options of the third-party libraries [HPX](https://hpx.stellar-group.org/) and [Kokkos](https://github.com/kokkos/kokkos) 
+by forwarding the command line options to the respective initialization functions. 
+Internally, these options are filtered out before they are passed to our command line parser utility. 
 
 ### Generating Artificial Data
 
 The repository comes with a Python3 script (in the `utility_scripts/` directory) to simply generate arbitrarily large classification and regression data sets.
 
-In order to use all functionality, the following Python3 modules must be installed:
+To use all functionality, the following Python3 modules must be installed:
 [`argparse`](https://docs.python.org/3/library/argparse.html), [`timeit`](https://docs.python.org/3/library/timeit.html), 
 [`numpy`](https://pypi.org/project/numpy/), [`pandas`](https://pypi.org/project/pandas/),
 [`sklearn`](https://scikit-learn.org/stable/), [`arff`](https://pypi.org/project/arff/),
@@ -643,7 +670,7 @@ optional arguments:
 
 ```
 
-An example invocation generating a classification data set consisting of blobs with 1000 data points with 200 features each and 
+An example invocation generating a classification data set consisting of blobs with 1000 data points with 200 features and 
 4 classes could look like:
 
 ```bash
@@ -656,7 +683,7 @@ An example invocation generating a linear regression data set consisting of 1000
 python3 generate_data.py --output data_file --format libsvm --problem linear --samples 1000 --features 200 regression
 ```
 
-### Training using `plssvm-train`
+### Training using plssvm-train
 
 ```bash
 ./plssvm-train --help
@@ -686,8 +713,8 @@ Usage:
   -a, --classification arg      the classification strategy to use for multi-class classification: oaa|oao (default: oaa)
   -b, --backend arg             choose the backend: automatic|openmp|hpx|cuda|hip|opencl|sycl|kokkos|stdpar (default: automatic)
   -p, --target_platform arg     choose the target platform: automatic|cpu|gpu_nvidia|gpu_amd|gpu_intel (default: automatic)
-      --sycl_kernel_invocation_type arg
-                                choose the kernel invocation type when using SYCL as backend: automatic|basic|work_group|hierarchical|scoped (default: automatic)
+      --sycl_data_parallel_kernel arg
+                                choose the data parallel kernel when using SYCL as backend: automatic|basic|work_group|hierarchical|scoped (default: automatic)
       --sycl_implementation_type arg
                                 choose the SYCL implementation to be used in the SYCL backend: automatic|dpcpp|adaptivecpp (default: automatic)
       --kokkos_execution_space arg
@@ -709,7 +736,7 @@ Usage:
 The help message only print options available based on the CMake invocation. 
 For example, if CUDA was not available during the build step, it will not show up as possible backend in the description of the `--backend` option.
 
-The most minimal example invocation is:
+The most minimal example of an invocation is:
 
 ```bash
 ./plssvm-train /path/to/data_file
@@ -734,7 +761,7 @@ The `--backend=automatic` option works as follows:
 - otherwise, if the `gpu_intel` target is available, check for existing backends in order `sycl` 🠦 `opencl` 🠦 `kokkos` 🠦 `stdpar`
 - otherwise, if the `cpu` target is available, check for existing backends in order `sycl` 🠦 `kokkos` 🠦 `opencl` 🠦 `openmp` 🠦 `hpx` 🠦 `stdpar`
 
-Note that during CMake configuration it is guaranteed that at least one of the above combinations does exist.
+Note that during CMake configuration, it is guaranteed that at least one of the above combinations does exist.
 
 The `--target_platform=automatic` option works for the different backends as follows:
 
@@ -747,18 +774,19 @@ The `--target_platform=automatic` option works for the different backends as fol
 - `Kokkos`: checks which execution spaces are available and which target platforms they support and then tries to find available devices in the following order: NVIDIA GPUs 🠦 AMD GPUs 🠦 Intel GPUs 🠦 CPU
 - `stdpar`: target device must be selected at compile time (using `PLSSVM_TARGET_PLATFORMS`) or using environment variables at runtime
 
-The `--sycl_kernel_invocation_type` and `--sycl_implementation_type` flags are only used if the `--backend` is `sycl`, otherwise a warning is emitted on `stderr`.
-If the `--sycl_kernel_invocation_type` is `automatic`, the `work_group` invocation type is currently always used.
+The `--sycl_data_parallel_kernel` and `--sycl_implementation_type` flags are only used if the `--backend` is `sycl`, otherwise a warning is emitted on `stderr`.
+If the `--sycl_data_parallel_kernel` is `automatic`, the `work_group` data parallel kernels are currently always used.
 If the `--sycl_implementation_type` is `automatic`, the used SYCL implementation is determined by the `PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION` CMake flag.
 If the `--kokkos_execution_space` is `automatic`, uses the best fitting execution space based on the provided and/or available target platforms.
 
-### Predicting using `plssvm-predict`
+### Predicting using plssvm-predict
 
-Our predict utility is fully conform to LIBSVM's model files. 
+Our `plssvm-predict` utility is fully conforming to LIBSVM's model files. 
 This means that our `plssvm-predict` can be used on model files learned with, e.g., LIBSVM's `svm-train`. 
 Note: this is not the case for the regression task since the `svm_type` filed mismatch between LIBSVM (`epsilon_svr`) 
-and PLSSVM (`c_svr`). To automatically convert between the two, simply use the `convert_model.py` script 
-(in the `utility_scripts/` directory) which simply replaces these fields with the respectively expected one 
+and PLSSVM (`c_svr`). 
+To automatically convert between the two, the `convert_model.py` script (in the `utility_scripts/` directory) 
+can be used which simply replaces these fields with the respectively expected one 
 (note that for large files doing that manually may be faster):
 
 ```bash
@@ -796,8 +824,8 @@ Usage:
 
   -b, --backend arg             choose the backend: automatic|openmp|hpx|cuda|hip|opencl|sycl|kokkos|stdpar (default: automatic)
   -p, --target_platform arg     choose the target platform: automatic|cpu|gpu_nvidia|gpu_amd|gpu_intel (default: automatic)
-      --sycl_kernel_invocation_type arg
-                                choose the kernel invocation type when using SYCL as backend: automatic|basic|work_group|hierarchical|scoped (default: automatic)
+      --sycl_data_parallel_kernel arg
+                                choose the data parallel kernel when using SYCL as backend: automatic|basic|work_group|hierarchical|scoped (default: automatic)
       --sycl_implementation_type arg
                                 choose the SYCL implementation to be used in the SYCL backend: automatic|dpcpp|adaptivecpp (default: automatic)
       --kokkos_execution_space arg
@@ -830,7 +858,7 @@ Another example targeting NVIDIA GPUs using the SYCL backend looks like:
 
 The `--target_platform=automatic` and `--sycl_implementation_type` flags work like in the training (`./plssvm-train`) case.
 
-### Data Scaling using `plssvm-scale`
+### Data Scaling using plssvm-scale
 
 ```bash
 ./plssvm-scale --help
@@ -872,7 +900,7 @@ An example invocation to scale a train and test file in the same way looks like:
 ### Distributed Memory Support via MPI
 
 We support distributed memory via MPI for `plssvm-train` and `plssvm-predict` while simultaneously allowing multiple devices per MPI rank.
-In order to use it, MPI must be found during the CMake configuration step.
+To use MPI, it must be found during the CMake configuration step.
 Note that if MPI couldn't be found, PLSSVM still works in shared memory mode only and internally disables all MPI related functionality.
 For example, to run PLSSVM via MPI on four nodes simply use the normal `mpirun` command:
 
@@ -892,17 +920,33 @@ Note that the number of provided load balancing weights must be equal to the use
 If one MPI rank has more than one device, all these devices on one MPI rank compute the same number of matrix elements. 
 
 Our MPI implementation, however, currently has some limitations:
-- the training, test, and model data is fully read by **every** MPI rank
-- the training, test, and model data is fully stored on **each** compute device on **every** MPI rank
+- **every** MPI rank fully reads the training, test, and model data
+- **each** compute device on **every** MPI rank fully stores the training, test, and model data
 - **only** the kernel matrix is really divided across **all** MPI ranks
 - while the expensive BLAS level 3 operations in the CG algorithm are computed in a distributed way, everything else is computed on **every** MPI rank
-- in the CG algorithm we communicate the whole matrix, although it would be sufficient to communicate only matrix parts
+- in the CG algorithm we communicate the whole matrix, although it would be enough to communicate only matrix parts
 - **only** the **main** MPI rank (per default rank 0) writes the output files
 - `plssvm-scale` **does not** support more than one MPI rank
 
+### Device Filtering
+
+Since PLSSVM supports devices from different target platforms as well as multiple devices from a single target platform,
+it may be necessary to filter them at runtime to, e.g., select only a single GPU in a multi-GPU setup.
+In general, this device filtering is done using environment variables. 
+However, the exact environment variable and syntax depends on the used backend:
+
+- `CUDA`: use [`CUDA_VISIBLE_DEVICES`](https://docs.nvidia.com/deploy/topics/topic_5_2_1.html) (e.g., `CUDA_VISIBLE_DEVICES=0,2`)
+- `HIP`: use [`HIP_VISIBLE_DEVICES`](https://rocm.docs.amd.com/en/latest/conceptual/gpu-isolation.html#hip-visible-devices) (e.g., `HIP_VISIBLE_DEVICES=0,2`)
+- `OpenCL`: use the PLSSVM specific `PLSSVM_OPENCL_DEVICE_FILTER` variable (e.g., `PLSSVM_OPENCL_DEVICE_FILTER=gpu_nvidia:0;gpu_nvidia:2`) with the syntax: `target_platform:device_id;...`;
+alternatively, in many cases the respective vendor mechanism can also be used
+- `SYCL` using DPC++/icpx: use [`ONEAPI_DEVICE_SELECTOR`](https://intel.github.io/llvm/EnvironmentVariables.html#oneapi-device-selector) (e.g., `ONEAPI_DEVICE_SELECTOR=cuda:0,2`)
+- `SYCL` using AdaptiveCpp: use [`ACPP_VISIBILITY_MASK`](https://github.com/AdaptiveCpp/AdaptiveCpp/blob/develop/doc/env_variables.md) for a broader backend level selector and the respective vendor specific environment variables for a more fine-grained selection mechanism
+- `Kokkos`: use the mechanism form the respective execution space
+- `stdpar`: use the mechanism from the respective implementation
+
 ### Example Code for PLSSVM Used as a Library
 
-A simple C++ program (`main_classification.cpp`) using PLSSVM as library for classification could look like:
+A simple C++ program (`main_classification.cpp`) using PLSSVM as a library for classification could look like:
 
 ```cpp
 #include "plssvm/core.hpp"
@@ -940,7 +984,7 @@ int main() {
         const std::vector<int> &correct_label = test_data.labels().value();
         std::cout << plssvm::classification_report{ correct_label, predicted_label } << std::endl;
 
-        // write model file to disk
+        // write the model file to disk
         model.save("model_file.libsvm");
     } catch (const plssvm::exception &e) {
         std::cerr << e.what_with_loc() << std::endl;
@@ -952,7 +996,7 @@ int main() {
 }
 ```
 
-A simple C++ program (`main_regression.cpp`) using PLSSVM as library for regression could look like:
+A simple C++ program (`main_regression.cpp`) using PLSSVM as a library for regression could look like:
 
 ```cpp
 #include "plssvm/core.hpp"
@@ -990,7 +1034,7 @@ int main() {
         const std::vector<plssvm::real_type> &correct_values = test_data.labels().value();
         std::cout << plssvm::regression_report{ correct_label, predicted_label } << std::endl;
 
-        // write model file to disk
+        // write the model file to disk
         model.save("model_file.libsvm");
     } catch (const plssvm::exception &e) {
         std::cerr << e.what_with_loc() << std::endl;
@@ -1036,7 +1080,7 @@ endforeach ()
 The `examples/python` directory contains the same examples using our PLSSVM Python bindings. 
 Additionally, it contains Python examples leveraging MPI to target distributed memory systems. 
 
-### Example Using the `sklearn` like Python Bindings Available For PLSSVM
+### Example Using the sklearn like Python Bindings Available For PLSSVM
 
 A classification example using PLSSVM's `SVC` Python binding and sklearn's breast cancer data set:
 
@@ -1083,13 +1127,13 @@ sklearn.inspection.DecisionBoundaryDisplay.from_estimator(
 )
 
 # scatter plot the decision boundary
-viridis = plt.cm.get_cmap('viridis', len(np.unique(y)))
+viridis = plt.get_cmap('viridis', len(np.unique(y)))
 plt.scatter(X[:, 0], X[:, 1],
             cmap=viridis,
             c=y,
             s=20, edgecolors="k")
 
-# generate legend handles and add handle
+# generate legend handles
 legend_handles = [plt.scatter([], [], color=viridis(color), label=f'{label}')
                   for label, color in zip(y_label, np.unique(y))]
 plt.legend(handles=legend_handles)
@@ -1111,7 +1155,10 @@ weighted avg       0.91      0.91      0.91       569
 Score: 91.39%
 ```
 <p align="center">
-  <img alt="Example classification task breast cancer decision boundary output." src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures/classification_example.png" width="80%">
+  <img 
+    alt="Example classification task breast cancer decision boundary output." 
+    src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures/classification_example.png" 
+    style="max-width:600px; width:80%; height:auto;">
 </p>
 
 A regression example comparing PLSSVM's `SVR` Python binding and `sklearn.SVR` using a sine curve:
@@ -1178,14 +1225,17 @@ plt.show()
 ```
 with an example output:
 <p align="center">
-  <img alt="Example regression output using a sine curve." src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures/regression_example.png" width="80%">
+  <img 
+    alt="Example regression output using a sine curve." 
+    src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures/regression_example.png" 
+    style="max-width:600px; width:50%; height:auto;">
 </p>
 
 Note that currently not all sklearn `SVC` and `SVR` functionality has been implemented in PLSSVM.
 The respective functions will throw a Python `AttributeError` if called.
 For a detailed overview of the functions that are currently implemented, see [our API documentation](bindings/Python/README.md).
 
-There are more examples located in the `examples/python/sklearn` directory that are copied from the sklearn repository and slightly changed for PLSSVM.
+There are more examples located in the [examples/python/sklearn](examples/python/sklearn/README.md) directory that are copied from the sklearn repository and slightly changed for PLSSVM.
 
 ## Citing PLSSVM
 
diff --git a/bindings/Python/.clang-tidy b/bindings/Python/.clang-tidy
new file mode 100644
index 000000000..cdf2ade2d
--- /dev/null
+++ b/bindings/Python/.clang-tidy
@@ -0,0 +1,6 @@
+---
+Checks: '
+-misc-include-cleaner,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/bindings/Python/CMakeLists.txt b/bindings/Python/CMakeLists.txt
index 19e8777c1..4d41f7fcf 100644
--- a/bindings/Python/CMakeLists.txt
+++ b/bindings/Python/CMakeLists.txt
@@ -10,9 +10,13 @@ message(STATUS "Building Python language bindings for PLSSVM.")
 
 find_package(Python COMPONENTS Interpreter Development)
 
+# ~~~
+# Note: Even with newer Pybind11 version, we cannot really use py::native_enum since it DOES NOT support string -> C++ enum
+#       conversions and I couldn't find a solution to make it work without worsening the public API.
+# ~~~
 # try finding pybind11
-set(PLSSVM_pybind11_VERSION v2.13.6)
-find_package(pybind11 2.13.6 QUIET)
+set(PLSSVM_pybind11_VERSION v3.0.1)
+find_package(pybind11 3.0.1 QUIET)
 if (pybind11_FOUND)
     message(STATUS "Found package pybind11.")
 else ()
@@ -39,6 +43,7 @@ set(PLSSVM_PYTHON_BINDINGS_SOURCES
     ${CMAKE_CURRENT_LIST_DIR}/model/regression_model.cpp
     ${CMAKE_CURRENT_LIST_DIR}/sklearn_like/svc.cpp
     ${CMAKE_CURRENT_LIST_DIR}/sklearn_like/svr.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/sklearn_like/tags.cpp
     ${CMAKE_CURRENT_LIST_DIR}/svm/csvm.cpp
     ${CMAKE_CURRENT_LIST_DIR}/svm/csvc.cpp
     ${CMAKE_CURRENT_LIST_DIR}/svm/csvr.cpp
@@ -73,7 +78,7 @@ if (TARGET ${PLSSVM_HPX_BACKEND_LIBRARY_NAME})
 endif ()
 if (TARGET ${PLSSVM_STDPAR_BACKEND_LIBRARY_NAME})
 
-    # AdaptiveCpp stdpar only support on the CPU when using our Python bindings
+    # AdaptiveCpp stdpar only support the CPU as target in our Python bindings
     if (PLSSVM_STDPAR_BACKEND STREQUAL "ACPP" AND (DEFINED PLSSVM_NVIDIA_TARGET_ARCHS OR DEFINED PLSSVM_AMD_TARGET_ARCHS OR DEFINED PLSSVM_INTEL_TARGET_ARCHS))
         message(
             FATAL_ERROR
@@ -116,6 +121,7 @@ target_compile_definitions(${PLSSVM_PYTHON_BINDINGS_LIBRARY_NAME} PRIVATE PYBIND
 
 # disable clang compiler warning
 target_compile_options(${PLSSVM_BASE_LIBRARY_NAME} PUBLIC $<$<COMPILE_LANG_AND_ID:CXX,Clang,IntelLLVM>:-Wno-self-assign-overloaded>)
+target_compile_options(${PLSSVM_BASE_LIBRARY_NAME} PUBLIC $<$<COMPILE_LANG_AND_ID:CXX,GNU,Clang,IntelLLVM>:-Wno-null-dereference>)
 target_compile_options(${PLSSVM_BASE_LIBRARY_NAME} PUBLIC -fPIC)
 
 include(GNUInstallDirs)
diff --git a/bindings/Python/README.md b/bindings/Python/README.md
index 504d2533b..d6786bd5a 100644
--- a/bindings/Python/README.md
+++ b/bindings/Python/README.md
@@ -1,3 +1,5 @@
+<!-- DOXYGEN_PYTHON_BINDINGS_LINK -->
+
 # The Python3 Bindings
 
 - [Sklearn like API for sklearn.svm.SVC](#sklearn-like-api-for-sklearnsvmsvc)
@@ -28,10 +30,9 @@ of [`sklearn.svm.SVC`](https://scikit-learn.org/stable/modules/generated/sklearn
 `sklearn.svm.SVR`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html) and one extremely closely
 to our C++ API.
 
-**Note**: this page is solely meant as an API reference and overview. For examples see the
-top-level [`../../examples/`](/examples) folder.
+**Note**: this page is solely meant as an API reference and overview. For examples see the examples folder.
 
-## Sklearn like API for `sklearn.svm.SVC`
+## Sklearn like API for sklearn.svm.SVC
 
 The following tables show the API provided
 by [`sklearn.svm.SVC`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html) and whether we currently
@@ -187,7 +188,7 @@ More detailed description of the class methods:
     - Returns:
         - `self : object`: The updated object.
 
-## Sklearn like API for `sklearn.svm.SVR`
+## Sklearn like API for sklearn.svm.SVR
 
 The following tables show the API provided
 by [`sklearn.svm.SVR`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html) and whether we currently
@@ -332,10 +333,10 @@ The following table lists all PLSSVM enumerations exposed on the Python side:
 
 If a SYCL implementation is available, additional enumerations are available:
 
-| enumeration            | values                                                       | description                                                                                                                                                                                                                                               |
-|------------------------|--------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `ImplementationType`   | `AUTOMATIC`, `DPCPP`, `ADAPTIVECPP`                          | The different supported SYCL implementation types (default: `AUTOMATIC`). If `AUTOMATIC` is provided, determines the used SYCL implementation based on the value of `-DPLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION` provided during PLSSVM'S build step. |
-| `KernelInvocationType` | `AUTOMATIC`, `BASIC`, `WORK_GROUP`, `HIERARCHICAL`, `SCOPED` | The different supported SYCL kernel invocation types (default: `AUTOMATIC`). If `AUTOMATIC` is provided, simply uses `WORK_GROUP`.                                                                                                                        |
+| enumeration          | values                                                       | description                                                                                                                                                                                                                                               |
+|----------------------|--------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `ImplementationType` | `AUTOMATIC`, `DPCPP`, `ADAPTIVECPP`                          | The different supported SYCL implementation types (default: `AUTOMATIC`). If `AUTOMATIC` is provided, determines the used SYCL implementation based on the value of `-DPLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION` provided during PLSSVM'S build step. |
+| `DataParallelKernel` | `AUTOMATIC`, `BASIC`, `WORK_GROUP`, `HIERARCHICAL`, `SCOPED` | The different supported SYCL data parallel kernels (default: `AUTOMATIC`). If `AUTOMATIC` is provided, simply uses `WORK_GROUP`.                                                                                                                          |
 
 If the stdpar backend is available, an additional enumeration is available:
 
@@ -355,7 +356,7 @@ If the Kokos backend is available, an additional enumeration is available:
 
 The following tables list all PLSSVM classes exposed on the Python side:
 
-#### `plssvm.Parameter`
+#### plssvm.Parameter
 
 The parameter class encapsulates all necessary hyperparameters needed to fit an SVM.
 
@@ -378,7 +379,7 @@ The parameter class encapsulates all necessary hyperparameters needed to fit an
 | `param1 != param2`    | Check whether two parameter objects aren't identical.                                               |
 | `print(param)`        | Overload to print a `plssvm.Parameter` object displaying the used hyper-parameters.                 |
 
-#### `plssvm.ClassificationDataSet` and `plssvm.RegressionDataSet`
+#### plssvm.ClassificationDataSet and plssvm.RegressionDataSet
 
 A class encapsulating a used classification or regression data set.
 The label types are either determined by the provided labels or if no labels are given or the data is read through a 
@@ -412,7 +413,7 @@ The following methods are **only** available for a `plssvm.ClassificationDataSet
 | `num_classes()` | Return the number of classes. **Note**: `0` if no labels are present. |
 | `classes()`     | Return the different classes, if labels are present.                  |
 
-#### `plssvm.MinMaxScaler`
+#### plssvm.MinMaxScaler
 
 A class encapsulating and performing the scaling of a data set to the provided `[lower, upper]` range.
 
@@ -430,7 +431,7 @@ A class encapsulating and performing the scaling of a data set to the provided `
 | `communicator()`     | Return the used MPI communicator.                                                                                 |
 | `print(scaling)`     | Overload to print a data set scaling object object displaying the scaling interval and number of scaling factors. |
 
-##### `plssvm.MinMaxScalerFactors`
+##### plssvm.MinMaxScalerFactors
 
 A class encapsulating a scaling factor for a specific feature in a data set obtained by `plssvm.MinMaxScaler`.
 **Note**: it shouldn't be necessary to directly use `plssvm.MinMaxScalerFactors` in user code.
@@ -449,7 +450,7 @@ A class encapsulating a scaling factor for a specific feature in a data set obta
 |-------------------------|----------------------------------------------------------------------------------------------------------------|
 | `print(scaling_factor)` | Overload to print a data set scaling object object displaying the feature's index, minimum, and maximum value. |
 
-#### `plssvm.CSVC` and `plssvm.CSVR`
+#### plssvm.CSVC and plssvm.CSVR
 
 The main class responsible for fitting an SVM model and later predicting or scoring new data sets.
 It uses either the provided backend type or the default determined one to create a PLSSVM C-SVM of the correct backend
@@ -469,7 +470,7 @@ The following constructors and methods are available for both classification `CS
 
 **Note**: if the backend type is `plssvm.BackendType.SYCL` two additional named parameters can be provided:
 `sycl_implementation_type` to choose between DPC++ and AdaptiveCpp as SYCL implementations
-and `sycl_kernel_invocation_type` to choose between the two different SYCL kernel invocation types.
+and `sycl_data_parallel_kernel` to choose between the different SYCL data parallel kernels.
 
 **Note**: if the backend type is `plssvm.BackendType.HPX` or `plssvm.BackendType.Kokkos` special initialization and
 finalization functions must be called.
@@ -490,7 +491,7 @@ However, this is **automatically** handled by our Python bindings on the module
 
 **Note**: the `classification` named parameter is not allowed for the `CSVR`!
 
-#### The backend `C-SVC`s and `C-SVR`s
+#### The backend C-SVCs and C-SVRs
 
 These classes represent the backend specific C-SVMs:
 - OpenMP: `plssvm.openmp.CSVC` and `plssvm.openmp.CSVR`
@@ -519,12 +520,12 @@ The following constructors and methods are available for both classification `CS
 | `CSVC(target, *, kernel_type=plssvm.KernelFunctionType.RBF, degree=3, gamma=plssvm.GammaCoefficientType.AUTO, coef0=0.0, cost=1.0, comm=*used MPI communicator*)` | Create a new C-SVM with the provided parameters and named arguments.                |
 
 In case of the SYCL C-SVMs (`plssvm.sycl.CSVM`, `plssvm.dpcpp.CSVM`, and `plssvm.adaptivecpp.CSVM`; the same for the 
-`CSVR`s), additionally, all constructors also accept the SYCL specific `sycl_kernel_invocation_type` keyword parameter.
+`CSVR`s), additionally, all constructors also accept the SYCL specific `sycl_data_parallel_kernel` keyword parameter.
 Also, the following method is additional available for the backend specific C-SVM:
 
-| methods                        | description                             |
-|--------------------------------|-----------------------------------------|
-| `get_kernel_invocation_type()` | Return the SYCL kernel invocation type. |
+| methods                      | description                                |
+|------------------------------|--------------------------------------------|
+| `get_data_parallel_kernel()` | Return the used SYCL data parallel kernel. |
 
 In case of the stdpar C-SVM (`plssvm.stdpar.CSVC` and `plssvm.stdpar.CSVR`) the following method is additional available for the backend specific
 C-SVM.
@@ -540,7 +541,7 @@ Also, the following method is additional available for the backend specific C-SV
 |-------------------------|-----------------------------------------|
 | `get_execution_space()` | Return the used Kokkos execution space. |
 
-#### `plssvm.ClassificationModel` and `plssvm::RegressionModel`
+#### plssvm.ClassificationModel and plssvm::RegressionModel
 
 A class encapsulating a model learned during a call to `plssvm.CSVC.fit()` or `plssvm::CSVR.fit()`. 
 
@@ -571,7 +572,7 @@ The following methods are **only** available for a `plssvm.ClassificationModel`:
 | `classes()`                 | Return the different classes.            |
 | `get_classification_type()` | Return the used classification strategy. |
 
-#### `plssvm.performance_tracking`
+#### plssvm.performance_tracking
 
 A submodule used to track various performance statistics like runtimes, but also the used setup and hyperparameters.
 The tracked metrics can be saved to a YAML file for later post-processing.
@@ -592,7 +593,7 @@ The tracked metrics can be saved to a YAML file for later post-processing.
 | `get_events()`                                     | Return all previously recorded events.                                                 |
 | `clear_tracking_entries()`                         | Remove all currently tracked entries from the performance tracker.                     |
 
-#### `plssvm.performance_tracking.Event`, `plssvm.performance_tracking.Events`
+#### plssvm.performance_tracking.Event, plssvm.performance_tracking.Events
 
 Two rather similar classes.
 **Note**: both classes are only available if PLSSVM was built with `-DPLSSVM_ENABLE_PERFORMANCE_TRACKING=ON`!
diff --git a/bindings/Python/backend_types.cpp b/bindings/Python/backend_types.cpp
index 7696ddaa8..6059c15be 100644
--- a/bindings/Python/backend_types.cpp
+++ b/bindings/Python/backend_types.cpp
@@ -9,18 +9,19 @@
 
 #include "plssvm/backend_types.hpp"  // plssvm::backend_type, plssvm::list_available_backends, plssvm::determine_default_backend
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::register_implicit_str_enum_conversion
+#include "plssvm/target_platforms.hpp"  // plssvm::list_available_target_platforms
 
-#include "pybind11/pybind11.h"  // py::module_, py::enum_
-#include "pybind11/stl.h"       // support for STL types: std::vector
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::register_implicit_str_enum_conversion
 
-#include <vector>  // std::vector
+#include "pybind11/pybind11.h"  // py::module_, py::enum_
+#include "pybind11/stl.h"       // NOLINT: support for STL types: std::vector
 
 namespace py = pybind11;
 
 void init_backend_types(py::module_ &m) {
     // bind enum class
-    py::enum_<plssvm::backend_type> py_enum(m, "BackendType", "Enum class for all possible backend types, all different SYCL implementations have the same backend type \"sycl\".");
+    py::enum_<plssvm::backend_type> py_enum(m, "BackendType", "enum.Enum", "Enum class for all possible backend types, all different SYCL implementations have the same backend type \"sycl\".");
     py_enum
         .value("AUTOMATIC", plssvm::backend_type::automatic, "the default backend; depends on the specified target platform")
         .value("OPENMP", plssvm::backend_type::openmp, "OpenMP to target CPUs only (currently no OpenMP target offloading support)")
diff --git a/bindings/Python/backends/adaptivecpp_csvm.cpp b/bindings/Python/backends/adaptivecpp_csvm.cpp
index bf43d85f1..1d5e0e6dd 100644
--- a/bindings/Python/backends/adaptivecpp_csvm.cpp
+++ b/bindings/Python/backends/adaptivecpp_csvm.cpp
@@ -6,21 +6,22 @@
  *          See the LICENSE.md file in the project root for full license information.
  */
 
-#include "plssvm/backend_types.hpp"                          // plssvm::adaptivecpp::backend_csvm_type_t
-#include "plssvm/backends/SYCL/AdaptiveCpp/csvm.hpp"         // plssvm::adaptivecpp::csvm
-#include "plssvm/backends/SYCL/exceptions.hpp"               // plssvm::adaptivecpp::backend_exception
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/constants.hpp"                              // plssvm::real_type
-#include "plssvm/exceptions/exceptions.hpp"                  // plssvm::exception
-#include "plssvm/gamma.hpp"                                  // plssvm::gamma
-#include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
-#include "plssvm/mpi/communicator.hpp"                       // plssvm::mpi::communicator
-#include "plssvm/parameter.hpp"                              // plssvm::parameter
-#include "plssvm/svm/csvc.hpp"                               // plssvm::csvc
-#include "plssvm/svm/csvm.hpp"                               // plssvm::csvm
-#include "plssvm/svm/csvr.hpp"                               // plssvm::csvr
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
-
+#include "plssvm/backend_types.hpp"                        // plssvm::adaptivecpp::backend_csvm_type_t
+#include "plssvm/backends/SYCL/AdaptiveCpp/csvm.hpp"       // plssvm::adaptivecpp::csvm
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/exceptions.hpp"             // plssvm::adaptivecpp::backend_exception
+#include "plssvm/constants.hpp"                            // plssvm::real_type
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::exception
+#include "plssvm/gamma.hpp"                                // plssvm::gamma
+#include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/parameter.hpp"                            // plssvm::parameter
+#include "plssvm/svm/csvc.hpp"                             // plssvm::csvc
+#include "plssvm/svm/csvm.hpp"                             // plssvm::csvm
+#include "plssvm/svm/csvr.hpp"                             // plssvm::csvr
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
+
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::register_py_exception
 
@@ -49,18 +50,18 @@ void bind_adaptivecpp_csvms(py::module_ &m, const std::string &csvm_name) {
     const std::string keyword_args_constructor_docstring{ fmt::format("create an AdaptiveCpp SYCL {} with the provided SVM parameter as separate keyword arguments including optional SYCL specific keyword arguments", csvm_name) };
 
     py::class_<backend_csvm_type, plssvm::adaptivecpp::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
-        .def(py::init([](const plssvm::target_platform target, const plssvm::parameter params, const plssvm::sycl::kernel_invocation_type invocation, plssvm::mpi::communicator comm) {
-                 return std::make_unique<backend_csvm_type>(std::move(comm), target, params, plssvm::sycl_kernel_invocation_type = invocation);
+        .def(py::init([](const plssvm::target_platform target, const plssvm::parameter params, const plssvm::sycl::data_parallel_kernel data_parallel_kernel_type, plssvm::mpi::communicator comm) {
+                 return std::make_unique<backend_csvm_type>(std::move(comm), target, params, plssvm::sycl_data_parallel_kernel = data_parallel_kernel_type);
              }),
              params_constructor_docstring.c_str(),
              py::arg("target") = plssvm::target_platform::automatic,
              py::kw_only(),
              py::arg("params") = default_params,
-             py::arg("sycl_kernel_invocation_type") = plssvm::sycl::kernel_invocation_type::automatic,
+             py::arg("sycl_data_parallel_kernel") = plssvm::sycl::data_parallel_kernel::automatic,
              py::arg("comm") = plssvm::mpi::communicator{})
-        .def(py::init([](const plssvm::target_platform target, const plssvm::kernel_function_type kernel_type, const int degree, const plssvm::gamma_type gamma, const plssvm::real_type coef0, const plssvm::real_type cost, const plssvm::sycl::kernel_invocation_type invocation, plssvm::mpi::communicator comm) {
+        .def(py::init([](const plssvm::target_platform target, const plssvm::kernel_function_type kernel_type, const int degree, const plssvm::gamma_type gamma, const plssvm::real_type coef0, const plssvm::real_type cost, const plssvm::sycl::data_parallel_kernel data_parallel_kernel_type, plssvm::mpi::communicator comm) {
                  const plssvm::parameter params{ kernel_type, degree, gamma, coef0, cost };
-                 return std::make_unique<backend_csvm_type>(std::move(comm), target, params, plssvm::sycl_kernel_invocation_type = invocation);
+                 return std::make_unique<backend_csvm_type>(std::move(comm), target, params, plssvm::sycl_data_parallel_kernel = data_parallel_kernel_type);
              }),
              keyword_args_constructor_docstring.c_str(),
              py::arg("target") = plssvm::target_platform::automatic,
@@ -70,11 +71,11 @@ void bind_adaptivecpp_csvms(py::module_ &m, const std::string &csvm_name) {
              py::arg("gamma") = default_params.gamma,
              py::arg("coef0") = default_params.coef0,
              py::arg("cost") = default_params.cost,
-             py::arg("sycl_kernel_invocation_type") = plssvm::sycl::kernel_invocation_type::automatic,
+             py::arg("sycl_data_parallel_kernel") = plssvm::sycl::data_parallel_kernel::automatic,
              py::arg("comm") = plssvm::mpi::communicator{})
-        .def("get_kernel_invocation_type", &plssvm::adaptivecpp::csvm::get_kernel_invocation_type, "get the kernel invocation type used in this SYCL C-SVM")
+        .def("get_data_parallel_kernel", &plssvm::adaptivecpp::csvm::get_data_parallel_kernel, "get the data parallel kernel used in this SYCL C-SVM")
         .def("__repr__", [csvm_name](const backend_csvm_type &self) {
-            return fmt::format("<plssvm.adaptivecpp.{} with {{ #devices: {}, kernel_invocation_type: {} }}>", csvm_name, self.num_available_devices(), self.get_kernel_invocation_type());
+            return fmt::format("<plssvm.adaptivecpp.{} with {{ #devices: {}, data_parallel_kernel: {} }}>", csvm_name, self.num_available_devices(), self.get_data_parallel_kernel());
         });
 }
 
diff --git a/bindings/Python/backends/cuda_csvm.cpp b/bindings/Python/backends/cuda_csvm.cpp
index f5984065d..b405c6e0d 100644
--- a/bindings/Python/backends/cuda_csvm.cpp
+++ b/bindings/Python/backends/cuda_csvm.cpp
@@ -20,6 +20,7 @@
 #include "plssvm/svm/csvr.hpp"                  // plssvm::csvr
 #include "plssvm/target_platforms.hpp"          // plssvm::target_platform
 
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::register_py_exception
 
diff --git a/bindings/Python/backends/dpcpp_csvm.cpp b/bindings/Python/backends/dpcpp_csvm.cpp
index 51dcd7e16..a9daa0de5 100644
--- a/bindings/Python/backends/dpcpp_csvm.cpp
+++ b/bindings/Python/backends/dpcpp_csvm.cpp
@@ -6,21 +6,22 @@
  *          See the LICENSE.md file in the project root for full license information.
  */
 
-#include "plssvm/backend_types.hpp"                          // plssvm::dpcpp::backend_csvm_type_t
-#include "plssvm/backends/SYCL/DPCPP/csvm.hpp"               // plssvm::dpcpp::csvm
-#include "plssvm/backends/SYCL/exceptions.hpp"               // plssvm::dpcpp::backend_exception
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/constants.hpp"                              // plssvm::real_type
-#include "plssvm/exceptions/exceptions.hpp"                  // plssvm::exception
-#include "plssvm/gamma.hpp"                                  // plssvm::gamma
-#include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
-#include "plssvm/mpi/communicator.hpp"                       // plssvm::mpi::communicator
-#include "plssvm/parameter.hpp"                              // plssvm::parameter
-#include "plssvm/svm/csvc.hpp"                               // plssvm::csvc
-#include "plssvm/svm/csvm.hpp"                               // plssvm::csvm
-#include "plssvm/svm/csvr.hpp"                               // plssvm::csvr
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
-
+#include "plssvm/backend_types.hpp"                        // plssvm::dpcpp::backend_csvm_type_t
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/DPCPP/csvm.hpp"             // plssvm::dpcpp::csvm
+#include "plssvm/backends/SYCL/exceptions.hpp"             // plssvm::dpcpp::backend_exception
+#include "plssvm/constants.hpp"                            // plssvm::real_type
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::exception
+#include "plssvm/gamma.hpp"                                // plssvm::gamma
+#include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/parameter.hpp"                            // plssvm::parameter
+#include "plssvm/svm/csvc.hpp"                             // plssvm::csvc
+#include "plssvm/svm/csvm.hpp"                             // plssvm::csvm
+#include "plssvm/svm/csvr.hpp"                             // plssvm::csvr
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
+
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::register_py_exception
 
@@ -49,18 +50,18 @@ void bind_dpcpp_csvms(py::module_ &m, const std::string &csvm_name) {
     const std::string keyword_args_constructor_docstring{ fmt::format("create a DPC++ SYCL {} with the provided SVM parameter as separate keyword arguments including optional SYCL specific keyword arguments", csvm_name) };
 
     py::class_<backend_csvm_type, plssvm::dpcpp::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
-        .def(py::init([](const plssvm::target_platform target, const plssvm::parameter params, const plssvm::sycl::kernel_invocation_type invocation, plssvm::mpi::communicator comm) {
-                 return std::make_unique<backend_csvm_type>(std::move(comm), target, params, plssvm::sycl_kernel_invocation_type = invocation);
+        .def(py::init([](const plssvm::target_platform target, const plssvm::parameter params, const plssvm::sycl::data_parallel_kernel data_parallel_kernel_type, plssvm::mpi::communicator comm) {
+                 return std::make_unique<backend_csvm_type>(std::move(comm), target, params, plssvm::sycl_data_parallel_kernel = data_parallel_kernel_type);
              }),
              params_constructor_docstring.c_str(),
              py::arg("target") = plssvm::target_platform::automatic,
              py::kw_only(),
              py::arg("params") = default_params,
-             py::arg("sycl_kernel_invocation_type") = plssvm::sycl::kernel_invocation_type::automatic,
+             py::arg("sycl_data_parallel_kernel") = plssvm::sycl::data_parallel_kernel::automatic,
              py::arg("comm") = plssvm::mpi::communicator{})
-        .def(py::init([](const plssvm::target_platform target, const plssvm::kernel_function_type kernel_type, const int degree, const plssvm::gamma_type gamma, const plssvm::real_type coef0, const plssvm::real_type cost, const plssvm::sycl::kernel_invocation_type invocation, plssvm::mpi::communicator comm) {
+        .def(py::init([](const plssvm::target_platform target, const plssvm::kernel_function_type kernel_type, const int degree, const plssvm::gamma_type gamma, const plssvm::real_type coef0, const plssvm::real_type cost, const plssvm::sycl::data_parallel_kernel data_parallel_kernel_type, plssvm::mpi::communicator comm) {
                  const plssvm::parameter params{ kernel_type, degree, gamma, coef0, cost };
-                 return std::make_unique<backend_csvm_type>(std::move(comm), target, params, plssvm::sycl_kernel_invocation_type = invocation);
+                 return std::make_unique<backend_csvm_type>(std::move(comm), target, params, plssvm::sycl_data_parallel_kernel = data_parallel_kernel_type);
              }),
              keyword_args_constructor_docstring.c_str(),
              py::arg("target") = plssvm::target_platform::automatic,
@@ -70,11 +71,11 @@ void bind_dpcpp_csvms(py::module_ &m, const std::string &csvm_name) {
              py::arg("gamma") = default_params.gamma,
              py::arg("coef0") = default_params.coef0,
              py::arg("cost") = default_params.cost,
-             py::arg("sycl_kernel_invocation_type") = plssvm::sycl::kernel_invocation_type::automatic,
+             py::arg("sycl_data_parallel_kernel") = plssvm::sycl::data_parallel_kernel::automatic,
              py::arg("comm") = plssvm::mpi::communicator{})
-        .def("get_kernel_invocation_type", &plssvm::dpcpp::csvm::get_kernel_invocation_type, "get the kernel invocation type used in this SYCL C-SVM")
+        .def("get_data_parallel_kernel", &plssvm::dpcpp::csvm::get_data_parallel_kernel, "get the data parallel kernel used in this SYCL C-SVM")
         .def("__repr__", [csvm_name](const backend_csvm_type &self) {
-            return fmt::format("<plssvm.dpcpp.{} with {{ #devices: {}, kernel_invocation_type: {} }}>", csvm_name, self.num_available_devices(), self.get_kernel_invocation_type());
+            return fmt::format("<plssvm.dpcpp.{} with {{ #devices: {}, data_parallel_kernel: {} }}>", csvm_name, self.num_available_devices(), self.get_data_parallel_kernel());
         });
 }
 
diff --git a/bindings/Python/backends/hip_csvm.cpp b/bindings/Python/backends/hip_csvm.cpp
index b1f6ca7f1..76230af67 100644
--- a/bindings/Python/backends/hip_csvm.cpp
+++ b/bindings/Python/backends/hip_csvm.cpp
@@ -20,6 +20,7 @@
 #include "plssvm/svm/csvr.hpp"                 // plssvm::csvr
 #include "plssvm/target_platforms.hpp"         // plssvm::target_platform
 
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::register_py_exception
 
diff --git a/bindings/Python/backends/hpx_csvm.cpp b/bindings/Python/backends/hpx_csvm.cpp
index 91d56d58c..3210dadcb 100644
--- a/bindings/Python/backends/hpx_csvm.cpp
+++ b/bindings/Python/backends/hpx_csvm.cpp
@@ -21,6 +21,7 @@
 #include "plssvm/svm/csvr.hpp"                 // plssvm::csvr
 #include "plssvm/target_platforms.hpp"         // plssvm::target_platform
 
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::register_py_exception
 
diff --git a/bindings/Python/backends/kokkos_csvm.cpp b/bindings/Python/backends/kokkos_csvm.cpp
index d55dddf2a..e96995d79 100644
--- a/bindings/Python/backends/kokkos_csvm.cpp
+++ b/bindings/Python/backends/kokkos_csvm.cpp
@@ -6,26 +6,27 @@
  *          See the LICENSE.md file in the project root for full license information.
  */
 
-#include "plssvm/backend_types.hpp"                    // plssvm::kokkos::backend_csvm_type_t
-#include "plssvm/backends/Kokkos/csvm.hpp"             // plssvm::kokkos::csvm
-#include "plssvm/backends/Kokkos/exceptions.hpp"       // plssvm::kokkos::backend_exception
-#include "plssvm/backends/Kokkos/execution_space.hpp"  // plssvm::kokkos::execution_space
-#include "plssvm/constants.hpp"                        // plssvm::real_type
-#include "plssvm/exceptions/exceptions.hpp"            // plssvm::exception
-#include "plssvm/gamma.hpp"                            // plssvm::gamma
-#include "plssvm/kernel_function_types.hpp"            // plssvm::kernel_function_type
-#include "plssvm/mpi/communicator.hpp"                 // plssvm::mpi::communicator
-#include "plssvm/parameter.hpp"                        // plssvm::parameter
-#include "plssvm/svm/csvc.hpp"                         // plssvm::csvc
-#include "plssvm/svm/csvm.hpp"                         // plssvm::csvm
-#include "plssvm/svm/csvr.hpp"                         // plssvm::csvr
-#include "plssvm/target_platforms.hpp"                 // plssvm::target_platform
-
+#include "plssvm/backend_types.hpp"                     // plssvm::kokkos::backend_csvm_type_t
+#include "plssvm/backends/Kokkos/csvm.hpp"              // plssvm::kokkos::csvm
+#include "plssvm/backends/Kokkos/exceptions.hpp"        // plssvm::kokkos::backend_exception
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"  // plssvm::kokkos::execution_space
+#include "plssvm/constants.hpp"                         // plssvm::real_type
+#include "plssvm/exceptions/exceptions.hpp"             // plssvm::exception
+#include "plssvm/gamma.hpp"                             // plssvm::gamma
+#include "plssvm/kernel_function_types.hpp"             // plssvm::kernel_function_type
+#include "plssvm/mpi/communicator.hpp"                  // plssvm::mpi::communicator
+#include "plssvm/parameter.hpp"                         // plssvm::parameter
+#include "plssvm/svm/csvc.hpp"                          // plssvm::csvc
+#include "plssvm/svm/csvm.hpp"                          // plssvm::csvm
+#include "plssvm/svm/csvr.hpp"                          // plssvm::csvr
+#include "plssvm/target_platforms.hpp"                  // plssvm::target_platform
+
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::{register_py_exception, register_implicit_str_enum_conversion}
 
 #include "fmt/format.h"         // fmt::format
-#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::exception, py::module_local
+#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::exception, py::module_local, py::enum_
 #include "pybind11/stl.h"       // support for STL types: std::variant
 
 #include <memory>   // std::make_unique
@@ -85,7 +86,7 @@ void init_kokkos_csvm(py::module_ &m, const py::exception<plssvm::exception> &ba
     py::module_ kokkos_module = m.def_submodule("kokkos", "a module containing all Kokkos backend specific functionality");
 
     // bind the enum class
-    py::enum_<plssvm::kokkos::execution_space> py_enum(kokkos_module, "ExecutionSpace", "Enum class for all supported Kokkos execution spaces in PLSSVM.");
+    py::enum_<plssvm::kokkos::execution_space> py_enum(kokkos_module, "ExecutionSpace", "enum.Enum", "Enum class for all supported Kokkos execution spaces in PLSSVM.");
     py_enum
         .value("AUTOMATIC", plssvm::kokkos::execution_space::automatic, "automatically determine the used Kokkos execution space; note: this does not necessarily correspond to Kokkos::DefaultExecutionSpace!")
         .value("CUDA", plssvm::kokkos::execution_space::cuda, "execution space representing execution on a CUDA device")
diff --git a/bindings/Python/backends/opencl_csvm.cpp b/bindings/Python/backends/opencl_csvm.cpp
index 9c3a2f3d0..cde51dad4 100644
--- a/bindings/Python/backends/opencl_csvm.cpp
+++ b/bindings/Python/backends/opencl_csvm.cpp
@@ -20,6 +20,7 @@
 #include "plssvm/svm/csvr.hpp"                    // plssvm::csvr
 #include "plssvm/target_platforms.hpp"            // plssvm::target_platform
 
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::register_py_exception
 
diff --git a/bindings/Python/backends/openmp_csvm.cpp b/bindings/Python/backends/openmp_csvm.cpp
index 095659542..3e3a67699 100644
--- a/bindings/Python/backends/openmp_csvm.cpp
+++ b/bindings/Python/backends/openmp_csvm.cpp
@@ -20,12 +20,13 @@
 #include "plssvm/svm/csvr.hpp"                    // plssvm::csvr
 #include "plssvm/target_platforms.hpp"            // plssvm::target_platform
 
-#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // NOLINT: a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::register_py_exception
 
 #include "fmt/format.h"         // fmt::format
 #include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::exception, py::module_local
-#include "pybind11/stl.h"       // support for STL types: std::variant
+#include "pybind11/stl.h"       // NOLINT: support for STL types: std::variant
 
 #include <memory>   // std::make_unique
 #include <string>   // std::string
diff --git a/bindings/Python/backends/stdpar_csvm.cpp b/bindings/Python/backends/stdpar_csvm.cpp
index df32403e3..84c52c0f3 100644
--- a/bindings/Python/backends/stdpar_csvm.cpp
+++ b/bindings/Python/backends/stdpar_csvm.cpp
@@ -21,11 +21,12 @@
 #include "plssvm/svm/csvr.hpp"                              // plssvm::csvr
 #include "plssvm/target_platforms.hpp"                      // plssvm::target_platform
 
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::{register_py_exception, register_implicit_str_enum_conversion}
 
 #include "fmt/format.h"         // fmt::format
-#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::exception, py::module_local
+#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::exception, py::module_local, py::enum_
 #include "pybind11/stl.h"       // support for STL types: std::variant
 
 #include <memory>   // std::make_unique
@@ -48,7 +49,7 @@ void bind_stdpar_csvms(py::module_ &m, const std::string &csvm_name) {
     const std::string params_constructor_docstring{ fmt::format("create an stdpar {} with the provided SVM parameter encapsulated in a plssvm.Parameter", csvm_name) };
     const std::string keyword_args_constructor_docstring{ fmt::format("create an stdpar {} with the provided SVM parameter as separate keyword arguments", csvm_name) };
 
-    py::class_<backend_csvm_type, plssvm::stdpar::csvm, csvm_type>(m, csvm_name.c_str())
+    py::class_<backend_csvm_type, plssvm::stdpar::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
         .def(py::init([](const plssvm::target_platform target, const plssvm::parameter params, plssvm::mpi::communicator comm) {
                  return std::make_unique<backend_csvm_type>(std::move(comm), target, params);
              }),
@@ -83,7 +84,7 @@ void init_stdpar_csvm(py::module_ &m, const py::exception<plssvm::exception> &ba
     py::module_ stdpar_module = m.def_submodule("stdpar", "a module containing all stdpar backend specific functionality");
 
     // bind the enum class
-    py::enum_<plssvm::stdpar::implementation_type> py_enum(stdpar_module, "ImplementationType", "Enum class for all supported stdpar implementations in PLSSVM.");
+    py::enum_<plssvm::stdpar::implementation_type> py_enum(stdpar_module, "ImplementationType", "enum.Enum", "Enum class for all supported stdpar implementations in PLSSVM.");
     py_enum
         .value("NVHPC", plssvm::stdpar::implementation_type::nvhpc, "use NVIDIA's HPC SDK (NVHPC) compiler nvc++")
         .value("ROC_STDPAR", plssvm::stdpar::implementation_type::roc_stdpar, "use AMD's roc-stdpar compiler (patched LLVM)")
diff --git a/bindings/Python/backends/sycl.cpp b/bindings/Python/backends/sycl.cpp
index 98c27214b..086481e9d 100644
--- a/bindings/Python/backends/sycl.cpp
+++ b/bindings/Python/backends/sycl.cpp
@@ -6,14 +6,15 @@
  *          See the LICENSE.md file in the project root for full license information.
  */
 
-#include "plssvm/backends/SYCL/exceptions.hpp"               // plssvm::sycl::backend_exception
-#include "plssvm/backends/SYCL/implementation_types.hpp"     // plssvm::sycl::{implementation_type, list_available_sycl_implementations}
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/exceptions/exceptions.hpp"                  // plssvm::exception
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/exceptions.hpp"             // plssvm::sycl::backend_exception
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::{implementation_type, list_available_sycl_implementations}
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::exception
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::{register_py_exception, register_implicit_str_enum_conversion}
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::{register_py_exception, register_implicit_str_enum_conversion}
 
-#include "pybind11/pybind11.h"  // py::module_, py::enum_, py::exception
+#include "pybind11/pybind11.h"  // py::module_, py::exception, py::enum_
 #include "pybind11/stl.h"       // support for STL types: std:vector
 
 #include <vector>  // std::vector
@@ -23,9 +24,6 @@
 
 namespace py = pybind11;
 
-py::module_ init_adaptivecpp_csvm(py::module_ &, const py::exception<plssvm::exception> &);
-py::module_ init_dpcpp_csvm(py::module_ &, const py::exception<plssvm::exception> &);
-
 void init_sycl(py::module_ &m, const py::exception<plssvm::exception> &base_exception) {
     // use its own submodule for the SYCL specific bindings
     py::module_ sycl_module = m.def_submodule("sycl", "a module containing all SYCL backend specific functionality");
@@ -34,7 +32,7 @@ void init_sycl(py::module_ &m, const py::exception<plssvm::exception> &base_exce
     plssvm::bindings::python::util::register_py_exception<plssvm::sycl::backend_exception>(sycl_module, "BackendError", base_exception);
 
     // bind the two enum classes
-    py::enum_<plssvm::sycl::implementation_type> py_enum_impl(sycl_module, "ImplementationType", "Enum class for all supported SYCL implementation in PLSSVM.");
+    py::enum_<plssvm::sycl::implementation_type> py_enum_impl(sycl_module, "ImplementationType", "enum.Enum", "Enum class for all supported SYCL implementation in PLSSVM.");
     py_enum_impl
         .value("AUTOMATIC", plssvm::sycl::implementation_type::automatic, "use the available SYCL implementation; if more than one implementation is available, the macro PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION must be defined during the CMake configuration")
         .value("DPCPP", plssvm::sycl::implementation_type::dpcpp, "use DPC++ as SYCL implementation")
@@ -45,16 +43,16 @@ void init_sycl(py::module_ &m, const py::exception<plssvm::exception> &base_exce
 
     sycl_module.def("list_available_sycl_implementations", &plssvm::sycl::list_available_sycl_implementations, "list all available SYCL implementations");
 
-    py::enum_<plssvm::sycl::kernel_invocation_type> py_enum_invocation(sycl_module, "KernelInvocationType", "Enum class for all possible SYCL kernel invocation types supported in PLSSVM.");
-    py_enum_invocation
-        .value("AUTOMATIC", plssvm::sycl::kernel_invocation_type::automatic, "use the best kernel invocation type for the current SYCL implementation and target hardware platform")
-        .value("BASIC", plssvm::sycl::kernel_invocation_type::basic, "use the basic data parallel kernel invocation type")
-        .value("WORK_GROUP", plssvm::sycl::kernel_invocation_type::work_group, "use the work-group data parallel kernel invocation type")
-        .value("HIERARCHICAL", plssvm::sycl::kernel_invocation_type::hierarchical, "use the hierarchical data parallel kernel invocation type")
-        .value("SCOPED", plssvm::sycl::kernel_invocation_type::scoped, "use the AdaptiveCpp specific scoped parallelism kernel invocation type");
+    py::enum_<plssvm::sycl::data_parallel_kernel> py_enum_data_parallel_kernel(sycl_module, "DataParallelKernel", "enum.Enum", "Enum class for all possible SYCL data parallel kernels supported in PLSSVM.");
+    py_enum_data_parallel_kernel
+        .value("AUTOMATIC", plssvm::sycl::data_parallel_kernel::automatic, "use the best data parallel kernel for the current SYCL implementation and target hardware platform")
+        .value("BASIC", plssvm::sycl::data_parallel_kernel::basic, "use the basic data parallel kernel")
+        .value("WORK_GROUP", plssvm::sycl::data_parallel_kernel::work_group, "use the work-group data parallel kernel")
+        .value("HIERARCHICAL", plssvm::sycl::data_parallel_kernel::hierarchical, "use the hierarchical data parallel kernel")
+        .value("SCOPED", plssvm::sycl::data_parallel_kernel::scoped, "use the AdaptiveCpp specific scoped parallelism kernel");
 
     // enable implicit conversion from string to enum
-    plssvm::bindings::python::util::register_implicit_str_enum_conversion<plssvm::sycl::kernel_invocation_type>(py_enum_invocation);
+    plssvm::bindings::python::util::register_implicit_str_enum_conversion<plssvm::sycl::data_parallel_kernel>(py_enum_data_parallel_kernel);
 
     // initialize SYCL binding classes
 #if defined(PLSSVM_SYCL_BACKEND_HAS_ADAPTIVECPP)
diff --git a/bindings/Python/bindings_fwd.hpp b/bindings/Python/bindings_fwd.hpp
new file mode 100644
index 000000000..ce12e8aa1
--- /dev/null
+++ b/bindings/Python/bindings_fwd.hpp
@@ -0,0 +1,61 @@
+/**
+ * @file
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Header forward declaring all helper functions used to create the Python bindings.
+ */
+
+#ifndef PLSSVM_BINDINGS_PYTHON_BINDINGS_FWD_HPP_
+#define PLSSVM_BINDINGS_PYTHON_BINDINGS_FWD_HPP_
+#pragma once
+
+#include "plssvm/exceptions/exceptions.hpp"  // plssvm::exceptions
+
+#include "pybind11/pybind11.h"  // py::module_, py::exception
+
+namespace py = pybind11;
+
+// forward declare binding functions
+void init_verbosity_levels(py::module_ &m);
+void init_performance_tracker(py::module_ &m);
+void init_events(py::module_ &m);
+void init_target_platforms(py::module_ &m);
+void init_solver_types(py::module_ &m);
+void init_svm_types(py::module_ &m);
+void init_backend_types(py::module_ &m);
+void init_gamma(py::module_ &m);
+void init_classification_types(py::module_ &m);
+void init_file_format_types(py::module_ &m);
+void init_kernel_function_types(py::module_ &m);
+void init_parameter(py::module_ &m);
+void init_kernel_functions(py::module_ &m);
+void init_classification_model(py::module_ &m);
+void init_regression_model(py::module_ &m);
+void init_min_max_scaler(py::module_ &m);
+void init_classification_data_set(py::module_ &m);
+void init_regression_data_set(py::module_ &m);
+void init_exceptions(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+void init_regression_report(py::module_ &m);
+void init_csvm(py::module_ &m);
+void init_csvc(py::module_ &m);
+void init_csvr(py::module_ &m);
+void init_openmp_csvm(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+void init_hpx_csvm(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+void init_stdpar_csvm(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+void init_cuda_csvm(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+void init_hip_csvm(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+void init_opencl_csvm(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+void init_sycl(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+py::module_ init_adaptivecpp_csvm(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+py::module_ init_dpcpp_csvm(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+void init_kokkos_csvm(py::module_ &m, const py::exception<plssvm::exception> &base_exception);
+
+void init_sklearn_tags(py::module_ &m);
+void init_sklearn_svc(py::module_ &m);
+void init_sklearn_svr(py::module_ &m);
+
+#endif  // PLSSVM_BINDINGS_PYTHON_BINDINGS_FWD_HPP_
diff --git a/bindings/Python/classification_types.cpp b/bindings/Python/classification_types.cpp
index 7d145ff84..d96a5b409 100644
--- a/bindings/Python/classification_types.cpp
+++ b/bindings/Python/classification_types.cpp
@@ -8,17 +8,17 @@
 
 #include "plssvm/classification_types.hpp"  // plssvm::classification_type, plssvm::classification_type_to_full_string, plssvm::calculate_number_of_classifiers
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::register_implicit_str_enum_conversion
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::register_implicit_str_enum_conversion
 
-#include "pybind11/pybind11.h"  // py::module_, py::enum_, py::arg
-
-#include <string>  // std::string
+#include "pybind11/cast.h"      // py::arg
+#include "pybind11/pybind11.h"  // py::module_, py::arg, py::enum_
 
 namespace py = pybind11;
 
 void init_classification_types(py::module_ &m) {
     // bind enum class
-    py::enum_<plssvm::classification_type> py_enum(m, "ClassificationType", "Enum class for all implemented multiclass classification strategies.");
+    py::enum_<plssvm::classification_type> py_enum(m, "ClassificationType", "enum.Enum", "Enum class for all implemented multiclass classification strategies.");
     py_enum
         .value("OAA", plssvm::classification_type::oaa, "use the one vs. all classification strategy (default)")
         .value("OAO", plssvm::classification_type::oao, "use the one vs. one classification strategy");
diff --git a/bindings/Python/data_set/classification_data_set.cpp b/bindings/Python/data_set/classification_data_set.cpp
index 1ffacb2e4..0f560b4b3 100644
--- a/bindings/Python/data_set/classification_data_set.cpp
+++ b/bindings/Python/data_set/classification_data_set.cpp
@@ -15,18 +15,19 @@
 #include "plssvm/matrix.hpp"                   // plssvm::soa_matrix
 #include "plssvm/mpi/communicator.hpp"         // plssvm::mpi::communicator
 
-#include "bindings/Python/data_set/variant_wrapper.hpp"                 // plssvm::bindings::python::util::classification_data_set_wrapper
-#include "bindings/Python/type_caster/label_vector_wrapper_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::util::label_vector_wrapper
-#include "bindings/Python/type_caster/matrix_type_caster.hpp"           // a custom Pybind11 type caster for a plssvm::matrix
-#include "bindings/Python/type_caster/mpi_type_caster.hpp"              // a custom Pybind11 type caster for a plssvm::mpi::communicator
-#include "bindings/Python/utility.hpp"                                  // plssvm::bindings::python::util::{create_instance, python_type_name_mapping, vector_to_pyarray}
+#include "bindings/Python/bindings_fwd.hpp"                                  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/data_set/variant_wrapper.hpp"                      // plssvm::bindings::python::util::classification_data_set_wrapper
+#include "bindings/Python/type_caster/label_vector_wrapper_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::util::label_vector_wrapper
+#include "bindings/Python/type_caster/matrix_type_caster.hpp"                // NOLINT: a custom Pybind11 type caster for a plssvm::matrix
+#include "bindings/Python/type_caster/mpi_type_caster.hpp"                   // NOLINT: a custom Pybind11 type caster for a plssvm::mpi::communicator
+#include "bindings/Python/utility.hpp"                                       // plssvm::bindings::python::util::{create_instance, python_type_name_mapping, vector_to_pyarray}
 
 #include "fmt/format.h"         // fmt::format
 #include "fmt/ranges.h"         // fmt::join
-#include "pybind11/numpy.h"     // py::array_t, py::array
-#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::kw_only, py::attribute_error
+#include "pybind11/cast.h"      // py::arg
+#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::kw_only, py::attribute_error, py::return_value_policy
 #include "pybind11/pytypes.h"   // py::type
-#include "pybind11/stl.h"       // support for STL types
+#include "pybind11/stl.h"       // NOLINT: support for STL types
 
 #include <memory>    // std::make_unique
 #include <optional>  // std::optional, std::nullopt
@@ -40,20 +41,17 @@ void init_classification_data_set(py::module_ &m) {
     using plssvm::bindings::python::util::classification_data_set_wrapper;
 
     py::class_<classification_data_set_wrapper>(m, "ClassificationDataSet", "Encapsulate all necessary data that is needed for training or predicting using an C-SVC.")
-        .def(py::init([](const std::string &filename, const std::optional<py::type> type, const plssvm::file_format_type format, const std::optional<plssvm::min_max_scaler> scaler, plssvm::mpi::communicator comm) {
+        .def(py::init([](const std::string &filename, const std::optional<py::type> &type, const plssvm::file_format_type format, const std::optional<plssvm::min_max_scaler> &scaler, plssvm::mpi::communicator comm) {
                  if (type.has_value()) {
                      if (scaler.has_value()) {
                          return std::make_unique<classification_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_data_set, typename classification_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), filename, format, scaler.value()));
-                     } else {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_data_set, typename classification_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), filename, format));
-                     }
-                 } else {
-                     if (scaler.has_value()) {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(comm), filename, format, scaler.value() });
-                     } else {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(comm), filename, format });
                      }
+                     return std::make_unique<classification_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_data_set, typename classification_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), filename, format));
+                 }
+                 if (scaler.has_value()) {
+                     return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(comm), filename, format, scaler.value() });
                  }
+                 return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(comm), filename, format });
              }),
              "create a new data set from the provided file and additional optional parameters like the used label type",
              py::arg("filename"),
@@ -62,20 +60,17 @@ void init_classification_data_set(py::module_ &m) {
              py::arg("format") = plssvm::file_format_type::libsvm,
              py::arg("scaler") = std::nullopt,
              py::arg("comm") = plssvm::mpi::communicator{})
-        .def(py::init([](plssvm::soa_matrix<plssvm::real_type> data, const std::optional<py::type> type, const std::optional<plssvm::min_max_scaler> scaler, plssvm::mpi::communicator comm) {
+        .def(py::init([](plssvm::soa_matrix<plssvm::real_type> data, const std::optional<py::type> &type, const std::optional<plssvm::min_max_scaler> &scaler, plssvm::mpi::communicator comm) {
                  if (type.has_value()) {
                      if (scaler.has_value()) {
                          return std::make_unique<classification_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_data_set, typename classification_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), std::move(data), scaler.value()));
-                     } else {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_data_set, typename classification_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), std::move(data)));
-                     }
-                 } else {
-                     if (scaler.has_value()) {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(comm), std::move(data), scaler.value() });
-                     } else {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(comm), std::move(data) });
                      }
+                     return std::make_unique<classification_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_data_set, typename classification_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), std::move(data)));
+                 }
+                 if (scaler.has_value()) {
+                     return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(comm), std::move(data), scaler.value() });
                  }
+                 return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(comm), std::move(data) });
              }),
              "create a new data set from the provided data and additional optional parameters like the used label type",
              py::arg("X"),
@@ -87,10 +82,9 @@ void init_classification_data_set(py::module_ &m) {
                  return std::visit([&](auto &&labels_vector) {
                      using label_type = typename plssvm::detail::remove_cvref_t<decltype(labels_vector)>::value_type;
                      if (scaler.has_value()) {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<label_type>(std::move(comm), std::move(data), std::move(labels_vector), scaler.value()));
-                     } else {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<label_type>(std::move(comm), std::move(data), std::move(labels_vector)));
+                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<label_type>(std::move(comm), std::move(data), std::forward<decltype(labels_vector)>(labels_vector), scaler.value()));
                      }
+                     return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<label_type>(std::move(comm), std::move(data), std::forward<decltype(labels_vector)>(labels_vector)));
                  },
                                    labels.labels);
              }),
@@ -108,9 +102,8 @@ void init_classification_data_set(py::module_ &m) {
             return std::visit([](auto &&data) {
                 if (!data.has_labels()) {
                     throw py::attribute_error{ "'ClassificationDataSet' object has no function 'labels'. Maybe this ClassificationDataSet was created without labels?" };
-                } else {
-                    return plssvm::bindings::python::util::vector_to_pyarray(data.labels()->get());
                 }
+                return plssvm::bindings::python::util::vector_to_pyarray(data.labels()->get());
             }, self.data_set); }, "the labels")
         // clang-format on
         .def("num_data_points", [](const classification_data_set_wrapper &self) { return std::visit([](auto &&data) { return data.num_data_points(); }, self.data_set); }, "the number of data points in the data set")
@@ -119,18 +112,16 @@ void init_classification_data_set(py::module_ &m) {
         .def("scaling_factors", [](const classification_data_set_wrapper &self) { return std::visit([](auto &&data) {
             if (!data.is_scaled()) {
                 throw py::attribute_error{ "'ClassificationDataSet' object has no function 'scaling_factors'. Maybe this ClassificationDataSet has not been scaled?" };
-            } else {
-                return data.scaling_factors().value();
-            } }, self.data_set); }, py::return_value_policy::reference_internal, "the factors used to scale this data set")
+            }
+            return data.scaling_factors().value(); }, self.data_set); }, py::return_value_policy::reference_internal, "the factors used to scale this data set")
         .def("num_classes", [](const classification_data_set_wrapper &self) { return std::visit([](auto &&data) { return data.num_classes(); }, self.data_set); }, "the number of classes")
         // clang-format off
         .def("classes", [](const classification_data_set_wrapper &self) {
             return std::visit([](auto &&data) {
                 if (!data.has_labels()) {
                     throw py::attribute_error{ "'ClassificationDataSet' object has no function 'classes'. Maybe this ClassificationDataSet was created without labels?" };
-                } else {
-                    return plssvm::bindings::python::util::vector_to_pyarray(data.classes().value());
                 }
+                return plssvm::bindings::python::util::vector_to_pyarray(data.classes().value());
             }, self.data_set); }, "the number of classes")
         .def("communicator", [](const classification_data_set_wrapper &self) { return std::visit([](auto &&data) { return data.communicator(); }, self.data_set); }, "the associated MPI communicator")
         .def("__repr__", [](const classification_data_set_wrapper &self) {
diff --git a/bindings/Python/data_set/min_max_scaler.cpp b/bindings/Python/data_set/min_max_scaler.cpp
index 5779b9e29..3a51725ab 100644
--- a/bindings/Python/data_set/min_max_scaler.cpp
+++ b/bindings/Python/data_set/min_max_scaler.cpp
@@ -11,14 +11,15 @@
 #include "plssvm/constants.hpp"         // plssvm::real_type
 #include "plssvm/mpi/communicator.hpp"  // plssvm::mpi::communicator
 
-#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // NOLINT: a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::vector_to_pyarray
 
 #include "fmt/format.h"         // fmt::format
 #include "pybind11/numpy.h"     // py::array
 #include "pybind11/pybind11.h"  // PYBIND11_NUMPY_DTYPE, py::module_, py::class_, py::init, py::arg
 #include "pybind11/pytypes.h"   // py::type
-#include "pybind11/stl.h"       // support for STL types
+#include "pybind11/stl.h"       // NOLINT: support for STL types
 
 #include <array>     // std::array
 #include <cstddef>   // std::size_t
@@ -61,7 +62,7 @@ void init_min_max_scaler(py::module_ &m) {
              py::arg("interval"),
              py::kw_only(),
              py::arg("comm") = plssvm::mpi::communicator{})
-        .def(py::init([](const py::tuple interval, plssvm::mpi::communicator comm) {
+        .def(py::init([](const py::tuple &interval, plssvm::mpi::communicator comm) {
                  if (interval.size() != 2) {
                      throw py::value_error{ fmt::format("MinMaxScaler can only be created from two interval values (lower, upper), but {} were provided!", interval.size()) };
                  }
@@ -84,9 +85,8 @@ void init_min_max_scaler(py::module_ &m) {
                 const auto scaling_factors = self.scaling_factors();
                 if (scaling_factors.has_value()) {
                     return plssvm::bindings::python::util::vector_to_pyarray(scaling_factors.value());
-                } else {
-                    return std::nullopt;
-                } }, "the scaling factors for each feature")
+                }
+                return std::nullopt; }, "the scaling factors for each feature")
         .def("communicator", &plssvm::min_max_scaler::communicator, "the associated MPI communicator")
         .def("__repr__", [](const plssvm::min_max_scaler &self) {
             std::string optional_repr{};
diff --git a/bindings/Python/data_set/regression_data_set.cpp b/bindings/Python/data_set/regression_data_set.cpp
index c0369ee0d..245abb5d5 100644
--- a/bindings/Python/data_set/regression_data_set.cpp
+++ b/bindings/Python/data_set/regression_data_set.cpp
@@ -15,18 +15,18 @@
 #include "plssvm/matrix.hpp"                   // plssvm::soa_matrix
 #include "plssvm/mpi/communicator.hpp"         // plssvm::mpi::communicator
 
-#include "bindings/Python/data_set/variant_wrapper.hpp"                 // plssvm::bindings::python::util::regression_data_set_wrapper
-#include "bindings/Python/type_caster/label_vector_wrapper_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::util::label_vector_wrapper
-#include "bindings/Python/type_caster/matrix_type_caster.hpp"           // a custom Pybind11 type caster for a plssvm::matrix
-#include "bindings/Python/type_caster/mpi_type_caster.hpp"              // a custom Pybind11 type caster for a plssvm::mpi::communicator
-#include "bindings/Python/utility.hpp"                                  // plssvm::bindings::python::util::{create_instance, python_type_name_mapping, vector_to_pyarray}
+#include "bindings/Python/bindings_fwd.hpp"                                  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/data_set/variant_wrapper.hpp"                      // plssvm::bindings::python::util::regression_data_set_wrapper
+#include "bindings/Python/type_caster/label_vector_wrapper_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::util::label_vector_wrapper
+#include "bindings/Python/type_caster/matrix_type_caster.hpp"                // NOLINT: a custom Pybind11 type caster for a plssvm::matrix
+#include "bindings/Python/type_caster/mpi_type_caster.hpp"                   // NOLINT: a custom Pybind11 type caster for a plssvm::mpi::communicator
+#include "bindings/Python/utility.hpp"                                       // plssvm::bindings::python::util::{create_instance, python_type_name_mapping, vector_to_pyarray}
 
 #include "fmt/format.h"         // fmt::format
-#include "fmt/ranges.h"         // fmt::join
-#include "pybind11/numpy.h"     // py::array_t, py::array
-#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::kw_only, py::object, py::attribute_error
+#include "pybind11/cast.h"      // py::arg
+#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::kw_only, py::object, py::attribute_error, py::return_value_policy
 #include "pybind11/pytypes.h"   // py::type
-#include "pybind11/stl.h"       // support for STL types
+#include "pybind11/stl.h"       // NOLINT: support for STL types
 
 #include <memory>    // std::make_unique
 #include <optional>  // std::optional, std::nullopt
@@ -40,20 +40,17 @@ void init_regression_data_set(py::module_ &m) {
     using plssvm::bindings::python::util::regression_data_set_wrapper;
 
     py::class_<regression_data_set_wrapper>(m, "RegressionDataSet", "Encapsulate all necessary data that is needed for training or predicting using an C-SVR.")
-        .def(py::init([](const std::string &filename, const std::optional<py::type> type, const plssvm::file_format_type format, const std::optional<plssvm::min_max_scaler> scaler, plssvm::mpi::communicator comm) {
+        .def(py::init([](const std::string &filename, const std::optional<py::type> &type, const plssvm::file_format_type format, const std::optional<plssvm::min_max_scaler> &scaler, plssvm::mpi::communicator comm) {
                  if (type.has_value()) {
                      if (scaler.has_value()) {
                          return std::make_unique<regression_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::regression_data_set, typename regression_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), filename, format, scaler.value()));
-                     } else {
-                         return std::make_unique<regression_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::regression_data_set, typename regression_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), filename, format));
-                     }
-                 } else {
-                     if (scaler.has_value()) {
-                         return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<double>{ std::move(comm), filename, format, scaler.value() });
-                     } else {
-                         return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<double>{ std::move(comm), filename, format });
                      }
+                     return std::make_unique<regression_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::regression_data_set, typename regression_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), filename, format));
+                 }
+                 if (scaler.has_value()) {
+                     return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<double>{ std::move(comm), filename, format, scaler.value() });
                  }
+                 return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<double>{ std::move(comm), filename, format });
              }),
              "create a new data set from the provided file and additional optional parameters",
              py::arg("filename"),
@@ -62,20 +59,17 @@ void init_regression_data_set(py::module_ &m) {
              py::arg("format") = plssvm::file_format_type::libsvm,
              py::arg("scaler") = std::nullopt,
              py::arg("comm") = plssvm::mpi::communicator{})
-        .def(py::init([](plssvm::soa_matrix<plssvm::real_type> data, const std::optional<py::type> type, const std::optional<plssvm::min_max_scaler> scaler, plssvm::mpi::communicator comm) {
+        .def(py::init([](plssvm::soa_matrix<plssvm::real_type> data, const std::optional<py::type> &type, const std::optional<plssvm::min_max_scaler> &scaler, plssvm::mpi::communicator comm) {
                  if (type.has_value()) {
                      if (scaler.has_value()) {
                          return std::make_unique<regression_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::regression_data_set, typename regression_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), std::move(data), scaler.value()));
-                     } else {
-                         return std::make_unique<regression_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::regression_data_set, typename regression_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), std::move(data)));
-                     }
-                 } else {
-                     if (scaler.has_value()) {
-                         return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<double>{ std::move(comm), std::move(data), scaler.value() });
-                     } else {
-                         return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<double>{ std::move(comm), std::move(data) });
                      }
+                     return std::make_unique<regression_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::regression_data_set, typename regression_data_set_wrapper::possible_data_set_types>(type.value(), std::move(comm), std::move(data)));
+                 }
+                 if (scaler.has_value()) {
+                     return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<double>{ std::move(comm), std::move(data), scaler.value() });
                  }
+                 return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<double>{ std::move(comm), std::move(data) });
              }),
              "create a new data set from the provided file and additional optional parameters",
              py::arg("X"),
@@ -87,10 +81,9 @@ void init_regression_data_set(py::module_ &m) {
                  return std::visit([&](auto &&labels_vector) {
                      using label_type = typename plssvm::detail::remove_cvref_t<decltype(labels_vector)>::value_type;
                      if (scaler.has_value()) {
-                         return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<label_type>(std::move(comm), std::move(data), std::move(labels_vector), scaler.value()));
-                     } else {
-                         return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<label_type>(std::move(comm), std::move(data), std::move(labels_vector)));
+                         return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<label_type>(std::move(comm), std::move(data), std::forward<decltype(labels_vector)>(labels_vector), scaler.value()));
                      }
+                     return std::make_unique<regression_data_set_wrapper>(plssvm::regression_data_set<label_type>(std::move(comm), std::move(data), std::forward<decltype(labels_vector)>(labels_vector)));
                  },
                                    labels.labels);
              }),
@@ -108,9 +101,8 @@ void init_regression_data_set(py::module_ &m) {
             return std::visit([](auto &&data) {
                 if (!data.has_labels()) {
                     throw py::attribute_error{ "'RegressionDataSet' object has no function 'labels'. Maybe this RegressionDataSet was created without labels?" };
-                } else {
-                    return plssvm::bindings::python::util::vector_to_pyarray(data.labels()->get());
                 }
+                return plssvm::bindings::python::util::vector_to_pyarray(data.labels()->get());
             }, self.data_set); }, "the labels")
         // clang-format on
         .def("num_data_points", [](const regression_data_set_wrapper &self) { return std::visit([](auto &&data) { return data.num_data_points(); }, self.data_set); }, "the number of data points in the data set")
@@ -119,9 +111,8 @@ void init_regression_data_set(py::module_ &m) {
         .def("scaling_factors", [](const regression_data_set_wrapper &self) { return std::visit([](auto &&data) {
             if (!data.is_scaled()) {
                 throw py::attribute_error{ "'RegressionDataSet' object has no function 'scaling_factors'. Maybe this RegressionDataSet has not been scaled?" };
-            } else {
-                return data.scaling_factors().value();
-            } }, self.data_set); }, py::return_value_policy::reference_internal, "the factors used to scale this data set")
+            }
+            return data.scaling_factors().value(); }, self.data_set); }, py::return_value_policy::reference_internal, "the factors used to scale this data set")
         // clang-format off
         .def("communicator", [](const regression_data_set_wrapper &self) { return std::visit([](auto &&data) { return data.communicator(); }, self.data_set); }, "the associated MPI communicator")
         .def("__repr__", [](const regression_data_set_wrapper &self) {
diff --git a/bindings/Python/data_set/variant_wrapper.hpp b/bindings/Python/data_set/variant_wrapper.hpp
index 46d853bf5..f9670427c 100644
--- a/bindings/Python/data_set/variant_wrapper.hpp
+++ b/bindings/Python/data_set/variant_wrapper.hpp
@@ -9,8 +9,8 @@
  * @brief Variant wrapper structs around PLSSVM classification and regression data sets. Used that we don't have to expose templates to the Python bindings.
  */
 
-#ifndef PLSSVM_BINDINGS_PYTHON_DATA_SET_WRAPPER_HPP_
-#define PLSSVM_BINDINGS_PYTHON_DATA_SET_WRAPPER_HPP_
+#ifndef PLSSVM_BINDINGS_PYTHON_DATA_SET_VARIANT_WRAPPER_HPP_
+#define PLSSVM_BINDINGS_PYTHON_DATA_SET_VARIANT_WRAPPER_HPP_
 #pragma once
 
 #include "plssvm/data_set/classification_data_set.hpp"  // plssvm::classification_data_set
@@ -116,4 +116,4 @@ struct regression_data_set_wrapper {
 
 }  // namespace plssvm::bindings::python::util
 
-#endif  // PLSSVM_BINDINGS_PYTHON_DATA_SET_WRAPPER_HPP_
+#endif  // PLSSVM_BINDINGS_PYTHON_DATA_SET_VARIANT_WRAPPER_HPP_
diff --git a/bindings/Python/detail/tracking/events.cpp b/bindings/Python/detail/tracking/events.cpp
index d08cfe5de..f2d3d89f5 100644
--- a/bindings/Python/detail/tracking/events.cpp
+++ b/bindings/Python/detail/tracking/events.cpp
@@ -8,17 +8,20 @@
 
 #include "plssvm/detail/tracking/events.hpp"  // plssvm::detail::tracking::events
 
-#include "fmt/chrono.h"         // format std::chrono types
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+
+#include "fmt/chrono.h"         // NOLINT: format std::chrono types
 #include "fmt/format.h"         // fmt::format
-#include "pybind11/chrono.h"    // bind std::chrono types
-#include "pybind11/pybind11.h"  // py::module_
-#include "pybind11/stl.h"       // bind STL types
+#include "pybind11/cast.h"      // py::arg
+#include "pybind11/chrono.h"    // NOLINT: bind std::chrono types
+#include "pybind11/pybind11.h"  // py::module_, py::overload_cast
+#include "pybind11/stl.h"       // NOLINT: bind STL types
 
 namespace py = pybind11;
 
 void init_events(py::module_ &m) {
     // use a detail.tracking.PerformanceTracker submodule for the performance tracking bindings
-    py::module_ tracking_module = m.def_submodule("performance_tracking", "a module containing performance tracking functionality");
+    const py::module_ tracking_module = m.def_submodule("performance_tracking", "a module containing performance tracking functionality");
 
     using event_type = plssvm::detail::tracking::events::event;
 
diff --git a/bindings/Python/detail/tracking/performance_tracker.cpp b/bindings/Python/detail/tracking/performance_tracker.cpp
index dcf0f0616..c3954bf74 100644
--- a/bindings/Python/detail/tracking/performance_tracker.cpp
+++ b/bindings/Python/detail/tracking/performance_tracker.cpp
@@ -11,9 +11,12 @@
 #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_
-#include "pybind11/stl.h"       // automatic bindings for std::optional and std::vector
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+
+#include "pybind11/cast.h"      // py::arg
+#include "pybind11/chrono.h"    // NOLINT: automatic bindings for std::chrono::milliseconds
+#include "pybind11/pybind11.h"  // py::module_, py::return_value_policy
+#include "pybind11/stl.h"       // NOLINT: automatic bindings for std::optional and std::vector
 
 #include <chrono>  // std::chrono::steady_clock::time_point
 #include <string>  // std::string
diff --git a/bindings/Python/exceptions/exceptions.cpp b/bindings/Python/exceptions/exceptions.cpp
index 71c1f7a92..084702f09 100644
--- a/bindings/Python/exceptions/exceptions.cpp
+++ b/bindings/Python/exceptions/exceptions.cpp
@@ -8,7 +8,8 @@
 
 #include "plssvm/exceptions/exceptions.hpp"  // PLSSVM specific exceptions
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::register_py_exception
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::register_py_exception
 
 #include "pybind11/pybind11.h"  // py::module_, py::exception
 
diff --git a/bindings/Python/file_format_types.cpp b/bindings/Python/file_format_types.cpp
index 71a891da0..e8502cea1 100644
--- a/bindings/Python/file_format_types.cpp
+++ b/bindings/Python/file_format_types.cpp
@@ -8,7 +8,8 @@
 
 #include "plssvm/file_format_types.hpp"  // plssvm::file_format_type
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::register_implicit_str_enum_conversion
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::register_implicit_str_enum_conversion
 
 #include "pybind11/pybind11.h"  // py::module_, py::enum_
 
@@ -16,7 +17,7 @@ namespace py = pybind11;
 
 void init_file_format_types(py::module_ &m) {
     // bind enum class
-    py::enum_<plssvm::file_format_type> py_enum(m, "FileFormatType", "Enum class for all supported file types.");
+    py::enum_<plssvm::file_format_type> py_enum(m, "FileFormatType", "enum.Enum", "Enum class for all supported file types.");
     py_enum
         .value("LIBSVM", plssvm::file_format_type::libsvm, "the LIBSVM file format (default); for the file format specification see: https://www.csie.ntu.edu.tw/~cjlin/libsvm/faq.html")
         .value("ARFF", plssvm::file_format_type::arff, "the ARFF file format; for the file format specification see: https://www.cs.waikato.ac.nz/~ml/weka/arff.html");
diff --git a/bindings/Python/gamma.cpp b/bindings/Python/gamma.cpp
index 207c85745..181803976 100644
--- a/bindings/Python/gamma.cpp
+++ b/bindings/Python/gamma.cpp
@@ -11,17 +11,19 @@
 #include "plssvm/constants.hpp"  // plssvm::real_type
 #include "plssvm/matrix.hpp"     // plssvm::aos_matrix
 
-#include "bindings/Python/type_caster/matrix_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::matrix
+#include "bindings/Python/bindings_fwd.hpp"                    // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/type_caster/matrix_type_caster.hpp"  // NOLINT: a custom Pybind11 type caster for a plssvm::matrix
 #include "bindings/Python/utility.hpp"                         // plssvm::bindings::python::util::register_implicit_str_enum_conversion
 
+#include "pybind11/cast.h"      // py::arg
 #include "pybind11/pybind11.h"  // py::module_, py::enum_
-#include "pybind11/stl.h"       // support for STL types: std::variant
+#include "pybind11/stl.h"       // NOLINT: support for STL types: std::variant
 
 namespace py = pybind11;
 
 void init_gamma(py::module_ &m) {
     // bind enum class
-    py::enum_<plssvm::gamma_coefficient_type> py_enum(m, "GammaCoefficientType", "Enum class for all possible gamma coefficient types (can also be a number).");
+    py::enum_<plssvm::gamma_coefficient_type> py_enum(m, "GammaCoefficientType", "enum.Enum", "Enum class for all possible gamma coefficient types (can also be a number).");
     py_enum
         .value("AUTOMATIC", plssvm::gamma_coefficient_type::automatic, "use a dynamic gamma value of 1 / num_features for the kernel functions")
         .value("SCALE", plssvm::gamma_coefficient_type::scale, "use a dynamic gamma value of 1 / (num_features * data.var()) for the kernel functions");
diff --git a/bindings/Python/kernel_function_types.cpp b/bindings/Python/kernel_function_types.cpp
index ca8c45c51..22d3f4a89 100644
--- a/bindings/Python/kernel_function_types.cpp
+++ b/bindings/Python/kernel_function_types.cpp
@@ -8,9 +8,11 @@
 
 #include "plssvm/kernel_function_types.hpp"  // plssvm::kernel_function_type
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::register_implicit_str_enum_conversion
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::register_implicit_str_enum_conversion
 
-#include "pybind11/pybind11.h"  // py::module_, py::enum_, py::arg
+#include "pybind11/cast.h"      // py::arg
+#include "pybind11/pybind11.h"  // py::module_, py::enum_
 
 namespace py = pybind11;
 
diff --git a/bindings/Python/kernel_functions.cpp b/bindings/Python/kernel_functions.cpp
index 84d28430a..a714f3868 100644
--- a/bindings/Python/kernel_functions.cpp
+++ b/bindings/Python/kernel_functions.cpp
@@ -13,8 +13,11 @@
 #include "plssvm/kernel_function_types.hpp"  // plssvm::kernel_function_type
 #include "plssvm/parameter.hpp"              // plssvm::parameter
 
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+
+#include "pybind11/cast.h"      // py::arg
 #include "pybind11/pybind11.h"  // py::module_, py::arg, py::kw_only
-#include "pybind11/stl.h"       // support for STL types: std::vector
+#include "pybind11/stl.h"       // NOLINT: support for STL types: std::vector
 
 #include <variant>  // std::holds_alternative, std::get
 #include <vector>   // std::vector
@@ -29,11 +32,11 @@ void init_kernel_functions(py::module_ &m) {
         "polynomial_kernel_function", [](const std::vector<plssvm::real_type> &x, const std::vector<plssvm::real_type> &y, const int degree, const plssvm::gamma_type gamma, const plssvm::real_type coef0) {
             if (std::holds_alternative<plssvm::real_type>(gamma)) {
                 return plssvm::kernel_function<plssvm::kernel_function_type::polynomial>(x, y, degree, std::get<plssvm::real_type>(gamma), coef0);
-            } else if (std::get<plssvm::gamma_coefficient_type>(gamma) == plssvm::gamma_coefficient_type::automatic) {
+            }
+            if (std::get<plssvm::gamma_coefficient_type>(gamma) == plssvm::gamma_coefficient_type::automatic) {
                 return plssvm::kernel_function<plssvm::kernel_function_type::polynomial>(x, y, degree, plssvm::real_type{ 1.0 } / static_cast<plssvm::real_type>(x.size()), coef0);
-            } else {
-                throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
             }
+            throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
         },
         "apply the polynomial kernel function to two vectors",
         py::arg("x"),
@@ -46,11 +49,11 @@ void init_kernel_functions(py::module_ &m) {
         "rbf_kernel_function", [](const std::vector<plssvm::real_type> &x, const std::vector<plssvm::real_type> &y, const plssvm::gamma_type gamma) {
             if (std::holds_alternative<plssvm::real_type>(gamma)) {
                 return plssvm::kernel_function<plssvm::kernel_function_type::rbf>(x, y, std::get<plssvm::real_type>(gamma));
-            } else if (std::get<plssvm::gamma_coefficient_type>(gamma) == plssvm::gamma_coefficient_type::automatic) {
+            }
+            if (std::get<plssvm::gamma_coefficient_type>(gamma) == plssvm::gamma_coefficient_type::automatic) {
                 return plssvm::kernel_function<plssvm::kernel_function_type::rbf>(x, y, plssvm::real_type{ 1.0 } / static_cast<plssvm::real_type>(x.size()));
-            } else {
-                throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
             }
+            throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
         },
         "apply the radial basis function kernel function to two vectors",
         py::arg("x"),
@@ -61,11 +64,11 @@ void init_kernel_functions(py::module_ &m) {
         "sigmoid_kernel_function", [](const std::vector<plssvm::real_type> &x, const std::vector<plssvm::real_type> &y, const plssvm::gamma_type gamma, const plssvm::real_type coef0) {
             if (std::holds_alternative<plssvm::real_type>(gamma)) {
                 return plssvm::kernel_function<plssvm::kernel_function_type::sigmoid>(x, y, std::get<plssvm::real_type>(gamma), coef0);
-            } else if (std::get<plssvm::gamma_coefficient_type>(gamma) == plssvm::gamma_coefficient_type::automatic) {
+            }
+            if (std::get<plssvm::gamma_coefficient_type>(gamma) == plssvm::gamma_coefficient_type::automatic) {
                 return plssvm::kernel_function<plssvm::kernel_function_type::sigmoid>(x, y, plssvm::real_type{ 1.0 } / static_cast<plssvm::real_type>(x.size()), coef0);
-            } else {
-                throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
             }
+            throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
         },
         "apply the sigmoid kernel function to two vectors",
         py::arg("x"),
@@ -77,11 +80,11 @@ void init_kernel_functions(py::module_ &m) {
         "laplacian_kernel_function", [](const std::vector<plssvm::real_type> &x, const std::vector<plssvm::real_type> &y, const plssvm::gamma_type gamma) {
             if (std::holds_alternative<plssvm::real_type>(gamma)) {
                 return plssvm::kernel_function<plssvm::kernel_function_type::laplacian>(x, y, std::get<plssvm::real_type>(gamma));
-            } else if (std::get<plssvm::gamma_coefficient_type>(gamma) == plssvm::gamma_coefficient_type::automatic) {
+            }
+            if (std::get<plssvm::gamma_coefficient_type>(gamma) == plssvm::gamma_coefficient_type::automatic) {
                 return plssvm::kernel_function<plssvm::kernel_function_type::laplacian>(x, y, plssvm::real_type{ 1.0 } / static_cast<plssvm::real_type>(x.size()));
-            } else {
-                throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
             }
+            throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
         },
         "apply the laplacian kernel function to two vectors",
         py::arg("x"),
@@ -92,11 +95,11 @@ void init_kernel_functions(py::module_ &m) {
         "chi_squared_kernel_function", [](const std::vector<plssvm::real_type> &x, const std::vector<plssvm::real_type> &y, const plssvm::gamma_type gamma) {
             if (std::holds_alternative<plssvm::real_type>(gamma)) {
                 return plssvm::kernel_function<plssvm::kernel_function_type::chi_squared>(x, y, std::get<plssvm::real_type>(gamma));
-            } else if (std::get<plssvm::gamma_coefficient_type>(gamma) == plssvm::gamma_coefficient_type::automatic) {
+            }
+            if (std::get<plssvm::gamma_coefficient_type>(gamma) == plssvm::gamma_coefficient_type::automatic) {
                 return plssvm::kernel_function<plssvm::kernel_function_type::chi_squared>(x, y, plssvm::real_type{ 1.0 } / static_cast<plssvm::real_type>(x.size()));
-            } else {
-                throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
             }
+            throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
         },
         "apply the chi-squared kernel function to two vectors",
         py::arg("x"),
@@ -109,17 +112,18 @@ void init_kernel_functions(py::module_ &m) {
             if (params.kernel_type == plssvm::kernel_function_type::linear) {
                 // gamma doesn't matter in the linear kernel function -> simply call the kernel
                 return plssvm::kernel_function(x, y, params);
-            } else if (std::holds_alternative<plssvm::real_type>(params.gamma)) {
+            }
+            if (std::holds_alternative<plssvm::real_type>(params.gamma)) {
                 // the gamma value matters, but already is a real_type -> simply call the kernel
                 return plssvm::kernel_function(x, y, params);
-            } else if (std::get<plssvm::gamma_coefficient_type>(params.gamma) == plssvm::gamma_coefficient_type::automatic) {
+            }
+            if (std::get<plssvm::gamma_coefficient_type>(params.gamma) == plssvm::gamma_coefficient_type::automatic) {
                 // the gamma value matters and is automatic -> convert it to a real_type
                 params.gamma = plssvm::real_type{ 1.0 } / static_cast<plssvm::real_type>(x.size());
                 return plssvm::kernel_function(x, y, params);
-            } else {
-                // the gamma value matters and is scale -> not supported
-                throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
             }
+            // the gamma value matters and is scale -> not supported
+            throw py::value_error{ "Can't use the 'scale' gamma option since the required variance can't be calculated!" };
         },
         "apply the kernel function defined in the parameter object to two vectors",
         py::arg("x"),
diff --git a/bindings/Python/main.cpp b/bindings/Python/main.cpp
index 777317de7..68a38e2a6 100644
--- a/bindings/Python/main.cpp
+++ b/bindings/Python/main.cpp
@@ -16,48 +16,14 @@
 #include "plssvm/verbosity_levels.hpp"                  // plssvm::verbosity_level
 #include "plssvm/version/version.hpp"                   // plssvm::version::{version, major, minor, patch}
 
-#include "pybind11/pybind11.h"  // PYBIND11_MODULE, py::module_, py::exception, py::register_exception_translator, py::make_tuple
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+
+#include "pybind11/cast.h"      // py::make_tuple
+#include "pybind11/pybind11.h"  // PYBIND11_MODULE, py::module_, py::exception, py::register_exception_translator
 #include "pybind11/pytypes.h"   // py::set_error
 
 #include <exception>  // std::exception_ptr, std::rethrow_exception
 
-namespace py = pybind11;
-
-// forward declare binding functions
-void init_verbosity_levels(py::module_ &);
-void init_performance_tracker(py::module_ &);
-void init_events(py::module_ &);
-void init_target_platforms(py::module_ &);
-void init_solver_types(py::module_ &);
-void init_svm_types(py::module_ &);
-void init_backend_types(py::module_ &);
-void init_gamma(py::module_ &);
-void init_classification_types(py::module_ &);
-void init_file_format_types(py::module_ &);
-void init_kernel_function_types(py::module_ &);
-void init_parameter(py::module_ &);
-void init_kernel_functions(py::module_ &);
-void init_classification_model(py::module_ &);
-void init_regression_model(py::module_ &);
-void init_min_max_scaler(py::module_ &);
-void init_classification_data_set(py::module_ &);
-void init_regression_data_set(py::module_ &);
-void init_exceptions(py::module_ &, const py::exception<plssvm::exception> &);
-void init_regression_report(py::module_ &);
-void init_csvm(py::module_ &);
-void init_csvc(py::module_ &);
-void init_csvr(py::module_ &);
-void init_openmp_csvm(py::module_ &, const py::exception<plssvm::exception> &);
-void init_hpx_csvm(py::module_ &, const py::exception<plssvm::exception> &);
-void init_stdpar_csvm(py::module_ &, const py::exception<plssvm::exception> &);
-void init_cuda_csvm(py::module_ &, const py::exception<plssvm::exception> &);
-void init_hip_csvm(py::module_ &, const py::exception<plssvm::exception> &);
-void init_opencl_csvm(py::module_ &, const py::exception<plssvm::exception> &);
-void init_sycl(py::module_ &, const py::exception<plssvm::exception> &);
-void init_kokkos_csvm(py::module_ &, const py::exception<plssvm::exception> &);
-void init_sklearn_svc(py::module_ &);
-void init_sklearn_svr(py::module_ &);
-
 PYBIND11_MODULE(plssvm, m) {
     m.doc() = "PLSSVM - Parallel Least Squares Support Vector Machine";
     m.attr("__version__") = plssvm::version::version;
@@ -98,8 +64,8 @@ PYBIND11_MODULE(plssvm, m) {
                  }));
 
     // register PLSSVM base exception
-    static py::exception<plssvm::exception> base_exception(m, "PLSSVMError");
-    py::register_exception_translator([](std::exception_ptr p) {
+    static const py::exception<plssvm::exception> base_exception(m, "PLSSVMError");
+    py::register_exception_translator([](std::exception_ptr p) {  // NOLINT: must be copied for each invocation
         try {
             if (p) {
                 std::rethrow_exception(p);
@@ -166,6 +132,7 @@ PYBIND11_MODULE(plssvm, m) {
 #endif
 
     py::module_ sklearn_like_svm_model = m.def_submodule("svm", "a module containing the sklearn like SVC and SVR implementations");
+    init_sklearn_tags(sklearn_like_svm_model);
     init_sklearn_svc(sklearn_like_svm_model);
     init_sklearn_svr(sklearn_like_svm_model);
 }
diff --git a/bindings/Python/model/classification_model.cpp b/bindings/Python/model/classification_model.cpp
index c6bf180f9..9cc704b8d 100644
--- a/bindings/Python/model/classification_model.cpp
+++ b/bindings/Python/model/classification_model.cpp
@@ -13,15 +13,18 @@
 #include "plssvm/matrix.hpp"              // plssvm::aos_matrix
 #include "plssvm/mpi/communicator.hpp"    // plssvm::mpi::communicator
 
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/model/variant_wrapper.hpp"        // plssvm::bindings::python::util::classification_model_wrapper
-#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
+#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // NOLINT: a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::{python_type_name_mapping, create_instance, vector_to_pyarray}
 
 #include "fmt/format.h"         // fmt::format
 #include "fmt/ranges.h"         // fmt::join
-#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::kw_only, py::array, py::list
-#include "pybind11/pytypes.h"   // py::type
-#include "pybind11/stl.h"       // support for STL types: std::vector
+#include "pybind11/cast.h"      // py::arg, py::kw_only, py::cast
+#include "pybind11/numpy.h"     // py::array
+#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init
+#include "pybind11/pytypes.h"   // py::type py::list
+#include "pybind11/stl.h"       // NOLINT: support for STL types
 
 #include <memory>    // std::make_unique
 #include <optional>  // std::optional, std::make_optional, std::nullopt
@@ -35,19 +38,18 @@ void init_classification_model(py::module_ &m) {
     using plssvm::bindings::python::util::classification_model_wrapper;
 
     py::class_<classification_model_wrapper>(m, "ClassificationModel", "Implements a class encapsulating the result of a call to the C-SVC fit function. A model is used to predict the labels of a new data set.")
-        .def(py::init([](const std::string &filename, const std::optional<py::type> type, plssvm::mpi::communicator comm) {
+        .def(py::init([](const std::string &filename, const std::optional<py::type> &type, plssvm::mpi::communicator comm) {
                  if (type.has_value()) {
                      return std::make_unique<classification_model_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_model, typename classification_model_wrapper::possible_model_types>(type.value(), std::move(comm), filename));
-                 } else {
-                     return std::make_unique<classification_model_wrapper>(plssvm::classification_model<std::string>{ std::move(comm), filename });
                  }
+                 return std::make_unique<classification_model_wrapper>(plssvm::classification_model<std::string>{ std::move(comm), filename });
              }),
              "load a previously learned classification model from a file",
              py::arg("filename"),
              py::kw_only(),
              py::arg("type") = std::nullopt,
              py::arg("comm") = plssvm::mpi::communicator{})
-        .def("save", [](const classification_model_wrapper &self, const std::string &filename) { return std::visit([&filename](auto &&model) { model.save(filename); }, self.model); }, "save the current model to a file", py::arg("filename"))
+        .def("save", [](const classification_model_wrapper &self, const std::string &filename) { std::visit([&filename](auto &&model) { model.save(filename); }, self.model); }, "save the current model to a file", py::arg("filename"))
         .def("num_support_vectors", [](const classification_model_wrapper &self) { return std::visit([](auto &&model) { return model.num_support_vectors(); }, self.model); }, "the number of support vectors (note: all training points become support vectors for LS-SVMs)")
         .def("num_features", [](const classification_model_wrapper &self) { return std::visit([](auto &&model) { return model.num_features(); }, self.model); }, "the number of features of the support vectors")
         .def("get_params", [](const classification_model_wrapper &self) { return std::visit([](auto &&model) { return model.get_params(); }, self.model); }, "the C-SVC hyper-parameters used to learn this model")
@@ -57,9 +59,8 @@ void init_classification_model(py::module_ &m) {
             return std::visit([](auto &&model) -> std::optional<py::array> {
                 if (model.labels().has_value()) {
                     return std::make_optional(plssvm::bindings::python::util::vector_to_pyarray(model.labels()->get()));
-                } else {
-                    return std::nullopt;
                 }
+                return std::nullopt;
             }, self.model); }, "the labels")
         .def("weights", [](const classification_model_wrapper &self) {
             return std::visit([](auto &&model) {
diff --git a/bindings/Python/model/regression_model.cpp b/bindings/Python/model/regression_model.cpp
index 5c22f6147..6cbbdfbbf 100644
--- a/bindings/Python/model/regression_model.cpp
+++ b/bindings/Python/model/regression_model.cpp
@@ -13,15 +13,18 @@
 #include "plssvm/matrix.hpp"              // plssvm::aos_matrix
 #include "plssvm/mpi/communicator.hpp"    // plssvm::mpi::communicator
 
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/model/variant_wrapper.hpp"        // plssvm::bindings::python::util::regression_model_wrapper
-#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
+#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // NOLINT: a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::{python_type_name_mapping, create_instance, vector_to_pyarray}
 
 #include "fmt/format.h"         // fmt::format
 #include "fmt/ranges.h"         // fmt::join
-#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::kw_only, py::array, py::list
+#include "pybind11/cast.h"      // py::cast, py::arg
+#include "pybind11/numpy.h"     // py::array
+#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::kw_only, py::array, py::list
 #include "pybind11/pytypes.h"   // py::type
-#include "pybind11/stl.h"       // support for STL types: std::vector
+#include "pybind11/stl.h"       // NOLINT: support for STL types: std::vector
 
 #include <memory>    // std::make_unique
 #include <optional>  // std::optional, std::make_optional, std::nullopt
@@ -35,19 +38,18 @@ void init_regression_model(py::module_ &m) {
     using plssvm::bindings::python::util::regression_model_wrapper;
 
     py::class_<regression_model_wrapper>(m, "RegressionModel", "Implements a class encapsulating the result of a call to the C-SVR fit function. A model is used to predict the labels of a new data set.")
-        .def(py::init([](const std::string &filename, const std::optional<py::type> type, plssvm::mpi::communicator comm) {
+        .def(py::init([](const std::string &filename, const std::optional<py::type> &type, plssvm::mpi::communicator comm) {
                  if (type.has_value()) {
                      return std::make_unique<regression_model_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::regression_model, typename regression_model_wrapper::possible_model_types>(type.value(), std::move(comm), filename));
-                 } else {
-                     return std::make_unique<regression_model_wrapper>(plssvm::regression_model<double>{ std::move(comm), filename });
                  }
+                 return std::make_unique<regression_model_wrapper>(plssvm::regression_model<double>{ std::move(comm), filename });
              }),
              "load a previously learned regression model from a file",
              py::arg("filename"),
              py::kw_only(),
              py::arg("type") = std::nullopt,
              py::arg("comm") = plssvm::mpi::communicator{})
-        .def("save", [](const regression_model_wrapper &self, const std::string &filename) { return std::visit([&filename](auto &&model) { model.save(filename); }, self.model); }, "save the current model to a file", py::arg("filename"))
+        .def("save", [](const regression_model_wrapper &self, const std::string &filename) { std::visit([&filename](auto &&model) { model.save(filename); }, self.model); }, "save the current model to a file", py::arg("filename"))
         .def("num_support_vectors", [](const regression_model_wrapper &self) { return std::visit([](auto &&model) { return model.num_support_vectors(); }, self.model); }, "the number of support vectors (note: all training points become support vectors for LS-SVMs)")
         .def("num_features", [](const regression_model_wrapper &self) { return std::visit([](auto &&model) { return model.num_features(); }, self.model); }, "the number of features of the support vectors")
         .def("get_params", [](const regression_model_wrapper &self) { return std::visit([](auto &&model) { return model.get_params(); }, self.model); }, "the C-SVR hyper-parameters used to learn this model")
@@ -57,9 +59,8 @@ void init_regression_model(py::module_ &m) {
             return std::visit([](auto &&model) -> std::optional<py::array> {
                 if (model.labels().has_value()) {
                     return std::make_optional(plssvm::bindings::python::util::vector_to_pyarray(model.labels()->get()));
-                } else {
-                    return std::nullopt;
                 }
+                return std::nullopt;
             }, self.model); }, "the labels")
         .def("weights", [](const regression_model_wrapper &self) {
             return std::visit([](auto &&model) {
diff --git a/bindings/Python/model/variant_wrapper.hpp b/bindings/Python/model/variant_wrapper.hpp
index 908a058af..77f0734ff 100644
--- a/bindings/Python/model/variant_wrapper.hpp
+++ b/bindings/Python/model/variant_wrapper.hpp
@@ -9,8 +9,8 @@
  * @brief Variant wrapper structs around PLSSVM classification and regression models. Used that we don't have to expose templates to the Python bindings.
  */
 
-#ifndef PLSSVM_BINDINGS_PYTHON_MODEL_WRAPPER_HPP_
-#define PLSSVM_BINDINGS_PYTHON_MODEL_WRAPPER_HPP_
+#ifndef PLSSVM_BINDINGS_PYTHON_MODEL_VARIANT_WRAPPER_HPP_
+#define PLSSVM_BINDINGS_PYTHON_MODEL_VARIANT_WRAPPER_HPP_
 #pragma once
 
 #include "plssvm/model/classification_model.hpp"  // plssvm::classification_model
@@ -94,4 +94,4 @@ struct regression_model_wrapper {
 
 }  // namespace plssvm::bindings::python::util
 
-#endif  // PLSSVM_BINDINGS_PYTHON_MODEL_WRAPPER_HPP_
+#endif  // PLSSVM_BINDINGS_PYTHON_MODEL_VARIANT_WRAPPER_HPP_
diff --git a/bindings/Python/parameter.cpp b/bindings/Python/parameter.cpp
index bd419e06f..2820b6d91 100644
--- a/bindings/Python/parameter.cpp
+++ b/bindings/Python/parameter.cpp
@@ -12,10 +12,17 @@
 #include "plssvm/gamma.hpp"                  // plssvm::gamma_type
 #include "plssvm/kernel_function_types.hpp"  // plssvm::kernel_function_type
 
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+
 #include "fmt/format.h"          // fmt::format
+#include "pybind11/cast.h"       // py::make_tuple
 #include "pybind11/operators.h"  // support for operators
-#include "pybind11/pybind11.h"   // py::module_, py::class_, py::init, py::return_value_policy, py::self
-#include "pybind11/stl.h"        // support for STL types
+#include "pybind11/pybind11.h"   // py::module_, py::class_, py::init, py::self, py::pickle, py::return_value_policy
+#include "pybind11/pytypes.h"    // py::tuple
+#include "pybind11/stl.h"        // NOLINT: support for STL types
+
+#include <cstddef>    // std::size_t
+#include <stdexcept>  // std::runtime_error
 
 namespace py = pybind11;
 
@@ -64,8 +71,8 @@ void init_parameter(py::module_ &m) {
             py::return_value_policy::reference,
             "change the cost parameter for the C-SVM")
         .def("equivalent", &plssvm::parameter::equivalent, "check whether two parameter objects are equivalent, i.e., the SVM hyper-parameters important for the current 'kernel_type' are the same")
-        .def(py::self == py::self, "check whether two parameter objects are identical")
-        .def(py::self != py::self, "check whether two parameter objects are different")
+        .def(py::self == py::self, "check whether two parameter objects are identical")  // NOLINT(misc-redundant-expression): the idiomatic Pybind11 way
+        .def(py::self != py::self, "check whether two parameter objects are different")  // NOLINT(misc-redundant-expression): the idiomatic Pybind11 way
         .def("__repr__", [](const plssvm::parameter &self) {
             return fmt::format("<plssvm.Parameter with {{ kernel_type: {}, degree: {}, gamma: {}, coef0: {}, cost: {} }}>",
                                self.kernel_type,
@@ -73,7 +80,24 @@ void init_parameter(py::module_ &m) {
                                self.gamma,
                                self.coef0,
                                self.cost);
-        });
+        })
+        .def(py::pickle(
+            // clang-format off
+            [](const plssvm::parameter &self) {  // __getstate__
+                // return a tuple that fully encodes the state of the object
+                return py::make_tuple(self.kernel_type, self.degree, self.gamma, self.coef0, self.cost);
+            },
+            [](py::tuple t) {  // NOLINT: __setstate__
+                constexpr std::size_t num_member_variables_of_plssvm_parameter = 5;
+                if (t.size() != num_member_variables_of_plssvm_parameter) {
+                    throw std::runtime_error{ "Invalid state!" };
+                }
+                // create a new C++ instance
+                return plssvm::parameter{ t[0].cast<plssvm::kernel_function_type>(), t[1].cast<int>(), t[2].cast<plssvm::real_type>(), t[3].cast<plssvm::real_type>(), t[4].cast<plssvm::real_type>() };
+            }
+            )
+             // clang-format on
+        );
 
     // bind free functions
     m.def("equivalent", &plssvm::equivalent, "check whether two parameter objects are equivalent, i.e., the SVM hyper-parameters important for the current 'kernel_type' are the same");
diff --git a/bindings/Python/regression_report.cpp b/bindings/Python/regression_report.cpp
index 55dabfcb9..48a0728fd 100644
--- a/bindings/Python/regression_report.cpp
+++ b/bindings/Python/regression_report.cpp
@@ -10,13 +10,14 @@
 
 #include "plssvm/detail/type_traits.hpp"  // plssvm::detail::remove_cvref_t
 
-#include "bindings/Python/data_set/variant_wrapper.hpp"                 // plssvm::bindings::python::util::regression_data_set_wrapper
-#include "bindings/Python/type_caster/label_vector_wrapper_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::util::label_vector_wrapper
+#include "bindings/Python/bindings_fwd.hpp"                                  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/data_set/variant_wrapper.hpp"                      // plssvm::bindings::python::util::regression_data_set_wrapper
+#include "bindings/Python/type_caster/label_vector_wrapper_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::util::label_vector_wrapper
 
 #include "fmt/format.h"         // fmt::format
 #include "pybind11/pybind11.h"  // py::module_, py::init, py::arg, py::kw_only, py::value_error
 #include "pybind11/pytypes.h"   // py::object
-#include "pybind11/stl.h"       // support for STL types
+#include "pybind11/stl.h"       // NOLINT: support for STL types
 
 #include <string>   // std::string
 #include <variant>  // std::visit, std::get
@@ -49,8 +50,7 @@ void init_regression_report(py::module_ &m) {
                  dict["r2_score"] = metrics.r2_score;
                  dict["squared_correlation_coefficient"] = metrics.squared_correlation_coefficient;
                  return dict;
-             } else {
-                 return py::str(fmt::format("{}", report));
              }
+             return py::str(fmt::format("{}", report));
          }, y_true.labels); }, "create a new regression report by calculating all metrics between the correct and predicted labels", py::arg("y_true"), py::arg("y_pred"), py::kw_only(), py::arg("force_finite") = true, py::arg("output_dict") = false);
 }
diff --git a/bindings/Python/sklearn_like/svc.cpp b/bindings/Python/sklearn_like/svc.cpp
index 0c1e53f2e..edeb5ebe7 100644
--- a/bindings/Python/sklearn_like/svc.cpp
+++ b/bindings/Python/sklearn_like/svc.cpp
@@ -7,7 +7,7 @@
  */
 
 #include "plssvm/classification_types.hpp"              // plssvm::classification_type
-#include "plssvm/constants.hpp"                         // plssvm::real_type
+#include "plssvm/constants.hpp"                         // plssvm::real_type, plssvm::DEFAULT_EPSILON
 #include "plssvm/csvm_factory.hpp"                      // plssvm::make_csvc
 #include "plssvm/data_set/classification_data_set.hpp"  // plssvm::classification_data_set
 #include "plssvm/detail/assert.hpp"                     // PLSSVM_ASSERT
@@ -20,30 +20,33 @@
 #include "plssvm/svm/csvc.hpp"                          // plssvm::csvc
 #include "plssvm/verbosity_levels.hpp"                  // plssvm::verbosity_level, plssvm::verbosity
 
-#include "bindings/Python/data_set/variant_wrapper.hpp"                 // plssvm::bindings::python::util::classification_data_set_wrapper
-#include "bindings/Python/model/variant_wrapper.hpp"                    // plssvm::bindings::python::util::classification_model_wrapper
-#include "bindings/Python/type_caster/label_vector_wrapper_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::label_vector_wrapper
-#include "bindings/Python/type_caster/matrix_type_caster.hpp"           // a custom Pybind11 type caster for a plssvm::matrix
-#include "bindings/Python/type_caster/matrix_wrapper_type_caster.hpp"   // a custom Pybind11 type caster for a plssvm::bindings::python::util::matrix_wrapper
-#include "bindings/Python/utility.hpp"                                  // plssvm::bindings::python::util::{check_kwargs_for_correctness, vector_to_pyarray}
-
-#include "fmt/format.h"          // fmt::format
-#include "fmt/ranges.h"          // fmt::join
-#include "pybind11/cast.h"       // py::cast
-#include "pybind11/numpy.h"      // support for STL types
-#include "pybind11/operators.h"  // support for operators
-#include "pybind11/pybind11.h"   // py::module_, py::class_, py::init, py::arg, py::return_value_policy, py::self, py::dynamic_attr, py::value_error, py::attribute_error
-#include "pybind11/pytypes.h"    // py::dict, py::kwargs, py::str
-#include "pybind11/stl.h"        // support for STL types
+#include "bindings/Python/bindings_fwd.hpp"                                  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/data_set/variant_wrapper.hpp"                      // plssvm::bindings::python::util::classification_data_set_wrapper
+#include "bindings/Python/model/variant_wrapper.hpp"                         // plssvm::bindings::python::util::classification_model_wrapper
+#include "bindings/Python/sklearn_like/tags.hpp"                             // Tags, TargetTags, TransformerTags, ClassifierTags, RegressorTags, InputTags
+#include "bindings/Python/type_caster/label_vector_wrapper_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::label_vector_wrapper
+#include "bindings/Python/type_caster/matrix_type_caster.hpp"                // NOLINT: a custom Pybind11 type caster for a plssvm::matrix
+#include "bindings/Python/type_caster/matrix_wrapper_type_caster.hpp"        // a custom Pybind11 type caster for a plssvm::bindings::python::util::matrix_wrapper
+#include "bindings/Python/utility.hpp"                                       // plssvm::bindings::python::util::{check_kwargs_for_correctness, vector_to_pyarray}
+
+#include "fmt/format.h"            // fmt::format
+#include "fmt/ranges.h"            // fmt::join
+#include "pybind11/buffer_info.h"  // py::buffer_info
+#include "pybind11/cast.h"         // py::cast, py::arg
+#include "pybind11/numpy.h"        // support for STL types
+#include "pybind11/operators.h"    // NOLINT: support for operators
+#include "pybind11/pybind11.h"     // py::module_, py::class_, py::init, py::return_value_policy, py::self, py::dynamic_attr, py::value_error, py::attribute_error, py::tuple, py::pickle
+#include "pybind11/pytypes.h"      // py::dict, py::kwargs, py::str
+#include "pybind11/stl.h"          // NOLINT: support for STL types
 
 #include <algorithm>  // std::fill
 #include <cstddef>    // std::size_t
 #include <cstdint>    // std::int32_t
-#include <cstdint>    // fixed-width integers
 #include <exception>  // std::exception
 #include <map>        // std::map
 #include <memory>     // std::unique_ptr, std::make_unique
 #include <optional>   // std::optional, std::nullopt
+#include <stdexcept>  // std::runtime_error
 #include <string>     // std::string
 #include <tuple>      // std::make_tuple, std::ignore
 #include <utility>    // std::move
@@ -145,9 +148,10 @@ struct svc {
     /**
      * @brief Return the currently used params.
      * @details Necessary for the same Python function and also the string representation.
+     * @params[in] deep_copy *unused*
      * @return a Python dictionary containing the used parameter (`[[nodiscard]]`)
      */
-    [[nodiscard]] py::dict get_params(const bool) const {
+    [[nodiscard]] py::dict get_params([[maybe_unused]] const bool deep_copy) const {
         PLSSVM_ASSERT(svm_ != nullptr, "svm_ may not be a nullptr! Maybe you forgot to initialize it?");
         const plssvm::parameter params = svm_->get_params();
 
@@ -189,7 +193,7 @@ struct svc {
 
             std::map<label_type, std::vector<int>> indices_per_class{};
             // init index-map map
-            for (const label_type &label : model.classes()) {
+            for (const label_type &label : model.classes()) {  // NOLINT(performance-implicit-conversion-in-loop): the types ARE identical
                 indices_per_class.insert({ label, std::vector<int>{} });
             }
             // sort the indices into the respective bucket based on their associated class
@@ -207,24 +211,24 @@ struct svc {
                           *model_);
     }
 
-    /// Pointer to the the stored PLSSVM C-SVC instance.
-    std::unique_ptr<plssvm::csvc> svm_{};
+    /// Pointer to the stored PLSSVM C-SVC instance.
+    std::unique_ptr<plssvm::csvc> svm_;
     /// The CG termination criterion if provided.
     plssvm::real_type epsilon_{};
     /// The maximum number of CG iterations if provided.
-    std::optional<unsigned long long> max_iter_{};
+    std::optional<unsigned long long> max_iter_;
     /// The used classification type (or decision function shape).
     plssvm::classification_type classification_{};
 
     /// The data type of the labels.
-    py::dtype py_dtype_{};
+    py::dtype py_dtype_;
     /// Pointer to the classification data set wrapper (represents data sets with all possible label types).
-    std::unique_ptr<possible_data_set_types> data_{};
+    std::unique_ptr<possible_data_set_types> data_;
     /// Pointer to the classification model wrapper (represents models with all possible label types).
-    std::unique_ptr<possible_model_types> model_{};
+    std::unique_ptr<possible_model_types> model_;
 
     /// The name of the features. Can only be provided via a Pandas DataFrame.
-    std::optional<std::vector<std::string>> feature_names_{};
+    std::optional<std::vector<std::string>> feature_names_;
 };
 
 void init_sklearn_svc(py::module_ &m) {
@@ -263,7 +267,7 @@ void init_sklearn_svc(py::module_ &m) {
                py::arg("coef0") = 0.0,
                // py::arg("shrinking") = true,
                // py::arg("probability") = false,
-               py::arg("tol") = 1e-10,
+               py::arg("tol") = plssvm::DEFAULT_EPSILON,
                // py::arg("cache_size") = 200,
                // py::arg("class_weight") = py::none{},
                py::arg("verbose") = false,
@@ -286,7 +290,7 @@ void init_sklearn_svc(py::module_ &m) {
             const auto size = static_cast<int>(std::visit([](auto &&model) { return model.num_classes(); }, *self.model_));
             py::array_t<plssvm::real_type, py::array::c_style> py_array(size);
             const py::buffer_info buffer = py_array.request();
-            auto ptr = static_cast<plssvm::real_type *>(buffer.ptr);
+            auto *ptr = static_cast<plssvm::real_type *>(buffer.ptr);
             std::fill(ptr, ptr + size, plssvm::real_type{ 1.0 });
             return py_array; }, "Multipliers of parameter C for each class. ndarray of shape (n_classes,)")
         .def_property_readonly("classes_", [](const svc &self) -> py::array {
@@ -382,7 +386,7 @@ void init_sklearn_svc(py::module_ &m) {
             }
 
             // convert 2D vector back to plssvm::matrix
-            return py::cast(plssvm::aos_matrix<plssvm::real_type>{ std::move(sorted_sv) }); }, "Support vectors. ndarray of shape (n_SV, n_features)")
+            return py::cast(plssvm::aos_matrix<plssvm::real_type>{ sorted_sv }); }, "Support vectors. ndarray of shape (n_SV, n_features)")
         .def_property_readonly("n_support_", [](const svc &self) -> py::array {
             if (self.model_ == nullptr) {
                 throw py::attribute_error{ "'SVC' object has no attribute 'n_support_'" };
@@ -393,7 +397,7 @@ void init_sklearn_svc(py::module_ &m) {
 
                 std::map<label_type, std::int32_t> occurrences{};
                 // init count map
-                for (const label_type &label : model.classes()) {
+                for (const label_type &label : model.classes()) {  // NOLINT(performance-implicit-conversion-in-loop): the types ARE identical
                     occurrences.insert({ label, std::int32_t{ 0 } });
                 }
                 // count occurrences
@@ -449,9 +453,8 @@ void init_sklearn_svc(py::module_ &m) {
                                     reduced_votes[i] = -votes(i, 0);
                                 }
                                 return plssvm::bindings::python::util::vector_to_pyarray(reduced_votes);
-                            } else {
-                                return py::cast(votes);
                             }
+                            return py::cast(votes);
                         }
                     case plssvm::classification_type::oao:
                         {
@@ -481,12 +484,12 @@ void init_sklearn_svc(py::module_ &m) {
                                         if (num_classes == 2) {
                                             // no special assembly needed in binary case
                                             return model.support_vectors();
-                                        } else {
-                                            // note: if this is changed, it must also be changed in the libsvm_model_parsing.hpp in the calculate_alpha_idx function!!!
-                                            // order the indices in increasing order
-                                            plssvm::soa_matrix<plssvm::real_type> temp{ plssvm::shape{ num_data_points_in_sub_matrix, num_features }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
-                                            std::vector<std::size_t> sorted_indices(num_data_points_in_sub_matrix);
-                                            std::merge(index_sets[i].cbegin(), index_sets[i].cend(), index_sets[j].cbegin(), index_sets[j].cend(), sorted_indices.begin());
+                                        }
+                                        // note: if this is changed, it must also be changed in the libsvm_model_parsing.hpp in the calculate_alpha_idx function!!!
+                                        // order the indices in increasing order
+                                        plssvm::soa_matrix<plssvm::real_type> temp{ plssvm::shape{ num_data_points_in_sub_matrix, num_features }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
+                                        std::vector<std::size_t> sorted_indices(num_data_points_in_sub_matrix);
+                                        std::merge(index_sets[i].cbegin(), index_sets[i].cend(), index_sets[j].cbegin(), index_sets[j].cend(), sorted_indices.begin());
 // copy the support vectors to the binary support vectors
 // NOTE: it seems that MSVC doesn't like the collapse clause inside a lambda function
 #if defined(_MSC_VER)
@@ -494,13 +497,12 @@ void init_sklearn_svc(py::module_ &m) {
 #else
     #pragma omp parallel for collapse(2)
 #endif
-                                            for (std::size_t si = 0; si < num_data_points_in_sub_matrix; ++si) {
-                                                for (std::size_t dim = 0; dim < num_features; ++dim) {
-                                                    temp(si, dim) = model.support_vectors()(sorted_indices[si], dim);
-                                                }
+                                        for (std::size_t si = 0; si < num_data_points_in_sub_matrix; ++si) {
+                                            for (std::size_t dim = 0; dim < num_features; ++dim) {
+                                                temp(si, dim) = model.support_vectors()(sorted_indices[si], dim);
                                             }
-                                            return temp;
                                         }
+                                        return temp;
                                     }();
 
                                     // we don't use the w optimization for the linear kernel here due to code simplicity
@@ -525,9 +527,8 @@ void init_sklearn_svc(py::module_ &m) {
                                     votes_access(pp, pos) *= plssvm::real_type{ -1.0 };
                                 }
                                 return votes.reshape(py::array::ShapeContainer{ votes.size() });
-                            } else {
-                                return votes;
                             }
+                            return votes;
                         }
                 }
                 // unreachable
@@ -554,7 +555,7 @@ void init_sklearn_svc(py::module_ &m) {
                 using possible_model_types = typename svc::possible_model_types;
 
                 // create the data set to fit
-                plssvm::classification_data_set<label_type> train_data{ std::move(data.matrix), std::move(labels_vector) };
+                plssvm::classification_data_set<label_type> train_data{ std::move(data.matrix), std::forward<decltype(labels_vector)>(labels_vector) };
 
                 // fit the model
                 if (self.max_iter_.has_value()) {
@@ -590,8 +591,8 @@ void init_sklearn_svc(py::module_ &m) {
                 // predict the data
                 return plssvm::bindings::python::util::vector_to_pyarray(self.svm_->predict(model, data_to_predict));
             }, *self.model_); }, "Perform classification on samples in X.", py::arg("X"))
-        .def("predict_log_proba", [](const svc &, py::array_t<plssvm::real_type>) { throw py::attribute_error{ "'SVC' object has no function 'predict_log_proba' (not implemented)" }; }, "Compute log probabilities of possible outcomes for samples in X.", py::arg("X"))
-        .def("predict_proba", [](const svc &, py::array_t<plssvm::real_type>) { throw py::attribute_error{ "'SVC' object has no function 'predict_proba' (not implemented)" }; }, "Compute probabilities of possible outcomes for samples in X.", py::arg("X"))
+        .def("predict_log_proba", [](const svc &, const py::array_t<plssvm::real_type> &) { throw py::attribute_error{ "'SVC' object has no function 'predict_log_proba' (not implemented)" }; }, "Compute log probabilities of possible outcomes for samples in X.", py::arg("X"))
+        .def("predict_proba", [](const svc &, const py::array_t<plssvm::real_type> &) { throw py::attribute_error{ "'SVC' object has no function 'predict_proba' (not implemented)" }; }, "Compute probabilities of possible outcomes for samples in X.", py::arg("X"))
         .def("score", [](svc &self, plssvm::soa_matrix<plssvm::real_type> data, plssvm::bindings::python::util::label_vector_wrapper<typename svc::possible_vector_types> labels, const std::optional<std::vector<plssvm::real_type>> &sample_weight) -> plssvm::real_type {
             PLSSVM_ASSERT(self.svm_ != nullptr, "svm_ may not be a nullptr! Maybe you forgot to initialize it?");
             // sanity check parameter
@@ -607,7 +608,7 @@ void init_sklearn_svc(py::module_ &m) {
                 // get the label types
                 using label_type = typename plssvm::detail::remove_cvref_t<decltype(labels_vector)>::value_type;
                 // create the data set to score
-                const plssvm::classification_data_set<label_type> data_to_score{ std::move(data), std::move(labels_vector) };
+                const plssvm::classification_data_set<label_type> data_to_score{ std::move(data), std::forward<decltype(labels_vector)>(labels_vector) };
                 // score the data
                 try {
                     return self.svm_->score(std::get<plssvm::classification_model<label_type>>(*self.model_), data_to_score);
@@ -698,10 +699,21 @@ void init_sklearn_svc(py::module_ &m) {
             new_svc.max_iter_ = self.max_iter_;
             new_svc.classification_ = self.classification_;
             return new_svc; }, "Clone the estimator.")
+        .def("__sklearn_tags__", [](const svc &self) -> Tags {
+            Tags sklearn_tags{};
+
+            // set non-default values
+            sklearn_tags.estimator_type = "classifier";
+            sklearn_tags.target_tags.one_d_labels = true;
+            sklearn_tags.classifier_tags = ClassifierTags{};
+            sklearn_tags.input_tags.sparse = true;
+            sklearn_tags.input_tags.positive_only = self.svm_->get_params().kernel_type == plssvm::kernel_function_type::chi_squared;
+
+            return sklearn_tags; }, "Set sklearn tags internally used for estimators.")
         .def("__repr__", [](const svc &self) {
             // get the currently used parameters
-            py::dict used_params = self.get_params(true);
-            py::dict default_params = svc{}.get_params(true);
+            const py::dict used_params = self.get_params(true);
+            const py::dict default_params = svc{}.get_params(true);
 
             std::vector<std::string> non_default_values{};
 
@@ -723,5 +735,21 @@ void init_sklearn_svc(py::module_ &m) {
                 }
             }
 
-            return fmt::format("plssvm.svm.SVC({})", fmt::join(non_default_values, ", ")); }, "Print the SVC showing all non-default parameters.");
+            return fmt::format("plssvm.svm.SVC({})", fmt::join(non_default_values, ", ")); }, "Print the SVC showing all non-default parameters.")
+        .def(py::pickle(
+            // clang-format off
+            [](const svc &self) {  // __getstate__
+                // return a tuple that fully encodes the state of the object
+                return py::make_tuple(self.svm_->get_params(), self.epsilon_, self.max_iter_, self.classification_);
+            },
+            [](py::tuple t) {  // NOLINT: __setstate__
+                if (t.size() != 4) {
+                    throw std::runtime_error{ "Invalid state!" };
+                }
+                // create a new C++ instance
+                return svc{ t[0].cast<plssvm::parameter>(), t[1].cast<plssvm::real_type>(), t[2].cast<std::optional<unsigned long long>>(), t[3].cast<plssvm::classification_type>() };
+            }
+            )
+             // clang-format on
+        );
 }
diff --git a/bindings/Python/sklearn_like/svr.cpp b/bindings/Python/sklearn_like/svr.cpp
index 0ebf68217..89017226a 100644
--- a/bindings/Python/sklearn_like/svr.cpp
+++ b/bindings/Python/sklearn_like/svr.cpp
@@ -6,9 +6,10 @@
  *          See the LICENSE.md file in the project root for full license information.
  */
 
-#include "plssvm/constants.hpp"                     // plssvm::real_type
+#include "plssvm/constants.hpp"                     // plssvm::real_type, plssvm::DEFAULT_EPSILON
 #include "plssvm/csvm_factory.hpp"                  // plssvm::make_csvr
 #include "plssvm/data_set/regression_data_set.hpp"  // plssvm::regression_data_set
+#include "plssvm/detail/assert.hpp"                 // PLSSVM_ASSERT
 #include "plssvm/detail/type_traits.hpp"            // plssvm::detail::remove_cvref_t
 #include "plssvm/gamma.hpp"                         // plssvm::gamma_coefficient_type, plssvm::gamma_type
 #include "plssvm/kernel_function_types.hpp"         // plssvm::kernel_function_type
@@ -18,31 +19,35 @@
 #include "plssvm/svm/csvr.hpp"                      // plssvm::csvr
 #include "plssvm/verbosity_levels.hpp"              // plssvm::verbosity_level, plssvm::verbosity
 
-#include "bindings/Python/data_set/variant_wrapper.hpp"                 // plssvm::bindings::python::util::regression_data_set_wrapper
-#include "bindings/Python/model/variant_wrapper.hpp"                    // plssvm::bindings::python::util::regression_model_wrapper
-#include "bindings/Python/type_caster/label_vector_wrapper_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::util::label_vector_wrapper
-#include "bindings/Python/type_caster/matrix_type_caster.hpp"           // a custom Pybind11 type caster for a plssvm::matrix
-#include "bindings/Python/type_caster/matrix_wrapper_type_caster.hpp"   // a custom Pybind11 type caster for a plssvm::bindings::python::util::matrix_wrapper
-#include "bindings/Python/utility.hpp"                                  // plssvm::bindings::python::util::{check_kwargs_for_correctness, vector_to_pyarray}
+#include "bindings/Python/bindings_fwd.hpp"                                  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/data_set/variant_wrapper.hpp"                      // plssvm::bindings::python::util::regression_data_set_wrapper
+#include "bindings/Python/model/variant_wrapper.hpp"                         // plssvm::bindings::python::util::regression_model_wrapper
+#include "bindings/Python/sklearn_like/tags.hpp"                             // Tags, TargetTags, TransformerTags, ClassifierTags, RegressorTags, InputTags
+#include "bindings/Python/type_caster/label_vector_wrapper_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::util::label_vector_wrapper
+#include "bindings/Python/type_caster/matrix_type_caster.hpp"                // NOLINT: a custom Pybind11 type caster for a plssvm::matrix
+#include "bindings/Python/type_caster/matrix_wrapper_type_caster.hpp"        // a custom Pybind11 type caster for a plssvm::bindings::python::util::matrix_wrapper
+#include "bindings/Python/utility.hpp"                                       // plssvm::bindings::python::util::{check_kwargs_for_correctness, vector_to_pyarray}
 
 #include "fmt/format.h"          // fmt::format
 #include "fmt/ranges.h"          // fmt::join
-#include "pybind11/cast.h"       // py::cast
+#include "pybind11/cast.h"       // py::cast, py::arg
 #include "pybind11/numpy.h"      // support for STL types
-#include "pybind11/operators.h"  // support for operators
-#include "pybind11/pybind11.h"   // py::module_, py::class_, py::init, py::arg, py::return_value_policy, py::self, py::dynamic_attr, py::value_error, py::attribute_error
+#include "pybind11/operators.h"  // NOLINT: support for operators
+#include "pybind11/pybind11.h"   // py::module_, py::class_, py::init, py::return_value_policy, py::self, py::dynamic_attr, py::value_error, py::attribute_error, py::tuple, py::pickle
 #include "pybind11/pytypes.h"    // py::dict, py::kwargs, py::str
-#include "pybind11/stl.h"        // support for STL types
-
-#include <cstdint>   // std::int32_t
-#include <memory>    // std::unique_ptr, std::make_unique
-#include <numeric>   // std::iota
-#include <optional>  // std::optional, std::nullopt
-#include <string>    // std::string
-#include <tuple>     // std::make_tuple
-#include <utility>   // std::move
-#include <variant>   // std::holds_alternative
-#include <vector>    // std::vector
+#include "pybind11/stl.h"        // NOLINT: support for STL types
+
+#include <cstdint>    // std::int32_t
+#include <exception>  // std::exception
+#include <memory>     // std::unique_ptr, std::make_unique
+#include <numeric>    // std::iota
+#include <optional>   // std::optional, std::nullopt
+#include <stdexcept>  // std::runtime_error
+#include <string>     // std::string
+#include <tuple>      // std::make_tuple
+#include <utility>    // std::move, std::forward
+#include <variant>    // std::holds_alternative
+#include <vector>     // std::vector
 
 namespace py = pybind11;
 
@@ -97,9 +102,10 @@ struct svr {
     /**
      * @brief Return the currently used params.
      * @details Necessary for the same Python function and also the string representation.
+     * @params[in] deep_copy *unused*
      * @return a Python dictionary containing the used parameter (`[[nodiscard]]`)
      */
-    [[nodiscard]] py::dict get_params(const bool) const {
+    [[nodiscard]] py::dict get_params([[maybe_unused]] const bool deep_copy) const {
         const plssvm::parameter params = svm_->get_params();
 
         // fill a Python dictionary with the supported keys and values
@@ -125,21 +131,21 @@ struct svr {
     }
 
     /// Pointer to the the stored PLSSVM C-SVR instance.
-    std::unique_ptr<plssvm::csvr> svm_{};
+    std::unique_ptr<plssvm::csvr> svm_;
     /// The CG termination criterion if provided.
     plssvm::real_type epsilon_{};
     /// The maximum number of CG iterations if provided.
-    std::optional<unsigned long long> max_iter_{};
+    std::optional<unsigned long long> max_iter_;
 
     /// The data type of the labels.
-    py::dtype py_dtype_{};
+    py::dtype py_dtype_;
     /// Pointer to the regression data set wrapper (represents data sets with all possible label types).
-    std::unique_ptr<possible_data_set_types> data_{};
+    std::unique_ptr<possible_data_set_types> data_;
     /// Pointer to the regression model wrapper (represents models with all possible label types).
-    std::unique_ptr<possible_model_types> model_{};
+    std::unique_ptr<possible_model_types> model_;
 
     /// The name of the features. Can only be provided via a Pandas DataFrame.
-    std::optional<std::vector<std::string>> feature_names_{};
+    std::optional<std::vector<std::string>> feature_names_;
 };
 
 void init_sklearn_svr(py::module_ &m) {
@@ -175,7 +181,7 @@ void init_sklearn_svr(py::module_ &m) {
                py::arg("degree") = 3,
                py::arg("gamma") = plssvm::gamma_coefficient_type::scale,
                py::arg("coef0") = 0.0,
-               py::arg("tol") = 1e-10,
+               py::arg("tol") = plssvm::DEFAULT_EPSILON,
                py::arg("C") = 1.0,
                // py::arg("epsilon") = 0.1,
                // py::arg("shrinking") = true,     // true
@@ -283,7 +289,7 @@ void init_sklearn_svr(py::module_ &m) {
                 using possible_model_types = typename svr::possible_model_types;
 
                 // create the data set to fit
-                plssvm::regression_data_set<label_type> train_data{ std::move(data.matrix), std::move(labels_vector) };
+                plssvm::regression_data_set<label_type> train_data{ std::move(data.matrix), std::forward<decltype(labels_vector)>(labels_vector) };
 
                 // fit the model using potentially provided keyword arguments
                 if (self.max_iter_.has_value()) {
@@ -330,12 +336,12 @@ void init_sklearn_svr(py::module_ &m) {
                 // get the label types
                 using label_type = typename plssvm::detail::remove_cvref_t<decltype(labels_vector)>::value_type;
                 // create the data set to score
-                const plssvm::regression_data_set<label_type> data_to_score{ std::move(data), std::move(labels_vector) };
+                const plssvm::regression_data_set<label_type> data_to_score{ std::move(data), std::forward<decltype(labels_vector)>(labels_vector) };
                 // score the data
                 try {
                     return self.svm_->score(std::get<plssvm::regression_model<label_type>>(*self.model_), data_to_score);
                 } catch (const std::exception &) {
-                    throw py::value_error{ fmt::format("The dtype of the labels to score is \"{}\", but the model was fitted with \"{}\". Please use the same types for fit and score!", labels.dtype.attr("name").cast<std::string>(), self.py_dtype_.attr("name").cast<std::string>()) };
+                    throw py::value_error{ fmt::format(R"(The dtype of the labels to score is "{}", but the model was fitted with "{}". Please use the same types for fit and score!)", labels.dtype.attr("name").cast<std::string>(), self.py_dtype_.attr("name").cast<std::string>()) };
                 }
             }, labels.labels); }, "Return the mean accuracy on the given test data and labels.", py::arg("X"), py::arg("y"), py::pos_only(), py::arg("sample_weight") = std::nullopt)
         .def("set_fit_request", [](const svr &) { throw py::attribute_error{ "'SVR' object has no function 'set_fit_request' (not implemented)" }; }, "Request metadata passed to the fit method.")
@@ -407,10 +413,21 @@ void init_sklearn_svr(py::module_ &m) {
             new_svr.epsilon_ = self.epsilon_;
             new_svr.max_iter_ = self.max_iter_;
             return new_svr; }, "Clone the estimator.")
+        .def("__sklearn_tags__", [](const svr &self) -> Tags {
+            Tags sklearn_tags{};
+
+            // set non-default values
+            sklearn_tags.estimator_type = "regressor";
+            sklearn_tags.target_tags.one_d_labels = true;
+            sklearn_tags.regressor_tags = RegressorTags{};
+            sklearn_tags.input_tags.sparse = true;
+            sklearn_tags.input_tags.positive_only = self.svm_->get_params().kernel_type == plssvm::kernel_function_type::chi_squared;
+
+            return sklearn_tags; }, "Set sklearn tags internally used for estimators.")
         .def("__repr__", [](const svr &self) {
             // get the currently used parameters
-            py::dict used_params = self.get_params(true);
-            py::dict default_params = svr{}.get_params(true);
+            const py::dict used_params = self.get_params(true);
+            const py::dict default_params = svr{}.get_params(true);
 
             std::vector<std::string> non_default_values{};
 
@@ -432,5 +449,22 @@ void init_sklearn_svr(py::module_ &m) {
                 }
             }
 
-            return fmt::format("plssvm.svm.SVR({})", fmt::join(non_default_values, ", ")); }, "Print the SVR showing all non-default parameters.");
+            return fmt::format("plssvm.svm.SVR({})", fmt::join(non_default_values, ", ")); }, "Print the SVR showing all non-default parameters.")
+        .def(py::pickle(
+            // clang-format off
+            [](const svr &self) {  // __getstate__
+                // return a tuple that fully encodes the state of the object
+                return py::make_tuple(self.svm_->get_params(), self.epsilon_, self.max_iter_);
+            },
+            [](py::tuple t) {  // NOLINT: __setstate__
+                if (t.size() != 3) {
+                    throw std::runtime_error{ "Invalid state!" };
+                }
+                // create a new C++ instance
+                return svr{ t[0].cast<plssvm::parameter>(), t[1].cast<plssvm::real_type>(), t[2].cast<std::optional<unsigned long long>>() };
+            }
+            )
+             // clang-format on
+        );
+    ;
 }
diff --git a/bindings/Python/sklearn_like/tags.cpp b/bindings/Python/sklearn_like/tags.cpp
new file mode 100644
index 000000000..16fa3e0d3
--- /dev/null
+++ b/bindings/Python/sklearn_like/tags.cpp
@@ -0,0 +1,293 @@
+/**
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ */
+
+#include "bindings/Python/sklearn_like/tags.hpp"  // Tags, TargetTags, TransformerTags, ClassifierTags, RegressorTags, InputTags
+
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+
+#include "fmt/format.h"         // fmt::format
+#include "fmt/ranges.h"         // fmt::join
+#include "pybind11/cast.h"      // py::cast, py::repr
+#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init
+#include "pybind11/stl.h"       // NOLINT: bind STL types
+
+#include <string>  // std::string
+
+namespace {
+
+[[nodiscard]] std::string bool_as_python_string(const bool b) {
+    return b ? "True" : "False";
+}
+
+}  // namespace
+
+void init_sklearn_tags(py::module_ &m) {
+    // TargetTags
+    py::class_<TargetTags>(m, "TargetTags")
+        .def(py::init<>())
+        .def_readwrite("required", &TargetTags::required)
+        .def_readwrite("one_d_labels", &TargetTags::one_d_labels)
+        .def_readwrite("two_d_labels", &TargetTags::two_d_labels)
+        .def_readwrite("positive_only", &TargetTags::positive_only)
+        .def_readwrite("multi_output", &TargetTags::multi_output)
+        .def_readwrite("single_output", &TargetTags::single_output)
+        .def("__repr__", [](const TargetTags &t) {
+            return fmt::format(
+                "TargetTags(required={}, one_d_labels={}, two_d_labels={}, "
+                "positive_only={}, multi_output={}, single_output={})",
+                bool_as_python_string(t.required),
+                bool_as_python_string(t.one_d_labels),
+                bool_as_python_string(t.two_d_labels),
+                bool_as_python_string(t.positive_only),
+                bool_as_python_string(t.multi_output),
+                bool_as_python_string(t.single_output));
+        })
+        .def(py::pickle(
+            // clang-format off
+            [](const TargetTags &self) {   // __getstate__
+                // return a tuple that fully encodes the state of the object
+                return py::make_tuple(self.required, self.one_d_labels, self.two_d_labels, self.positive_only, self.multi_output, self.single_output);
+            },
+            [](py::tuple t) {  // NOLINT: __setstate__
+                if (t.size() != 6) {
+                    throw std::runtime_error{ "Invalid TargetTags pickle state" };
+                }
+                // create a new C++ instance
+                TargetTags tags;
+                tags.required = t[0].cast<bool>();
+                tags.one_d_labels = t[1].cast<bool>();
+                tags.two_d_labels = t[2].cast<bool>();
+                tags.positive_only = t[3].cast<bool>();
+                tags.multi_output = t[4].cast<bool>();
+                tags.single_output = t[5].cast<bool>();
+                return tags;
+            }
+            )
+             // clang-format on
+        );
+
+    // TransformerTags
+    py::class_<TransformerTags>(m, "TransformerTags")
+        .def(py::init<>())
+        .def_readwrite("preserves_dtype", &TransformerTags::preserves_dtype)
+        .def("__repr__", [](const TransformerTags &t) {
+            return fmt::format(
+                "TransformerTags(preserves_dtype=[{}])",
+                fmt::join(t.preserves_dtype, ", "));
+        })
+        .def(py::pickle(
+            // clang-format off
+            [](const TransformerTags &self) {   // __getstate__
+                // return a tuple that fully encodes the state of the object
+                return py::make_tuple(self.preserves_dtype);
+            },
+            [](py::tuple t) {  // NOLINT: __setstate__
+                if (t.size() != 1) {
+                    throw std::runtime_error{ "Invalid TransformerTags pickle state" };
+                }
+                // create a new C++ instance
+                TransformerTags tags;
+                tags.preserves_dtype = t[0].cast<std::vector<std::string>>();
+                return tags;
+            }
+            )
+             // clang-format on
+        );
+
+    // ClassifierTags
+    py::class_<ClassifierTags>(m, "ClassifierTags")
+        .def(py::init<>())
+        .def_readwrite("poor_score", &ClassifierTags::poor_score)
+        .def_readwrite("multi_class", &ClassifierTags::multi_class)
+        .def_readwrite("multi_label", &ClassifierTags::multi_label)
+        .def("__repr__", [](const ClassifierTags &t) {
+            return fmt::format(
+                "ClassifierTags(poor_score={}, multi_class={}, multi_label={})",
+                bool_as_python_string(t.poor_score),
+                bool_as_python_string(t.multi_class),
+                bool_as_python_string(t.multi_label));
+        })
+        .def(py::pickle(
+            // clang-format off
+            [](const ClassifierTags &self) {   // __getstate__
+                // return a tuple that fully encodes the state of the object
+                return py::make_tuple(self.poor_score, self.multi_class, self.multi_label);
+            },
+            [](py::tuple t) {  // NOLINT: __setstate__
+                if (t.size() != 3) {
+                    throw std::runtime_error{ "Invalid ClassifierTags pickle state" };
+                }
+                // create a new C++ instance
+                ClassifierTags tags;
+                tags.poor_score = t[0].cast<bool>();
+                tags.multi_class = t[1].cast<bool>();
+                tags.multi_label = t[2].cast<bool>();
+                return tags;
+            }
+            )
+             // clang-format on
+        );
+
+    // RegressorTags
+    py::class_<RegressorTags>(m, "RegressorTags")
+        .def(py::init<>())
+        .def_readwrite("poor_score", &RegressorTags::poor_score)
+        .def("__repr__", [](const RegressorTags &t) {
+            return fmt::format(
+                "RegressorTags(poor_score={})",
+                bool_as_python_string(t.poor_score));
+        })
+        .def(py::pickle(
+            // clang-format off
+            [](const RegressorTags &self) {   // __getstate__
+                // return a tuple that fully encodes the state of the object
+                return py::make_tuple(self.poor_score);
+            },
+            [](py::tuple t) {  // NOLINT: __setstate__
+                if (t.size() != 1) {
+                    throw std::runtime_error{ "Invalid RegressorTags pickle state" };
+                }
+                // create a new C++ instance
+                RegressorTags tags;
+                tags.poor_score = t[0].cast<bool>();
+                return tags;
+            }
+            )
+             // clang-format on
+        );
+
+    // InputTags
+    py::class_<InputTags>(m, "InputTags")
+        .def(py::init<>())
+        .def_readwrite("one_d_array", &InputTags::one_d_array)
+        .def_readwrite("two_d_array", &InputTags::two_d_array)
+        .def_readwrite("three_d_array", &InputTags::three_d_array)
+        .def_readwrite("sparse", &InputTags::sparse)
+        .def_readwrite("categorical", &InputTags::categorical)
+        .def_readwrite("string", &InputTags::string)
+        .def_readwrite("dict", &InputTags::dict)
+        .def_readwrite("positive_only", &InputTags::positive_only)
+        .def_readwrite("allow_nan", &InputTags::allow_nan)
+        .def_readwrite("pairwise", &InputTags::pairwise)
+        .def("__repr__", [](const InputTags &t) {
+            return fmt::format(
+                "InputTags(one_d_array={}, two_d_array={}, three_d_array={}, "
+                "sparse={}, categorical={}, string={}, dict={}, "
+                "positive_only={}, allow_nan={}, pairwise={})",
+                bool_as_python_string(t.one_d_array),
+                bool_as_python_string(t.two_d_array),
+                bool_as_python_string(t.three_d_array),
+                bool_as_python_string(t.sparse),
+                bool_as_python_string(t.categorical),
+                bool_as_python_string(t.string),
+                bool_as_python_string(t.dict),
+                bool_as_python_string(t.positive_only),
+                bool_as_python_string(t.allow_nan),
+                bool_as_python_string(t.pairwise));
+        })
+        .def(py::pickle(
+            // clang-format off
+            [](const InputTags &self) {   // __getstate__
+                // return a tuple that fully encodes the state of the object
+                return py::make_tuple(self.one_d_array, self.two_d_array, self.three_d_array, self.sparse, self.categorical,
+                                      self.string, self.dict, self.positive_only, self.allow_nan, self.pairwise);
+            },
+            [](py::tuple t) {  // NOLINT: __setstate__
+                if (t.size() != 10) {
+                    throw std::runtime_error{ "Invalid InputTags pickle state" };
+                }
+                // create a new C++ instance
+                InputTags tags;
+                tags.one_d_array = t[0].cast<bool>();
+                tags.two_d_array = t[1].cast<bool>();
+                tags.three_d_array = t[2].cast<bool>();;
+                tags.sparse = t[3].cast<bool>();
+                tags.categorical = t[4].cast<bool>();
+                tags.string = t[5].cast<bool>();
+                tags.dict = t[6].cast<bool>();
+                tags.positive_only = t[7].cast<bool>();
+                tags.allow_nan = t[8].cast<bool>();
+                tags.pairwise = t[9].cast<bool>();
+                return tags;
+            }
+            )
+             // clang-format on
+        );
+
+    // Tags (root object)
+    py::class_<Tags>(m, "Tags")
+        .def(py::init<>())
+        .def_readwrite("estimator_type", &Tags::estimator_type)
+        .def_readwrite("target_tags", &Tags::target_tags)
+        .def_readwrite("transformer_tags", &Tags::transformer_tags)
+        .def_readwrite("classifier_tags", &Tags::classifier_tags)
+        .def_readwrite("regressor_tags", &Tags::regressor_tags)
+        .def_readwrite("array_api_support", &Tags::array_api_support)
+        .def_readwrite("no_validation", &Tags::no_validation)
+        .def_readwrite("non_deterministic", &Tags::non_deterministic)
+        .def_readwrite("requires_fit", &Tags::requires_fit)
+        .def_readwrite("_skip_test", &Tags::_skip_test)
+        .def_readwrite("input_tags", &Tags::input_tags)
+        .def("__repr__", [](const Tags &t) {
+            const std::string estimator_type = t.estimator_type.has_value()
+                                                   ? fmt::format("'{}'", t.estimator_type.value())
+                                                   : "None";
+            const auto &tag_as_string_or_none = [](const auto &opt_tag) -> std::string {
+                if (!opt_tag.has_value()) {
+                    return "None";
+                }
+                return py::repr(py::cast(opt_tag.value())).template cast<std::string>();
+            };
+
+            return fmt::format(
+                "Tags(estimator_type={}, target_tags={}, transformer_tags={}, "
+                "classifier_tags={}, regressor_tags={}, array_api_support={}, "
+                "no_validation={}, non_deterministic={}, requires_fit={}, "
+                "_skip_test={}, input_tags={})",
+                estimator_type,
+                py::repr(py::cast(t.target_tags)).cast<std::string>(),
+                tag_as_string_or_none(t.transformer_tags),
+                tag_as_string_or_none(t.classifier_tags),
+                tag_as_string_or_none(t.regressor_tags),
+                bool_as_python_string(t.array_api_support),
+                bool_as_python_string(t.no_validation),
+                bool_as_python_string(t.non_deterministic),
+                bool_as_python_string(t.requires_fit),
+                bool_as_python_string(t._skip_test),
+                py::repr(py::cast(t.input_tags)).cast<std::string>());
+        })
+        .def(py::pickle(
+            // clang-format off
+            [](const Tags &self) {   // __getstate__
+                // return a tuple that fully encodes the state of the object
+                return py::make_tuple(self.estimator_type, self.target_tags, self.transformer_tags, self.classifier_tags, self.regressor_tags,
+                                      self.array_api_support, self.no_validation, self.non_deterministic, self.requires_fit, self._skip_test, self.input_tags);
+            },
+            [](py::tuple t) {  // NOLINT: __setstate__
+                if (t.size() != 11) {
+                    throw std::runtime_error{ "Invalid Tags pickle state" };
+                }
+                // create a new C++ instance
+                Tags tags;
+                tags.estimator_type = t[0].cast<std::optional<std::string>>();
+                tags.target_tags = t[1].cast<TargetTags>();
+                tags.transformer_tags = t[2].cast<std::optional<TransformerTags>>();
+                tags.classifier_tags = t[3].cast<std::optional<ClassifierTags>>();
+                tags.regressor_tags = t[4].cast<std::optional<RegressorTags>>();
+                tags.array_api_support = t[5].cast<bool>();
+                tags.no_validation = t[6].cast<bool>();
+                tags.non_deterministic = t[7].cast<bool>();
+                tags.requires_fit = t[8].cast<bool>();
+                tags._skip_test = t[9].cast<bool>();
+                tags.input_tags = t[10].cast<InputTags>();
+                return tags;
+            }
+            )
+             // clang-format on
+        );
+}
diff --git a/bindings/Python/sklearn_like/tags.hpp b/bindings/Python/sklearn_like/tags.hpp
new file mode 100644
index 000000000..94efb3099
--- /dev/null
+++ b/bindings/Python/sklearn_like/tags.hpp
@@ -0,0 +1,125 @@
+/**
+ * @file
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Implements tags classes used for sklearn's `__sklearn_tags__` attribute.
+ */
+
+#ifndef PLSSVM_BINDINGS_PYTHON_SKLEARN_LIKE_TAGS_HPP_
+#define PLSSVM_BINDINGS_PYTHON_SKLEARN_LIKE_TAGS_HPP_
+#pragma once
+
+#include <optional>  // std::optional
+#include <string>    // std::string
+#include <vector>    // std::vector
+
+/**
+ * @brief Tags for the target data.
+ */
+struct TargetTags {
+    /// Whether the estimator requires y to be passed to `fit`, `fit_predict`, or `fit_transform` methods.
+    bool required = true;
+    /// Whether the input is a 1D labels (y).
+    bool one_d_labels = false;
+    /// Whether the input is a 2D labels (y).
+    bool two_d_labels = false;
+    /// Whether the estimator requires a positive y (only applicable for regression).
+    bool positive_only = false;
+    /// Whether a regressor supports multi-target outputs or a classifier supports multi-class multi-output.
+    bool multi_output = false;
+    /// Whether the target can be single-output. This can be `false` if the estimator supports only multi-output cases.
+    bool single_output = true;
+};
+
+/**
+ * @brief Tags for the transformer.
+ */
+struct TransformerTags {
+    /// Applies only on transformers.
+    /// It corresponds to the data types which will be preserved such that `X_trans.dtype` is the same as `X.dtype` after calling `transformer.transform(X)`.
+    std::vector<std::string> preserves_dtype{ "float64" };
+};
+
+/**
+ * @brief Tags for the classifier.
+ */
+struct ClassifierTags {
+    /// Whether the estimator fails to provide a “reasonable” test-set score, which currently for classification is an
+    /// accuracy of 0.83 on `make_blobs(n_samples=300, random_state=0)`.
+    bool poor_score = false;
+    /// Whether the classifier can handle multi-class classification.
+    bool multi_class = true;
+    /// Whether the classifier supports multi-label output: a data point can be predicted to belong to a variable number of classes.
+    bool multi_label = false;
+};
+
+/**
+ * @brief Tags for the regressor.
+ */
+struct RegressorTags {
+    /// Whether the estimator fails to provide a “reasonable” test-set score, which currently for regression is an R2 of 0.5 on
+    /// `make_regression(n_samples=200, n_features=10, n_informative=1, bias=5.0, noise=20, random_state=42)`.
+    bool poor_score = false;
+};
+
+/**
+ * @brief Tags for the input data.
+ */
+struct InputTags {
+    /// Whether the input can be a 1D array.
+    bool one_d_array = false;
+    /// Whether the input can be a 2D array.
+    bool two_d_array = true;
+    /// Whether the input can be a 3D array.
+    bool three_d_array = false;
+    /// Whether the input can be a sparse matrix.
+    bool sparse = false;
+    /// Whether the input can be categorical.
+    bool categorical = false;
+    /// Whether the input can be an array-like of strings.
+    bool string = false;
+    /// Whether the input can be a dictionary.
+    bool dict = false;
+    /// Whether the estimator requires positive X.
+    bool positive_only = false;
+    /// Whether the estimator supports data with missing values encoded as `np.nan`.
+    bool allow_nan = false;
+    /// This boolean attribute indicates whether the data(`X`), fit and similar methods consists of pairwise measures
+    /// over samples rather than a feature representation for each sample. It is usually `true` where an estimator has
+    /// a metric or affinity or kernel parameter with value "precomputed".
+    bool pairwise = false;
+};
+
+/**
+ * @brief Tags for the estimator.
+ */
+struct Tags {
+    /// The type of the estimator. Can be one of: - “classifier” - “regressor” - “transformer” - “clusterer” - “outlier_detector” - “density_estimator”
+    std::optional<std::string> estimator_type;
+    /// The target(y) tags.
+    TargetTags target_tags;
+    /// The transformer tags.
+    std::optional<TransformerTags> transformer_tags;
+    /// The classifier tags.
+    std::optional<ClassifierTags> classifier_tags;
+    /// The regressor tags.
+    std::optional<RegressorTags> regressor_tags;
+    /// Whether the estimator supports Array API compatible inputs.
+    bool array_api_support = false;
+    /// Whether the estimator skips input-validation. This is only meant for stateless and dummy transformers!
+    bool no_validation = false;
+    /// Whether the estimator is not deterministic given a fixed `random_state`.
+    bool non_deterministic = false;
+    /// Whether the estimator requires to be fitted before calling one of `transform`, `predict`, `predict_proba`, or `decision_function`.
+    bool requires_fit = true;
+    /// Whether to skip common tests entirely. Don’t use this unless you have a very good reason.
+    bool _skip_test = false;
+    /// The input data(X) tags.
+    InputTags input_tags;
+};
+
+#endif  // PLSSVM_BINDINGS_PYTHON_SKLEARN_LIKE_TAGS_HPP_
diff --git a/bindings/Python/solver_types.cpp b/bindings/Python/solver_types.cpp
index f8309fb4b..e0ed3557b 100644
--- a/bindings/Python/solver_types.cpp
+++ b/bindings/Python/solver_types.cpp
@@ -8,7 +8,8 @@
 
 #include "plssvm/solver_types.hpp"  // plssvm::solver_type
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::register_implicit_str_enum_conversion
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::register_implicit_str_enum_conversion
 
 #include "pybind11/pybind11.h"  // py::module_, py::enum_
 
@@ -16,7 +17,7 @@ namespace py = pybind11;
 
 void init_solver_types(py::module_ &m) {
     // bind enum class
-    py::enum_<plssvm::solver_type> py_enum(m, "SolverType", "Enum class for all possible solver types implemented in PLSSVM.");
+    py::enum_<plssvm::solver_type> py_enum(m, "SolverType", "enum.Enum", "Enum class for all possible solver types implemented in PLSSVM.");
     py_enum
         .value("AUTOMATIC", plssvm::solver_type::automatic, "the default solver type; depends on the available device and system memory")
         .value("CG_EXPLICIT", plssvm::solver_type::cg_explicit, "explicitly assemble the kernel matrix on the device")
diff --git a/bindings/Python/svm/csvc.cpp b/bindings/Python/svm/csvc.cpp
index 1e9bd6c58..1368725da 100644
--- a/bindings/Python/svm/csvc.cpp
+++ b/bindings/Python/svm/csvc.cpp
@@ -10,26 +10,28 @@
 
 #include "plssvm/backend_types.hpp"                     // plssvm::backend_type
 #include "plssvm/classification_types.hpp"              // plssvm::classification_type
-#include "plssvm/constants.hpp"                         // plssvm::real_type
+#include "plssvm/constants.hpp"                         // plssvm::real_type, plssvm::DEFAULT_EPSILON
 #include "plssvm/data_set/classification_data_set.hpp"  // plssvm::classification_data_set
 #include "plssvm/detail/type_traits.hpp"                // plssvm::detail::remove_cvref_t
 #include "plssvm/gamma.hpp"                             // plssvm::gamma_type
 #include "plssvm/kernel_function_types.hpp"             // plssvm::kernel_function_type
-#include "plssvm/model/classification_model.hpp"        // plssvm::classification_model
 #include "plssvm/mpi/communicator.hpp"                  // plssvm::mpi::communicator
 #include "plssvm/parameter.hpp"                         // plssvm::parameter, named arguments
 #include "plssvm/solver_types.hpp"                      // plssvm::solver_type
 #include "plssvm/target_platforms.hpp"                  // plssvm::target_platform
 
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/data_set/variant_wrapper.hpp"     // plssvm::bindings::python::util::classification_data_set_wrapper
 #include "bindings/Python/model/variant_wrapper.hpp"        // plssvm::bindings::python::util::classification_model_wrapper
 #include "bindings/Python/svm/utility.hpp"                  // plssvm::bindings::python::util::assemble_csvm
-#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
+#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // NOLINT: a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::{python_type_name_mapping, vector_to_pyarray}
 
 #include "fmt/format.h"         // fmt::format
-#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::kw_only, py::kwargs, py::value_error
-#include "pybind11/stl.h"       // support for STL types: std::optional
+#include "pybind11/cast.h"      // py::arg
+#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::kw_only, py::value_error
+#include "pybind11/pytypes.h"   // py::kwargs
+#include "pybind11/stl.h"       // NOLINT: support for STL types: std::optional
 
 #include <exception>    // std::exception
 #include <optional>     // std::optional, std::nullopt
@@ -81,16 +83,15 @@ void init_csvc(py::module_ &m) {
                                                                       plssvm::max_iter = max_iter.value(),
                                                                       plssvm::classification = classification,
                                                                       plssvm::solver = solver) };
-                    } else {
-                        return classification_model_wrapper{ self.fit(data,
-                                                                      plssvm::epsilon = epsilon,
-                                                                      plssvm::classification = classification,
-                                                                      plssvm::solver = solver) };
                     }
+                    return classification_model_wrapper{ self.fit(data,
+                                                                  plssvm::epsilon = epsilon,
+                                                                  plssvm::classification = classification,
+                                                                  plssvm::solver = solver) };
                 }, data_set.data_set); }, "fit a model using the current C-SVC on the provided data",
                 py::arg("data"),
                 py::kw_only(),
-                py::arg("epsilon") = plssvm::real_type{ 1e-10 },
+                py::arg("epsilon") = plssvm::DEFAULT_EPSILON,
                 py::arg("max_iter") = std::nullopt,
                 py::arg("classification") = plssvm::classification_type::oaa,
                 py::arg("solver") = plssvm::solver_type::automatic)
diff --git a/bindings/Python/svm/csvm.cpp b/bindings/Python/svm/csvm.cpp
index 78a1d4fb9..a4a091cf7 100644
--- a/bindings/Python/svm/csvm.cpp
+++ b/bindings/Python/svm/csvm.cpp
@@ -13,10 +13,13 @@
 #include "plssvm/kernel_function_types.hpp"  // plssvm::kernel_function_type
 #include "plssvm/parameter.hpp"              // plssvm::parameter, named arguments
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::check_kwargs_for_correctness
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::check_kwargs_for_correctness
 
+#include "pybind11/cast.h"      // py::arg
 #include "pybind11/pybind11.h"  // py::module_, py::class_, py::arg, py::kwargs, py::module_local
-#include "pybind11/stl.h"       // support for STL types: std::variant
+#include "pybind11/pytypes.h"   // py::kwargs
+#include "pybind11/stl.h"       // NOLINT: support for STL types: std::variant
 
 namespace py = pybind11;
 
diff --git a/bindings/Python/svm/csvr.cpp b/bindings/Python/svm/csvr.cpp
index 23dddb1c1..ee9c508b2 100644
--- a/bindings/Python/svm/csvr.cpp
+++ b/bindings/Python/svm/csvr.cpp
@@ -9,26 +9,27 @@
 #include "plssvm/svm/csvr.hpp"  // plssvm::csvr
 
 #include "plssvm/backend_types.hpp"                 // plssvm::backend_type
-#include "plssvm/constants.hpp"                     // plssvm::real_type
+#include "plssvm/constants.hpp"                     // plssvm::real_type, plssvm::DEFAULT_EPSILON
 #include "plssvm/data_set/regression_data_set.hpp"  // plssvm::regression_data_set
 #include "plssvm/detail/type_traits.hpp"            // plssvm::detail::remove_cvref_t
 #include "plssvm/gamma.hpp"                         // plssvm::gamma_type
 #include "plssvm/kernel_function_types.hpp"         // plssvm::kernel_function_type
-#include "plssvm/model/regression_model.hpp"        // plssvm::regression_model
 #include "plssvm/mpi/communicator.hpp"              // plssvm::mpi::communicator
 #include "plssvm/parameter.hpp"                     // plssvm::parameter, named arguments
 #include "plssvm/solver_types.hpp"                  // plssvm::solver_type
 #include "plssvm/target_platforms.hpp"              // plssvm::target_platform
 
+#include "bindings/Python/bindings_fwd.hpp"                 // forward declare all helper functions to create the Python bindings
 #include "bindings/Python/data_set/variant_wrapper.hpp"     // plssvm::bindings::python::util::regression_data_set_wrapper
 #include "bindings/Python/model/variant_wrapper.hpp"        // plssvm::bindings::python::util::regression_model_wrapper
 #include "bindings/Python/svm/utility.hpp"                  // plssvm::bindings::python::util::assemble_csvm
-#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // a custom Pybind11 type caster for a plssvm::mpi::communicator
+#include "bindings/Python/type_caster/mpi_type_caster.hpp"  // NOLINT: a custom Pybind11 type caster for a plssvm::mpi::communicator
 #include "bindings/Python/utility.hpp"                      // plssvm::bindings::python::util::{python_type_name_mapping, vector_to_pyarray}
 
 #include "fmt/format.h"         // fmt::format
-#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::kw_only, py::kwargs, py::value_error
-#include "pybind11/stl.h"       // support for STL types: std::optional
+#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::kw_only, py::value_error
+#include "pybind11/pytypes.h"   // py::kwargs
+#include "pybind11/stl.h"       // NOLINT: support for STL types: std::optional
 
 #include <exception>    // std::exception
 #include <optional>     // std::optional, std::nullopt
@@ -79,15 +80,14 @@ void init_csvr(py::module_ &m) {
                                                                       plssvm::epsilon = epsilon,
                                                                       plssvm::max_iter = max_iter.value(),
                                                                       plssvm::solver = solver) };
-                    } else {
-                        return regression_model_wrapper{ self.fit(data,
-                                                                      plssvm::epsilon = epsilon,
-                                                                      plssvm::solver = solver) };
                     }
+                    return regression_model_wrapper{ self.fit(data,
+                                                                  plssvm::epsilon = epsilon,
+                                                                  plssvm::solver = solver) };
                 }, data_set.data_set); }, "fit a model using the current C-SVR on the provided data",
                 py::arg("data"),
                 py::kw_only(),
-                py::arg("epsilon") = plssvm::real_type{ 1e-10 },
+                py::arg("epsilon") = plssvm::DEFAULT_EPSILON,
                 py::arg("max_iter") = std::nullopt,
                 py::arg("solver") = plssvm::solver_type::automatic)
         .def("predict", [](const plssvm::csvr &self, const regression_model_wrapper &trained_model, const regression_data_set_wrapper &data_set) {
diff --git a/bindings/Python/svm/utility.hpp b/bindings/Python/svm/utility.hpp
index 38019bf8b..3273b0673 100644
--- a/bindings/Python/svm/utility.hpp
+++ b/bindings/Python/svm/utility.hpp
@@ -13,14 +13,14 @@
 #define PLSSVM_BINDINGS_PYTHON_SVM_UTILITY_HPP_
 #pragma once
 
-#include "plssvm/backend_types.hpp"                          // plssvm::backend_type
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::execution_space
-#include "plssvm/backends/SYCL/implementation_types.hpp"     // plssvm::sycl::implementation_type
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/csvm_factory.hpp"                           // plssvm::make_csvm
-#include "plssvm/mpi/communicator.hpp"                       // plssvm::mpi::communicator
-#include "plssvm/parameter.hpp"                              // plssvm::parameter, named arguments
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"     // plssvm::kokkos::execution_space
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::implementation_type
+#include "plssvm/csvm_factory.hpp"                         // plssvm::make_csvm
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/parameter.hpp"                            // plssvm::parameter, named arguments
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::check_kwargs_for_correctness
 
@@ -46,7 +46,7 @@ namespace plssvm::bindings::python::util {
 template <typename csvm_type>
 [[nodiscard]] inline std::unique_ptr<csvm_type> assemble_csvm(const plssvm::backend_type backend, const plssvm::target_platform target, const plssvm::parameter &params, plssvm::mpi::communicator comm, const py::kwargs &optional_args) {
     // check keyword arguments
-    plssvm::bindings::python::util::check_kwargs_for_correctness(optional_args, { "foo", "sycl_implementation_type", "sycl_kernel_invocation_type", "kokkos_execution_space" });
+    plssvm::bindings::python::util::check_kwargs_for_correctness(optional_args, { "foo", "sycl_implementation_type", "sycl_data_parallel_kernel", "kokkos_execution_space" });
 
     if (backend == plssvm::backend_type::sycl) {
         // parse SYCL specific keyword arguments
@@ -54,13 +54,14 @@ template <typename csvm_type>
         if (optional_args.contains("sycl_implementation_type")) {
             impl_type = optional_args["sycl_implementation_type"].cast<plssvm::sycl::implementation_type>();
         }
-        plssvm::sycl::kernel_invocation_type invocation_type = plssvm::sycl::kernel_invocation_type::automatic;
-        if (optional_args.contains("sycl_kernel_invocation_type")) {
-            invocation_type = optional_args["sycl_kernel_invocation_type"].cast<plssvm::sycl::kernel_invocation_type>();
+        plssvm::sycl::data_parallel_kernel data_parallel_kernel_type = plssvm::sycl::data_parallel_kernel::automatic;
+        if (optional_args.contains("sycl_data_parallel_kernel")) {
+            data_parallel_kernel_type = optional_args["sycl_data_parallel_kernel"].cast<plssvm::sycl::data_parallel_kernel>();
         }
 
-        return plssvm::make_csvm<csvm_type>(backend, std::move(comm), target, params, plssvm::sycl_implementation_type = impl_type, plssvm::sycl_kernel_invocation_type = invocation_type);
-    } else if (backend == plssvm::backend_type::kokkos) {
+        return plssvm::make_csvm<csvm_type>(backend, std::move(comm), target, params, plssvm::sycl_implementation_type = impl_type, plssvm::sycl_data_parallel_kernel = data_parallel_kernel_type);
+    }
+    if (backend == plssvm::backend_type::kokkos) {
         // parse Kokkos specific keyword arguments
         plssvm::kokkos::execution_space space = plssvm::kokkos::execution_space::automatic;
         if (optional_args.contains("kokkos_execution_space")) {
@@ -68,9 +69,8 @@ template <typename csvm_type>
         }
 
         return plssvm::make_csvm<csvm_type>(backend, std::move(comm), target, params, plssvm::kokkos_execution_space = space);
-    } else {
-        return plssvm::make_csvm<csvm_type>(backend, std::move(comm), target, params);
     }
+    return plssvm::make_csvm<csvm_type>(backend, std::move(comm), target, params);
 }
 
 }  // namespace plssvm::bindings::python::util
diff --git a/bindings/Python/svm_types.cpp b/bindings/Python/svm_types.cpp
index 793354c12..401113927 100644
--- a/bindings/Python/svm_types.cpp
+++ b/bindings/Python/svm_types.cpp
@@ -8,15 +8,17 @@
 
 #include "plssvm/svm_types.hpp"  // plssvm::svm_type, plssvm::list_available_svm_types, plssvm::svm_type_from_model_file
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::register_implicit_str_enum_conversion
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::register_implicit_str_enum_conversion
 
+#include "pybind11/cast.h"      // py::arg
 #include "pybind11/pybind11.h"  // py::module_, py::enum_
 
 namespace py = pybind11;
 
 void init_svm_types(py::module_ &m) {
     // bind enum class
-    py::enum_<plssvm::svm_type> py_enum(m, "SVMType", "Enum class for all implemented SVM types in PLSSVM.");
+    py::enum_<plssvm::svm_type> py_enum(m, "SVMType", "enum.Enum", "Enum class for all implemented SVM types in PLSSVM.");
     py_enum
         .value("CSVC", plssvm::svm_type::csvc, "use a C-SVC for classification")
         .value("CSVR", plssvm::svm_type::csvr, "use a C-SVR for classification");
@@ -26,6 +28,6 @@ void init_svm_types(py::module_ &m) {
 
     // bind free functions
     m.def("list_available_svm_types", &plssvm::list_available_svm_types, "list the available SVM types");
-    m.def("svm_type_to_task_name", &plssvm::svm_type_to_task_name, "get the task name (e.g., \"classification\" or \"regression\") based on the provided SVMType", py::arg("svm_type"));
+    m.def("svm_type_to_task_name", &plssvm::svm_type_to_task_name, R"(get the task name (e.g., "classification" or "regression") based on the provided SVMType)", py::arg("svm_type"));
     m.def("svm_type_from_model_file", &plssvm::svm_type_from_model_file, "determine the SVMType based on the provided LIBSVM model file", py::arg("filename"));
 }
diff --git a/bindings/Python/target_platforms.cpp b/bindings/Python/target_platforms.cpp
index e47be725b..530a30385 100644
--- a/bindings/Python/target_platforms.cpp
+++ b/bindings/Python/target_platforms.cpp
@@ -8,16 +8,17 @@
 
 #include "plssvm/target_platforms.hpp"  // plssvm::target_platform, plssvm::list_available_target_platforms, plssvm::determine_default_target_platform
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::register_implicit_str_enum_conversion
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::register_implicit_str_enum_conversion
 
 #include "pybind11/pybind11.h"  // py::module_, py::enum_
-#include "pybind11/stl.h"       // support for STL types: std::vector
+#include "pybind11/stl.h"       // NOLINT: support for STL types: std::vector
 
 namespace py = pybind11;
 
 void init_target_platforms(py::module_ &m) {
     // bind enum class
-    py::enum_<plssvm::target_platform> py_enum(m, "TargetPlatform", "Enum class for all possible targets that PLSSVM supports.");
+    py::enum_<plssvm::target_platform> py_enum(m, "TargetPlatform", "enum.Enum", "Enum class for all possible targets that PLSSVM supports.");
     py_enum
         .value("AUTOMATIC", plssvm::target_platform::automatic, "the default target with respect to the used backend type; checks for available devices in the following order: NVIDIA GPUs -> AMD GPUs -> Intel GPUs -> CPUs")
         .value("CPU", plssvm::target_platform::cpu, "target CPUs only (Intel, AMD, IBM, ...)")
diff --git a/bindings/Python/type_caster/label_vector_wrapper_caster.hpp b/bindings/Python/type_caster/label_vector_wrapper_type_caster.hpp
similarity index 92%
rename from bindings/Python/type_caster/label_vector_wrapper_caster.hpp
rename to bindings/Python/type_caster/label_vector_wrapper_type_caster.hpp
index becd60845..fb18dc20f 100644
--- a/bindings/Python/type_caster/label_vector_wrapper_caster.hpp
+++ b/bindings/Python/type_caster/label_vector_wrapper_type_caster.hpp
@@ -72,11 +72,10 @@ template <typename T>
     if (arr.size() == 0) {
         // return an empty vector
         return std::vector<T>{};
-    } else {
-        // convert py::array to std::vector
-        auto arr_t = arr.cast<py::array_t<T>>();
-        return std::vector<T>(arr_t.data(0), arr_t.data(0) + arr_t.shape(0));
     }
+    // convert py::array to std::vector
+    auto arr_t = arr.cast<py::array_t<T>>();
+    return std::vector<T>(arr_t.data(0), arr_t.data(0) + arr_t.shape(0));
 }
 
 /**
@@ -98,12 +97,12 @@ template <typename T>
 template <typename possible_vector_types>
 [[nodiscard]] possible_vector_types generic_pyarray_to_vector(const py::array &arr) {
     // sanity check the passed py::array
-    if (!(arr.flags() & py::array::c_style)) {
+    if (!(arr.flags() & py::array::c_style)) {  // NOLINT(hicpp-signed-bitwise): Pybind11 way to do this
         throw py::value_error{ "The py::array must be C-contiguous" };
     }
 
     // the type used in the py::array
-    py::dtype type = arr.dtype();
+    const py::dtype type = arr.dtype();
 
     PLSSVM_CREATE_PYARRAY_TO_VECTOR_MAPPINGS(bool)
     PLSSVM_CREATE_PYARRAY_TO_VECTOR_MAPPINGS(std::int8_t)
@@ -127,14 +126,13 @@ template <typename possible_vector_types>
             if (arr.size() == 0) {
                 // return an empty vector
                 return std::vector<std::string>{};
-            } else {
-                std::vector<std::string> result;
-                result.reserve(arr.shape(0));
-                for (py::handle item : arr) {
-                    result.push_back(py::cast<std::string>(item));
-                }
-                return result;
             }
+            std::vector<std::string> result;
+            result.reserve(arr.shape(0));
+            for (const py::handle &item : arr) {
+                result.push_back(py::cast<std::string>(item));
+            }
+            return result;
         }
     }
 
@@ -205,9 +203,9 @@ template <typename possible_vector_types>
     py::type highest_type{ py::module_::import("builtins").attr("bool") };
     int highest_precedence{ -1 };
     for (std::size_t i = 0; i < py::len(list); ++i) {
-        py::object item = list[i];
-        py::type type = py::type::of(item);
-        int precedence = precedence_map.at(type);
+        const py::object item = list[i];
+        const py::type type = py::type::of(item);
+        const int precedence = precedence_map.at(type);
         if (precedence > highest_precedence) {
             highest_precedence = precedence;
             highest_type = type;
@@ -263,7 +261,7 @@ struct label_vector_wrapper {
     /// The labels.
     PossibleTypes labels{};
     /// The actually used Python dtype.
-    py::dtype dtype{};
+    py::dtype dtype;
 };
 
 }  // namespace plssvm::bindings::python::util
@@ -286,9 +284,11 @@ struct type_caster<plssvm::bindings::python::util::label_vector_wrapper<Possible
     /**
      * @brief Convert a label_vector_wrapper to a Numpy ndarray.
      * @param[in] labels the labels vector to convert to a Python Numpy ndarray
+     * @params[in] rvp *unused*
+     * @params[in] h *unused*
      * @return a Pybind11 handle to the Numpy ndarray
      */
-    static py::handle cast(const label_vector_wrapper_type &labels, py::return_value_policy, py::handle) {
+    static py::handle cast(const label_vector_wrapper_type &labels, [[maybe_unused]] const py::return_value_policy rvp, [[maybe_unused]] const py::handle h) {
         // convert a generic std::vector to a Numpy ndarray
         return std::visit([](auto &&vec) { return plssvm::bindings::python::util::vector_to_pyarray(vec).release(); }, labels.labels);
     }
@@ -296,9 +296,10 @@ struct type_caster<plssvm::bindings::python::util::label_vector_wrapper<Possible
     /**
      * @brief Try converting a Python object @p obj to a label_vector_wrapper.
      * @param[in] obj the object to convert
+     * @params[in] allow_implicit_conversions *unused*
      * @return `true` if the conversion was successful, `false` otherwise
      */
-    bool load(py::handle obj, bool) {
+    bool load(py::handle obj, [[maybe_unused]] const bool allow_implicit_conversions) {
         if (py::isinstance<py::list>(obj)) {
             // provided obj is a Python list
             auto [labels, dtype] = plssvm::bindings::python::util::generic_pylist_to_vector<PossibleTypes>(py::cast<py::list>(obj));
@@ -317,7 +318,7 @@ struct type_caster<plssvm::bindings::python::util::label_vector_wrapper<Possible
                 arr = obj.attr("values").cast<py::array>();
                 arr = arr.reshape({ arr.size() });
             } else {
-                throw py::value_error{ fmt::format("Unsupported data type: {}", std::string{ py::str(obj.get_type().attr("__name__")) }) };
+                throw py::value_error{ fmt::format("Unsupported data type: {}", std::string{ py::str(py::type::of(obj).attr("__name__")) }) };
             }
 
             // sanity check the number of elements in the numpy array
diff --git a/bindings/Python/type_caster/matrix_type_caster.hpp b/bindings/Python/type_caster/matrix_type_caster.hpp
index 0231beb76..852182384 100644
--- a/bindings/Python/type_caster/matrix_type_caster.hpp
+++ b/bindings/Python/type_caster/matrix_type_caster.hpp
@@ -55,9 +55,11 @@ struct type_caster<plssvm::matrix<T, layout>> {
      * @details If the PLSSVM matrix's memory layout is AoS, uses a Numpy ndarray with c_style layout,
      *          if the PLSSVM matrix's memory layout is SoA, uses a Numpy ndarray with f_style layout.
      * @param[in] matr the PLSSVM matrix to convert to a Numpy ndarray
+     * @params[in] rvp *unused*
+     * @params[in] h *unused*
      * @return a Pybind11 handle to the Numpy ndarray
      */
-    static py::handle cast(const matrix_type &matr, py::return_value_policy, py::handle) {
+    static py::handle cast(const matrix_type &matr, [[maybe_unused]] const py::return_value_policy rvp, [[maybe_unused]] const py::handle h) {
         const std::size_t num_data_points = matr.num_rows();
         const std::size_t num_features = matr.num_cols();
 
@@ -66,7 +68,7 @@ struct type_caster<plssvm::matrix<T, layout>> {
 
         // create the Python numpy array
         py_array_type arr({ num_data_points, num_features });
-        py::buffer_info buffer = arr.request();
+        const py::buffer_info buffer = arr.request();
         T *ptr = static_cast<T *>(buffer.ptr);
 
         // check if the provided matrix has padding entries -> must be removed
@@ -103,14 +105,14 @@ struct type_caster<plssvm::matrix<T, layout>> {
         const std::size_t num_cols = arr.shape(1);
 
         // get the underlying raw memory
-        py::buffer_info buffer = arr.request();
+        const py::buffer_info buffer = arr.request();
         const T *ptr = static_cast<T *>(buffer.ptr);
 
         // note: the conversions use OpenMP -> remove Python's Global Interpreter Lock
         const py::gil_scoped_release release;
 
         // check the memory layout of the Python Numpy array
-        if constexpr (static_cast<bool>(Flags & py::array::c_style)) {
+        if constexpr (static_cast<bool>(Flags & py::array::c_style)) {  // NOLINT(hicpp-signed-bitwise): Pybind11 way to do this
             // the provided Python Numpy array has C style layout
             if constexpr (layout == plssvm::layout_type::aos) {
                 // memory layout of Python Numpy array and PLSSVM matrix are the same -> can use memcpy to convert
@@ -130,7 +132,7 @@ struct type_caster<plssvm::matrix<T, layout>> {
                 // unsupported PLSSVM matrix memory layout
                 return false;
             }
-        } else if constexpr (static_cast<bool>(Flags & py::array::f_style)) {
+        } else if constexpr (static_cast<bool>(Flags & py::array::f_style)) {  // NOLINT(hicpp-signed-bitwise): Pybind11 way to do this
             if constexpr (layout == plssvm::layout_type::aos) {
                 // the memory layouts don't match -> must use loops to convert layouts
 #pragma omp parallel for collapse(2)
@@ -161,13 +163,14 @@ struct type_caster<plssvm::matrix<T, layout>> {
      * @brief Try converting a Python object @p obj to a plssvm::matrix.
      * @detauls Honors different Numpy ndarray memory layouts (c_style or f_style) and PLSSVM matrix layout types.
      * @param[in] obj the object to convert
+     * @params[in] allow_implicit_conversion *unused*
      * @return `true` if the conversion was successful, `false` otherwise
      * @throws py::value_error if the provided Python list is empty (or one-dimensional)
      * @throws py::value_error if the provided 2D Python list has inhomogeneous shape
      * @throws py::value_error if @p obj is not a Numpy ndarray, Pandas DataFrame, SciPy sparse matrix, or Python 2D list
      * @throws py::value_error if the Numpy ndarray doesn't have a two-dimensional shape
      */
-    bool load(py::handle obj, bool) {
+    bool load(py::handle obj, [[maybe_unused]] const bool allow_implicit_conversion) {
         // special case py::list
         if (py::isinstance<py::list>(obj)) {
             // provided obj is a Python list -> check if it is a correct py::list of py::list
@@ -215,7 +218,7 @@ struct type_caster<plssvm::matrix<T, layout>> {
                 // provided obj is a SciPy sparse matrix
                 arr = obj.attr("toarray")().cast<py::array>();
             } else {
-                throw py::value_error{ fmt::format("Unsupported data type: {}", std::string{ py::str(obj.get_type().attr("__name__")) }) };
+                throw py::value_error{ fmt::format("Unsupported data type: {}", std::string{ py::str(py::type::of(obj).attr("__name__")) }) };
             }
 
             // sanity check the number of elements in the numpy array
@@ -237,27 +240,27 @@ struct type_caster<plssvm::matrix<T, layout>> {
             value = matrix_type{ plssvm::shape{ num_rows, num_cols }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
 
             // get the underlying buffer
-            py::buffer_info buffer = arr.request();
+            const py::buffer_info buffer = arr.request();
 
             // check the memory layout of the Python Numpy array
             if (plssvm::bindings::python::util::is_c_contiguous<T>(buffer)) {
                 // array is already c_style -> no need to force cast
                 return copy_pyarray_to_matrix(arr.cast<py::array_t<T, py::array::c_style>>());
-            } else if (plssvm::bindings::python::util::is_f_contiguous<T>(buffer)) {
+            }
+            if (plssvm::bindings::python::util::is_f_contiguous<T>(buffer)) {
                 // array is already f_style -> no need to force cast
                 return copy_pyarray_to_matrix(arr.cast<py::array_t<T, py::array::f_style>>());
-            } else {
-                // array is non-contiguous
-                if constexpr (layout == plssvm::layout_type::aos) {
-                    // if we want to get a PLSSVM matrix in AoS layout, force casting to c_style is more performant
-                    return copy_pyarray_to_matrix(arr.cast<py::array_t<T, py::array::c_style | py::array::forcecast>>());
-                } else if constexpr (layout == plssvm::layout_type::soa) {
-                    // if we want to get a PLSSVM matrix in SoA layout, force casting to f_style is more performant
-                    return copy_pyarray_to_matrix(arr.cast<py::array_t<T, py::array::f_style | py::array::forcecast>>());
-                } else {
-                    return false;
-                }
             }
+            // array is non-contiguous
+            if constexpr (layout == plssvm::layout_type::aos) {
+                // if we want to get a PLSSVM matrix in AoS layout, force casting to c_style is more performant
+                return copy_pyarray_to_matrix(arr.cast<py::array_t<T, py::array::c_style | py::array::forcecast>>());
+            }
+            if constexpr (layout == plssvm::layout_type::soa) {
+                // if we want to get a PLSSVM matrix in SoA layout, force casting to f_style is more performant
+                return copy_pyarray_to_matrix(arr.cast<py::array_t<T, py::array::f_style | py::array::forcecast>>());
+            }
+            return false;
         }
 
         return true;
diff --git a/bindings/Python/type_caster/matrix_wrapper_type_caster.hpp b/bindings/Python/type_caster/matrix_wrapper_type_caster.hpp
index de1105077..a22e2457d 100644
--- a/bindings/Python/type_caster/matrix_wrapper_type_caster.hpp
+++ b/bindings/Python/type_caster/matrix_wrapper_type_caster.hpp
@@ -41,7 +41,7 @@ struct matrix_wrapper {
     /// The PLSSVM matrix.
     plssvm::matrix<T, layout> matrix{};
     /// The optionally available feature names.
-    std::optional<std::vector<std::string>> feature_names{};
+    std::optional<std::vector<std::string>> feature_names;
 };
 
 /**
@@ -77,9 +77,11 @@ struct type_caster<plssvm::bindings::python::util::matrix_wrapper<T, layout>> {
     /**
      * @brief Convert a matrix_wrapper to a Numpy ndarray. Simply calls the custom type caster for a plssvm::matrix.
      * @param[in] matr the PLSSVM matrix to convert to a Numpy ndarray
+     * @params[in] rvp *unused*
+     * @params[in] h *unused*
      * @return a Pybind11 handle to the Numpy ndarray
      */
-    static py::handle cast(const matrix_type &matr, py::return_value_policy, py::handle) {
+    static py::handle cast(const matrix_type &matr, [[maybe_unused]] const py::return_value_policy rvp, [[maybe_unused]] const py::handle h) {
         return py::cast(matr.matrix);
     }
 
@@ -87,11 +89,12 @@ struct type_caster<plssvm::bindings::python::util::matrix_wrapper<T, layout>> {
      * @brief Try converting a Python object @p obj to a matrix_wrapper.
      * @detauls Calls the custom type caster for a plssvm::matrix and, additionally, tries to gather the feature names.
      * @param[in] obj the object to convert
+     * @params[in] allow_implicit_conversions *unused*
      * @return `true` if the conversion was successful, `false` otherwise
      * @throws py::value_error all exceptions from the custom plssvm::matrix type caster
      * @throws py::value_error if not all column names are strings
      */
-    bool load(py::handle obj, bool) {
+    bool load(py::handle obj, [[maybe_unused]] const bool allow_implicit_conversions) {
         // convert the object to a plssvm::matrix
         value.matrix = obj.cast<plssvm::matrix<T, layout>>();
 
@@ -101,7 +104,7 @@ struct type_caster<plssvm::bindings::python::util::matrix_wrapper<T, layout>> {
                 const auto &list = obj.attr("columns").cast<py::list>();
                 std::vector<std::string> column_names{};
                 column_names.reserve(list.size());
-                for (py::handle item : list) {
+                for (const py::handle &item : list) {
                     // note: column names are only set if they are ALL strings
                     if (!py::isinstance<py::str>(item)) {
                         throw py::type_error{
diff --git a/bindings/Python/type_caster/mpi_type_caster.hpp b/bindings/Python/type_caster/mpi_type_caster.hpp
index 35ff98ec9..b7997a51d 100644
--- a/bindings/Python/type_caster/mpi_type_caster.hpp
+++ b/bindings/Python/type_caster/mpi_type_caster.hpp
@@ -39,9 +39,11 @@ struct type_caster<plssvm::mpi::communicator> {
     /**
      * @brief Convert a plssvm::mpi::communicator to a mpi4py communicator.
      * @param[in] comm the PLSSVM MPI communicator wrapper
+     * @params[in] rvp *unused*
+     * @params[in] h *unused*
      * @return a Pybind11 handle to the mpi4py communicator
      */
-    static py::handle cast([[maybe_unused]] const plssvm::mpi::communicator &comm, py::return_value_policy, py::handle) {
+    static py::handle cast([[maybe_unused]] const plssvm::mpi::communicator &comm, [[maybe_unused]] const py::return_value_policy rvp, [[maybe_unused]] const py::handle h) {
 #if defined(PLSSVM_HAS_MPI_ENABLED)
         // we have MPI enabled
         try {
@@ -61,10 +63,11 @@ struct type_caster<plssvm::mpi::communicator> {
     /**
      * @brief Try converting a Python object @p obj to a plssvm::mpi::communicator.
      * @param[in] obj the object to convert
+     * @params[in] allow_implicit_conversions *unused*
      * @return `true` if the conversion was successful, `false` otherwise
      * @throws py::value_error if PLSSVM was built without MPI support, but a communicator was explicitly provided in Python
      */
-    bool load([[maybe_unused]] py::handle obj, bool) {
+    bool load([[maybe_unused]] py::handle obj, [[maybe_unused]] const bool allow_implicit_conversion) {
 #if defined(PLSSVM_HAS_MPI_ENABLED)
         try {
             // check if we can find mpi4py
@@ -75,31 +78,28 @@ struct type_caster<plssvm::mpi::communicator> {
                 const MPI_Fint f_handle = obj.attr("py2f")().cast<MPI_Fint>();
                 value = plssvm::mpi::communicator{ MPI_Comm_f2c(f_handle) };
                 return true;
-            } else {
-                // something else was provided -> abort type casting
-                return false;
             }
+            // something else was provided -> abort type casting
+            return false;
         } catch (const py::error_already_set &) {
             // we couldn't find mpi4py
             if (obj.is_none()) {
                 // but "comm" wasn't set -> we can use our default plssvm::mpi::communicator
                 value = plssvm::mpi::communicator{};
                 return true;
-            } else {
-                // something was provided -> abort type casting
-                return false;
             }
+            // something was provided -> abort type casting
+            return false;
         }
 #else
         // we haven't MPI enabled -> check whether the "comm" argument has been provided
         if (!obj.is_none()) {
             // "comm" has been provided -> we can't use it -> throw an exception
             throw py::value_error{ "ERROR: an MPI communicator was explicitly provided, but PLSSVM was built without support for MPI!" };
-        } else {
-            // "comm" was not provided -> use a default constructed plssvm::mpi::communicator that essentially does nothing
-            value = plssvm::mpi::communicator{};
-            return true;
         }
+        // "comm" was not provided -> use a default constructed plssvm::mpi::communicator that essentially does nothing
+        value = plssvm::mpi::communicator{};
+        return true;
 #endif
     }
 };
diff --git a/bindings/Python/utility.hpp b/bindings/Python/utility.hpp
index f795b4d2a..b9e26c574 100644
--- a/bindings/Python/utility.hpp
+++ b/bindings/Python/utility.hpp
@@ -21,13 +21,12 @@
 
 #include "fmt/format.h"         // fmt::format
 #include "pybind11/numpy.h"     // py::array, py::array_t, py::buffer_info, py::array::c_style
-#include "pybind11/pybind11.h"  // py::kwargs, py::value_error, py::isinstance, py::str, py::module_, py::register_exception_translator, py::set_error, py::object, py::len, py::enum_, py::implicitly_convertible
+#include "pybind11/pybind11.h"  // py::kwargs, py::value_error, py::isinstance, py::str, py::module_, py::enum_, py::register_exception_translator, py::set_error, py::object, py::len, py::exception
 #include "pybind11/pytypes.h"   // py::type, py::ssize_t
 
 #include <cstdint>      // fixed-width integers
 #include <cstring>      // std::memcpy
 #include <exception>    // std::exception_ptr, std::rethrow_exception
-#include <sstream>      // std::istringstream
 #include <string>       // std::string
 #include <string_view>  // std::string_view
 #include <type_traits>  // std::is_same_v, std::false_type
@@ -112,8 +111,8 @@ inline void check_kwargs_for_correctness(const py::kwargs &args, const std::vect
  */
 template <typename Exception, typename BaseException>
 void register_py_exception(py::module_ &m, const std::string &py_exception_name, BaseException &base_exception) {
-    static py::exception<Exception> py_exception(m, py_exception_name.c_str(), base_exception.ptr());
-    py::register_exception_translator([](std::exception_ptr p) {
+    static const py::exception<Exception> py_exception(m, py_exception_name.c_str(), base_exception.ptr());
+    py::register_exception_translator([](std::exception_ptr p) {  // NOLINT(performance-unnecessary-value-param): const & does not compile
         try {
             if (p) {
                 std::rethrow_exception(p);
@@ -196,7 +195,7 @@ PLSSVM_CREATE_PYTHON_TYPE_NAME_MAPPING(std::string, "str")
  * @return the constructed @p Instance wrapped in a std::variant of type @p PossibleTypes (`[[nodiscard]]`)
  */
 template <template <typename> typename Instance, typename PossibleTypes, typename... Args>
-[[nodiscard]] PossibleTypes create_instance(const py::type type, Args &&...args) {
+[[nodiscard]] PossibleTypes create_instance(const py::type &type, Args &&...args) {
     const py::module_ np = py::module_::import("numpy");
 
     // boolean
@@ -292,7 +291,7 @@ template <typename T>
         return py::array{ l };
     } else {
         py::array_t<T, py::array::c_style> arr(vec.size());
-        py::buffer_info buffer = arr.request();
+        const py::buffer_info buffer = arr.request();
         T *ptr = static_cast<T *>(buffer.ptr);
         if constexpr (std::is_same_v<T, bool>) {
             // can't use memcpy with std::vector<bool>
diff --git a/bindings/Python/verbosity_levels.cpp b/bindings/Python/verbosity_levels.cpp
index 05c9dfe20..fd3239246 100644
--- a/bindings/Python/verbosity_levels.cpp
+++ b/bindings/Python/verbosity_levels.cpp
@@ -8,17 +8,17 @@
 
 #include "plssvm/verbosity_levels.hpp"  // plssvm::verbosity_level, bitwise operator overloads, plssvm::verbosity
 
-#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::register_implicit_str_enum_conversion
+#include "bindings/Python/bindings_fwd.hpp"  // forward declare all helper functions to create the Python bindings
+#include "bindings/Python/utility.hpp"       // plssvm::bindings::python::util::register_implicit_str_enum_conversion
 
 #include "pybind11/cast.h"
-#include "pybind11/operators.h"  // pybind operator overloading
-#include "pybind11/pybind11.h"   // py::module_, py::enum_, py::self, py::arg
+#include "pybind11/pybind11.h"  // py::module_, py::self, py::arg, py::enum_
 
 namespace py = pybind11;
 
 void init_verbosity_levels(py::module_ &m) {
     // bind enum class
-    py::enum_<plssvm::verbosity_level> py_enum(m, "VerbosityLevel", "Enum class for all possible verbosity levels used in our own logging infrastructure.");
+    py::enum_<plssvm::verbosity_level> py_enum(m, "VerbosityLevel", "enum.Flag", "Enum class for all possible verbosity levels used in our own logging infrastructure.");
     py_enum
         .value("QUIET", plssvm::verbosity_level::quiet, "nothing is logged to the standard output to stdout")
         .value("LIBSVM", plssvm::verbosity_level::libsvm, "log the same messages as LIBSVM (used for better LIBSVM conformity) to stdout")
@@ -26,13 +26,6 @@ void init_verbosity_levels(py::module_ &m) {
         .value("WARNING", plssvm::verbosity_level::warning, "log all messages related to warning to stderr")
         .value("FULL", plssvm::verbosity_level::full, "log all messages to stdout");
 
-    // bind the bitwise operations
-    py_enum
-        .def(py::self | py::self)
-        .def(py::self |= py::self)
-        .def(py::self & py::self)
-        .def(py::self &= py::self);
-
     // enable implicit conversion from string to enum
     plssvm::bindings::python::util::register_implicit_str_enum_conversion<plssvm::verbosity_level>(py_enum);
 
diff --git a/cmake/filter_compile_commands.cmake b/cmake/filter_compile_commands.cmake
new file mode 100644
index 000000000..1a140f05f
--- /dev/null
+++ b/cmake/filter_compile_commands.cmake
@@ -0,0 +1,42 @@
+# Authors: Alexander Van Craen, Marcel Breyer
+# Copyright (C): 2018-today The PLSSVM project - All Rights Reserved
+# License: This file is part of the PLSSVM project which is released under the MIT license.
+#          See the LICENSE.md file in the project root for full license information.
+########################################################################################################################
+
+# read the compile_commands.json file with ALL compiler flags including the ones that should be removed
+file(READ "${PLSSVM_COMPILE_COMMANDS_JSON_FILE}" CONTENTS)
+
+# create a list of all offensive flags (the order IS important!)
+set(PLSSVM_OFFENSIVE_CLANG_TIDY_FLAGS
+    # stdpar NVHPC
+    "-gpu=(fastmath|unified)"
+    "-stdpar=(gpu|multicore)"
+    "-tp=native"
+    "-mp"
+    "(^|[ \t])-fast([ \t]|$)"
+    # stdpar Intel LLVM (icpx)
+    "-fiopenmp"
+    "-fsycl-pstl-offload=(cpu|gpu)"
+    "-fsycl-targets=[^ ]+"
+    # (stdpar) AdaptiveCpp
+    "--acpp-stdpar-unconditional-offload"
+    "--acpp-stdpar-system-usm"
+    "--acpp-stdpar"
+    "--acpp-targets=[^ ]+"
+    # Intel LLVM (icpx)
+    "-fno-sycl-id-queries-fit-in-int"
+    # Kokkos SYCL
+    "-Xsycl-target-backend=[^ ]+"
+    "-fno-sycl-rdc"
+    "-fsycl-dead-args-optimization"
+    "-fsycl-unnamed-lambda"
+)
+
+# remove problematic flags (regex-based)
+foreach (flag_regex IN LISTS PLSSVM_OFFENSIVE_CLANG_TIDY_FLAGS)
+    string(REGEX REPLACE "${flag_regex}" "" CONTENTS "${CONTENTS}")
+endforeach ()
+
+# write the new compile_commands.json file were the offending compiler flags are removed
+file(WRITE "${PLSSVM_COMPILE_COMMANDS_JSON_FILE}" "${CONTENTS}")
diff --git a/cmake/presets/acpp.json b/cmake/presets/acpp.json
index c2196fdd3..36fdf470a 100644
--- a/cmake/presets/acpp.json
+++ b/cmake/presets/acpp.json
@@ -11,6 +11,7 @@
         "PLSSVM_ENABLE_SYCL_ADAPTIVECPP_BACKEND": "ON",
         "PLSSVM_ENABLE_SYCL_DPCPP_BACKEND": "OFF",
         "PLSSVM_SYCL_BACKEND_ADAPTIVECPP_USE_GENERIC_SSCP": "ON",
+        "PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS": "OFF",
         "PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION": "adaptivecpp"
       }
     },
@@ -23,6 +24,7 @@
         "PLSSVM_ENABLE_SYCL_ADAPTIVECPP_BACKEND": "ON",
         "PLSSVM_ENABLE_SYCL_DPCPP_BACKEND": "OFF",
         "PLSSVM_SYCL_BACKEND_ADAPTIVECPP_USE_GENERIC_SSCP": "ON",
+        "PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS": "OFF",
         "PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION": "adaptivecpp",
         "PLSSVM_ENABLE_LANGUAGE_BINDINGS": "ON",
         "PLSSVM_ENABLE_PYTHON_BINDINGS": "ON"
@@ -37,6 +39,7 @@
         "PLSSVM_ENABLE_SYCL_ADAPTIVECPP_BACKEND": "ON",
         "PLSSVM_ENABLE_SYCL_DPCPP_BACKEND": "OFF",
         "PLSSVM_SYCL_BACKEND_ADAPTIVECPP_USE_GENERIC_SSCP": "ON",
+        "PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS": "OFF",
         "PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION": "adaptivecpp"
       }
     }
diff --git a/cmake/presets/dpcpp.json b/cmake/presets/dpcpp.json
index d8d4efda4..7ed50eff7 100644
--- a/cmake/presets/dpcpp.json
+++ b/cmake/presets/dpcpp.json
@@ -40,7 +40,8 @@
         "PLSSVM_ENABLE_SYCL_ADAPTIVECPP_BACKEND": "OFF",
         "PLSSVM_ENABLE_SYCL_DPCPP_BACKEND": "ON",
         "PLSSVM_SYCL_BACKEND_DPCPP_USE_LEVEL_ZERO": "ON",
-        "PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION": "dpcpp"
+        "PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION": "dpcpp",
+        "PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS": "OFF"
       }
     }
   ],
diff --git a/cmake/presets/icpx.json b/cmake/presets/icpx.json
index ae509b5cf..1aeb9a13b 100644
--- a/cmake/presets/icpx.json
+++ b/cmake/presets/icpx.json
@@ -40,7 +40,8 @@
         "PLSSVM_ENABLE_SYCL_ADAPTIVECPP_BACKEND": "OFF",
         "PLSSVM_ENABLE_SYCL_DPCPP_BACKEND": "ON",
         "PLSSVM_SYCL_BACKEND_DPCPP_USE_LEVEL_ZERO": "ON",
-        "PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION": "dpcpp"
+        "PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION": "dpcpp",
+        "PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS": "OFF"
       }
     }
   ],
diff --git a/cmake/presets/stdpar.json b/cmake/presets/stdpar.json
index 9c96b083c..c05e3c585 100644
--- a/cmake/presets/stdpar.json
+++ b/cmake/presets/stdpar.json
@@ -70,7 +70,7 @@
       "inherits": "common",
       "filter": {
         "include": {
-          "name": "stdpar.*"
+          "name": "(s|S)tdpar.*"
         }
       }
     }
diff --git a/cmake/presets/stdpar_acpp.json b/cmake/presets/stdpar_acpp.json
index 29bd79e11..5246ba571 100644
--- a/cmake/presets/stdpar_acpp.json
+++ b/cmake/presets/stdpar_acpp.json
@@ -74,7 +74,7 @@
       "inherits": "common",
       "filter": {
         "include": {
-          "name": "stdpar.*"
+          "name": "(s|S)tdpar.*"
         }
       }
     }
diff --git a/cmake/presets/stdpar_gcc.json b/cmake/presets/stdpar_gcc.json
index ebf4fbe41..6f0397e26 100644
--- a/cmake/presets/stdpar_gcc.json
+++ b/cmake/presets/stdpar_gcc.json
@@ -70,7 +70,7 @@
       "inherits": "common",
       "filter": {
         "include": {
-          "name": "stdpar.*"
+          "name": "(s|S)tdpar.*"
         }
       }
     }
diff --git a/cmake/presets/stdpar_intelllvm.json b/cmake/presets/stdpar_intelllvm.json
index 14f47a0c0..08d9ae604 100644
--- a/cmake/presets/stdpar_intelllvm.json
+++ b/cmake/presets/stdpar_intelllvm.json
@@ -73,7 +73,7 @@
       "inherits": "common",
       "filter": {
         "include": {
-          "name": "stdpar.*"
+          "name": "(s|S)tdpar.*"
         }
       }
     }
diff --git a/cmake/presets/stdpar_nvhpc.json b/cmake/presets/stdpar_nvhpc.json
index 5862509d3..ecd7be984 100644
--- a/cmake/presets/stdpar_nvhpc.json
+++ b/cmake/presets/stdpar_nvhpc.json
@@ -73,7 +73,7 @@
       "inherits": "common",
       "filter": {
         "include": {
-          "name": "stdpar.*"
+          "name": "(s|S)tdpar.*"
         }
       }
     }
diff --git a/cmake/presets/stdpar_rocstdpar.json b/cmake/presets/stdpar_rocstdpar.json
index 83d69c9d6..abca6ee16 100644
--- a/cmake/presets/stdpar_rocstdpar.json
+++ b/cmake/presets/stdpar_rocstdpar.json
@@ -73,7 +73,7 @@
       "inherits": "common",
       "filter": {
         "include": {
-          "name": "stdpar.*"
+          "name": "(s|S)tdpar.*"
         }
       }
     }
diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt
index 072b8873e..afd22227a 100644
--- a/docs/CMakeLists.txt
+++ b/docs/CMakeLists.txt
@@ -30,6 +30,7 @@ set(DOXYGEN_INLINE_INHERITED_MEMB "YES")
 set(DOXYGEN_USE_MATHJAX "YES")
 set(DOXYGEN_PROJECT_LOGO "${PROJECT_SOURCE_DIR}/docs/resources/logo_90x55.png")
 set(DOXYGEN_EXCLUDE_SYMBOLS "*_HPP_")
+set(DOXYGEN_HTML_COLORSTYLE "TOGGLE")
 
 set(DOXYGEN_DOT_IMAGE_FORMAT "svg")
 set(DOXYGEN_DOT_GRAPH_MAX_NODES "100")
@@ -43,7 +44,7 @@ set(DOXYGEN_ENABLE_PREPROCESSING "YES")
 set(DOXYGEN_MACRO_EXPANSION "YES")
 set(DOXYGEN_EXPAND_ONLY_PREDEF "YES")
 set(DOXYGEN_EXPAND_AS_DEFINED "YES")
-set(DOXYGEN_PREDEFINED "__attribute__((x))=;__CUDA_ARCH__=0")
+set(DOXYGEN_PREDEFINED "__attribute__((x))=;__CUDA_ARCH__=0;PLSSVM_BACKENDS_CUDA_DETAIL_UTILITY_CUH_")
 
 set(DOXYGEN_VERBATIM_VARS DOXYGEN_ALIASES)
 set(DOXYGEN_ALIASES [[license="\par License^^\parblock^^"  ]])
@@ -51,18 +52,43 @@ set(DOXYGEN_ALIASES [[license="\par License^^\parblock^^"  ]])
 # sanitize README formulas for Doxygen if the sed utility is available
 find_program(PLSSVM_HAS_SED "sed")
 if (PLSSVM_HAS_SED)
-    set(DOXYGEN_FILTER_PATTERNS
-        "*.md=sed -e '1,90 s/\\$/\\\\f\\$/g' -e '/^## Table of Contents/,/^## Introduction to PLSSVM/{//!d}' -e 's/^## Table of Contents/@tableofcontents/g' -e '/^# The Python3 Bindings/,/^We currently support two kinds of Python3 bindings/{//!d}' -e 's/^# The Python3 Bindings/@tableofcontents{HTML:3}/g' -e '/^#/ s/`//g'"
+    message(STATUS "Found the sed utility used to sanitize the READMEs for a better Doxygen output.")
+    set(DOXYGEN_MD_FILTER
+        # replace markdown math syntax with the corresponding Doxygen syntax, BUT ONLY in the first 350 lines
+        " -e '1,350 s/\\$/\\\\f\\$/g'"
+        # remove section between 'Table of Contents' and 'Introduction'
+        " -e '/^## Table of Contents/,/^## Introduction to PLSSVM/{//!d}'"
+        # convert Markdown header to Doxygen TOC
+        " -e 's/^## Table of Contents/@tableofcontents/g'"
+        # remove Python Bindings intro section
+        " -e '/^# The Python3 Bindings/,/^We currently support two kinds of Python3 bindings/{//!d}'"
+        # fix Doxygen problems when linking to other Markdown files
+        " -e 's|\\[examples/python/interactive\\](examples/python/interactive/README.md)|\\\\ref examples_interactive|g'"
+        " -e 's|<!-- DOXYGEN_INTERACTIVE_EXAMPLE_LINK -->|/* \\\\page examples_interactive Interactive Example|g'"
+        " -e 's|\\[examples/python/sklearn\\](examples/python/sklearn/README.md)|\\\\ref examples_sklearn|g'"
+        " -e 's|<!-- DOXYGEN_SKLEARN_EXAMPLE_LINK -->|/* \\\\page examples_sklearn Sklearn Examples|g'"
+        " -e 's|\\[our API documentation\\](bindings/Python/README.md)|\\\\ref bindings_python|g'"
+        " -e 's|<!-- DOXYGEN_PYTHON_BINDINGS_LINK -->|/* \\\\page bindings_python Python Bindings|g'"
+        # replace emoji codes with unicode symbols
+        " -e 's|:white_check_mark:|✓|g'"
+        " -e 's|:x:|✗|g'"
+        # convert Markdown header to Doxygen TOC (msut be done here)
+        " -e 's/^# The Python3 Bindings/@tableofcontents{HTML:3}/g'"
     )
+    string(JOIN " " DOXYGEN_MD_FILTER_CMD ${DOXYGEN_MD_FILTER})
+
+    set(DOXYGEN_FILTER_PATTERNS "*.md=sed ${DOXYGEN_MD_FILTER_CMD}")
     list(APPEND DOXYGEN_FILTER_PATTERNS
          "*.cl=sed -e 's/ PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST)/, Args... PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST)/g'"
     )
 endif ()
 
+message(STATUS "Add custom doc target.")
+
 # add doxygen as target
 doxygen_add_docs(
     doc
-    "${PROJECT_SOURCE_DIR}/include;${PROJECT_SOURCE_DIR}/docs/resources;${PROJECT_SOURCE_DIR}/README.md;${PROJECT_SOURCE_DIR}/bindings/Python/README.md;${PROJECT_SOURCE_DIR}/examples/python/interactive/README.md"
+    "${PROJECT_SOURCE_DIR}/include;${PROJECT_SOURCE_DIR}/docs/resources;${PROJECT_SOURCE_DIR}/README.md;${PROJECT_SOURCE_DIR}/bindings/Python/README.md;${PROJECT_SOURCE_DIR}/examples/python/sklearn/README.md;${PROJECT_SOURCE_DIR}/examples/python/interactive/README.md"
     ALL # add to the default build target
     WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
     COMMENT "Generating API documentation with Doxygen"
diff --git a/docs/resources/dirs.dox b/docs/resources/dirs.dox
index 412fe72b1..3eb50e8af 100644
--- a/docs/resources/dirs.dox
+++ b/docs/resources/dirs.dox
@@ -642,6 +642,17 @@
  * @brief Directory containing work-group data parallel kernel implementations for the predictions using the SYCL backend.
  */
 
+/**
+ * @dir include/plssvm/backends/SYCL/kernel/detail
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Directory containing kernel implementations for utility functions using the SYCL backend.
+ */
+
 /**
  * @dir include/plssvm/backends/SYCL/DPCPP
  * @author Alexander Van Craen
diff --git a/examples/python/interactive/README.md b/examples/python/interactive/README.md
index 8b69277ad..2e46b7a6c 100644
--- a/examples/python/interactive/README.md
+++ b/examples/python/interactive/README.md
@@ -1,4 +1,6 @@
-# Interactive live comparison between `sklearn.svm` and PLSSVM
+<!-- DOXYGEN_INTERACTIVE_EXAMPLE_LINK -->
+
+# Interactive live comparison between sklearn.svm and PLSSVM
 
 This directory contains a bokeh application that can be used to compare `sklearn.svm`'s and PLSSVM's classification and 
 regression implementation directly besides each other. 
@@ -6,7 +8,7 @@ It is possible to change all available hyperparameters, e.g., kernel function, d
 respective kernel function parameters. Additionally, the number of  classes and datapoints as well as the used dataset 
 can be changed on the fly.
 
-![Example of our bokeh application visualization between sklearn.svm and PLSSVM.](https://github.com/SC-SGS/PLSSVM/raw/regression/.figures/plssvm_bokeh.gif)
+![Example of our bokeh application visualization between sklearn.svm and PLSSVM.](https://github.com/SC-SGS/PLSSVM/raw/develop/.figures/plssvm_bokeh.gif)
 
 # Requirements
 
diff --git a/examples/python/sklearn/README.md b/examples/python/sklearn/README.md
index 94be4e276..41062d5b7 100644
--- a/examples/python/sklearn/README.md
+++ b/examples/python/sklearn/README.md
@@ -1,3 +1,5 @@
+<!-- DOXYGEN_SKLEARN_EXAMPLE_LINK -->
+
 # Toy Examples of PLSSVM using its sklearn like plssvm.SVC and plssvm.SVR Python bindings
 
 This directory contains examples for our sklearn like `plssvm.SVC` and `plssvm.SVR` Python bindings. 
@@ -30,7 +32,7 @@ The four datasets are:
 4. a dataset with **four** classes created via `sklearn.datasets.make_blobs`
 
 <p align="center">
-  <img alt="plot_classifier_comparison.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/classifier_comparison.png" width="100%">
+  <img alt="plot_classifier_comparison.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/classifier_comparison.png" width="100%">
 </p>
 
 ```text
@@ -92,7 +94,7 @@ Note that now hyperparameter optimizations were performed.
 This examples shows how we can calculate the decision boundary using the model's `coef0_` and `intercept_` attributes.
 
 <p align="center">
-  <img alt="plot_decision_boundaries_via_coef_and_intercept.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/decision_boundaries_via_coef_and_intercept.png" width="80%">
+  <img alt="plot_decision_boundaries_via_coef_and_intercept.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/decision_boundaries_via_coef_and_intercept.png" width="80%">
 </p>
 
 ```text
@@ -106,7 +108,7 @@ This examples plots the decision boundaries for an example with four classes usi
 The darker the shading, the higher is the confidence that a sample corresponds to the respective class.
 
 <p align="center">
-  <img alt="plot_decision_boundary_confidence.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/decision_boundary_confidence.png" width="80%">
+  <img alt="plot_decision_boundary_confidence.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/decision_boundary_confidence.png" width="80%">
 </p>
 
 ```text
@@ -121,7 +123,7 @@ Training score plssvm.SVC(C=10.0, decision_function_shape='ovo'): 0.95
 This example showcases the decision boundary differences when using the different supported kernel functions and classification types in PLSSVM.
 
 <p align="center">
-  <img alt="plot_different_classifiers.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/different_classifiers.png" width="100%">
+  <img alt="plot_different_classifiers.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/different_classifiers.png" width="100%">
 </p>
 
 ```text
@@ -146,12 +148,12 @@ All kernel functions except the `sigmoid` kernel work rather good in this toy ex
 This example is the standard digits classification example from `sklearn` using PLSSVM as `SVC` implementation. 
 
 <p align="center">
-  <img alt="plot_digit_classification.py confusion matrix" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/digit_classification_confusion_matrix.png" width="60%">
+  <img alt="plot_digit_classification.py confusion matrix" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/digit_classification_confusion_matrix.png" width="60%">
 </p>
 
 <p align="center">
-  <img alt="plot_digit_classification.py output 1" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/digit_classification_1.png" width="40%">
-  <img alt="plot_digit_classification.py output 2" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/digit_classification_2.png" width="40%">
+  <img alt="plot_digit_classification.py output 1" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/digit_classification_1.png" width="40%">
+  <img alt="plot_digit_classification.py output 2" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/digit_classification_2.png" width="40%">
 </p>
 
 ```text
@@ -211,12 +213,12 @@ With the same default parameters, PLSSVM also achieves a high accuracy of 96%.
 This example is the standard face recognition classification example from `sklearn` using PLSSVM as `SVC` implementation.
 
 <p align="center">
-  <img alt="plot_face_recognition.py confusion matrix" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/face_recognition_confusion_matrix.png" width="60%">
+  <img alt="plot_face_recognition.py confusion matrix" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/face_recognition_confusion_matrix.png" width="60%">
 </p>
 
 <p align="center">
-  <img alt="plot_face_recognition.py result prediction" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/face_recognition.png" width="48%">
-  <img alt="plot_face_recognition.py eigenfaces" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/face_recognition_eigenfaces.png" width="48%">
+  <img alt="plot_face_recognition.py result prediction" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/face_recognition.png" width="48%">
+  <img alt="plot_face_recognition.py eigenfaces" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/face_recognition_eigenfaces.png" width="48%">
 </p>
 
 ```text
@@ -256,7 +258,7 @@ Again, with the same default parameters, PLSSVM also achieves a high accuracy of
 This example is the standard feature discretization example from `sklearn` using PLSSVM as `SVC` implementation.
 
 <p align="center">
-  <img alt="plot_rbf_parameters.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/feature_discretization.png" width="100%">
+  <img alt="plot_rbf_parameters.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/feature_discretization.png" width="100%">
 </p>
 
 ```text
@@ -294,11 +296,11 @@ This example is the standard rbf parameter example from `sklearn` using PLSSVM a
 Plotted are the decision boundaries different `gamma` and `C` parameter combinations.
 
 <p align="center">
-  <img alt="plot_rbf_parameters.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/rbf_parameters.png" width="80%">
+  <img alt="plot_rbf_parameters.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/rbf_parameters.png" width="80%">
 </p>
 
 <p align="center">
-  <img alt="plot_rbf_parameters.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/rbf_parameters_accuracy.png" width="50%">
+  <img alt="plot_rbf_parameters.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/rbf_parameters_accuracy.png" width="50%">
 </p>
 
 ```text
@@ -310,11 +312,11 @@ The best parameters are {'C': np.float64(1.0), 'gamma': np.float64(0.1)} with a
 This example is similar to `plot_rbf_parameters_classes.py` but uses three classes instead of a binary classification problem. 
 
 <p align="center">
-  <img alt="plot_rbf_parameters_3_classes.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/rbf_parameters_3_classes.png" width="80%">
+  <img alt="plot_rbf_parameters_3_classes.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/rbf_parameters_3_classes.png" width="80%">
 </p>
 
 <p align="center">
-  <img alt="plot_rbf_parameters_3_classes.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/rbf_parameters_accuracy_3_classes.png" width="50%">
+  <img alt="plot_rbf_parameters_3_classes.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/rbf_parameters_accuracy_3_classes.png" width="50%">
 </p>
 
 ```text
@@ -326,7 +328,7 @@ The best parameters are {'C': np.float64(1000000000.0), 'gamma': np.float64(0.00
 A simple example plotting the separating hyperplane computed by the `SVC`.
 
 <p align="center">
-  <img alt="plot_separating_hyperplane.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/separating_hyperplane.png" width="50%">
+  <img alt="plot_separating_hyperplane.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/separating_hyperplane.png" width="50%">
 </p>
 
 ## plot_svm_anova.py
@@ -334,14 +336,14 @@ A simple example plotting the separating hyperplane computed by the `SVC`.
 An example showing how to use a univariate feature selection before running an `SVC` to improve the classification scores
 
 <p align="center">
-  <img alt="plot_svm_anova.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/svm_anova.png" width="50%">
+  <img alt="plot_svm_anova.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/svm_anova.png" width="50%">
 </p>
 
 ## plot_svm_kernels.py
 
 An example showing the decision boundary of different PLSSVM kernel functions on a two-dimensional binary data set:
 <p align="center">
-  <img alt="plot_svm_kernels.py used data set" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/svm_kernels_data.png" width="25%">
+  <img alt="plot_svm_kernels.py used data set" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/svm_kernels_data.png" width="25%">
 </p>
 
 The decision boundaries of the different kernels look as follows:
@@ -350,36 +352,36 @@ The decision boundaries of the different kernels look as follows:
     <tr>
         <td>
             <p align="center">
-              <img alt="plot_svm_kernels.py linear kernel decision boundary" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/svm_kernels_linear.png" width="90%">
+              <img alt="plot_svm_kernels.py linear kernel decision boundary" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/svm_kernels_linear.png" width="90%">
             </p>
         </td>
         <td>
             <p align="center">
-              <img alt="plot_svm_kernels.py polynomial kernel decision boundary" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/svm_kernels_poly.png" width="90%">
+              <img alt="plot_svm_kernels.py polynomial kernel decision boundary" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/svm_kernels_poly.png" width="90%">
             </p>
         </td>
         <td>
             <p align="center">
-              <img alt="plot_svm_kernels.py rbf kernel decision boundary" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/svm_kernels_rbf.png" width="90%">
+              <img alt="plot_svm_kernels.py rbf kernel decision boundary" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/svm_kernels_rbf.png" width="90%">
             </p>
         </td>
     </tr>
     <tr>
         <td>
             <p align="center">
-              <img alt="plot_svm_kernels.py sigmoid kernel decision boundary" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/svm_kernels_sigmoid.png" width="90%">
+              <img alt="plot_svm_kernels.py sigmoid kernel decision boundary" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/svm_kernels_sigmoid.png" width="90%">
             </p>
         </td>
         <td>
             <p align="center">
-              <img alt="plot_svm_kernels.py laplacian kernel decision boundary" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/svm_kernels_laplacian.png" width="90%">
+              <img alt="plot_svm_kernels.py laplacian kernel decision boundary" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/svm_kernels_laplacian.png" width="90%">
             </p>
         </td>
     </tr>
 </table>
 
 <p align="center">
-  <img alt="plot_svm_kernels.py xor problem" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/svm_kernels_xor.png" width="80%">
+  <img alt="plot_svm_kernels.py xor problem" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/svm_kernels_xor.png" width="80%">
 </p>
 
 ## plot_svm_margin.py
@@ -387,7 +389,7 @@ The decision boundaries of the different kernels look as follows:
 An example showing the margins between the support vectors and the separating hyperplane.
 
 <p align="center">
-  <img alt="plot_svm_margin.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/svm_margin.png" width="60%">
+  <img alt="plot_svm_margin.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/svm_margin.png" width="60%">
 </p>
 
 ## plot_svm_regression.py
@@ -398,7 +400,7 @@ A small examples showing the different PLSSVM kernel functions for three differe
 3. irregular function
 
 <p align="center">
-  <img alt="plot_svm_regression.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/svm_regression.png" width="100%">
+  <img alt="plot_svm_regression.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/svm_regression.png" width="100%">
 </p>
 
 ```text
@@ -436,11 +438,11 @@ The Street View House Numbers (SVHN) dataset (http://ufldl.stanford.edu/housenum
 samples and 26'032 test samples with 3072 features each (32x32 RGB images) of house numbers obtained by Google Street View images.
 
 <p align="center">
-  <img alt="plot_SVHN.py confusion matrix" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/real_world/svhn_confusion_matrix.png" width="60%">
+  <img alt="plot_SVHN.py confusion matrix" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/real_world/svhn_confusion_matrix.png" width="60%">
 </p>
 
 <p align="center">
-  <img alt="plot_SVHN.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/real_world/svhn.png" width="1000%">
+  <img alt="plot_SVHN.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/real_world/svhn.png" width="1000%">
 </p>
 
 ```text
@@ -475,11 +477,11 @@ The fashion MNIST dataset (https://www.kaggle.com/datasets/zalando-research/fash
 samples and 14'000 test samples with 784 features each (28x28 gray scale images) of Zalando's article images.
 
 <p align="center">
-  <img alt="plot_fashion_MNIST.py confusion matrix" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/real_world/fashion_mnist_confusion_matrix.png" width="60%">
+  <img alt="plot_fashion_MNIST.py confusion matrix" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/real_world/fashion_mnist_confusion_matrix.png" width="60%">
 </p>
 
 <p align="center">
-  <img alt="plot_fashion_MNIST.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/real_world/fashion_mnist.png" width="80%">
+  <img alt="plot_fashion_MNIST.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/real_world/fashion_mnist.png" width="80%">
 </p>
 
 ```text
@@ -514,7 +516,7 @@ The California Housing Prices dataset (https://www.kaggle.com/datasets/camnugent
 16'512 training and 4128 test samples with 8 features each from the 1990 California census.
 
 <p align="center">
-  <img alt="plot_california_housing.py output" src="https://github.com/SC-SGS/PLSSVM/raw/regression/.figures//sklearn_examples/real_world/california_housing.png" width="60%">
+  <img alt="plot_california_housing.py output" src="https://github.com/SC-SGS/PLSSVM/raw/develop/.figures//sklearn_examples/real_world/california_housing.png" width="60%">
 </p>
 
 ```
diff --git a/examples/python/sklearn/plot_classifier_comparison.py b/examples/python/sklearn/plot_classifier_comparison.py
index 85285e7b5..b6af09d57 100644
--- a/examples/python/sklearn/plot_classifier_comparison.py
+++ b/examples/python/sklearn/plot_classifier_comparison.py
@@ -92,7 +92,10 @@
             best_model = name
 
         # create the decision boundary
-        DecisionBoundaryDisplay.from_estimator(clf, X, cmap=cm, alpha=0.8, ax=ax, eps=0.5)
+        if ds_name == "blobs":
+            DecisionBoundaryDisplay.from_estimator(clf, X, alpha=0.8, ax=ax, eps=0.5)
+        else:
+            DecisionBoundaryDisplay.from_estimator(clf, X, cmap=cm, alpha=0.8, ax=ax, eps=0.5)
 
         # plot the training points
         ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="k")
diff --git a/examples/python/sklearn/plot_feature_discretization.py b/examples/python/sklearn/plot_feature_discretization.py
index 4aa696b1e..ec9860dda 100644
--- a/examples/python/sklearn/plot_feature_discretization.py
+++ b/examples/python/sklearn/plot_feature_discretization.py
@@ -42,7 +42,7 @@ def get_name(estimator):
     (
         make_pipeline(
             StandardScaler(),
-            KBinsDiscretizer(encode="onehot", random_state=0),
+            KBinsDiscretizer(encode="onehot", random_state=0, quantile_method='averaged_inverted_cdf'),
             LogisticRegression(random_state=0),
         ),
         {
@@ -53,7 +53,7 @@ def get_name(estimator):
     (
         make_pipeline(
             StandardScaler(),
-            KBinsDiscretizer(encode="onehot", random_state=0),
+            KBinsDiscretizer(encode="onehot", random_state=0, quantile_method='averaged_inverted_cdf'),
             SVC(kernel="linear"),
         ),
         {
diff --git a/examples/python/sklearn_like_svc.py b/examples/python/sklearn_like_svc.py
index e9d8934c3..19f12f6a8 100644
--- a/examples/python/sklearn_like_svc.py
+++ b/examples/python/sklearn_like_svc.py
@@ -40,7 +40,7 @@
 )
 
 # scatter plot the decision boundary
-viridis = plt.cm.get_cmap('viridis', len(np.unique(y)))
+viridis = plt.get_cmap('viridis', len(np.unique(y)))
 plt.scatter(X[:, 0], X[:, 1],
             cmap=viridis,
             c=y,
diff --git a/include/plssvm/backend_types.hpp b/include/plssvm/backend_types.hpp
index 222d7f78f..cd15cf9be 100644
--- a/include/plssvm/backend_types.hpp
+++ b/include/plssvm/backend_types.hpp
@@ -16,8 +16,7 @@
 #pragma once
 
 #include "plssvm/backends/SYCL/implementation_types.hpp"  // plssvm::sycl::implementation_type
-#include "plssvm/detail/type_traits.hpp"                  // plssvm::detail::remove_cvref_t
-#include "plssvm/detail/type_traits.hpp"                  // plssvm::detail::is_one_type_of
+#include "plssvm/detail/type_traits.hpp"                  // plssvm::detail::{is_one_type_of, remove_cvref_t}
 #include "plssvm/target_platforms.hpp"                    // plssvm::list_available_target_platforms
 
 #include "fmt/base.h"     // fmt::formatter
diff --git a/include/plssvm/backends/CUDA/csvm.hpp b/include/plssvm/backends/CUDA/csvm.hpp
index ec02c80c0..18e08e1a5 100644
--- a/include/plssvm/backends/CUDA/csvm.hpp
+++ b/include/plssvm/backends/CUDA/csvm.hpp
@@ -28,6 +28,7 @@
 #include "plssvm/target_platforms.hpp"                    // plssvm::target_platform
 
 #include <cstddef>      // std::size_t
+#include <optional>     // std::optional
 #include <type_traits>  // std::true_type
 #include <utility>      // std::forward
 #include <vector>       // std::vector
@@ -94,6 +95,10 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, int, detail::
      * @copydoc plssvm::csvm::get_max_mem_alloc_size
      */
     [[nodiscard]] std::vector<::plssvm::detail::memory_size> get_max_mem_alloc_size() const final;
+    /**
+     * @copydoc plssvm::csvm::get_local_memory
+     */
+    [[nodiscard]] std::vector<std::optional<::plssvm::detail::memory_size>> get_local_memory() const final;
     /**
      * @copydoc plssvm::detail::gpu_csvm::get_max_work_group_size
      */
@@ -153,8 +158,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvc(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::cuda::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVC using the CUDA backend with the parameters given through @p params.
@@ -163,8 +167,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     csvc(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::cuda::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVC using the CUDA backend on the @p target platform with the parameters given through @p params.
@@ -245,8 +248,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvr(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::cuda::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVR using the CUDA backend with the parameters given through @p params.
@@ -255,8 +257,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvr(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::cuda::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVR using the CUDA backend on the @p target platform with the parameters given through @p params.
diff --git a/include/plssvm/backends/CUDA/detail/device_ptr.cuh b/include/plssvm/backends/CUDA/detail/device_ptr.cuh
index de2d8546d..43c6eadc3 100644
--- a/include/plssvm/backends/CUDA/detail/device_ptr.cuh
+++ b/include/plssvm/backends/CUDA/detail/device_ptr.cuh
@@ -9,8 +9,8 @@
  * @brief Small wrapper around a CUDA device pointer.
  */
 
-#ifndef PLSSVM_BACKENDS_CUDA_DETAIL_DEVICE_PTR_HPP_
-#define PLSSVM_BACKENDS_CUDA_DETAIL_DEVICE_PTR_HPP_
+#ifndef PLSSVM_BACKENDS_CUDA_DETAIL_DEVICE_PTR_CUH_
+#define PLSSVM_BACKENDS_CUDA_DETAIL_DEVICE_PTR_CUH_
 #pragma once
 
 #include "plssvm/backends/gpu_device_ptr.hpp"  // plssvm::detail::gpu_device_ptr
@@ -131,4 +131,4 @@ extern template class device_ptr<double>;
 
 }  // namespace plssvm::cuda::detail
 
-#endif  // PLSSVM_BACKENDS_CUDA_DETAIL_DEVICE_PTR_HPP_
+#endif  // PLSSVM_BACKENDS_CUDA_DETAIL_DEVICE_PTR_CUH_
diff --git a/include/plssvm/backends/CUDA/detail/pinned_memory.cuh b/include/plssvm/backends/CUDA/detail/pinned_memory.cuh
index 20534629e..4b7e3e106 100644
--- a/include/plssvm/backends/CUDA/detail/pinned_memory.cuh
+++ b/include/plssvm/backends/CUDA/detail/pinned_memory.cuh
@@ -9,8 +9,8 @@
  * @brief Small wrapper around RAII enabled cudaHostRegister.
  */
 
-#ifndef PLSSVM_BACKENDS_CUDA_DETAIL_PINNED_MEMORY_HPP_
-#define PLSSVM_BACKENDS_CUDA_DETAIL_PINNED_MEMORY_HPP_
+#ifndef PLSSVM_BACKENDS_CUDA_DETAIL_PINNED_MEMORY_CUH_
+#define PLSSVM_BACKENDS_CUDA_DETAIL_PINNED_MEMORY_CUH_
 #pragma once
 
 #include "plssvm/backends/host_pinned_memory.hpp"  // plssvm::detail::host_pinned_memory
@@ -100,4 +100,4 @@ extern template class pinned_memory<double>;
 
 }  // namespace plssvm::cuda::detail
 
-#endif  // PLSSVM_BACKENDS_CUDA_DETAIL_PINNED_MEMORY_HPP_
+#endif  // PLSSVM_BACKENDS_CUDA_DETAIL_PINNED_MEMORY_CUH_
diff --git a/include/plssvm/backends/CUDA/detail/utility.cuh b/include/plssvm/backends/CUDA/detail/utility.cuh
index e35d03bf6..d5b51a947 100644
--- a/include/plssvm/backends/CUDA/detail/utility.cuh
+++ b/include/plssvm/backends/CUDA/detail/utility.cuh
@@ -9,13 +9,17 @@
  * @brief Utility functions for the CUDA backend.
  */
 
-#ifndef PLSSVM_BACKENDS_CUDA_DETAIL_UTILITY_HPP_
-#define PLSSVM_BACKENDS_CUDA_DETAIL_UTILITY_HPP_
+#ifndef PLSSVM_BACKENDS_CUDA_DETAIL_UTILITY_CUH_
+#define PLSSVM_BACKENDS_CUDA_DETAIL_UTILITY_CUH_
 #pragma once
 
 #include "plssvm/backends/CUDA/exceptions.hpp"  // plssvm::cuda::backend_exception
 #include "plssvm/backends/execution_range.hpp"  // plssvm::detail::dim_type
 
+#include "cuda_runtime_api.h"  // cudaGetErrorName, cudaGetErrorString
+#include "driver_types.h"      // cudaError_t, cudaSuccess
+#include "vector_types.h"      // dim3
+
 #include "fmt/base.h"     // fmt::formatter
 #include "fmt/format.h"   // fmt::format
 #include "fmt/ostream.h"  // fmt::ostream_formatter
@@ -34,6 +38,8 @@
         throw plssvm::cuda::backend_exception{ fmt::format("CUDA assert '{}' ({}): {}", cudaGetErrorName(err), err, cudaGetErrorString(err)) }; \
     }
 
+// NOLINTBEGIN(misc-use-internal-linkage): false positive diagnostic for .cuh files
+
 namespace plssvm::cuda::detail {
 
 /**
@@ -69,6 +75,13 @@ void peek_at_last_error();
  */
 void device_synchronize(int device);
 
+/**
+ * @brief Get the name of the CUDA @p device.
+ * @param[in] device the device
+ * @return the CUDA device name (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::string get_device_name(int device);
+
 /**
  * @brief Get the CUDA runtime version as pretty string.
  * @details Parses the returned integer according to: https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART____VERSION.html#group__CUDART____VERSION_1g0e3952c7802fd730432180f1f4a6cdc6
@@ -80,9 +93,11 @@ void device_synchronize(int device);
 
 /// @cond Doxygen_suppress
 
+// NOLINTEND(misc-use-internal-linkage)
+
 template <>
 struct fmt::formatter<cudaError_t> : fmt::ostream_formatter { };
 
 /// @endcond
 
-#endif  // PLSSVM_BACKENDS_CUDA_DETAIL_UTILITY_HPP_
+#endif  // PLSSVM_BACKENDS_CUDA_DETAIL_UTILITY_CUH_
diff --git a/include/plssvm/backends/CUDA/kernel/cg_explicit/blas.cuh b/include/plssvm/backends/CUDA/kernel/cg_explicit/blas.cuh
index 2f7b37a0f..ab6c7b11b 100644
--- a/include/plssvm/backends/CUDA/kernel/cg_explicit/blas.cuh
+++ b/include/plssvm/backends/CUDA/kernel/cg_explicit/blas.cuh
@@ -13,7 +13,9 @@
 #define PLSSVM_BACKENDS_CUDA_KERNEL_CG_EXPLICIT_BLAS_CUH_
 #pragma once
 
-#include "plssvm/constants.hpp"  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+
+#include <cstddef>  // std::size_t
 
 namespace plssvm::cuda::detail {
 
@@ -22,8 +24,8 @@ namespace plssvm::cuda::detail {
  * @details In a multi-GPU setting, this function is only responsible for the rows this device is responsible for!
  * @param[in] num_rows the number of rows in @p A and @p C
  * @param[in] num_rhs the number of columns in @p B and @p C
- * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
- * @param[in] row_offset the first row this device is responsible for
+ * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+ * @param[in] device_row_offset the first row this device is responsible for
  * @param[in] alpha the scalar alpha value
  * @param[in] A the matrix @p A
  * @param[in] B the matrix @p B
@@ -32,78 +34,77 @@ namespace plssvm::cuda::detail {
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_symm(const unsigned long long num_rows, const unsigned long long num_rhs, const unsigned long long device_specific_num_rows, const unsigned long long row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;  // # rhs -> num_rhs
-    const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;  // # rows -> device_specific_num_rows
-    const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-
-    // create the shared memory arrays used for caching data point features
-    __shared__ real_type A_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __shared__ real_type B_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+__global__ void device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type A_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type B_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // create a thread private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
-    // iterate over all features using blocking to be able to cache them for faster memory accesses
-    for (unsigned long long dim = 0; dim < (num_rows - row_offset); dim += FEATURE_BLOCK_SIZE_ull) {
-        // load data into shared memory
-        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const auto global_i = i_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-            const auto global_j = j_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-
-            // determine on which side of the diagonal we are located
-            if (dim + threadIdx_y < global_j) {
-                A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim + threadIdx_y) * (num_rows - row_offset + PADDING_SIZE_ull) + global_j - (dim + threadIdx_y) * (dim + threadIdx_y + 1ull) / 2ull];
-            } else {
-                A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[global_j * (num_rows - row_offset + PADDING_SIZE_ull) + dim + threadIdx_y - global_j * (global_j + 1ull) / 2ull];
-            }
-            // determine on which side of the diagonal we are located
-            if (dim + threadIdx.y + THREAD_BLOCK_SIZE < global_j) {
-                A_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows - row_offset + PADDING_SIZE_ull) + global_j - (dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (dim + threadIdx_y + THREAD_BLOCK_SIZE_ull + 1ull) / 2ull];
-            } else {
-                A_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[global_j * (num_rows - row_offset + PADDING_SIZE_ull) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull - global_j * (global_j + 1ull) / 2ull];
+    {
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rhs
+        const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
+
+        // iterate over all values using blocking to be able to cache them for faster memory accesses
+        for (std::size_t dim_block = 0; dim_block < (num_rows - device_row_offset); dim_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into shared memory
+            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the shared memory
+                // determine on which side of the diagonal we are located
+                if (dim_block + threadIdx_y < global_j_idx_linear) {
+                    A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim_block + threadIdx_y) * (num_rows - device_row_offset + PADDING_SIZE_uz) + global_j_idx_linear - (dim_block + threadIdx_y) * (dim_block + threadIdx_y + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                } else {
+                    A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[global_j_idx_linear * (num_rows - device_row_offset + PADDING_SIZE_uz) + dim_block + threadIdx_y - global_j_idx_linear * (global_j_idx_linear + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                }
+                B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(dim_block + device_row_offset + threadIdx_y) * (num_rhs + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
             }
-
-            B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(dim + row_offset + threadIdx_y) * (num_rhs + PADDING_SIZE_ull) + global_i];
-            B_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(dim + row_offset + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rhs + PADDING_SIZE_ull) + global_i];
-        }
-        __syncthreads();  // wait until all threads loaded their part of the data
-
-        // perform the dot product calculation
-        for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    temp[internal_i][internal_j] += A_cache[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i];
+            __syncthreads();  // wait until all threads loaded their part of the data
+
+            // perform the dot product calculation
+            for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        temp[internal_i][internal_j] += A_cache[dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i];
+                    }
                 }
             }
+            __syncthreads();  // wait until all threads performed their part of the calculations
         }
-        __syncthreads();  // wait until all threads performed their part of the calculations
     }
 
+    // calculate the indices used in the current thread
+    const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+    const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
     // apply the (partial) BLAS operation and update C
     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const auto global_i = i + static_cast<unsigned long long>(internal_i);
-            const auto device_global_j = j + static_cast<unsigned long long>(internal_j);
-            const auto global_j = row_offset + j + static_cast<unsigned long long>(internal_j);
-
-            // be sure to not perform out of bounds accesses
-            if (global_i < num_rhs && device_global_j < device_specific_num_rows) {
-                C[global_j * (num_rhs + PADDING_SIZE_ull) + global_i] = alpha * temp[internal_i][internal_j] + beta * C[global_j * (num_rhs + PADDING_SIZE_ull) + global_i];
+            // calculate the indices to access the global data and the data with respect to the current device
+            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+            const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+            const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+            // be sure to not perform out-of-bounds accesses
+            if (global_i_idx < num_rhs && device_global_j_idx < device_num_rows) {
+                C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx] = alpha * temp[internal_i][internal_j] + beta * C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx];  // SoA
             }
         }
     }
@@ -115,8 +116,8 @@ __global__ void device_kernel_symm(const unsigned long long num_rows, const unsi
  * @param[in] num_rows the number of rows in @p A and @p C
  * @param[in] num_rhs the number of columns in @p B and @p C
  * @param[in] num_mirror_rows the number of rows to mirror down
- * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
- * @param[in] row_offset the first row this device is responsible for
+ * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+ * @param[in] device_row_offset the first row this device is responsible for
  * @param[in] alpha the scalar alpha value
  * @param[in] A the matrix @p A
  * @param[in] B the matrix @p B
@@ -125,68 +126,72 @@ __global__ void device_kernel_symm(const unsigned long long num_rows, const unsi
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_symm_mirror(const unsigned long long num_rows, const unsigned long long num_rhs, const unsigned long long num_mirror_rows, const unsigned long long device_specific_num_rows, const unsigned long long row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;  // # rhs -> num_rhs
-    const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;  // # rows -> num_mirror_rows
-    const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-
-    // create the shared memory arrays used for caching data point features
-    __shared__ real_type A_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __shared__ real_type B_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+__global__ void device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type A_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type B_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // create a thread private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
-    // iterate over the remaining features using blocking to be able to cache them for faster memory accesses
-    for (unsigned long long dim = 0; dim < device_specific_num_rows; dim += FEATURE_BLOCK_SIZE_ull) {
-        // load data into shared memory
-        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const auto global_i = i_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-            const auto global_j = j_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-
-            // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-            A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim + threadIdx_y) * (num_rows - row_offset + PADDING_SIZE_ull) - (dim + threadIdx_y - 1ull) * (dim + threadIdx_y) / 2ull + device_specific_num_rows - (dim + threadIdx_y) + global_j];
-            A_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows - row_offset + PADDING_SIZE_ull) - (dim + threadIdx_y + THREAD_BLOCK_SIZE_ull - 1ull) * (dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) / 2ull + device_specific_num_rows - (dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) + global_j];
-            B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(row_offset + dim + threadIdx_y) * (num_rhs + PADDING_SIZE_ull) + global_i];
-            B_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(row_offset + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rhs + PADDING_SIZE_ull) + global_i];
-        }
-        __syncthreads();  // wait until all threads loaded their part of the data
-
-        // perform the feature reduction calculation
-        for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    temp[internal_i][internal_j] += A_cache[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i];
+    {
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rhs
+        const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_mirror_rows
+
+        // iterate over the remaining values using blocking to be able to cache them for faster memory accesses
+        for (std::size_t dim_block = 0; dim_block < device_num_rows; dim_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into shared memory
+            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the shared memory
+                A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim_block + threadIdx_y) * (num_rows - device_row_offset + PADDING_SIZE_uz) - (dim_block + threadIdx_y - std::size_t{ 1 }) * (dim_block + threadIdx_y) / std::size_t{ 2 } + device_num_rows - (dim_block + threadIdx_y) + global_j_idx_linear];  // SoA, upper triangular matrix only
+                B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(device_row_offset + dim_block + threadIdx_y) * (num_rhs + PADDING_SIZE_uz) + global_i_idx_linear];                                                                                                                                               // SoA
+            }
+            __syncthreads();  // wait until all threads loaded their part of the data
+
+            // perform the dot product calculation
+            for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        temp[internal_i][internal_j] += A_cache[dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i];
+                    }
                 }
             }
+            __syncthreads();  // wait until all threads performed their part of the calculations
         }
-        __syncthreads();  // wait until all threads performed their part of the calculations
     }
 
+    // calculate the indices used in the current thread
+    const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+    const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
+
     // apply the (remaining) BLAS operation and update C
     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const auto global_i = i + static_cast<unsigned long long>(internal_i);
-            const auto partial_global_j = j + static_cast<unsigned long long>(internal_j);
-            const auto global_j = row_offset + device_specific_num_rows + j + static_cast<unsigned long long>(internal_j);
-
-            // be sure to not perform out of bounds accesses
-            if (global_i < num_rhs && partial_global_j < num_mirror_rows) {
-                C[global_j * (num_rhs + PADDING_SIZE_ull) + global_i] = alpha * temp[internal_i][internal_j] + beta * C[global_j * (num_rhs + PADDING_SIZE_ull) + global_i];
+            // calculate the indices to access the global data and the data with respect to the current device
+            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+            const auto partial_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+            const auto global_j_idx = device_row_offset + device_num_rows + partial_global_j_idx;
+
+            // be sure to not perform out-of-bounds accesses
+            if (global_i_idx < num_rhs && partial_global_j_idx < num_mirror_rows) {
+                C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx] = alpha * temp[internal_i][internal_j] + beta * C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx];  // SoA
             }
         }
     }
@@ -200,27 +205,29 @@ __global__ void device_kernel_symm_mirror(const unsigned long long num_rows, con
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_inplace_matrix_add(const unsigned long long num_cols, real_type *lhs, const real_type *rhs, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
+__global__ void device_kernel_inplace_matrix_add(const std::size_t num_cols, real_type *lhs, const real_type *rhs, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
 
     // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;  // # num_rows
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;  // # num_rhs
+    const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+    const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const auto global_i = i + static_cast<unsigned long long>(internal_i);
-            const auto global_j = j + static_cast<unsigned long long>(internal_j);
+            // calculate the indices to access the global data
+            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+            const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-            lhs[global_i * (num_cols + PADDING_SIZE_ull) + global_j] += rhs[global_i * (num_cols + PADDING_SIZE_ull) + global_j];
+            lhs[global_i_idx * (num_cols + PADDING_SIZE_uz) + global_j_idx] += rhs[global_i_idx * (num_cols + PADDING_SIZE_uz) + global_j_idx];  // SoA
         }
     }
 }
@@ -233,27 +240,29 @@ __global__ void device_kernel_inplace_matrix_add(const unsigned long long num_co
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_inplace_matrix_scale(const unsigned long long num_cols, real_type *lhs, const real_type scale, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
+__global__ void device_kernel_inplace_matrix_scale(const std::size_t num_cols, real_type *lhs, const real_type scale, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
 
     // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;  // # num_rows
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;  // # num_rhs
+    const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+    const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const auto global_i = i + static_cast<unsigned long long>(internal_i);
-            const auto global_j = j + static_cast<unsigned long long>(internal_j);
+            // calculate the indices to access the global data
+            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+            const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-            lhs[global_i * (num_cols + PADDING_SIZE_ull) + global_j] *= scale;
+            lhs[global_i_idx * (num_cols + PADDING_SIZE_uz) + global_j_idx] *= scale;  // SoA
         }
     }
 }
diff --git a/include/plssvm/backends/CUDA/kernel/cg_explicit/kernel_matrix_assembly.cuh b/include/plssvm/backends/CUDA/kernel/cg_explicit/kernel_matrix_assembly.cuh
index 8a766b7db..8037226c7 100644
--- a/include/plssvm/backends/CUDA/kernel/cg_explicit/kernel_matrix_assembly.cuh
+++ b/include/plssvm/backends/CUDA/kernel/cg_explicit/kernel_matrix_assembly.cuh
@@ -14,20 +14,22 @@
 #pragma once
 
 #include "plssvm/backends/CUDA/kernel/kernel_functions.cuh"  // plssvm::cuda::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
 
+#include <cstddef>  // std::size_t
+
 namespace plssvm::cuda::detail {
 
 /**
  * @brief Create the explicit kernel matrix using the @p kernel_function.
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
- * @param[out] kernel_matrix_d the calculated kernel matrix
- * @param[in] data_d the data points to calculate the kernel matrix from
+ * @param[out] kernel_matrix the calculated kernel matrix
+ * @param[in] data the data points to calculate the kernel matrix from
  * @param[in] num_rows the total number of data points (= total number of rows)
  * @param[in] device_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data_d the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data the current device is responsible for
  * @param[in] num_features the number of features per data point
  * @param[in] q the vector used in the dimensional reduction
  * @param[in] QA_cost the scalar used in the dimensional reduction
@@ -37,80 +39,84 @@ namespace plssvm::cuda::detail {
  * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
  */
 template <kernel_function_type kernel_function, typename... Args>
-__global__ void device_kernel_assembly(real_type *kernel_matrix_d, const real_type *data_d, const unsigned long long num_rows, const unsigned long long device_num_rows, const unsigned long long row_offset, const unsigned long long num_features, const real_type *q, const real_type QA_cost, const real_type cost, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset, Args... kernel_function_parameter) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;
-    const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;
-    const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-
-    // create the shared memory arrays used for caching data point features
-    __shared__ real_type data_cache_i[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __shared__ real_type data_cache_j[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+__global__ void device_kernel_assembly(real_type *kernel_matrix, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type *q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type data_i_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type data_j_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // only calculate the upper triangular matrix -> can't use threadIdx since all threads in a warp must progress further
     if (blockIdx_x >= blockIdx_y) {
         // create a thread private array used for internal caching
         real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (unsigned long long dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ull) {
-            // load data into shared memory
-            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_i = row_offset + i_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-                const auto global_j = row_offset + j_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                data_cache_i[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y) * (num_rows + 1ull + PADDING_SIZE_ull) + global_i];
-                data_cache_i[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows + 1ull + PADDING_SIZE_ull) + global_i];
-                data_cache_j[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y) * (num_rows + 1ull + PADDING_SIZE_ull) + global_j];
-                data_cache_j[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows + 1ull + PADDING_SIZE_ull) + global_j];
-            }
-            __syncthreads();  // wait until all threads loaded their part of the data
-
-            // perform the feature reduction calculation
-            for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i],
-                                                                                                data_cache_j[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j]);
+        {
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rows - device_row_offset
+            const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
+
+            // iterate over all features using blocking to be able to cache them for faster memory accesses
+            for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into shared memory
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = device_row_offset + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_j_idx_linear = device_row_offset + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the shared memory
+                    data_i_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data[(feature_block + threadIdx_y) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                    data_j_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data[(feature_block + threadIdx_y) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
+                }
+                __syncthreads();  // wait until all threads loaded their part of the data
+
+                // perform the feature reduction calculation
+                for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache[feature][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                    data_j_cache[feature][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j]);
+                        }
                     }
                 }
+                __syncthreads();  // wait until all threads performed their part of the calculations
             }
-            __syncthreads();  // wait until all threads performed their part of the calculations
         }
 
+        // calculate the indices used in the current thread
+        const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+        const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
         // apply the remaining part of the kernel function and store the value in the output kernel matrix
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                // calculate the indices to access the kernel matrix (the part stored on the current device)
-                const auto device_global_i = i + static_cast<unsigned long long>(internal_i);
-                const auto global_i = row_offset + i + static_cast<unsigned long long>(internal_i);
-                const auto device_global_j = j + static_cast<unsigned long long>(internal_j);
-                const auto global_j = row_offset + j + static_cast<unsigned long long>(internal_j);
-
-                // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                if (device_global_i < (num_rows - row_offset) && device_global_j < device_num_rows && global_i >= global_j) {
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_i_idx = device_row_offset + device_global_i_idx;
+                const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
                     real_type temp_ij = temp[internal_i][internal_j];
-                    temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter...) + QA_cost - q[global_i] - q[global_j];
+                    // apply the final kernel function
+                    temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter...) + QA_cost - q[global_i_idx] - q[global_j_idx];
                     // apply the cost on the diagonal
-                    if (global_i == global_j) {
+                    if (global_i_idx == global_j_idx) {
                         temp_ij += cost;
                     }
-                    // update the kernel matrix
-                    kernel_matrix_d[device_global_j * (num_rows - row_offset + PADDING_SIZE_ull) - device_global_j * (device_global_j + 1ull) / 2ull + device_global_i] = temp_ij;
+                    // update the upper triangular kernel matrix
+                    kernel_matrix[device_global_j_idx * (num_rows - device_row_offset + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i_idx] = temp_ij;
                 }
             }
         }
diff --git a/include/plssvm/backends/CUDA/kernel/cg_implicit/kernel_matrix_assembly_blas.cuh b/include/plssvm/backends/CUDA/kernel/cg_implicit/kernel_matrix_assembly_blas.cuh
index 62f24d6bf..72147e55c 100644
--- a/include/plssvm/backends/CUDA/kernel/cg_implicit/kernel_matrix_assembly_blas.cuh
+++ b/include/plssvm/backends/CUDA/kernel/cg_implicit/kernel_matrix_assembly_blas.cuh
@@ -13,10 +13,13 @@
 #define PLSSVM_BACKENDS_CUDA_KERNEL_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_CUH_
 #pragma once
 
-#include "plssvm/backends/CUDA/kernel/detail/atomics.cuh"    // atomicAdd for double precision floating point numbers on older CUDA hardware
-#include "plssvm/backends/CUDA/kernel/kernel_functions.cuh"  // plssvm::cuda::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
-#include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/backends/CUDA/kernel/detail/atomics.cuh"            // atomicAdd for double precision floating point numbers on older CUDA hardware
+#include "plssvm/backends/CUDA/kernel/detail/reinterpret_array.cuh"  // plssvm::cuda::detail::reinterpret_array
+#include "plssvm/backends/CUDA/kernel/kernel_functions.cuh"          // plssvm::cuda::detail::{feature_reduce, apply_kernel_function}
+#include "plssvm/constants.hpp"                                      // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/kernel_function_types.hpp"                          // plssvm::kernel_function_type
+
+#include <cstddef>  // std::size_t
 
 namespace plssvm::cuda::detail {
 
@@ -26,10 +29,10 @@ namespace plssvm::cuda::detail {
  * @tparam Args the types of the parameters necessary for the specific kernel function
  * @param[in] alpha the scalar alpha value
  * @param[in] q the vector used in the dimensional reduction
- * @param[in] data_d the data points to calculate the implicit kernel matrix from
+ * @param[in] data the data points to calculate the implicit kernel matrix from
  * @param[in] num_rows the total number of data points (= total number of rows)
  * @param[in] device_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data_d the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data the current device is responsible for
  * @param[in] num_features the number of features per data point
  * @param[in] QA_cost the scalar used in the dimensional reduction
  * @param[in] cost the cost factor the diagonal is scaled with
@@ -41,56 +44,64 @@ namespace plssvm::cuda::detail {
  * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
  */
 template <kernel_function_type kernel_function, typename... Args>
-__global__ void device_kernel_assembly_symm(const real_type alpha, const real_type *q, const real_type *data_d, const unsigned long long num_rows, const unsigned long long device_num_rows, const unsigned long long row_offset, const unsigned long long num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const unsigned long long num_classes, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset, Args... kernel_function_parameter) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
+__global__ void device_kernel_assembly_symm(const real_type alpha, const real_type *q, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
 
     // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;
-    const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;
-    const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
+    const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+    const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
+    // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+    const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rows - device_row_offset
+    const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type cache_one[THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type cache_two[THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // only calculate the upper triangular matrix -> can't use threadIdx since all threads in a warp must progress further
     if (blockIdx_x >= blockIdx_y) {
         // create a thread private array used for internal caching
         real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
+        //*************************************************************************//
+        //                   inplace kernel matrix construction                    //
+        //*************************************************************************//
         {
-            // create the shared memory arrays used for caching data point features
-            __shared__ real_type data_cache_i[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-            __shared__ real_type data_cache_j[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+            // reinterpret the shared memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+            auto *data_i_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_one);
+            auto *data_j_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_two);
 
             // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (unsigned long long dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ull) {
+            for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
                 // load data into shared memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_i = row_offset + i_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-                    const auto global_j = row_offset + j_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    data_cache_i[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y) * (num_rows + 1ull + PADDING_SIZE_ull) + global_i];
-                    data_cache_i[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows + 1ull + PADDING_SIZE_ull) + global_i];
-                    data_cache_j[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y) * (num_rows + 1ull + PADDING_SIZE_ull) + global_j];
-                    data_cache_j[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows + 1ull + PADDING_SIZE_ull) + global_j];
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = device_row_offset + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_j_idx_linear = device_row_offset + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the shared memory
+                    data_i_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data[(feature_block + threadIdx_y) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                    data_j_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data[(feature_block + threadIdx_y) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
                 }
                 __syncthreads();  // wait until all threads loaded their part of the data
 
                 // perform the feature reduction calculation
-                for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
                     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i],
-                                                                                                    data_cache_j[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j]);
+                            temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache[feature][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                    data_j_cache[feature][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j]);
                         }
                     }
                 }
@@ -101,16 +112,18 @@ __global__ void device_kernel_assembly_symm(const real_type alpha, const real_ty
         // apply the remaining part of the kernel function and store the value in the output kernel matrix
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = row_offset + i + static_cast<unsigned long long>(internal_i);
-                const auto device_global_i = i + static_cast<unsigned long long>(internal_i);
-                const auto global_j = row_offset + j + static_cast<unsigned long long>(internal_j);
-                const auto device_global_j = j + static_cast<unsigned long long>(internal_j);
-
-                // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                if ((device_global_i < (num_rows - row_offset) && device_global_j < device_num_rows && global_i >= global_j)) {
-                    temp[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp[internal_i][internal_j], kernel_function_parameter...) + QA_cost - q[global_i] - q[global_j];
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_i_idx = device_row_offset + device_global_i_idx;
+                const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
+                    // apply the final kernel function
+                    temp[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp[internal_i][internal_j], kernel_function_parameter...) + QA_cost - q[global_i_idx] - q[global_j_idx];
                     // apply the cost on the diagonal
-                    if (global_i == global_j) {
+                    if (global_i_idx == global_j_idx) {
                         temp[internal_i][internal_j] += cost;
                     }
                 } else {
@@ -120,95 +133,101 @@ __global__ void device_kernel_assembly_symm(const real_type alpha, const real_ty
             }
         }
 
-        // calculate C += alpha * temp * B for the UPPER triangular matrix
+        //*************************************************************************//
+        //     calculate C += alpha * temp * B for the UPPER triangular matrix     //
+        //*************************************************************************//
         {
-            // same shared memory size but with different dimensions
-            __shared__ real_type B_cache[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][FEATURE_BLOCK_SIZE];
-            __shared__ real_type C_out_cache[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][FEATURE_BLOCK_SIZE];
+            // reinterpret the shared memory arrays to be of shape [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][THREAD_BLOCK_SIZE]
+            auto *B_cache = reinterpret_array<THREAD_BLOCK_SIZE>(cache_one);
+            auto *C_out_cache = reinterpret_array<THREAD_BLOCK_SIZE>(cache_two);
 
             // iterate over all classes using blocking to be able to cache them for faster memory accesses
-            for (unsigned long long dim = 0; dim < num_classes; dim += FEATURE_BLOCK_SIZE_ull) {
+            for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
                 // load data into shared memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_i = row_offset + i_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = device_row_offset + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    B_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y] = alpha * B[global_i * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y];
-                    B_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y + THREAD_BLOCK_SIZE] = alpha * B[global_i * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull];
-                    C_out_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y] = real_type{ 0.0 };
-                    C_out_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y + THREAD_BLOCK_SIZE] = real_type{ 0.0 };
+                    // store the values in the shared memory
+                    B_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y] = alpha * B[global_i_idx_linear * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y];  // SoA
+                    C_out_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y] = real_type{ 0.0 };                                                                          // SoA
                 }
                 __syncthreads();  // wait until all threads loaded their part of the data
 
                 // calculate intermediate results and store them in shared memory
-                for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            C_out_cache[threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j][(class_idx + threadIdx.x) % FEATURE_BLOCK_SIZE] +=
-                                temp[internal_i][internal_j] * B_cache[threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i][(class_idx + threadIdx.x) % FEATURE_BLOCK_SIZE];
+                            C_out_cache[threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j][(class_idx + threadIdx.x) % THREAD_BLOCK_SIZE] +=
+                                temp[internal_i][internal_j] * B_cache[threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i][(class_idx + threadIdx.x) % THREAD_BLOCK_SIZE];
                         }
                     }
                     __syncthreads();  // wait until all threads performed their part of the calculations
                 }
 
-                // add intermediate cached results to C
+                // atomically add the intermediate cached results to the C matrix
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_j = row_offset + j + static_cast<unsigned long long>(internal);
-                    atomicAdd(&C[global_j * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_x], C_out_cache[threadIdx.y * INTERNAL_BLOCK_SIZE + internal][threadIdx.x]);
-                    atomicAdd(&C[global_j * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_x + THREAD_BLOCK_SIZE_ull], C_out_cache[threadIdx.y * INTERNAL_BLOCK_SIZE + internal][threadIdx.x + THREAD_BLOCK_SIZE]);
+                    // calculate the indices to access the global data
+                    const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal);
+
+                    atomicAdd(&C[global_j_idx * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_x], C_out_cache[threadIdx.y * INTERNAL_BLOCK_SIZE + internal][threadIdx.x]);  // SoA
                 }
-                __syncthreads();  // wai until all threads updated C with their values
+                __syncthreads();  // wait until all threads updated C with their values
             }
         }
 
         // set potential diagonal entries in temp to 0.0 such that we don't apply the main diagonal twice to C
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = row_offset + i + static_cast<unsigned long long>(internal_i);
-                const auto global_j = row_offset + j + static_cast<unsigned long long>(internal_j);
+                // calculate the indices to access the global data
+                const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
 
-                if (global_i == global_j) {
+                // update the diagonal
+                if (global_i_idx == global_j_idx) {
                     temp[internal_i][internal_j] = real_type{ 0.0 };
                 }
             }
         }
 
-        // calculate C += alpha * temp * B for the LOWER triangular matrix
+        //*************************************************************************//
+        //     calculate C += alpha * temp * B for the LOWER triangular matrix     //
+        //*************************************************************************//
         {
-            // same shared memory size but with different dimensions
-            __shared__ real_type B_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-            __shared__ real_type C_out_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+            // reinterpret the shared memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+            auto *B_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_one);
+            auto *C_out_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_two);
 
             // iterate over all classes using blocking to be able to cache them for faster memory accesses
-            for (unsigned long long dim = 0; dim < num_classes; dim += FEATURE_BLOCK_SIZE_ull) {
+            for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
                 // load data into shared memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_j = row_offset + j_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_j_idx_linear = device_row_offset + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha * B[global_j * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y];
-                    B_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha * B[global_j * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull];
+                    // store the values in the shared memory
+                    B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha * B[global_j_idx_linear * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y];  // SoA
                     C_out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = real_type{ 0.0 };
-                    C_out_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = real_type{ 0.0 };
                 }
                 __syncthreads();  // wait until all threads loaded their part of the data
 
                 // calculate intermediate results and store them in shared memory
-                for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            C_out_cache[(class_idx + threadIdx.y) % FEATURE_BLOCK_SIZE][internal_i * THREAD_BLOCK_SIZE + threadIdx.x] +=
-                                temp[internal_i][internal_j] * B_cache[(class_idx + threadIdx.y) % FEATURE_BLOCK_SIZE][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j];
+                            C_out_cache[(class_idx + threadIdx.y) % THREAD_BLOCK_SIZE][internal_i * THREAD_BLOCK_SIZE + threadIdx.x] +=
+                                temp[internal_i][internal_j] * B_cache[(class_idx + threadIdx.y) % THREAD_BLOCK_SIZE][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j];
                         }
                     }
                     __syncthreads();  // wait until all threads performed their part of the calculations
                 }
 
-                // add intermediate cached results to C
+                // atomically add the intermediate cached results to the C matrix
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_i = row_offset + i + static_cast<unsigned long long>(internal);
-                    atomicAdd(&C[global_i * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y], C_out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x]);
-                    atomicAdd(&C[global_i * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull], C_out_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x]);
+                    // calculate the indices to access the global data
+                    const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal);
+
+                    atomicAdd(&C[global_i_idx * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y], C_out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x]);  // SoA
                 }
                 __syncthreads();  // wait until all threads updated C with their values
             }
diff --git a/include/plssvm/backends/CUDA/kernel/detail/atomics.cuh b/include/plssvm/backends/CUDA/kernel/detail/atomics.cuh
index c31732a29..f33ff7ff8 100644
--- a/include/plssvm/backends/CUDA/kernel/detail/atomics.cuh
+++ b/include/plssvm/backends/CUDA/kernel/detail/atomics.cuh
@@ -9,8 +9,8 @@
  * @brief Defines an atomic add function for double precision floating point types for older CUDA architectures.
  */
 
-#ifndef PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_ATOMICS_HPP_
-#define PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_ATOMICS_HPP_
+#ifndef PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_ATOMICS_CUH_
+#define PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_ATOMICS_CUH_
 #pragma once
 
 namespace plssvm::cuda::detail {
@@ -36,4 +36,4 @@ __device__ __forceinline__ double atomicAdd(double *addr, const double val) {
 
 }  // namespace plssvm::cuda::detail
 
-#endif  // PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_ATOMICS_HPP_
+#endif  // PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_ATOMICS_CUH_
diff --git a/include/plssvm/backends/CUDA/kernel/detail/fill_kernel.cuh b/include/plssvm/backends/CUDA/kernel/detail/fill_kernel.cuh
index d45d20155..819fd2ee9 100644
--- a/include/plssvm/backends/CUDA/kernel/detail/fill_kernel.cuh
+++ b/include/plssvm/backends/CUDA/kernel/detail/fill_kernel.cuh
@@ -9,10 +9,12 @@
  * @brief Defines a CUDA function for filling a device pointer with a specific value.
  */
 
-#ifndef PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_FILL_KERNEL_HPP_
-#define PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_FILL_KERNEL_HPP_
+#ifndef PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_FILL_KERNEL_CUH_
+#define PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_FILL_KERNEL_CUH_
 #pragma once
 
+// NOLINTBEGIN(misc-use-internal-linkage): false positive diagnostic for .cuh files
+
 namespace plssvm::cuda::detail {
 
 /**
@@ -35,4 +37,6 @@ __global__ void fill_array(value_type *data, const value_type value, const size_
 
 }  // namespace plssvm::cuda::detail
 
-#endif  // PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_FILL_KERNEL_HPP_
+// NOLINTEND(misc-use-internal-linkage)
+
+#endif  // PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_FILL_KERNEL_CUH_
diff --git a/include/plssvm/backends/CUDA/kernel/detail/reinterpret_array.cuh b/include/plssvm/backends/CUDA/kernel/detail/reinterpret_array.cuh
new file mode 100644
index 000000000..eb39e4500
--- /dev/null
+++ b/include/plssvm/backends/CUDA/kernel/detail/reinterpret_array.cuh
@@ -0,0 +1,49 @@
+/**
+ * @file
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Defines a utility function to reinterpret a 2D array inside a CUDA kernel.
+ */
+
+#ifndef PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_REINTERPRET_ARRAY_CUH_
+#define PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_REINTERPRET_ARRAY_CUH_
+#pragma once
+
+#include <cstddef>  // std::size_t
+
+namespace plssvm::cuda::detail {
+
+/**
+ * @brief Given the input array of dimensions [N][M], reinterpret it to be of dimensions [...][SIZE].
+ * @tparam SIZE the new y-dimension size of the array
+ * @tparam T the type of the values in the array
+ * @tparam N the x-dimension of the array
+ * @tparam M the y-dimension of the array
+ * @param[in] input the array to reinterpret
+ * @return the array of the newly specified dimensions (`[[nodiscard]]`)
+ */
+template <std::size_t SIZE, typename T, std::size_t N, std::size_t M>
+inline __device__ auto *reinterpret_array(T (&input)[N][M]) noexcept {
+    return reinterpret_cast<T(*)[SIZE]>(input);  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast): reinterpret_cast necessary
+}
+
+/**
+ * @brief Given the input array of dimensions [N], reinterpret it to be of dimensions [...][SIZE].
+ * @tparam SIZE the new y-dimension size of the array
+ * @tparam T the type of the values in the array
+ * @tparam N the dimension of the array
+ * @param[in] input the array to reinterpret
+ * @return the array of the newly specified dimensions (`[[nodiscard]]`)
+ */
+template <std::size_t SIZE, typename T, std::size_t N>
+inline __device__ auto *reinterpret_array(T (&input)[N]) noexcept {
+    return reinterpret_cast<T(*)[SIZE]>(input);  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast): reinterpret_cast necessary
+}
+
+}  // namespace plssvm::cuda::detail
+
+#endif  // PLSSVM_BACKENDS_CUDA_KERNEL_DETAIL_REINTERPRET_ARRAY_CUH_
diff --git a/include/plssvm/backends/CUDA/kernel/kernel_functions.cuh b/include/plssvm/backends/CUDA/kernel/kernel_functions.cuh
index 8003a51a3..758883251 100644
--- a/include/plssvm/backends/CUDA/kernel/kernel_functions.cuh
+++ b/include/plssvm/backends/CUDA/kernel/kernel_functions.cuh
@@ -9,8 +9,8 @@
  * @brief Implement the different kernel functions on the GPU using CUDA.
  */
 
-#ifndef PLSSVM_BACKENDS_CUDA_KERNEL_KERNEL_FUNCTIONS_HPP_
-#define PLSSVM_BACKENDS_CUDA_KERNEL_KERNEL_FUNCTIONS_HPP_
+#ifndef PLSSVM_BACKENDS_CUDA_KERNEL_KERNEL_FUNCTIONS_CUH_
+#define PLSSVM_BACKENDS_CUDA_KERNEL_KERNEL_FUNCTIONS_CUH_
 #pragma once
 
 #include "plssvm/constants.hpp"              // plssvm::real_type
@@ -51,42 +51,17 @@ template <>
 
 /**
  * @brief Fast integer power function. Computes base^exponent and takes advantage of the fact that degree may only be positive integer values.
- * @details Hardcodes the power function for degree <= 6, uses a simple for loop otherwise.
  * @param[in] base the base
  * @param[in] exponent the exponent
  * @return base^exponent (`[[nodiscard]]`)
  */
 [[nodiscard]] __device__ __forceinline__ real_type powi(const real_type base, const int exponent) {
-    switch (exponent) {
-        case 0: return real_type{ 1.0 };
-        case 1: return base;
-        case 2: return base * base;
-        case 3: return base * base * base;
-        case 4:
-            {
-                const real_type temp = base * base;
-                return temp * temp;
-            }
-        case 5:
-            {
-                const real_type temp = base * base;
-                return temp * temp * base;
-            }
-        case 6:
-            {
-                const real_type temp = base * base * base;
-                return temp * temp;
-            }
-        default:
-            {
-                // generic integer power function
-                real_type result{ 1.0 };
-                for (int i = 0; i < exponent; ++i) {
-                    result *= base;
-                }
-                return result;
-            }
+    // generic integer power function
+    real_type result{ 1.0 };
+    for (int i = 0; i < exponent; ++i) {
+        result *= base;
     }
+    return result;
 }
 
 //***************************************************//
@@ -221,4 +196,4 @@ template <>
 
 }  // namespace plssvm::cuda::detail
 
-#endif  // PLSSVM_BACKENDS_CUDA_KERNEL_KERNEL_FUNCTIONS_HPP_
+#endif  // PLSSVM_BACKENDS_CUDA_KERNEL_KERNEL_FUNCTIONS_CUH_
diff --git a/include/plssvm/backends/CUDA/kernel/predict_kernel.cuh b/include/plssvm/backends/CUDA/kernel/predict_kernel.cuh
index 204d6bd97..4a41d1bc0 100644
--- a/include/plssvm/backends/CUDA/kernel/predict_kernel.cuh
+++ b/include/plssvm/backends/CUDA/kernel/predict_kernel.cuh
@@ -9,172 +9,187 @@
  * @brief Defines the functions used for prediction for the C-SVM using the CUDA backend.
  */
 
-#ifndef PLSSVM_BACKENDS_CUDA_KERNEL_PREDICT_KERNEL_HPP_
-#define PLSSVM_BACKENDS_CUDA_KERNEL_PREDICT_KERNEL_HPP_
+#ifndef PLSSVM_BACKENDS_CUDA_KERNEL_PREDICT_KERNEL_CUH_
+#define PLSSVM_BACKENDS_CUDA_KERNEL_PREDICT_KERNEL_CUH_
 #pragma once
 
-#include "plssvm/backends/CUDA/kernel/detail/atomics.cuh"    // atomicAdd for double precision floating point numbers on older CUDA hardware
-#include "plssvm/backends/CUDA/kernel/kernel_functions.cuh"  // plssvm::cuda::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
-#include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/backends/CUDA/kernel/detail/atomics.cuh"            // atomicAdd for double precision floating point numbers on older CUDA hardware
+#include "plssvm/backends/CUDA/kernel/detail/reinterpret_array.cuh"  // plssvm::cuda::detail::reinterpret_array
+#include "plssvm/backends/CUDA/kernel/kernel_functions.cuh"          // plssvm::cuda::detail::{feature_reduce, apply_kernel_function}
+#include "plssvm/constants.hpp"                                      // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/kernel_function_types.hpp"                          // plssvm::kernel_function_type
+
+#include <cstddef>  // std::size_t
 
 namespace plssvm::cuda::detail {
 
 /**
  * @brief Calculate the `w` vector used to speedup the prediction using the linear kernel function.
- * @param[out] w_d the vector to speedup the linear prediction
- * @param[in] alpha_d the previously learned weights
- * @param[in] sv_d the support vectors
+ * @param[out] w the vector to speedup the linear prediction
+ * @param[in] alpha the previously learned weights
+ * @param[in] support_vectors the support vectors
  * @param[in] num_classes the number of classes
  * @param[in] num_sv the number of support vectors
- * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
- * @param[in] sv_offset the first support vector (row in @p alpha_d) the current device is responsible for
+ * @param[in] device_num_sv the number of support vectors the current device is responsible for
+ * @param[in] device_sv_offset the first support vector (row in @p alpha) the current device is responsible for
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_w_linear(real_type *w_d, const real_type *alpha_d, const real_type *sv_d, const unsigned long long num_classes, const unsigned long long num_sv, const unsigned long long device_specific_num_sv, const unsigned long long sv_offset, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto feature_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;
-    const auto feature_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;
-    const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-
-    // create the shared memory arrays used for caching data point features
-    __shared__ real_type data_cache_feature[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __shared__ real_type data_cache_alpha[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+__global__ void device_kernel_w_linear(real_type *w, const real_type *alpha, const real_type *support_vectors, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_num_sv, const std::size_t device_sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type feature_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type alpha_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // create a thread private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
-    // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-    for (unsigned long long sv = 0; sv < device_specific_num_sv; sv += THREAD_BLOCK_SIZE_ull) {
-        // load data into shared memory
-        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const auto global_feature_idx = feature_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-            const auto global_class_idx = class_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
+    {
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto feature_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_features
+        const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;    // num_classes
 
-            data_cache_feature[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = sv_d[global_feature_idx * (device_specific_num_sv + PADDING_SIZE_ull) + sv + threadIdx_y];  // SoA
-            data_cache_alpha[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha_d[global_class_idx * (num_sv + PADDING_SIZE_ull) + sv + sv_offset + threadIdx_y];       // AoS
-        }
-        __syncthreads();  // wait until all threads loaded their part of the data
+        // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
+        for (std::size_t sv_block = 0; sv_block < device_num_sv; sv_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into shared memory
+            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_feature_idx_linear = feature_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-        // perform the dot product calculation
-        for (unsigned block_dim = 0; block_dim < THREAD_BLOCK_SIZE; ++block_dim) {
-            for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
-                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    temp[internal_feature][internal_class] += data_cache_alpha[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_feature[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_feature];
+                // store the values in the shared memory
+                feature_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = support_vectors[global_feature_idx_linear * (device_num_sv + PADDING_SIZE_uz) + sv_block + threadIdx_y];  // SoA
+                alpha_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha[global_class_idx_linear * (num_sv + PADDING_SIZE_uz) + sv_block + device_sv_offset + threadIdx_y];    // AoS
+            }
+            __syncthreads();  // wait until all threads loaded their part of the data
+
+            // perform the dot product calculation
+            for (unsigned sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                    for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                        temp[internal_feature][internal_class] += alpha_cache[sv][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_class] * feature_cache[sv][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_feature];
+                    }
                 }
             }
+            __syncthreads();  // wait until all threads performed their part of the calculations
         }
-        __syncthreads();  // wait until all threads performed their part of the calculations
     }
 
-    // update global array with local one
+    // calculate the indices used in the current thread
+    const auto feature_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+    const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;    // num_classes
+
+    // update the global w-vector with the locally cached values
     for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
         for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-            const auto global_feature_idx = feature_idx + static_cast<unsigned long long>(internal_feature);
-            const auto global_class_idx = class_idx + static_cast<unsigned long long>(internal_class);
+            // calculate the indices to access the global data
+            const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+            const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-            w_d[global_feature_idx * (num_classes + PADDING_SIZE_ull) + global_class_idx] = temp[internal_feature][internal_class];
+            w[global_feature_idx * (num_classes + PADDING_SIZE_uz) + global_class_idx] = temp[internal_feature][internal_class];  // SoA
         }
     }
 }
 
 /**
- * @brief Predict the @p predict_points_d using the linear kernel speeding up the calculation using the @p w_d vector.
- * @param[out] prediction_d the predicted values
- * @param[in] w_d the vector to speedup the calculations
- * @param[in] rho_d the previously learned bias
- * @param[in] predict_points_d the data points to predict
+ * @brief Predict the @p predict_points using the linear kernel speeding up the calculation using the @p w vector.
+ * @param[out] prediction the predicted values
+ * @param[in] w the vector to speedup the calculations
+ * @param[in] rho the previously learned bias
+ * @param[in] predict_points the data points to predict
  * @param[in] num_classes the number of classes
  * @param[in] num_predict_points the number of data points to predict
  * @param[in] num_features the number of features per data point
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_predict_linear(real_type *prediction_d, const real_type *w_d, const real_type *rho_d, const real_type *predict_points_d, const unsigned long long num_classes, const unsigned long long num_predict_points, const unsigned long long num_features, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;
-    const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;
-    const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-
-    // create the shared memory arrays used for caching data point features
-    __shared__ real_type data_cache_pp[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __shared__ real_type data_cache_w[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+__global__ void device_kernel_predict_linear(real_type *prediction, const real_type *w, const real_type *rho, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type pp_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type w_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // create a thread private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
-    // iterate over all features using blocking to be able to cache them for faster memory accesses
-    for (unsigned long long dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ull) {
-        // load data into shared memory
-        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const auto global_pp_idx = pp_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-            const auto global_class_idx = class_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-
-            // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-            data_cache_pp[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points_d[(dim + threadIdx_y) * (num_predict_points + PADDING_SIZE_ull) + global_pp_idx];
-            data_cache_pp[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_predict_points + PADDING_SIZE_ull) + global_pp_idx];
-            data_cache_w[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = w_d[(dim + threadIdx_y) * (num_classes + PADDING_SIZE_ull) + global_class_idx];
-            data_cache_w[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = w_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_classes + PADDING_SIZE_ull) + global_class_idx];
-        }
-        __syncthreads();  // wait until all threads loaded their part of the data
+    {
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;     // num_predict_points
+        const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_classes
+
+        // iterate over all features using blocking to be able to cache them for faster memory accesses
+        for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into shared memory
+            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-        // perform the dot product calculation
-        for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-            for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
-                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    temp[internal_pd][internal_class] += data_cache_w[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_pp[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_pd];
+                // store the values in the shared memory
+                pp_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points[(feature_block + threadIdx_y) * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                w_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = w[(feature_block + threadIdx_y) * (num_classes + PADDING_SIZE_uz) + global_class_idx_linear];                    // SoA
+            }
+            __syncthreads();  // wait until all threads loaded their part of the data
+
+            // perform the dot product calculation
+            for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                    for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                        temp[internal_pp][internal_class] += w_cache[feature][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_class] * pp_cache[feature][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_pp];
+                    }
                 }
             }
+            __syncthreads();  // wait until all threads performed their part of the calculations
         }
-        __syncthreads();  // wait until all threads performed their part of the calculations
     }
 
-    // update global array with local one
-    for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+    // calculate the indices used in the current thread
+    const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;     // num_predict_points
+    const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
+
+    // update the global array with the local one
+    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
         for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-            const auto global_pp_idx = pp_idx + static_cast<unsigned long long>(internal_pd);
-            const auto global_class_idx = class_idx + static_cast<unsigned long long>(internal_class);
+            // calculate the indices to access the global data
+            const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
+            const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-            prediction_d[global_pp_idx * (num_classes + PADDING_SIZE_ull) + global_class_idx] = temp[internal_pd][internal_class] - rho_d[global_class_idx];
+            prediction[global_pp_idx * (num_classes + PADDING_SIZE_uz) + global_class_idx] = temp[internal_pp][internal_class] - rho[global_class_idx];  // AoS
         }
     }
 }
 
 /**
- * @brief Predict the @p predict_points_d using the @p kernel_function.
+ * @brief Predict the @p predict_points using the @p kernel_function.
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
- * @param[in] prediction_d the predicted values
- * @param[in] alpha_d the previously learned weights
- * @param[in] rho_d the previously learned biases
- * @param[in] sv_d the support vectors
- * @param[in] predict_points_d the data points to predict
+ * @param[in] prediction the predicted values
+ * @param[in] alpha the previously learned weights
+ * @param[in] rho the previously learned biases
+ * @param[in] support_vectors the support vectors
+ * @param[in] predict_points the data points to predict
  * @param[in] num_classes the number of classes
  * @param[in] num_sv the number of support vectors
  * @param[in] num_predict_points the number of data points to predict
@@ -184,53 +199,55 @@ __global__ void device_kernel_predict_linear(real_type *prediction_d, const real
  * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
  */
 template <kernel_function_type kernel_function, typename... Args>
-__global__ void device_kernel_predict(real_type *prediction_d, const real_type *alpha_d, const real_type *rho_d, const real_type *sv_d, const real_type *predict_points_d, const unsigned long long num_classes, const unsigned long long num_sv, const unsigned long long num_predict_points, const unsigned long long num_features, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset, Args... kernel_function_parameter) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;
-    const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
+__global__ void device_kernel_predict(real_type *prediction, const real_type *alpha, const real_type *rho, const real_type *support_vectors, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type cache_one[THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type cache_two[THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // create a thread private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
     {
-        // create the shared memory arrays used for caching data point features
-        __shared__ real_type data_cache_pp[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-        __shared__ real_type data_cache_sv[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+        // reinterpret the shared memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+        auto *pp_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_one);
+        auto *sv_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_two);
+
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_predict_points
+        const auto sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_support_vectors
 
         // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (unsigned long long dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ull) {
+        for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
             // load data into shared memory
             for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_pp_idx = pp_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE;
-                const auto global_sv_idx = sv_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                data_cache_pp[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points_d[(dim + threadIdx_y) * (num_predict_points + PADDING_SIZE_ull) + global_pp_idx];
-                data_cache_pp[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_predict_points + PADDING_SIZE_ull) + global_pp_idx];
-                data_cache_sv[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = sv_d[(dim + threadIdx_y) * (num_sv + PADDING_SIZE_ull) + global_sv_idx];
-                data_cache_sv[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = sv_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_sv + PADDING_SIZE_ull) + global_sv_idx];
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the shared memory
+                pp_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points[(feature_block + threadIdx_y) * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                sv_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = support_vectors[(feature_block + threadIdx_y) * (num_sv + PADDING_SIZE_uz) + global_sv_idx_linear];             // SoA
             }
             __syncthreads();  // wait until all threads loaded their part of the data
 
             // perform the feature reduction calculation
-            for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+            for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                     for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                        temp[internal_pd][internal_sv] += detail::feature_reduce<kernel_function>(data_cache_sv[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_sv],
-                                                                                                  data_cache_pp[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_pd]);
+                        temp[internal_pp][internal_sv] += detail::feature_reduce<kernel_function>(sv_cache[feature][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_sv],
+                                                                                                  pp_cache[feature][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_pp]);
                     }
                 }
             }
@@ -239,55 +256,57 @@ __global__ void device_kernel_predict(real_type *prediction_d, const real_type *
     }
 
     // update temp using the respective kernel function
-    for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {  // NOLINT(modernize-loop-convert): false positive range-based for loop modernize
         for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-            temp[internal_pd][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pd][internal_sv], kernel_function_parameter...);
+            temp[internal_pp][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pp][internal_sv], kernel_function_parameter...);
         }
     }
 
     {
-        // same shared memory size but with different dimensions
-        __shared__ real_type alpha_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-        __shared__ real_type out_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+        // reinterpret the shared memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+        auto *alpha_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_one);
+        auto *out_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_two);
 
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (unsigned long long dim = 0; dim < num_classes; dim += FEATURE_BLOCK_SIZE_ull) {
+        // calculate the indices used in the current thread
+        const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_support_vectors
+
+        // iterate over all classes using blocking to be able to cache them for faster memory accesses
+        for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
             // load data into shared memory
             for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const unsigned long long global_sv_idx = sv_idx_linear + internal * THREAD_BLOCK_SIZE;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                alpha_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha_d[(dim + threadIdx_y) * (num_sv + PADDING_SIZE_ull) + global_sv_idx];
-                alpha_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_sv + PADDING_SIZE_ull) + global_sv_idx];
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
+                // store the values in the shared memory
+                alpha_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha[(class_block + threadIdx_y) * (num_sv + PADDING_SIZE_uz) + global_sv_idx_linear];  // AoS
                 // the bias (rho) must only be applied once for all support vectors
-                if (blockIdx_y == 0ull) {
-                    out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = -rho_d[dim + threadIdx_y];
-                    out_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = -rho_d[dim + threadIdx_y + THREAD_BLOCK_SIZE_ull];
+                if (blockIdx_y == std::size_t{ 0 }) {
+                    out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = -rho[class_block + threadIdx_y];
                 } else {
                     out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = real_type{ 0.0 };
-                    out_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = real_type{ 0.0 };
                 }
             }
             __syncthreads();  // wait until all threads loaded their part of the data
 
             // calculate intermediate results and store them in shared memory
-            for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
-                for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+            for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
+                for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                     for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                        out_cache[(class_idx + threadIdx.y) % FEATURE_BLOCK_SIZE][internal_pd * THREAD_BLOCK_SIZE + threadIdx.x] +=
-                            temp[internal_pd][internal_sv] * alpha_cache[(class_idx + threadIdx.y) % FEATURE_BLOCK_SIZE][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_sv];
+                        out_cache[(class_idx + threadIdx.y) % THREAD_BLOCK_SIZE][internal_pp * THREAD_BLOCK_SIZE + threadIdx.x] +=
+                            temp[internal_pp][internal_sv] * alpha_cache[(class_idx + threadIdx.y) % THREAD_BLOCK_SIZE][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_sv];
                     }
                 }
                 __syncthreads();  // wait until all threads performed their part of the calculations
             }
 
-            // add intermediate cached results to prediction_d
+            // atomically add the intermediate cached results to the prediction
             for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_pp_idx = pp_idx + static_cast<unsigned long long>(internal);
+                // calculate the indices to access the global data
+                const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal);
 
-                atomicAdd(&prediction_d[global_pp_idx * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y], out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x]);
-                atomicAdd(&prediction_d[global_pp_idx * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull], out_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x]);
+                atomicAdd(&prediction[global_pp_idx * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y], out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x]);
             }
             __syncthreads();  // wait until all threads updated their part of the prediction
         }
@@ -296,4 +315,4 @@ __global__ void device_kernel_predict(real_type *prediction_d, const real_type *
 
 }  // namespace plssvm::cuda::detail
 
-#endif  // PLSSVM_BACKENDS_CUDA_KERNEL_PREDICT_KERNEL_HPP_
+#endif  // PLSSVM_BACKENDS_CUDA_KERNEL_PREDICT_KERNEL_CUH_
diff --git a/include/plssvm/backends/HIP/csvm.hpp b/include/plssvm/backends/HIP/csvm.hpp
index e1f64e58e..06d76a60d 100644
--- a/include/plssvm/backends/HIP/csvm.hpp
+++ b/include/plssvm/backends/HIP/csvm.hpp
@@ -28,6 +28,7 @@
 #include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include <cstddef>      // std::size_t
+#include <optional>     // std::optional
 #include <type_traits>  // std::true_type
 #include <utility>      // std::forward
 #include <vector>       // std::vector
@@ -94,6 +95,10 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, int, detail::
      * @copydoc plssvm::csvm::get_max_mem_alloc_size
      */
     [[nodiscard]] std::vector<::plssvm::detail::memory_size> get_max_mem_alloc_size() const final;
+    /**
+     * @copydoc plssvm::csvm::get_local_memory
+     */
+    [[nodiscard]] std::vector<std::optional<::plssvm::detail::memory_size>> get_local_memory() const final;
     /**
      * @copydoc plssvm::detail::gpu_csvm::get_max_work_group_size
      */
@@ -153,8 +158,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvc(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::hip::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVC using the HIP backend with the parameters given through @p params.
@@ -163,8 +167,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     csvc(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::hip::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVC using the HIP backend on the @p target platform with the parameters given through @p params.
@@ -245,8 +248,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvr(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::hip::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVR using the HIP backend with the parameters given through @p params.
@@ -255,8 +257,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvr(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::hip::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVR using the HIP backend on the @p target platform with the parameters given through @p params.
diff --git a/include/plssvm/backends/HIP/detail/device_ptr.hip.hpp b/include/plssvm/backends/HIP/detail/device_ptr.hip.hpp
index 26490d4ac..1b50f89f2 100644
--- a/include/plssvm/backends/HIP/detail/device_ptr.hip.hpp
+++ b/include/plssvm/backends/HIP/detail/device_ptr.hip.hpp
@@ -9,8 +9,8 @@
  * @brief Small wrapper around a HIP device pointer.
  */
 
-#ifndef PLSSVM_BACKENDS_HIP_DETAIL_DEVICE_PTR_HPP_
-#define PLSSVM_BACKENDS_HIP_DETAIL_DEVICE_PTR_HPP_
+#ifndef PLSSVM_BACKENDS_HIP_DETAIL_DEVICE_PTR_HIP_HPP_
+#define PLSSVM_BACKENDS_HIP_DETAIL_DEVICE_PTR_HIP_HPP_
 #pragma once
 
 #include "plssvm/backends/gpu_device_ptr.hpp"  // plssvm::detail::gpu_device_ptr
@@ -131,4 +131,4 @@ extern template class device_ptr<double>;
 
 }  // namespace plssvm::hip::detail
 
-#endif  // PLSSVM_BACKENDS_HIP_DETAIL_DEVICE_PTR_HPP_
+#endif  // PLSSVM_BACKENDS_HIP_DETAIL_DEVICE_PTR_HIP_HPP_
diff --git a/include/plssvm/backends/HIP/detail/pinned_memory.hip.hpp b/include/plssvm/backends/HIP/detail/pinned_memory.hip.hpp
index 9bf3d1f75..1632ce783 100644
--- a/include/plssvm/backends/HIP/detail/pinned_memory.hip.hpp
+++ b/include/plssvm/backends/HIP/detail/pinned_memory.hip.hpp
@@ -9,8 +9,8 @@
  * @brief Small wrapper around RAII enabled hipHostRegister.
  */
 
-#ifndef PLSSVM_BACKENDS_HIP_DETAIL_PINNED_MEMORY_HPP_
-#define PLSSVM_BACKENDS_HIP_DETAIL_PINNED_MEMORY_HPP_
+#ifndef PLSSVM_BACKENDS_HIP_DETAIL_PINNED_MEMORY_HIP_HPP_
+#define PLSSVM_BACKENDS_HIP_DETAIL_PINNED_MEMORY_HIP_HPP_
 #pragma once
 
 #include "plssvm/backends/host_pinned_memory.hpp"  // plssvm::detail::host_pinned_memory
@@ -100,4 +100,4 @@ extern template class pinned_memory<double>;
 
 }  // namespace plssvm::hip::detail
 
-#endif  // PLSSVM_BACKENDS_HIP_DETAIL_PINNED_MEMORY_HPP_
+#endif  // PLSSVM_BACKENDS_HIP_DETAIL_PINNED_MEMORY_HIP_HPP_
diff --git a/include/plssvm/backends/HIP/detail/utility.hip.hpp b/include/plssvm/backends/HIP/detail/utility.hip.hpp
index b30c11b2c..14792a8f9 100644
--- a/include/plssvm/backends/HIP/detail/utility.hip.hpp
+++ b/include/plssvm/backends/HIP/detail/utility.hip.hpp
@@ -9,8 +9,8 @@
  * @brief Utility functions for the HIP backend.
  */
 
-#ifndef PLSSVM_BACKENDS_HIP_DETAIL_UTILITY_HPP_
-#define PLSSVM_BACKENDS_HIP_DETAIL_UTILITY_HPP_
+#ifndef PLSSVM_BACKENDS_HIP_DETAIL_UTILITY_HIP_HPP_
+#define PLSSVM_BACKENDS_HIP_DETAIL_UTILITY_HIP_HPP_
 #pragma once
 
 #include "plssvm/backends/execution_range.hpp"  // plssvm::detail::dim_type
@@ -76,6 +76,13 @@ void device_synchronize(int device);
  */
 [[nodiscard]] std::string get_runtime_version();
 
+/**
+ * @brief Get the name of the HIP @p device.
+ * @param[in] device the device
+ * @return the HIP device name (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::string get_device_name(int device);
+
 /**
  * @brief Get the HIP runtime string.
  * @details Either HIP or CUDA depending on which runtimes was used during CMake.
@@ -92,4 +99,4 @@ struct fmt::formatter<hipError_t> : fmt::ostream_formatter { };
 
 /// @endcond
 
-#endif  // PLSSVM_BACKENDS_HIP_DETAIL_UTILITY_HPP_
+#endif  // PLSSVM_BACKENDS_HIP_DETAIL_UTILITY_HIP_HPP_
diff --git a/include/plssvm/backends/HIP/kernel/cg_explicit/blas.hip.hpp b/include/plssvm/backends/HIP/kernel/cg_explicit/blas.hip.hpp
index 124688d3a..795a8113b 100644
--- a/include/plssvm/backends/HIP/kernel/cg_explicit/blas.hip.hpp
+++ b/include/plssvm/backends/HIP/kernel/cg_explicit/blas.hip.hpp
@@ -9,15 +9,17 @@
  * @brief Functions for explicitly performing a BLAS GEMM like matrix-matrix multiplication using the HIP backend.
  */
 
-#ifndef PLSSVM_BACKENDS_HIP_CG_EXPLICIT_BLAS_HIP_HPP_
-#define PLSSVM_BACKENDS_HIP_CG_EXPLICIT_BLAS_HIP_HPP_
+#ifndef PLSSVM_BACKENDS_HIP_KERNEL_CG_EXPLICIT_BLAS_HIP_HPP_
+#define PLSSVM_BACKENDS_HIP_KERNEL_CG_EXPLICIT_BLAS_HIP_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 
 #include "hip/hip_runtime.h"
 #include "hip/hip_runtime_api.h"
 
+#include <cstddef>  // std::size_t
+
 namespace plssvm::hip::detail {
 
 /**
@@ -25,8 +27,8 @@ namespace plssvm::hip::detail {
  * @details In a multi-GPU setting, this function is only responsible for the rows this device is responsible for!
  * @param[in] num_rows the number of rows in @p A and @p C
  * @param[in] num_rhs the number of columns in @p B and @p C
- * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
- * @param[in] row_offset the first row this device is responsible for
+ * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+ * @param[in] device_row_offset the first row this device is responsible for
  * @param[in] alpha the scalar alpha value
  * @param[in] A the matrix @p A
  * @param[in] B the matrix @p B
@@ -35,78 +37,77 @@ namespace plssvm::hip::detail {
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_symm(const unsigned long long num_rows, const unsigned long long num_rhs, const unsigned long long device_specific_num_rows, const unsigned long long row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;  // # rhs -> num_rhs
-    const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;  // # rows -> device_specific_num_rows
-    const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-
-    // create the shared memory arrays used for caching data point features
-    __shared__ real_type A_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __shared__ real_type B_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+__global__ void device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type A_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type B_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // create a thread private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
-    // iterate over all features using blocking to be able to cache them for faster memory accesses
-    for (unsigned long long dim = 0; dim < (num_rows - row_offset); dim += FEATURE_BLOCK_SIZE_ull) {
-        // load data into shared memory
-        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const auto global_i = i_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-            const auto global_j = j_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-
-            // determine on which side of the diagonal we are located
-            if (dim + threadIdx_y < global_j) {
-                A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim + threadIdx_y) * (num_rows - row_offset + PADDING_SIZE_ull) + global_j - (dim + threadIdx_y) * (dim + threadIdx_y + 1ull) / 2ull];
-            } else {
-                A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[global_j * (num_rows - row_offset + PADDING_SIZE_ull) + dim + threadIdx_y - global_j * (global_j + 1ull) / 2ull];
-            }
-            // determine on which side of the diagonal we are located
-            if (dim + threadIdx.y + THREAD_BLOCK_SIZE < global_j) {
-                A_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows - row_offset + PADDING_SIZE_ull) + global_j - (dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (dim + threadIdx_y + THREAD_BLOCK_SIZE_ull + 1ull) / 2ull];
-            } else {
-                A_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[global_j * (num_rows - row_offset + PADDING_SIZE_ull) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull - global_j * (global_j + 1ull) / 2ull];
+    {
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rhs
+        const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
+
+        // iterate over all values using blocking to be able to cache them for faster memory accesses
+        for (std::size_t dim_block = 0; dim_block < (num_rows - device_row_offset); dim_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into shared memory
+            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the shared memory
+                // determine on which side of the diagonal we are located
+                if (dim_block + threadIdx_y < global_j_idx_linear) {
+                    A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim_block + threadIdx_y) * (num_rows - device_row_offset + PADDING_SIZE_uz) + global_j_idx_linear - (dim_block + threadIdx_y) * (dim_block + threadIdx_y + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                } else {
+                    A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[global_j_idx_linear * (num_rows - device_row_offset + PADDING_SIZE_uz) + dim_block + threadIdx_y - global_j_idx_linear * (global_j_idx_linear + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                }
+                B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(dim_block + device_row_offset + threadIdx_y) * (num_rhs + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
             }
-
-            B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(dim + row_offset + threadIdx_y) * (num_rhs + PADDING_SIZE_ull) + global_i];
-            B_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(dim + row_offset + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rhs + PADDING_SIZE_ull) + global_i];
-        }
-        __syncthreads();  // wait until all threads loaded their part of the data
-
-        // perform the dot product calculation
-        for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    temp[internal_i][internal_j] += A_cache[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i];
+            __syncthreads();  // wait until all threads loaded their part of the data
+
+            // perform the dot product calculation
+            for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        temp[internal_i][internal_j] += A_cache[dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i];
+                    }
                 }
             }
+            __syncthreads();  // wait until all threads performed their part of the calculations
         }
-        __syncthreads();  // wait until all threads performed their part of the calculations
     }
 
+    // calculate the indices used in the current thread
+    const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+    const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
     // apply the (partial) BLAS operation and update C
     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const auto global_i = i + static_cast<unsigned long long>(internal_i);
-            const auto device_global_j = j + static_cast<unsigned long long>(internal_j);
-            const auto global_j = row_offset + j + static_cast<unsigned long long>(internal_j);
-
-            // be sure to not perform out of bounds accesses
-            if (global_i < num_rhs && device_global_j < device_specific_num_rows) {
-                C[global_j * (num_rhs + PADDING_SIZE_ull) + global_i] = alpha * temp[internal_i][internal_j] + beta * C[global_j * (num_rhs + PADDING_SIZE_ull) + global_i];
+            // calculate the indices to access the global data and the data with respect to the current device
+            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+            const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+            const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+            // be sure to not perform out-of-bounds accesses
+            if (global_i_idx < num_rhs && device_global_j_idx < device_num_rows) {
+                C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx] = alpha * temp[internal_i][internal_j] + beta * C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx];  // SoA
             }
         }
     }
@@ -118,8 +119,8 @@ __global__ void device_kernel_symm(const unsigned long long num_rows, const unsi
  * @param[in] num_rows the number of rows in @p A and @p C
  * @param[in] num_rhs the number of columns in @p B and @p C
  * @param[in] num_mirror_rows the number of rows to mirror down
- * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
- * @param[in] row_offset the first row this device is responsible for
+ * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+ * @param[in] device_row_offset the first row this device is responsible for
  * @param[in] alpha the scalar alpha value
  * @param[in] A the matrix @p A
  * @param[in] B the matrix @p B
@@ -128,68 +129,72 @@ __global__ void device_kernel_symm(const unsigned long long num_rows, const unsi
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_symm_mirror(const unsigned long long num_rows, const unsigned long long num_rhs, const unsigned long long num_mirror_rows, const unsigned long long device_specific_num_rows, const unsigned long long row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;  // # rhs -> num_rhs
-    const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;  // # rows -> num_mirror_rows
-    const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-
-    // create the shared memory arrays used for caching data point features
-    __shared__ real_type A_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __shared__ real_type B_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+__global__ void device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type A_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type B_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // create a thread private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
-    // iterate over the remaining features using blocking to be able to cache them for faster memory accesses
-    for (unsigned long long dim = 0; dim < device_specific_num_rows; dim += FEATURE_BLOCK_SIZE_ull) {
-        // load data into shared memory
-        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const auto global_i = i_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-            const auto global_j = j_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-
-            // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-            A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim + threadIdx_y) * (num_rows - row_offset + PADDING_SIZE_ull) - (dim + threadIdx_y - 1ull) * (dim + threadIdx_y) / 2ull + device_specific_num_rows - (dim + threadIdx_y) + global_j];
-            A_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows - row_offset + PADDING_SIZE_ull) - (dim + threadIdx_y + THREAD_BLOCK_SIZE_ull - 1ull) * (dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) / 2ull + device_specific_num_rows - (dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) + global_j];
-            B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(row_offset + dim + threadIdx_y) * (num_rhs + PADDING_SIZE_ull) + global_i];
-            B_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(row_offset + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rhs + PADDING_SIZE_ull) + global_i];
-        }
-        __syncthreads();  // wait until all threads loaded their part of the data
-
-        // perform the feature reduction calculation
-        for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    temp[internal_i][internal_j] += A_cache[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i];
+    {
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rhs
+        const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_mirror_rows
+
+        // iterate over the remaining values using blocking to be able to cache them for faster memory accesses
+        for (std::size_t dim_block = 0; dim_block < device_num_rows; dim_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into shared memory
+            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the shared memory
+                A_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = A[(dim_block + threadIdx_y) * (num_rows - device_row_offset + PADDING_SIZE_uz) - (dim_block + threadIdx_y - std::size_t{ 1 }) * (dim_block + threadIdx_y) / std::size_t{ 2 } + device_num_rows - (dim_block + threadIdx_y) + global_j_idx_linear];  // SoA, upper triangular matrix only
+                B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = B[(device_row_offset + dim_block + threadIdx_y) * (num_rhs + PADDING_SIZE_uz) + global_i_idx_linear];                                                                                                                                               // SoA
+            }
+            __syncthreads();  // wait until all threads loaded their part of the data
+
+            // perform the dot product calculation
+            for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        temp[internal_i][internal_j] += A_cache[dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i];
+                    }
                 }
             }
+            __syncthreads();  // wait until all threads performed their part of the calculations
         }
-        __syncthreads();  // wait until all threads performed their part of the calculations
     }
 
+    // calculate the indices used in the current thread
+    const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+    const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
+
     // apply the (remaining) BLAS operation and update C
     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const auto global_i = i + static_cast<unsigned long long>(internal_i);
-            const auto partial_global_j = j + static_cast<unsigned long long>(internal_j);
-            const auto global_j = row_offset + device_specific_num_rows + j + static_cast<unsigned long long>(internal_j);
-
-            // be sure to not perform out of bounds accesses
-            if (global_i < num_rhs && partial_global_j < num_mirror_rows) {
-                C[global_j * (num_rhs + PADDING_SIZE_ull) + global_i] = alpha * temp[internal_i][internal_j] + beta * C[global_j * (num_rhs + PADDING_SIZE_ull) + global_i];
+            // calculate the indices to access the global data and the data with respect to the current device
+            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+            const auto partial_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+            const auto global_j_idx = device_row_offset + device_num_rows + partial_global_j_idx;
+
+            // be sure to not perform out-of-bounds accesses
+            if (global_i_idx < num_rhs && partial_global_j_idx < num_mirror_rows) {
+                C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx] = alpha * temp[internal_i][internal_j] + beta * C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx];  // SoA
             }
         }
     }
@@ -203,27 +208,29 @@ __global__ void device_kernel_symm_mirror(const unsigned long long num_rows, con
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_inplace_matrix_add(const unsigned long long num_cols, real_type *lhs, const real_type *rhs, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
+__global__ void device_kernel_inplace_matrix_add(const std::size_t num_cols, real_type *lhs, const real_type *rhs, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
 
     // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;  // # num_rows
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;  // # num_rhs
+    const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+    const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const auto global_i = i + static_cast<unsigned long long>(internal_i);
-            const auto global_j = j + static_cast<unsigned long long>(internal_j);
+            // calculate the indices to access the global data
+            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+            const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-            lhs[global_i * (num_cols + PADDING_SIZE_ull) + global_j] += rhs[global_i * (num_cols + PADDING_SIZE_ull) + global_j];
+            lhs[global_i_idx * (num_cols + PADDING_SIZE_uz) + global_j_idx] += rhs[global_i_idx * (num_cols + PADDING_SIZE_uz) + global_j_idx];  // SoA
         }
     }
 }
@@ -236,31 +243,33 @@ __global__ void device_kernel_inplace_matrix_add(const unsigned long long num_co
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_inplace_matrix_scale(const unsigned long long num_cols, real_type *lhs, const real_type scale, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
+__global__ void device_kernel_inplace_matrix_scale(const std::size_t num_cols, real_type *lhs, const real_type scale, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
 
     // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;  // # num_rows
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;  // # num_rhs
+    const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+    const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const auto global_i = i + static_cast<unsigned long long>(internal_i);
-            const auto global_j = j + static_cast<unsigned long long>(internal_j);
+            // calculate the indices to access the global data
+            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+            const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-            lhs[global_i * (num_cols + PADDING_SIZE_ull) + global_j] *= scale;
+            lhs[global_i_idx * (num_cols + PADDING_SIZE_uz) + global_j_idx] *= scale;  // SoA
         }
     }
 }
 
 }  // namespace plssvm::hip::detail
 
-#endif  // PLSSVM_BACKENDS_HIP_CG_EXPLICIT_BLAS_HIP_HPP_
+#endif  // PLSSVM_BACKENDS_HIP_KERNEL_CG_EXPLICIT_BLAS_HIP_HPP_
diff --git a/include/plssvm/backends/HIP/kernel/cg_explicit/kernel_matrix_assembly.hip.hpp b/include/plssvm/backends/HIP/kernel/cg_explicit/kernel_matrix_assembly.hip.hpp
index 75a3cd9a5..bb6bb6418 100644
--- a/include/plssvm/backends/HIP/kernel/cg_explicit/kernel_matrix_assembly.hip.hpp
+++ b/include/plssvm/backends/HIP/kernel/cg_explicit/kernel_matrix_assembly.hip.hpp
@@ -9,28 +9,30 @@
  * @brief Functions for explicitly assembling the kernel matrix using the HIP backend.
  */
 
-#ifndef PLSSVM_BACKENDS_HIP_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HIP_HPP_
-#define PLSSVM_BACKENDS_HIP_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HIP_HPP_
+#ifndef PLSSVM_BACKENDS_HIP_KERNEL_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HIP_HPP_
+#define PLSSVM_BACKENDS_HIP_KERNEL_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HIP_HPP_
 #pragma once
 
 #include "plssvm/backends/HIP/kernel/kernel_functions.hip.hpp"  // plssvm::hip::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                                 // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                                 // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                     // plssvm::kernel_function_type
 
 #include "hip/hip_runtime.h"
 #include "hip/hip_runtime_api.h"
 
+#include <cstddef>  // std::size_t
+
 namespace plssvm::hip::detail {
 
 /**
  * @brief Create the explicit kernel matrix using the @p kernel_function.
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
- * @param[out] kernel_matrix_d the calculated kernel matrix
- * @param[in] data_d the data points to calculate the kernel matrix from
+ * @param[out] kernel_matrix the calculated kernel matrix
+ * @param[in] data the data points to calculate the kernel matrix from
  * @param[in] num_rows the total number of data points (= total number of rows)
  * @param[in] device_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data_d the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data_d the current device is responsible for
  * @param[in] num_features the number of features per data point
  * @param[in] q the vector used in the dimensional reduction
  * @param[in] QA_cost the scalar used in the dimensional reduction
@@ -40,80 +42,84 @@ namespace plssvm::hip::detail {
  * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
  */
 template <kernel_function_type kernel_function, typename... Args>
-__global__ void device_kernel_assembly(real_type *kernel_matrix_d, const real_type *data_d, const unsigned long long num_rows, const unsigned long long device_num_rows, const unsigned long long row_offset, const unsigned long long num_features, const real_type *q, const real_type QA_cost, const real_type cost, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset, Args... kernel_function_parameter) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;
-    const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;
-    const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-
-    // create the shared memory arrays used for caching data point features
-    __shared__ real_type data_cache_i[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __shared__ real_type data_cache_j[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+__global__ void device_kernel_assembly(real_type *kernel_matrix, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type *q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type data_i_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type data_j_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // only calculate the upper triangular matrix -> can't use threadIdx since all threads in a wavefront must progress further
     if (blockIdx_x >= blockIdx_y) {
         // create a thread private array used for internal caching
         real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (unsigned long long dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ull) {
-            // load data into shared memory
-            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_i = row_offset + i_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-                const auto global_j = row_offset + j_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                data_cache_i[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y) * (num_rows + 1ull + PADDING_SIZE_ull) + global_i];
-                data_cache_i[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows + 1ull + PADDING_SIZE_ull) + global_i];
-                data_cache_j[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y) * (num_rows + 1ull + PADDING_SIZE_ull) + global_j];
-                data_cache_j[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows + 1ull + PADDING_SIZE_ull) + global_j];
-            }
-            __syncthreads();  // wait until all threads loaded their part of the data
-
-            // perform the feature reduction calculation
-            for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i],
-                                                                                                data_cache_j[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j]);
+        {
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rows - device_row_offset
+            const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
+
+            // iterate over all features using blocking to be able to cache them for faster memory accesses
+            for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into shared memory
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = device_row_offset + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_j_idx_linear = device_row_offset + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the shared memory
+                    data_i_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data[(feature_block + threadIdx_y) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                    data_j_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data[(feature_block + threadIdx_y) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
+                }
+                __syncthreads();  // wait until all threads loaded their part of the data
+
+                // perform the feature reduction calculation
+                for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache[feature][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                    data_j_cache[feature][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j]);
+                        }
                     }
                 }
+                __syncthreads();  // wait until all threads performed their part of the calculations
             }
-            __syncthreads();  // wait until all threads performed their part of the calculations
         }
 
+        // calculate the indices used in the current thread
+        const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+        const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
         // apply the remaining part of the kernel function and store the value in the output kernel matrix
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                // calculate the indices to access the kernel matrix (the part stored on the current device)
-                const auto device_global_i = i + static_cast<unsigned long long>(internal_i);
-                const auto global_i = row_offset + i + static_cast<unsigned long long>(internal_i);
-                const auto device_global_j = j + static_cast<unsigned long long>(internal_j);
-                const auto global_j = row_offset + j + static_cast<unsigned long long>(internal_j);
-
-                // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                if (device_global_i < (num_rows - row_offset) && device_global_j < device_num_rows && global_i >= global_j) {
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_i_idx = device_row_offset + device_global_i_idx;
+                const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
                     real_type temp_ij = temp[internal_i][internal_j];
-                    temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter...) + QA_cost - q[global_i] - q[global_j];
+                    // apply the final kernel function
+                    temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter...) + QA_cost - q[global_i_idx] - q[global_j_idx];
                     // apply the cost on the diagonal
-                    if (global_i == global_j) {
+                    if (global_i_idx == global_j_idx) {
                         temp_ij += cost;
                     }
-                    // update the kernel matrix
-                    kernel_matrix_d[device_global_j * (num_rows - row_offset + PADDING_SIZE_ull) - device_global_j * (device_global_j + 1ull) / 2ull + device_global_i] = temp_ij;
+                    // update the upper triangular kernel matrix
+                    kernel_matrix[device_global_j_idx * (num_rows - device_row_offset + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i_idx] = temp_ij;
                 }
             }
         }
@@ -122,4 +128,4 @@ __global__ void device_kernel_assembly(real_type *kernel_matrix_d, const real_ty
 
 }  // namespace plssvm::hip::detail
 
-#endif  // PLSSVM_BACKENDS_HIP_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HIP_HPP_
+#endif  // PLSSVM_BACKENDS_HIP_KERNEL_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HIP_HPP_
diff --git a/include/plssvm/backends/HIP/kernel/cg_implicit/kernel_matrix_assembly_blas.hip.hpp b/include/plssvm/backends/HIP/kernel/cg_implicit/kernel_matrix_assembly_blas.hip.hpp
index 77820e35a..52f74d3f8 100644
--- a/include/plssvm/backends/HIP/kernel/cg_implicit/kernel_matrix_assembly_blas.hip.hpp
+++ b/include/plssvm/backends/HIP/kernel/cg_implicit/kernel_matrix_assembly_blas.hip.hpp
@@ -9,17 +9,20 @@
  * @brief Functions for explicitly assembling the kernel matrix using the HIP backend.
  */
 
-#ifndef PLSSVM_BACKENDS_HIP_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HIP_HPP_
-#define PLSSVM_BACKENDS_HIP_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HIP_HPP_
+#ifndef PLSSVM_BACKENDS_HIP_KERNEL_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HIP_HPP_
+#define PLSSVM_BACKENDS_HIP_KERNEL_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HIP_HPP_
 #pragma once
 
-#include "plssvm/backends/HIP/kernel/kernel_functions.hip.hpp"  // plssvm::hip::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                                 // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
-#include "plssvm/kernel_function_types.hpp"                     // plssvm::kernel_function_type
+#include "plssvm/backends/HIP/kernel/detail/reinterpret_array.hip.hpp"  // plssvm::hip::detail::reinterpret_array
+#include "plssvm/backends/HIP/kernel/kernel_functions.hip.hpp"          // plssvm::hip::detail::{feature_reduce, apply_kernel_function}
+#include "plssvm/constants.hpp"                                         // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/kernel_function_types.hpp"                             // plssvm::kernel_function_type
 
 #include "hip/hip_runtime.h"
 #include "hip/hip_runtime_api.h"
 
+#include <cstddef>  // std::size_t
+
 namespace plssvm::hip::detail {
 
 /**
@@ -28,10 +31,10 @@ namespace plssvm::hip::detail {
  * @tparam Args the types of the parameters necessary for the specific kernel function
  * @param[in] alpha the scalar alpha value
  * @param[in] q the vector used in the dimensional reduction
- * @param[in] data_d the data points to calculate the implicit kernel matrix from
+ * @param[in] data the data points to calculate the implicit kernel matrix from
  * @param[in] num_rows the total number of data points (= total number of rows)
  * @param[in] device_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data_d the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data the current device is responsible for
  * @param[in] num_features the number of features per data point
  * @param[in] QA_cost the scalar used in the dimensional reduction
  * @param[in] cost the cost factor the diagonal is scaled with
@@ -43,56 +46,64 @@ namespace plssvm::hip::detail {
  * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
  */
 template <kernel_function_type kernel_function, typename... Args>
-__global__ void device_kernel_assembly_symm(const real_type alpha, const real_type *q, const real_type *data_d, const unsigned long long num_rows, const unsigned long long device_num_rows, const unsigned long long row_offset, const unsigned long long num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const unsigned long long num_classes, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset, Args... kernel_function_parameter) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
+__global__ void device_kernel_assembly_symm(const real_type alpha, const real_type *q, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
 
     // calculate the indices used in the current thread
-    const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;
-    const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;
-    const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
+    const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+    const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
+    // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+    const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rows - device_row_offset
+    const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type cache_one[THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type cache_two[THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // only calculate the upper triangular matrix -> can't use threadIdx since all threads in a wavefront must progress further
     if (blockIdx_x >= blockIdx_y) {
         // create a thread private array used for internal caching
         real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
+        //*************************************************************************//
+        //                   inplace kernel matrix construction                    //
+        //*************************************************************************//
         {
-            // create the shared memory arrays used for caching data point features
-            __shared__ real_type data_cache_i[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-            __shared__ real_type data_cache_j[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+            // reinterpret the shared memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+            auto *data_i_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_one);
+            auto *data_j_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_two);
 
             // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (unsigned long long dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ull) {
+            for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
                 // load data into shared memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_i = row_offset + i_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-                    const auto global_j = row_offset + j_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    data_cache_i[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y) * (num_rows + 1ull + PADDING_SIZE_ull) + global_i];
-                    data_cache_i[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows + 1ull + PADDING_SIZE_ull) + global_i];
-                    data_cache_j[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y) * (num_rows + 1ull + PADDING_SIZE_ull) + global_j];
-                    data_cache_j[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_rows + 1ull + PADDING_SIZE_ull) + global_j];
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = device_row_offset + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_j_idx_linear = device_row_offset + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the shared memory
+                    data_i_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data[(feature_block + threadIdx_y) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                    data_j_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = data[(feature_block + threadIdx_y) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
                 }
                 __syncthreads();  // wait until all threads loaded their part of the data
 
                 // perform the feature reduction calculation
-                for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
                     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i],
-                                                                                                    data_cache_j[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j]);
+                            temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache[feature][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                    data_j_cache[feature][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j]);
                         }
                     }
                 }
@@ -103,16 +114,18 @@ __global__ void device_kernel_assembly_symm(const real_type alpha, const real_ty
         // apply the remaining part of the kernel function and store the value in the output kernel matrix
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = row_offset + i + static_cast<unsigned long long>(internal_i);
-                const auto device_global_i = i + static_cast<unsigned long long>(internal_i);
-                const auto global_j = row_offset + j + static_cast<unsigned long long>(internal_j);
-                const auto device_global_j = j + static_cast<unsigned long long>(internal_j);
-
-                // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                if ((device_global_i < (num_rows - row_offset) && device_global_j < device_num_rows && global_i >= global_j)) {
-                    temp[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp[internal_i][internal_j], kernel_function_parameter...) + QA_cost - q[global_i] - q[global_j];
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_i_idx = device_row_offset + device_global_i_idx;
+                const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
+                    // apply the final kernel function
+                    temp[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp[internal_i][internal_j], kernel_function_parameter...) + QA_cost - q[global_i_idx] - q[global_j_idx];
                     // apply the cost on the diagonal
-                    if (global_i == global_j) {
+                    if (global_i_idx == global_j_idx) {
                         temp[internal_i][internal_j] += cost;
                     }
                 } else {
@@ -122,95 +135,101 @@ __global__ void device_kernel_assembly_symm(const real_type alpha, const real_ty
             }
         }
 
-        // calculate C += alpha * temp * B for the UPPER triangular matrix
+        //*************************************************************************//
+        //     calculate C += alpha * temp * B for the UPPER triangular matrix     //
+        //*************************************************************************//
         {
-            // same shared memory size but with different dimensions
-            __shared__ real_type B_cache[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][FEATURE_BLOCK_SIZE];
-            __shared__ real_type C_out_cache[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][FEATURE_BLOCK_SIZE];
+            // reinterpret the shared memory arrays to be of shape [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][THREAD_BLOCK_SIZE]
+            auto *B_cache = reinterpret_array<THREAD_BLOCK_SIZE>(cache_one);
+            auto *C_out_cache = reinterpret_array<THREAD_BLOCK_SIZE>(cache_two);
 
             // iterate over all classes using blocking to be able to cache them for faster memory accesses
-            for (unsigned long long dim = 0; dim < num_classes; dim += FEATURE_BLOCK_SIZE_ull) {
+            for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
                 // load data into shared memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_i = row_offset + i_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = device_row_offset + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    B_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y] = alpha * B[global_i * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y];
-                    B_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y + THREAD_BLOCK_SIZE] = alpha * B[global_i * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull];
-                    C_out_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y] = real_type{ 0.0 };
-                    C_out_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y + THREAD_BLOCK_SIZE] = real_type{ 0.0 };
+                    // store the values in the shared memory
+                    B_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y] = alpha * B[global_i_idx_linear * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y];  // SoA
+                    C_out_cache[internal * THREAD_BLOCK_SIZE + threadIdx.x][threadIdx.y] = real_type{ 0.0 };                                                                          // SoA
                 }
                 __syncthreads();  // wait until all threads loaded their part of the data
 
                 // calculate intermediate results and store them in shared memory
-                for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            C_out_cache[threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j][(class_idx + threadIdx.x) % FEATURE_BLOCK_SIZE] +=
-                                temp[internal_i][internal_j] * B_cache[threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i][(class_idx + threadIdx.x) % FEATURE_BLOCK_SIZE];
+                            C_out_cache[threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j][(class_idx + threadIdx.x) % THREAD_BLOCK_SIZE] +=
+                                temp[internal_i][internal_j] * B_cache[threadIdx.x * INTERNAL_BLOCK_SIZE + internal_i][(class_idx + threadIdx.x) % THREAD_BLOCK_SIZE];
                         }
                     }
                     __syncthreads();  // wait until all threads performed their part of the calculations
                 }
 
-                // add intermediate cached results to C
+                // atomically add the intermediate cached results to the C matrix
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_j = row_offset + j + static_cast<unsigned long long>(internal);
-                    atomicAdd(&C[global_j * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_x], C_out_cache[threadIdx.y * INTERNAL_BLOCK_SIZE + internal][threadIdx.x]);
-                    atomicAdd(&C[global_j * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_x + THREAD_BLOCK_SIZE_ull], C_out_cache[threadIdx.y * INTERNAL_BLOCK_SIZE + internal][threadIdx.x + THREAD_BLOCK_SIZE]);
+                    // calculate the indices to access the global data
+                    const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal);
+
+                    atomicAdd(&C[global_j_idx * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_x], C_out_cache[threadIdx.y * INTERNAL_BLOCK_SIZE + internal][threadIdx.x]);  // SoA
                 }
-                __syncthreads();  // wai until all threads updated C with their values
+                __syncthreads();  // wait until all threads updated C with their values
             }
         }
 
         // set potential diagonal entries in temp to 0.0 such that we don't apply the main diagonal twice to C
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = row_offset + i + static_cast<unsigned long long>(internal_i);
-                const auto global_j = row_offset + j + static_cast<unsigned long long>(internal_j);
+                // calculate the indices to access the global data
+                const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
 
-                if (global_i == global_j) {
+                // update the diagonal
+                if (global_i_idx == global_j_idx) {
                     temp[internal_i][internal_j] = real_type{ 0.0 };
                 }
             }
         }
 
-        // calculate C += alpha * temp * B for the LOWER triangular matrix
+        //*************************************************************************//
+        //     calculate C += alpha * temp * B for the LOWER triangular matrix     //
+        //*************************************************************************//
         {
-            // same shared memory size but with different dimensions
-            __shared__ real_type B_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-            __shared__ real_type C_out_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+            // reinterpret the shared memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+            auto *B_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_one);
+            auto *C_out_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_two);
 
             // iterate over all classes using blocking to be able to cache them for faster memory accesses
-            for (unsigned long long dim = 0; dim < num_classes; dim += FEATURE_BLOCK_SIZE_ull) {
+            for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
                 // load data into shared memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_j = row_offset + j_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_j_idx_linear = device_row_offset + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha * B[global_j * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y];
-                    B_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha * B[global_j * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull];
+                    // store the values in the shared memory
+                    B_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha * B[global_j_idx_linear * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y];  // SoA
                     C_out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = real_type{ 0.0 };
-                    C_out_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = real_type{ 0.0 };
                 }
                 __syncthreads();  // wait until all threads loaded their part of the data
 
                 // calculate intermediate results and store them in shared memory
-                for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            C_out_cache[(class_idx + threadIdx.y) % FEATURE_BLOCK_SIZE][internal_i * THREAD_BLOCK_SIZE + threadIdx.x] +=
-                                temp[internal_i][internal_j] * B_cache[(class_idx + threadIdx.y) % FEATURE_BLOCK_SIZE][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j];
+                            C_out_cache[(class_idx + threadIdx.y) % THREAD_BLOCK_SIZE][internal_i * THREAD_BLOCK_SIZE + threadIdx.x] +=
+                                temp[internal_i][internal_j] * B_cache[(class_idx + threadIdx.y) % THREAD_BLOCK_SIZE][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_j];
                         }
                     }
                     __syncthreads();  // wait until all threads performed their part of the calculations
                 }
 
-                // add intermediate cached results to C
+                // atomically add the intermediate cached results to the C matrix
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_i = row_offset + i + static_cast<unsigned long long>(internal);
-                    atomicAdd(&C[global_i * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y], C_out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x]);
-                    atomicAdd(&C[global_i * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull], C_out_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x]);
+                    // calculate the indices to access the global data
+                    const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal);
+
+                    atomicAdd(&C[global_i_idx * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y], C_out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x]);  // SoA
                 }
                 __syncthreads();  // wait until all threads updated C with their values
             }
@@ -220,4 +239,4 @@ __global__ void device_kernel_assembly_symm(const real_type alpha, const real_ty
 
 }  // namespace plssvm::hip::detail
 
-#endif  // PLSSVM_BACKENDS_HIP_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HIP_HPP_
+#endif  // PLSSVM_BACKENDS_HIP_KERNEL_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HIP_HPP_
diff --git a/include/plssvm/backends/HIP/kernel/detail/fill_kernel.hip.hpp b/include/plssvm/backends/HIP/kernel/detail/fill_kernel.hip.hpp
index 710a759f2..ae78adf9b 100644
--- a/include/plssvm/backends/HIP/kernel/detail/fill_kernel.hip.hpp
+++ b/include/plssvm/backends/HIP/kernel/detail/fill_kernel.hip.hpp
@@ -9,8 +9,8 @@
  * @brief Defines a HIP function for filling a device pointer with a specific value.
  */
 
-#ifndef PLSSVM_BACKENDS_HIP_DETAIL_FILL_KERNEL_HPP_
-#define PLSSVM_BACKENDS_HIP_DETAIL_FILL_KERNEL_HPP_
+#ifndef PLSSVM_BACKENDS_HIP_KERNEL_DETAIL_FILL_KERNEL_HIP_HPP_
+#define PLSSVM_BACKENDS_HIP_KERNEL_DETAIL_FILL_KERNEL_HIP_HPP_
 #pragma once
 
 #include "hip/hip_runtime.h"      // HIP runtime functions
@@ -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_KERNEL_DETAIL_FILL_KERNEL_HIP_HPP_
diff --git a/include/plssvm/backends/HIP/kernel/detail/reinterpret_array.hip.hpp b/include/plssvm/backends/HIP/kernel/detail/reinterpret_array.hip.hpp
new file mode 100644
index 000000000..0269656fb
--- /dev/null
+++ b/include/plssvm/backends/HIP/kernel/detail/reinterpret_array.hip.hpp
@@ -0,0 +1,49 @@
+/**
+ * @file
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Defines a utility function to reinterpret a 2D array inside a HIP kernel.
+ */
+
+#ifndef PLSSVM_BACKENDS_HIP_KERNEL_DETAIL_REINTERPRET_ARRAY_HIP_HPP_
+#define PLSSVM_BACKENDS_HIP_KERNEL_DETAIL_REINTERPRET_ARRAY_HIP_HPP_
+#pragma once
+
+#include <cstddef>  // std::size_t
+
+namespace plssvm::hip::detail {
+
+/**
+ * @brief Given the input array of dimensions [N][M], reinterpret it to be of dimensions [...][SIZE].
+ * @tparam SIZE the new y-dimension size of the array
+ * @tparam T the type of the values in the array
+ * @tparam N the x-dimension of the array
+ * @tparam M the y-dimension of the array
+ * @param[in] input the array to reinterpret
+ * @return the array of the newly specified dimensions (`[[nodiscard]]`)
+ */
+template <std::size_t SIZE, typename T, std::size_t N, std::size_t M>
+inline __device__ auto *reinterpret_array(T (&input)[N][M]) noexcept {
+    return reinterpret_cast<T(*)[SIZE]>(input);  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast): reinterpret_cast necessary
+}
+
+/**
+ * @brief Given the input array of dimensions [N], reinterpret it to be of dimensions [...][SIZE].
+ * @tparam SIZE the new y-dimension size of the array
+ * @tparam T the type of the values in the array
+ * @tparam N the dimension of the array
+ * @param[in] input the array to reinterpret
+ * @return the array of the newly specified dimensions (`[[nodiscard]]`)
+ */
+template <std::size_t SIZE, typename T, std::size_t N>
+inline __device__ auto *reinterpret_array(T (&input)[N]) noexcept {
+    return reinterpret_cast<T(*)[SIZE]>(input);  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast): reinterpret_cast necessary
+}
+
+}  // namespace plssvm::hip::detail
+
+#endif  // PLSSVM_BACKENDS_HIP_KERNEL_DETAIL_REINTERPRET_ARRAY_HIP_HPP_
diff --git a/include/plssvm/backends/HIP/kernel/kernel_functions.hip.hpp b/include/plssvm/backends/HIP/kernel/kernel_functions.hip.hpp
index a98bb0715..7205934dd 100644
--- a/include/plssvm/backends/HIP/kernel/kernel_functions.hip.hpp
+++ b/include/plssvm/backends/HIP/kernel/kernel_functions.hip.hpp
@@ -9,8 +9,8 @@
  * @brief Implement the different kernel functions on the GPU using HIP.
  */
 
-#ifndef PLSSVM_BACKENDS_HIP_KERNEL_KERNEL_FUNCTIONS_HPP_
-#define PLSSVM_BACKENDS_HIP_KERNEL_KERNEL_FUNCTIONS_HPP_
+#ifndef PLSSVM_BACKENDS_HIP_KERNEL_KERNEL_FUNCTIONS_HIP_HPP_
+#define PLSSVM_BACKENDS_HIP_KERNEL_KERNEL_FUNCTIONS_HIP_HPP_
 #pragma once
 
 #include "plssvm/constants.hpp"              // plssvm::real_type
@@ -51,42 +51,17 @@ template <>
 
 /**
  * @brief Fast integer power function. Computes base^exponent and takes advantage of the fact that degree may only be positive integer values.
- * @details Hardcodes the power function for degree <= 6, uses a simple for loop otherwise.
  * @param[in] base the base
  * @param[in] exponent the exponent
  * @return base^exponent (`[[nodiscard]]`)
  */
 [[nodiscard]] __device__ __forceinline__ real_type powi(const real_type base, const int exponent) {
-    switch (exponent) {
-        case 0: return real_type{ 1.0 };
-        case 1: return base;
-        case 2: return base * base;
-        case 3: return base * base * base;
-        case 4:
-            {
-                const real_type temp = base * base;
-                return temp * temp;
-            }
-        case 5:
-            {
-                const real_type temp = base * base;
-                return temp * temp * base;
-            }
-        case 6:
-            {
-                const real_type temp = base * base * base;
-                return temp * temp;
-            }
-        default:
-            {
-                // generic integer power function
-                real_type result{ 1.0 };
-                for (int i = 0; i < exponent; ++i) {
-                    result *= base;
-                }
-                return result;
-            }
+    // generic integer power function
+    real_type result{ 1.0 };
+    for (int i = 0; i < exponent; ++i) {
+        result *= base;
     }
+    return result;
 }
 
 //***************************************************//
@@ -221,4 +196,4 @@ template <>
 
 }  // namespace plssvm::hip::detail
 
-#endif  // PLSSVM_BACKENDS_HIP_KERNEL_KERNEL_FUNCTIONS_HPP_
+#endif  // PLSSVM_BACKENDS_HIP_KERNEL_KERNEL_FUNCTIONS_HIP_HPP_
diff --git a/include/plssvm/backends/HIP/kernel/predict_kernel.hip.hpp b/include/plssvm/backends/HIP/kernel/predict_kernel.hip.hpp
index 6e349927e..27d44c67e 100644
--- a/include/plssvm/backends/HIP/kernel/predict_kernel.hip.hpp
+++ b/include/plssvm/backends/HIP/kernel/predict_kernel.hip.hpp
@@ -9,174 +9,189 @@
  * @brief Defines the functions used for prediction for the C-SVM using the HIP backend.
  */
 
-#ifndef PLSSVM_BACKENDS_HIP_PREDICT_KERNEL_HIP_HPP_
-#define PLSSVM_BACKENDS_HIP_PREDICT_KERNEL_HIP_HPP_
+#ifndef PLSSVM_BACKENDS_HIP_KERNEL_PREDICT_KERNEL_HIP_HPP_
+#define PLSSVM_BACKENDS_HIP_KERNEL_PREDICT_KERNEL_HIP_HPP_
 #pragma once
 
-#include "plssvm/backends/HIP/kernel/kernel_functions.hip.hpp"  // plssvm::hip::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                                 // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
-#include "plssvm/kernel_function_types.hpp"                     // plssvm::kernel_function_type
+#include "plssvm/backends/HIP/kernel/detail/reinterpret_array.hip.hpp"  // plssvm::hip::detail::reinterpret_array
+#include "plssvm/backends/HIP/kernel/kernel_functions.hip.hpp"          // plssvm::hip::detail::{feature_reduce, apply_kernel_function}
+#include "plssvm/constants.hpp"                                         // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/kernel_function_types.hpp"                             // plssvm::kernel_function_type
 
 #include "hip/hip_runtime.h"
 #include "hip/hip_runtime_api.h"
 
+#include <cstddef>  // std::size_t
+
 namespace plssvm::hip::detail {
 
 /**
  * @brief Calculate the `w` vector used to speedup the prediction using the linear kernel function.
- * @param[out] w_d the vector to speedup the linear prediction
- * @param[in] alpha_d the previously learned weights
- * @param[in] sv_d the support vectors
+ * @param[out] w the vector to speedup the linear prediction
+ * @param[in] alpha the previously learned weights
+ * @param[in] support_vectors the support vectors
  * @param[in] num_classes the number of classes
  * @param[in] num_sv the number of support vectors
- * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
- * @param[in] sv_offset the first support vector (row in @p alpha_d) the current device is responsible for
+ * @param[in] device_num_sv the number of support vectors the current device is responsible for
+ * @param[in] device_sv_offset the first support vector (row in @p alpha) the current device is responsible for
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_w_linear(real_type *w_d, const real_type *alpha_d, const real_type *sv_d, const unsigned long long num_classes, const unsigned long long num_sv, const unsigned long long device_specific_num_sv, const unsigned long long sv_offset, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto feature_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;
-    const auto feature_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;
-    const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-
-    // create the shared memory arrays used for caching data point features
-    __shared__ real_type data_cache_feature[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __shared__ real_type data_cache_alpha[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+__global__ void device_kernel_w_linear(real_type *w, const real_type *alpha, const real_type *support_vectors, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_num_sv, const std::size_t device_sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type feature_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type alpha_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // create a thread private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
-    // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-    for (unsigned long long sv = 0; sv < device_specific_num_sv; sv += THREAD_BLOCK_SIZE_ull) {
-        // load data into shared memory
-        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const auto global_feature_idx = feature_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-            const auto global_class_idx = class_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
+    {
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto feature_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_features
+        const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;    // num_classes
 
-            data_cache_feature[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = sv_d[global_feature_idx * (device_specific_num_sv + PADDING_SIZE_ull) + sv + threadIdx_y];  // SoA
-            data_cache_alpha[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha_d[global_class_idx * (num_sv + PADDING_SIZE_ull) + sv + sv_offset + threadIdx_y];       // AoS
-        }
-        __syncthreads();  // wait until all threads loaded their part of the data
+        // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
+        for (std::size_t sv_block = 0; sv_block < device_num_sv; sv_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into shared memory
+            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_feature_idx_linear = feature_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-        // perform the dot product calculation
-        for (unsigned block_dim = 0; block_dim < THREAD_BLOCK_SIZE; ++block_dim) {
-            for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
-                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    temp[internal_feature][internal_class] += data_cache_alpha[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_feature[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_feature];
+                // store the values in the shared memory
+                feature_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = support_vectors[global_feature_idx_linear * (device_num_sv + PADDING_SIZE_uz) + sv_block + threadIdx_y];  // SoA
+                alpha_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha[global_class_idx_linear * (num_sv + PADDING_SIZE_uz) + sv_block + device_sv_offset + threadIdx_y];    // AoS
+            }
+            __syncthreads();  // wait until all threads loaded their part of the data
+
+            // perform the dot product calculation
+            for (unsigned sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                    for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                        temp[internal_feature][internal_class] += alpha_cache[sv][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_class] * feature_cache[sv][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_feature];
+                    }
                 }
             }
+            __syncthreads();  // wait until all threads performed their part of the calculations
         }
-        __syncthreads();  // wait until all threads performed their part of the calculations
     }
 
-    // update global array with local one
+    // calculate the indices used in the current thread
+    const auto feature_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+    const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;    // num_classes
+
+    // update the global w-vector with the locally cached values
     for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
         for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-            const auto global_feature_idx = feature_idx + static_cast<unsigned long long>(internal_feature);
-            const auto global_class_idx = class_idx + static_cast<unsigned long long>(internal_class);
+            // calculate the indices to access the global data
+            const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+            const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-            w_d[global_feature_idx * (num_classes + PADDING_SIZE_ull) + global_class_idx] = temp[internal_feature][internal_class];
+            w[global_feature_idx * (num_classes + PADDING_SIZE_uz) + global_class_idx] = temp[internal_feature][internal_class];  // SoA
         }
     }
 }
 
 /**
- * @brief Predict the @p predict_points_d using the linear kernel speeding up the calculation using the @p w_d vector.
- * @param[out] prediction_d the predicted values
- * @param[in] w_d the vector to speedup the calculations
- * @param[in] rho_d the previously learned bias
- * @param[in] predict_points_d the data points to predict
+ * @brief Predict the @p predict_points using the linear kernel speeding up the calculation using the @p w vector.
+ * @param[out] prediction the predicted values
+ * @param[in] w the vector to speedup the calculations
+ * @param[in] rho the previously learned bias
+ * @param[in] predict_points the data points to predict
  * @param[in] num_classes the number of classes
  * @param[in] num_predict_points the number of data points to predict
  * @param[in] num_features the number of features per data point
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__global__ void device_kernel_predict_linear(real_type *prediction_d, const real_type *w_d, const real_type *rho_d, const real_type *predict_points_d, const unsigned long long num_classes, const unsigned long long num_predict_points, const unsigned long long num_features, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;
-    const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ull;
-    const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-
-    // create the shared memory arrays used for caching data point features
-    __shared__ real_type data_cache_pp[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __shared__ real_type data_cache_w[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+__global__ void device_kernel_predict_linear(real_type *prediction, const real_type *w, const real_type *rho, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type pp_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type w_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // create a thread private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
-    // iterate over all features using blocking to be able to cache them for faster memory accesses
-    for (unsigned long long dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ull) {
-        // load data into shared memory
-        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const auto global_pp_idx = pp_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-            const auto global_class_idx = class_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE_ull;
-
-            // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-            data_cache_pp[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points_d[(dim + threadIdx_y) * (num_predict_points + PADDING_SIZE_ull) + global_pp_idx];
-            data_cache_pp[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_predict_points + PADDING_SIZE_ull) + global_pp_idx];
-            data_cache_w[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = w_d[(dim + threadIdx_y) * (num_classes + PADDING_SIZE_ull) + global_class_idx];
-            data_cache_w[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = w_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_classes + PADDING_SIZE_ull) + global_class_idx];
-        }
-        __syncthreads();  // wait until all threads loaded their part of the data
+    {
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;     // num_predict_points
+        const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_classes
+
+        // iterate over all features using blocking to be able to cache them for faster memory accesses
+        for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into shared memory
+            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-        // perform the dot product calculation
-        for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-            for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
-                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    temp[internal_pd][internal_class] += data_cache_w[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_pp[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_pd];
+                // store the values in the shared memory
+                pp_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points[(feature_block + threadIdx_y) * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                w_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = w[(feature_block + threadIdx_y) * (num_classes + PADDING_SIZE_uz) + global_class_idx_linear];                    // SoA
+            }
+            __syncthreads();  // wait until all threads loaded their part of the data
+
+            // perform the dot product calculation
+            for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                    for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                        temp[internal_pp][internal_class] += w_cache[feature][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_class] * pp_cache[feature][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_pp];
+                    }
                 }
             }
+            __syncthreads();  // wait until all threads performed their part of the calculations
         }
-        __syncthreads();  // wait until all threads performed their part of the calculations
     }
 
-    // update global array with local one
-    for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+    // calculate the indices used in the current thread
+    const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;     // num_predict_points
+    const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
+
+    // update the global array with the local one
+    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
         for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-            const auto global_pp_idx = pp_idx + static_cast<unsigned long long>(internal_pd);
-            const auto global_class_idx = class_idx + static_cast<unsigned long long>(internal_class);
+            // calculate the indices to access the global data
+            const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
+            const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-            prediction_d[global_pp_idx * (num_classes + PADDING_SIZE_ull) + global_class_idx] = temp[internal_pd][internal_class] - rho_d[global_class_idx];
+            prediction[global_pp_idx * (num_classes + PADDING_SIZE_uz) + global_class_idx] = temp[internal_pp][internal_class] - rho[global_class_idx];  // AoS
         }
     }
 }
 
 /**
- * @brief Predict the @p predict_points_d using the @p kernel_function.
+ * @brief Predict the @p predict_points using the @p kernel_function.
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
- * @param[in] prediction_d the predicted values
- * @param[in] alpha_d the previously learned weights
- * @param[in] rho_d the previously learned biases
- * @param[in] sv_d the support vectors
- * @param[in] predict_points_d the data points to predict
+ * @param[in] prediction the predicted values
+ * @param[in] alpha the previously learned weights
+ * @param[in] rho the previously learned biases
+ * @param[in] support_vectors the support vectors
+ * @param[in] predict_points the data points to predict
  * @param[in] num_classes the number of classes
  * @param[in] num_sv the number of support vectors
  * @param[in] num_predict_points the number of data points to predict
@@ -186,53 +201,55 @@ __global__ void device_kernel_predict_linear(real_type *prediction_d, const real
  * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
  */
 template <kernel_function_type kernel_function, typename... Args>
-__global__ void device_kernel_predict(real_type *prediction_d, const real_type *alpha_d, const real_type *rho_d, const real_type *sv_d, const real_type *predict_points_d, const unsigned long long num_classes, const unsigned long long num_sv, const unsigned long long num_predict_points, const unsigned long long num_features, const unsigned long long grid_x_offset, const unsigned long long grid_y_offset, Args... kernel_function_parameter) {
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto threadIdx_x = static_cast<unsigned long long>(threadIdx.x);                // current thread in block x-dimension
-    const auto threadIdx_y = static_cast<unsigned long long>(threadIdx.y);                // current thread in block y-dimension
-    const auto blockDim_x = static_cast<unsigned long long>(blockDim.x);                  // number of threads in block x-dimension
-    const auto blockDim_y = static_cast<unsigned long long>(blockDim.y);                  // number of threads in block y-dimension
-    const auto blockIdx_x = static_cast<unsigned long long>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const auto blockIdx_y = static_cast<unsigned long long>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-    const auto INTERNAL_BLOCK_SIZE_ull = static_cast<unsigned long long>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_ull = static_cast<unsigned long long>(THREAD_BLOCK_SIZE);
-    const auto FEATURE_BLOCK_SIZE_ull = static_cast<unsigned long long>(FEATURE_BLOCK_SIZE);
-    const auto PADDING_SIZE_ull = static_cast<unsigned long long>(PADDING_SIZE);
-
-    // calculate the indices used in the current thread
-    const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ull;
-    const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
-    const auto sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ull + threadIdx_x;
+__global__ void device_kernel_predict(real_type *prediction, const real_type *alpha, const real_type *rho, const real_type *support_vectors, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) {
+    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+    const auto threadIdx_x = static_cast<std::size_t>(threadIdx.x);                // current thread in block x-dimension
+    const auto threadIdx_y = static_cast<std::size_t>(threadIdx.y);                // current thread in block y-dimension
+    const auto blockDim_x = static_cast<std::size_t>(blockDim.x);                  // number of threads in block x-dimension
+    const auto blockDim_y = static_cast<std::size_t>(blockDim.y);                  // number of threads in block y-dimension
+    const auto blockIdx_x = static_cast<std::size_t>(blockIdx.x) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size is too large
+    const auto blockIdx_y = static_cast<std::size_t>(blockIdx.y) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size is too large
+
+    // create two shared memory arrays used for caching
+    __shared__ real_type cache_one[THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __shared__ real_type cache_two[THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // create a thread private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
 
     {
-        // create the shared memory arrays used for caching data point features
-        __shared__ real_type data_cache_pp[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-        __shared__ real_type data_cache_sv[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+        // reinterpret the shared memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+        auto *pp_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_one);
+        auto *sv_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_two);
+
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_predict_points
+        const auto sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_support_vectors
 
         // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (unsigned long long dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ull) {
+        for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
             // load data into shared memory
             for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_pp_idx = pp_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE;
-                const auto global_sv_idx = sv_idx_linear + static_cast<unsigned long long>(internal) * THREAD_BLOCK_SIZE;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                data_cache_pp[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points_d[(dim + threadIdx_y) * (num_predict_points + PADDING_SIZE_ull) + global_pp_idx];
-                data_cache_pp[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_predict_points + PADDING_SIZE_ull) + global_pp_idx];
-                data_cache_sv[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = sv_d[(dim + threadIdx_y) * (num_sv + PADDING_SIZE_ull) + global_sv_idx];
-                data_cache_sv[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = sv_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_sv + PADDING_SIZE_ull) + global_sv_idx];
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the shared memory
+                pp_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = predict_points[(feature_block + threadIdx_y) * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                sv_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = support_vectors[(feature_block + threadIdx_y) * (num_sv + PADDING_SIZE_uz) + global_sv_idx_linear];             // SoA
             }
             __syncthreads();  // wait until all threads loaded their part of the data
 
             // perform the feature reduction calculation
-            for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+            for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                     for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                        temp[internal_pd][internal_sv] += detail::feature_reduce<kernel_function>(data_cache_sv[block_dim][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_sv],
-                                                                                                  data_cache_pp[block_dim][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_pd]);
+                        temp[internal_pp][internal_sv] += detail::feature_reduce<kernel_function>(sv_cache[feature][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_sv],
+                                                                                                  pp_cache[feature][threadIdx.x * INTERNAL_BLOCK_SIZE + internal_pp]);
                     }
                 }
             }
@@ -241,55 +258,57 @@ __global__ void device_kernel_predict(real_type *prediction_d, const real_type *
     }
 
     // update temp using the respective kernel function
-    for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {  // NOLINT(modernize-loop-convert): false positive range-based for loop modernize
         for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-            temp[internal_pd][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pd][internal_sv], kernel_function_parameter...);
+            temp[internal_pp][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pp][internal_sv], kernel_function_parameter...);
         }
     }
 
     {
-        // same shared memory size but with different dimensions
-        __shared__ real_type alpha_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-        __shared__ real_type out_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+        // reinterpret the shared memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+        auto *alpha_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_one);
+        auto *out_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_two);
 
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (unsigned long long dim = 0; dim < num_classes; dim += FEATURE_BLOCK_SIZE_ull) {
+        // calculate the indices used in the current thread
+        const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_support_vectors
+
+        // iterate over all classes using blocking to be able to cache them for faster memory accesses
+        for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
             // load data into shared memory
             for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const unsigned long long global_sv_idx = sv_idx_linear + internal * THREAD_BLOCK_SIZE;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                alpha_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha_d[(dim + threadIdx_y) * (num_sv + PADDING_SIZE_ull) + global_sv_idx];
-                alpha_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ull) * (num_sv + PADDING_SIZE_ull) + global_sv_idx];
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
+                // store the values in the shared memory
+                alpha_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = alpha[(class_block + threadIdx_y) * (num_sv + PADDING_SIZE_uz) + global_sv_idx_linear];  // AoS
                 // the bias (rho) must only be applied once for all support vectors
-                if (blockIdx_y == 0ull) {
-                    out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = -rho_d[dim + threadIdx_y];
-                    out_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = -rho_d[dim + threadIdx_y + THREAD_BLOCK_SIZE_ull];
+                if (blockIdx_y == std::size_t{ 0 }) {
+                    out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = -rho[class_block + threadIdx_y];
                 } else {
                     out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x] = real_type{ 0.0 };
-                    out_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x] = real_type{ 0.0 };
                 }
             }
             __syncthreads();  // wait until all threads loaded their part of the data
 
             // calculate intermediate results and store them in shared memory
-            for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
-                for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+            for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
+                for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                     for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                        out_cache[(class_idx + threadIdx.y) % FEATURE_BLOCK_SIZE][internal_pd * THREAD_BLOCK_SIZE + threadIdx.x] +=
-                            temp[internal_pd][internal_sv] * alpha_cache[(class_idx + threadIdx.y) % FEATURE_BLOCK_SIZE][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_sv];
+                        out_cache[(class_idx + threadIdx.y) % THREAD_BLOCK_SIZE][internal_pp * THREAD_BLOCK_SIZE + threadIdx.x] +=
+                            temp[internal_pp][internal_sv] * alpha_cache[(class_idx + threadIdx.y) % THREAD_BLOCK_SIZE][threadIdx.y * INTERNAL_BLOCK_SIZE + internal_sv];
                     }
                 }
                 __syncthreads();  // wait until all threads performed their part of the calculations
             }
 
-            // add intermediate cached results to prediction_d
+            // atomically add the intermediate cached results to the prediction
             for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_pp_idx = pp_idx + static_cast<unsigned long long>(internal);
+                // calculate the indices to access the global data
+                const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal);
 
-                atomicAdd(&prediction_d[global_pp_idx * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y], out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x]);
-                atomicAdd(&prediction_d[global_pp_idx * (num_classes + PADDING_SIZE_ull) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ull], out_cache[threadIdx.y + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + threadIdx.x]);
+                atomicAdd(&prediction[global_pp_idx * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y], out_cache[threadIdx.y][internal * THREAD_BLOCK_SIZE + threadIdx.x]);
             }
             __syncthreads();  // wait until all threads updated their part of the prediction
         }
@@ -298,4 +317,4 @@ __global__ void device_kernel_predict(real_type *prediction_d, const real_type *
 
 }  // namespace plssvm::hip::detail
 
-#endif  // PLSSVM_BACKENDS_HIP_PREDICT_KERNEL_HIP_HPP_
+#endif  // PLSSVM_BACKENDS_HIP_KERNEL_PREDICT_KERNEL_HIP_HPP_
diff --git a/include/plssvm/backends/HPX/csvm.hpp b/include/plssvm/backends/HPX/csvm.hpp
index 37afd8638..5668e0171 100644
--- a/include/plssvm/backends/HPX/csvm.hpp
+++ b/include/plssvm/backends/HPX/csvm.hpp
@@ -29,6 +29,7 @@
 
 #include <cstddef>      // std::size_t
 #include <memory>       // std::addressof
+#include <optional>     // std::optional
 #include <type_traits>  // std::true_type
 #include <utility>      // std::forward, std::pair
 #include <vector>       // std::vector
@@ -99,6 +100,10 @@ class csvm : virtual public ::plssvm::csvm {
      * @copydoc plssvm::csvm::get_max_mem_alloc_size
      */
     [[nodiscard]] std::vector<::plssvm::detail::memory_size> get_max_mem_alloc_size() const final;
+    /**
+     * @copydoc plssvm::csvm::get_local_memory
+     */
+    [[nodiscard]] std::vector<std::optional<::plssvm::detail::memory_size>> get_local_memory() const final;
 
     //***************************************************//
     //                        fit                        //
@@ -134,8 +139,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvc(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::hpx::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVC using the HPX backend with the parameters given through @p params.
@@ -144,8 +148,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     csvc(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::hpx::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVC using the HPX backend on the @p target platform with the parameters given through @p params.
@@ -226,8 +229,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvr(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::hpx::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVR using the HPX backend with the parameters given through @p params.
@@ -236,8 +238,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     csvr(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::hpx::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVR using the HPX backend on the @p target platform with the parameters given through @p params.
diff --git a/include/plssvm/backends/HPX/kernel/cg_explicit/blas.hpp b/include/plssvm/backends/HPX/kernel/cg_explicit/blas.hpp
index 20cbad247..77c1fcf9b 100644
--- a/include/plssvm/backends/HPX/kernel/cg_explicit/blas.hpp
+++ b/include/plssvm/backends/HPX/kernel/cg_explicit/blas.hpp
@@ -34,60 +34,63 @@ namespace plssvm::hpx::detail {
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a symmetric matrix (memory optimized), @p B and @p C are matrices, and @p alpha and @p beta are scalars.
  * @param[in] num_rows the number of rows in @p A and @p C
  * @param[in] num_rhs the number of columns in @p B and @p C
- * @param[in] device_specific_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data the current device is responsible for
+ * @param[in] device_num_rows the number of rows the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data the current device is responsible for
  * @param[in] alpha the scalar alpha value
  * @param[in] A the matrix @p A
  * @param[in] B the matrix @p B
  * @param[in] beta the scalar beta value
  * @param[in,out] C the matrix @p C, also used as result matrix
  */
-inline void device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const std::vector<real_type> &A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
-    PLSSVM_ASSERT(!A.empty(), "A matrix may not be empty!");
+inline void device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
+    PLSSVM_ASSERT(A != nullptr, "The A matrix result pointer must be valid!");
     PLSSVM_ASSERT(B.shape() == (plssvm::shape{ num_rhs, num_rows }), "B matrix sizes mismatch!: {} != [{}, {}]", B.shape(), num_rhs, num_rows);
     PLSSVM_ASSERT(C.shape() == (plssvm::shape{ num_rhs, num_rows }), "C matrix sizes mismatch!: {} != [{}, {}]", C.shape(), num_rhs, num_rows);
-    PLSSVM_ASSERT(num_rows >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, num_rows);
-    PLSSVM_ASSERT(num_rows >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, num_rows);
+    PLSSVM_ASSERT(num_rows >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, num_rows);
+    PLSSVM_ASSERT(num_rows >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, num_rows);
 
     // calculate constants
     const auto blocked_num_rhs = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rhs) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_rows) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_device_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_rows) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-    // define range over which should be iterated
-    std::vector<std::size_t> range(blocked_num_rhs * blocked_device_specific_num_rows);  // define range over which should be iterated
+    // define the range over which should be iterated
+    std::vector<std::size_t> range(blocked_num_rhs * blocked_device_num_rows);
     std::iota(range.begin(), range.end(), 0);
 
     ::hpx::for_each(::hpx::execution::par_unseq, range.cbegin(), range.cend(), [&](const std::size_t idx) {
         // calculate the indices used in the current thread
-        const std::size_t rhs = idx / blocked_device_specific_num_rows;
-        const std::size_t row = idx % blocked_device_specific_num_rows;
-
-        const std::size_t rhs_idx = rhs * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t row_idx = row * INTERNAL_BLOCK_SIZE_uz;
+        const std::size_t i_idx = (idx / blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+        const std::size_t j_idx = (idx % blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
         // create a thread private array used for internal caching
         std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-        // iterate over all features
-        for (std::size_t dim = 0; dim < (num_rows - row_offset); ++dim) {
+        // iterate over all values using blocking
+        for (std::size_t dim_block = 0; dim_block < (num_rows - device_row_offset); dim_block += THREAD_BLOCK_SIZE_uz) {
             // perform the dot product calculation
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                    const std::size_t global_row = row_idx + static_cast<std::size_t>(internal_j);
-
-                    real_type A_val = 0.0;
-                    // determine on which side of the diagonal we are located
-                    if (dim < global_row) {
-                        A_val = A[dim * (num_rows - row_offset + PADDING_SIZE_uz) + global_row - dim * (dim + std::size_t{ 1 }) / std::size_t{ 2 }];
-                    } else {
-                        A_val = A[global_row * (num_rows - row_offset + PADDING_SIZE_uz) + dim - global_row * (global_row + std::size_t{ 1 }) / std::size_t{ 2 }];
+                    // calculate the indices to access the global data
+                    const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                    real_type sum{ 0.0 };
+                    for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE_uz; ++dim) {
+                        real_type A_cache = 0.0;
+                        // determine on which side of the diagonal we are located
+                        if (dim_block + dim < global_j_idx) {
+                            A_cache = A[(dim_block + dim) * (num_rows - device_row_offset + PADDING_SIZE_uz) + global_j_idx - (dim_block + dim) * (dim_block + dim + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                        } else {
+                            A_cache = A[global_j_idx * (num_rows - device_row_offset + PADDING_SIZE_uz) + dim_block + dim - global_j_idx * (global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                        }
+                        sum += A_cache * B(global_i_idx, dim_block + dim + device_row_offset);
                     }
-                    temp[internal_i][internal_j] += A_val * B(global_rhs, dim + row_offset);
+                    temp[internal_j][internal_i] += sum;
                 }
             }
         }
@@ -95,13 +98,14 @@ inline void device_kernel_symm(const std::size_t num_rows, const std::size_t num
         // apply the (partial) BLAS operation and update C
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                const std::size_t device_global_row = row_idx + static_cast<std::size_t>(internal_j);
-                const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_j);
-
-                // be sure to not perform out of bounds accesses
-                if (global_rhs < num_rhs && device_global_row < device_specific_num_rows) {
-                    C(global_rhs, global_row) = alpha * temp[internal_i][internal_j] + beta * C(global_rhs, global_row);
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses
+                if (global_i_idx < num_rhs && device_global_j_idx < device_num_rows) {
+                    C(global_i_idx, global_j_idx) = alpha * temp[internal_j][internal_i] + beta * C(global_i_idx, global_j_idx);  // SoA
                 }
             }
         }
@@ -113,70 +117,74 @@ inline void device_kernel_symm(const std::size_t num_rows, const std::size_t num
  * @param[in] num_rows the number of rows in @p A and @p C
  * @param[in] num_rhs the number of columns in @p B and @p C
  * @param[in] num_mirror_rows the number of rows to mirror down
- * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
- * @param[in] row_offset the first row this device is responsible for
+ * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+ * @param[in] device_row_offset the first row this device is responsible for
  * @param[in] alpha the scalar alpha value
  * @param[in] A the matrix @p A
  * @param[in] B the matrix @p B
  * @param[in] beta the scalar beta value
  * @param[in,out] C the matrix @p C, also used as result matrix
  */
-inline void device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const std::vector<real_type> &A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
+inline void device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
     // compute: C = alpha * A * B + beta * C with A in m x k, B in n x k, and C in n x m, alpha, beta as scalar
-    PLSSVM_ASSERT(!A.empty(), "A matrix may not be empty!");
+    PLSSVM_ASSERT(A != nullptr, "The A matrix result pointer must be valid!");
     PLSSVM_ASSERT(B.shape() == (plssvm::shape{ num_rhs, num_rows }), "B matrix sizes mismatch!: {} != [{}, {}]", B.shape(), num_rhs, num_rows);
     PLSSVM_ASSERT(C.shape() == (plssvm::shape{ num_rhs, num_rows }), "C matrix sizes mismatch!: {} != [{}, {}]", C.shape(), num_rhs, num_rows);
-    PLSSVM_ASSERT(num_rows >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, num_rows);
+    PLSSVM_ASSERT(num_rows >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, num_rows);
     PLSSVM_ASSERT(num_rows >= num_mirror_rows, "The number of mirror rows ({}) cannot be greater the the total number of rows ({})!", num_mirror_rows, num_rows);
-    PLSSVM_ASSERT(num_rows >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, num_rows);
+    PLSSVM_ASSERT(num_rows >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, num_rows);
 
     // calculate constants
     const auto blocked_num_rhs = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rhs) / INTERNAL_BLOCK_SIZE));
     const auto blocked_num_mirror_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_mirror_rows) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-    // define range over which should be iterated
-    std::vector<std::size_t> range(blocked_num_rhs * blocked_num_mirror_rows);  // define range over which should be iterated
+    // define the range over which should be iterated
+    std::vector<std::size_t> range(blocked_num_rhs * blocked_num_mirror_rows);
     std::iota(range.begin(), range.end(), 0);
 
     ::hpx::for_each(::hpx::execution::par_unseq, range.cbegin(), range.cend(), [&](const std::size_t idx) {
         // calculate the indices used in the current thread
-        const std::size_t rhs = idx / blocked_num_mirror_rows;
-        const std::size_t row = idx % blocked_num_mirror_rows;
-
-        const std::size_t rhs_idx = rhs * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t row_idx = row * INTERNAL_BLOCK_SIZE_uz;
+        const std::size_t i_idx = (idx / blocked_num_mirror_rows) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+        const std::size_t j_idx = (idx % blocked_num_mirror_rows) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
 
         // create a thread private array used for internal caching
         std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-        // iterate over all features
-        for (std::size_t dim = 0; dim < device_specific_num_rows; ++dim) {
+        // iterate over the remaining values using blocking
+        for (std::size_t dim_block = 0; dim_block < device_num_rows; dim_block += THREAD_BLOCK_SIZE_uz) {
             // perform the dot product calculation
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                    const std::size_t global_row = row_idx + static_cast<std::size_t>(internal_j);
-
-                    const real_type A_val = A[dim * (num_rows - row_offset + PADDING_SIZE_uz) - (dim - std::size_t{ 1 }) * dim / std::size_t{ 2 } + device_specific_num_rows - dim + global_row];
-                    temp[internal_i][internal_j] += A_val * B(global_rhs, row_offset + dim);
+                    // calculate the indices to access the global data
+                    const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                    real_type sum{ 0.0 };
+                    for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE_uz; ++dim) {
+                        sum += A[(dim_block + dim) * (num_rows - device_row_offset + PADDING_SIZE_uz) - (dim_block + dim - std::size_t{ 1 }) * (dim_block + dim) / std::size_t{ 2 } + device_num_rows - (dim_block + dim) + global_j_idx] *  // SoA, upper triangular matrix only
+                               B(global_i_idx, dim_block + dim + device_row_offset);                                                                                                                                                         // SoA
+                    }
+                    temp[internal_j][internal_i] += sum;
                 }
             }
         }
 
-        // apply the (partial) BLAS operation and update C
+        // apply the (remaining) BLAS operation and update C
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                const std::size_t partial_global_row = row_idx + static_cast<std::size_t>(internal_j);
-                const std::size_t global_row = row_offset + device_specific_num_rows + row_idx + static_cast<std::size_t>(internal_j);
-
-                // be sure to not perform out of bounds accesses
-                if (global_rhs < num_rhs && partial_global_row < num_mirror_rows) {
-                    C(global_rhs, global_row) = alpha * temp[internal_i][internal_j] + beta * C(global_rhs, global_row);
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto partial_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset + device_num_rows + partial_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses
+                if (global_i_idx < num_rhs && partial_global_j_idx < num_mirror_rows) {
+                    C(global_i_idx, global_j_idx) = alpha * temp[internal_j][internal_i] + beta * C(global_i_idx, global_j_idx);  // SoA
                 }
             }
         }
diff --git a/include/plssvm/backends/HPX/kernel/cg_explicit/kernel_matrix_assembly.hpp b/include/plssvm/backends/HPX/kernel/cg_explicit/kernel_matrix_assembly.hpp
index e575c6af2..5534663ad 100644
--- a/include/plssvm/backends/HPX/kernel/cg_explicit/kernel_matrix_assembly.hpp
+++ b/include/plssvm/backends/HPX/kernel/cg_explicit/kernel_matrix_assembly.hpp
@@ -15,7 +15,7 @@
 #pragma once
 
 #include "plssvm/backends/HPX/kernel/kernel_functions.hpp"  // plssvm::hpx::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                             // plssvm::{real_type, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                             // plssvm::{real_type, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/detail/assert.hpp"                         // PLSSVM_ASSERT
 #include "plssvm/kernel_function_types.hpp"                 // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                                // plssvm::aos_matrix
@@ -32,82 +32,90 @@
 namespace plssvm::hpx::detail {
 
 /**
- * @brief Assemble the kernel matrix using the @p kernel function.
- * @tparam kernel the compile-time kernel function to use
- * @tparam Args the types of the potential additional arguments for the @p kernel function
+ * @brief Assemble the kernel matrix using the @p kernel_function function.
+ * @tparam kernel_function the compile-time kernel function to use
+ * @tparam Args the types of the potential additional arguments for the @p kernel_function function
  * @param[out] kernel_matrix the resulting kernel matrix
  * @param[in] data the data matrix
- * @param[in] device_specific_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data the current device is responsible for
+ * @param[in] device_num_rows the number of rows the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data the current device is responsible for
  * @param[in] q the `q` vector
  * @param[in] QA_cost he bottom right matrix entry multiplied by cost
  * @param[in] cost 1 / the cost parameter in the C-SVM
- * @param[in] kernel_function_parameter the potential additional arguments for the @p kernel function
+ * @param[in] kernel_function_parameter the potential additional arguments for the @p kernel_function function
  */
-template <kernel_function_type kernel, typename... Args>
-void device_kernel_assembly(std::vector<real_type> &kernel_matrix, const soa_matrix<real_type> &data, const std::size_t device_specific_num_rows, const std::size_t row_offset, const std::vector<real_type> &q, const real_type QA_cost, const real_type cost, Args... kernel_function_parameter) {
+template <kernel_function_type kernel_function, typename... Args>
+void device_kernel_assembly(real_type *kernel_matrix, const soa_matrix<real_type> &data, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::vector<real_type> &q, const real_type QA_cost, const real_type cost, Args... kernel_function_parameter) {
+    PLSSVM_ASSERT(kernel_matrix != nullptr, "The kernel matrix result pointer must be valid!");
     PLSSVM_ASSERT(q.size() == data.num_rows() - 1, "Sizes mismatch!: {} != {}", q.size(), data.num_rows() - 1);
-    PLSSVM_ASSERT(!kernel_matrix.empty(), "A matrix may not be empty!");
-    PLSSVM_ASSERT(q.size() >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, q.size());
-    PLSSVM_ASSERT(q.size() >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, q.size());
+    PLSSVM_ASSERT(q.size() >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, q.size());
+    PLSSVM_ASSERT(q.size() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, q.size());
     PLSSVM_ASSERT(cost != real_type{ 0.0 }, "cost must not be 0.0 since it is 1 / plssvm::cost!");
 
     // calculate constants
     const std::size_t num_rows = data.num_rows() - 1;
     const std::size_t num_features = data.num_cols();
-    const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - row_offset) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_rows) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - device_row_offset) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_device_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_rows) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-    // count the number of entries in the final index list
-    std::vector<std::size_t> indices(blocked_row_range * blocked_device_specific_num_rows);  // define range over which should be iterated
+    // define the range over which should be iterated
+    std::vector<std::size_t> indices(blocked_row_range * blocked_device_num_rows);
     std::iota(indices.begin(), indices.end(), 0);
 
     ::hpx::for_each(::hpx::execution::par_unseq, indices.cbegin(), indices.cend(), [&](const std::size_t idx) {
         // calculate the indices used in the current thread
-        const std::size_t row_idx = (idx / blocked_device_specific_num_rows) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t col_idx = (idx % blocked_device_specific_num_rows) * INTERNAL_BLOCK_SIZE_uz;
+        const std::size_t i_idx = (idx % blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+        const std::size_t j_idx = (idx / blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
         // only calculate the upper triangular matrix
-        if (row_idx >= col_idx) {
-            // only calculate the upper triangular matrix -> done be only iterating over valid row <-> col pairs
+        if (i_idx >= j_idx) {
             // create a thread private array used for internal caching
             std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
             // iterate over all features
-            for (std::size_t dim = 0; dim < num_features; ++dim) {
+            for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
                 // perform the feature reduction calculation
-                for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                    for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                        const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                        const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
-
-                        temp[internal_row][internal_col] += detail::feature_reduce<kernel>(data(global_row, dim), data(global_col, dim));
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        // calculate the indices to access the global data
+                        const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                        const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
+
+                        real_type sum{ 0.0 };
+                        for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                            sum += detail::feature_reduce<kernel_function>(data(global_i_idx, feature_block + feature),   // SoA
+                                                                           data(global_j_idx, feature_block + feature));  // SoA
+                        }
+                        temp[internal_j][internal_i] += sum;
                     }
                 }
             }
 
             // apply the remaining part of the kernel function and store the value in the output kernel matrix
-            for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                    // calculate the indices to access the kernel matrix (the part stored on the current device)
-                    const std::size_t device_global_row = row_idx + static_cast<std::size_t>(internal_row);
-                    const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                    const std::size_t device_global_col = col_idx + static_cast<std::size_t>(internal_col);
-                    const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
-
-                    // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                    if (device_global_row < (num_rows - row_offset) && device_global_col < device_specific_num_rows && global_row >= global_col) {
-                        real_type temp_ij = temp[internal_row][internal_col];
-                        temp_ij = detail::apply_kernel_function<kernel>(temp_ij, kernel_function_parameter...) + QA_cost - q[global_row] - q[global_col];
+            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_i_idx = device_row_offset + device_global_i_idx;
+                    const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                    if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
+                        real_type temp_ij = temp[internal_j][internal_i];
+                        // apply the final kernel function
+                        temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter...) + QA_cost - q[global_i_idx] - q[global_j_idx];
                         // apply the cost on the diagonal
-                        if (global_row == global_col) {
+                        if (global_i_idx == global_j_idx) {
                             temp_ij += cost;
                         }
-                        kernel_matrix[device_global_col * (num_rows - row_offset + PADDING_SIZE_uz) - device_global_col * (device_global_col + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_row] = temp_ij;
+                        // update the upper triangular kernel matrix
+                        kernel_matrix[device_global_j_idx * (num_rows - device_row_offset + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i_idx] = temp_ij;
                     }
                 }
             }
diff --git a/include/plssvm/backends/HPX/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp b/include/plssvm/backends/HPX/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
index 06df89dac..9102b318b 100644
--- a/include/plssvm/backends/HPX/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
+++ b/include/plssvm/backends/HPX/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
@@ -34,25 +34,25 @@
 namespace plssvm::hpx::detail {
 
 /**
- * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
- * @tparam kernel the compile-time kernel function to use
- * @tparam Args the types of the potential additional arguments for the @p kernel function
+ * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel_function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
+ * @tparam kernel_function the compile-time kernel function to use
+ * @tparam Args the types of the potential additional arguments for the @p kernel_function function
  * @param[in] alpha the scalar alpha value
  * @param[in] q the `q` vector
  * @param[in] data the data matrix
- * @param[in] device_specific_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data the current device is responsible for
+ * @param[in] device_num_rows the number of rows the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data the current device is responsible for
  * @param[in] QA_cost he bottom right matrix entry multiplied by cost
  * @param[in] cost 1 / the cost parameter in the C-SVM
  * @param[in] B the matrix @p B
  * @param[in,out] C the matrix @p C
- * @param[in] kernel_function_parameter the potential additional arguments for the @p kernel function
+ * @param[in] kernel_function_parameter the potential additional arguments for the @p kernel_function function
  */
-template <kernel_function_type kernel, typename... Args>
-inline void device_kernel_assembly_symm(const real_type alpha, const std::vector<real_type> &q, const soa_matrix<real_type> &data, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type QA_cost, const real_type cost, const soa_matrix<real_type> &B, soa_matrix<real_type> &C, Args... kernel_function_parameter) {
+template <kernel_function_type kernel_function, typename... Args>
+inline void device_kernel_assembly_symm(const real_type alpha, const std::vector<real_type> &q, const soa_matrix<real_type> &data, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type QA_cost, const real_type cost, const soa_matrix<real_type> &B, soa_matrix<real_type> &C, Args... kernel_function_parameter) {
     PLSSVM_ASSERT(q.size() == data.num_rows() - 1, "Sizes mismatch!: {} != {}", q.size(), data.num_rows() - 1);
-    PLSSVM_ASSERT(q.size() >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, q.size());
-    PLSSVM_ASSERT(q.size() >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, q.size());
+    PLSSVM_ASSERT(q.size() >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, q.size());
+    PLSSVM_ASSERT(q.size() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, q.size());
     PLSSVM_ASSERT(cost != real_type{ 0.0 }, "cost must not be 0.0 since it is 1 / plssvm::cost!");
     PLSSVM_ASSERT(B.shape() == C.shape(), "The matrices B and C must have the same shape!");
     PLSSVM_ASSERT(B.num_cols() == q.size(), "The number of columns in B ({}) must be the same as the values in q ({})!", B.num_cols(), q.size());
@@ -61,64 +61,93 @@ inline void device_kernel_assembly_symm(const real_type alpha, const std::vector
     const std::size_t num_rows = data.num_rows() - 1;
     const std::size_t num_features = data.num_cols();
     const std::size_t num_classes = B.num_rows();
-    const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - row_offset) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_rows) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - device_row_offset) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_device_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_rows) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
 
-    // count the number of entries in the final index list
-    std::vector<std::size_t> indices(blocked_row_range * blocked_device_specific_num_rows);  // define range over which should be iterated
+    // define the range over which should be iterated
+    std::vector<std::size_t> indices(blocked_row_range * blocked_device_num_rows);
     std::iota(indices.begin(), indices.end(), 0);
 
     ::hpx::for_each(::hpx::execution::par_unseq, indices.cbegin(), indices.cend(), [&](const std::size_t idx) {
         // calculate the indices used in the current thread
-        const std::size_t row_idx = (idx / blocked_device_specific_num_rows) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t col_idx = (idx % blocked_device_specific_num_rows) * INTERNAL_BLOCK_SIZE_uz;
+        const std::size_t i_idx = (idx % blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+        const std::size_t j_idx = (idx / blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
         // only calculate the upper triangular matrix
-        if (row_idx >= col_idx) {
-            // only calculate the upper triangular matrix -> done be only iterating over valid row <-> col pairs
+        if (i_idx >= j_idx) {
             // create a thread private array used for internal caching
             std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-            // iterate over all features
-            for (std::size_t dim = 0; dim < num_features; ++dim) {
-                for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                    for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                        const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                        const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
-
-                        temp[internal_row][internal_col] += detail::feature_reduce<kernel>(data(global_row, dim), data(global_col, dim));
+            //*************************************************************************//
+            //                   inplace kernel matrix construction                    //
+            //*************************************************************************//
+            // iterate over all features using blocking
+            for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        // calculate the indices to access the global data
+                        const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                        const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
+
+                        real_type sum{ 0.0 };
+                        for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                            sum += detail::feature_reduce<kernel_function>(data(global_i_idx, feature_block + feature),   // SoA
+                                                                           data(global_j_idx, feature_block + feature));  // SoA
+                        }
+                        temp[internal_j][internal_i] += sum;
                     }
                 }
             }
 
             // apply the remaining part of the kernel function and store the value in the output kernel matrix
-            for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                    const std::size_t device_global_row = row_idx + static_cast<std::size_t>(internal_row);
-                    const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                    const std::size_t device_global_col = col_idx + static_cast<std::size_t>(internal_col);
-                    const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
-
-                    // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                    if (device_global_row < (num_rows - row_offset) && device_global_col < device_specific_num_rows && global_row >= global_col) {
-                        real_type temp_ij = temp[internal_row][internal_col];
-                        temp_ij = detail::apply_kernel_function<kernel>(temp_ij, kernel_function_parameter...) + QA_cost - q[global_row] - q[global_col];
+            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_i_idx = device_row_offset + device_global_i_idx;
+                    const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                    if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
+                        // apply the final kernel function
+                        temp[internal_j][internal_i] = detail::apply_kernel_function<kernel_function>(temp[internal_j][internal_i], kernel_function_parameter...) + QA_cost - q[global_i_idx] - q[global_j_idx];
                         // apply the cost on the diagonal
-                        if (global_row == global_col) {
-                            temp_ij += cost;
-                            // calculate the values of alpha * A * B
-                            for (std::size_t class_idx = 0; class_idx < num_classes; ++class_idx) {
-                                atomic_ref<real_type>{ C(class_idx, global_row) } += alpha * temp_ij * B(class_idx, global_row);
+                        if (global_i_idx == global_j_idx) {
+                            temp[internal_j][internal_i] += cost;
+                        }
+                    } else {
+                        // be sure to set the value to zero otherwise
+                        temp[internal_j][internal_i] = real_type{ 0.0 };
+                    }
+                }
+            }
+
+            //*************************************************************************//
+            //                     calculate C += alpha * temp * B                     //
+            //*************************************************************************//
+            for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        // calculate the indices to access the global data
+                        const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                        const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
+
+                        if (global_i_idx == global_j_idx) {
+                            // only apply once to the diagonal
+                            for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
+                                atomic_ref<real_type>{ C(class_block + class_idx, global_i_idx) } += alpha * temp[internal_j][internal_i] * B(class_block + class_idx, global_i_idx);
                             }
                         } else {
-                            // calculate the values of alpha * A * B
-                            for (std::size_t class_idx = 0; class_idx < num_classes; ++class_idx) {
-                                atomic_ref<real_type>{ C(class_idx, global_row) } += alpha * temp_ij * B(class_idx, global_col);
+                            // apply it for the upper and lower triangular matrix
+                            for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
+                                atomic_ref<real_type>{ C(class_block + class_idx, global_i_idx) } += alpha * temp[internal_j][internal_i] * B(class_block + class_idx, global_j_idx);
                                 // symmetry
-                                atomic_ref<real_type>{ C(class_idx, global_col) } += alpha * temp_ij * B(class_idx, global_row);
+                                atomic_ref<real_type>{ C(class_block + class_idx, global_j_idx) } += alpha * temp[internal_j][internal_i] * B(class_block + class_idx, global_i_idx);
                             }
                         }
                     }
diff --git a/include/plssvm/backends/HPX/kernel/kernel_functions.hpp b/include/plssvm/backends/HPX/kernel/kernel_functions.hpp
index 6c0cd8a43..35e79d01d 100644
--- a/include/plssvm/backends/HPX/kernel/kernel_functions.hpp
+++ b/include/plssvm/backends/HPX/kernel/kernel_functions.hpp
@@ -28,42 +28,17 @@ namespace plssvm::hpx::detail {
 
 /**
  * @brief Fast integer power function. Computes base^exponent and takes advantage of the fact that degree may only be positive integer values.
- * @details Hardcodes the power function for degree <= 6, uses a simple for loop otherwise.
  * @param[in] base the base
  * @param[in] exponent the exponent
  * @return base^exponent (`[[nodiscard]]`)
  */
 [[nodiscard]] inline real_type powi(const real_type base, const int exponent) {
-    switch (exponent) {
-        case 0: return real_type{ 1.0 };
-        case 1: return base;
-        case 2: return base * base;
-        case 3: return base * base * base;
-        case 4:
-            {
-                const real_type temp = base * base;
-                return temp * temp;
-            }
-        case 5:
-            {
-                const real_type temp = base * base;
-                return temp * temp * base;
-            }
-        case 6:
-            {
-                const real_type temp = base * base * base;
-                return temp * temp;
-            }
-        default:
-            {
-                // generic integer power function
-                real_type result{ 1.0 };
-                for (int i = 0; i < exponent; ++i) {
-                    result *= base;
-                }
-                return result;
-            }
+    // generic integer power function
+    real_type result{ 1.0 };
+    for (int i = 0; i < exponent; ++i) {
+        result *= base;
     }
+    return result;
 }
 
 //***************************************************//
diff --git a/include/plssvm/backends/HPX/kernel/predict_kernel.hpp b/include/plssvm/backends/HPX/kernel/predict_kernel.hpp
index 7ea68e172..1673523ef 100644
--- a/include/plssvm/backends/HPX/kernel/predict_kernel.hpp
+++ b/include/plssvm/backends/HPX/kernel/predict_kernel.hpp
@@ -16,7 +16,7 @@
 
 #include "plssvm/backends/HPX/detail/utility.hpp"           // plssvm::hpx::detail::atomic_ref
 #include "plssvm/backends/HPX/kernel/kernel_functions.hpp"  // plssvm::hpx::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                             // plssvm::{real_type, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                             // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/detail/assert.hpp"                         // PLSSVM_ASSERT
 #include "plssvm/kernel_function_types.hpp"                 // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                                // plssvm::aos_matrix, plssvm::soa_matrix
@@ -38,59 +38,64 @@ namespace plssvm::hpx::detail {
  * @param[out] w the vector to speedup the linear prediction
  * @param[in] alpha the previously learned weights
  * @param[in] support_vectors the support vectors
- * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
- * @param[in] sv_offset the first row in @p support_vectors the current device is responsible for
+ * @param[in] device_num_sv the number of support vectors the current device is responsible for
+ * @param[in] device_sv_offset the first row in @p support_vectors the current device is responsible for
  */
-inline void device_kernel_w_linear(soa_matrix<real_type> &w, const aos_matrix<real_type> &alpha, const soa_matrix<real_type> &support_vectors, const std::size_t device_specific_num_sv, const std::size_t sv_offset) {
+inline void device_kernel_w_linear(soa_matrix<real_type> &w, const aos_matrix<real_type> &alpha, const soa_matrix<real_type> &support_vectors, const std::size_t device_num_sv, const std::size_t device_sv_offset) {
     PLSSVM_ASSERT(alpha.num_cols() == support_vectors.num_rows(), "Size mismatch: {} vs {}!", alpha.num_cols(), support_vectors.num_rows());
     PLSSVM_ASSERT(w.shape() == (plssvm::shape{ alpha.num_rows(), support_vectors.num_cols() }), "Shape mismatch: {} vs {}!", w.shape(), (plssvm::shape{ alpha.num_rows(), support_vectors.num_cols() }));
-    PLSSVM_ASSERT(support_vectors.num_rows() >= device_specific_num_sv, "The number of place specific sv ({}) cannot be greater the the total number of sv ({})!", device_specific_num_sv, support_vectors.num_rows());
-    PLSSVM_ASSERT(support_vectors.num_rows() >= sv_offset, "The sv offset ({}) cannot be greater the the total number of sv ({})!", sv_offset, support_vectors.num_rows());
+    PLSSVM_ASSERT(support_vectors.num_rows() >= device_num_sv, "The number of place specific sv ({}) cannot be greater the the total number of sv ({})!", device_num_sv, support_vectors.num_rows());
+    PLSSVM_ASSERT(support_vectors.num_rows() >= device_sv_offset, "The sv offset ({}) cannot be greater the the total number of sv ({})!", device_sv_offset, support_vectors.num_rows());
 
     // calculate constants
     const std::size_t num_classes = alpha.num_rows();
-    const auto blocked_num_classes = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_classes) / INTERNAL_BLOCK_SIZE));
     const std::size_t num_features = support_vectors.num_cols();
     const auto blocked_num_features = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_features) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_num_classes = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_classes) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
 
-    // define range over which should be iterated
+    // define the range over which should be iterated
     std::vector<std::size_t> range(blocked_num_classes * blocked_num_features);
     std::iota(range.begin(), range.end(), 0);
 
     ::hpx::for_each(::hpx::execution::par_unseq, range.cbegin(), range.cend(), [&](const std::size_t idx) {
         // calculate the indices used in the current thread
-        const std::size_t feature = idx / blocked_num_classes;
-        const std::size_t c = idx % blocked_num_classes;
-
-        const std::size_t feature_idx = feature * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t class_idx = c * INTERNAL_BLOCK_SIZE_uz;
+        const std::size_t feature_idx = (idx / blocked_num_classes) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+        const std::size_t class_idx = (idx % blocked_num_classes) * INTERNAL_BLOCK_SIZE_uz;    // num_classes
 
         // create a thread private array used for internal caching
         std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-        // iterate over all features
-        for (std::size_t sv = 0; sv < device_specific_num_sv; ++sv) {
-            // perform the feature reduction calculation
+        // iterate over all support vectors using blocking
+        for (std::size_t sv_block = 0; sv_block < device_num_sv; sv_block += THREAD_BLOCK_SIZE_uz) {
+            // perform the dot product calculation
             for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
                 for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    const std::size_t global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
-                    const std::size_t global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
-
-                    temp[internal_feature][internal_class] += alpha(global_class_idx, sv_offset + sv) * support_vectors(sv_offset + sv, global_feature_idx);
+                    // calculate the indices to access the global data
+                    const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                    const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                    real_type sum{ 0.0 };
+                    for (std::size_t sv = 0; sv < THREAD_BLOCK_SIZE_uz; ++sv) {
+                        sum += support_vectors(device_sv_offset + sv_block + sv, global_feature_idx) *  // SoA
+                               alpha(global_class_idx, device_sv_offset + sv_block + sv);               // AoS
+                    }
+                    temp[internal_class][internal_feature] += sum;
                 }
             }
         }
 
-        // update global array with local one
+        // store the result back to the w vector
         for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
             for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                const std::size_t global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
-                const std::size_t global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+                // calculate the indices to access the global data
+                const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                w(global_class_idx, global_feature_idx) = temp[internal_feature][internal_class];
+                w(global_class_idx, global_feature_idx) = temp[internal_class][internal_feature];  // SoA
             }
         }
     });
@@ -102,63 +107,65 @@ inline void device_kernel_w_linear(soa_matrix<real_type> &w, const aos_matrix<re
  * @param[in] w the vector to speedup the calculations
  * @param[in] rho the previously learned bias
  * @param[in] predict_points the data points to predict
- * @param[in] device_specific_num_predict_points the number of predict points the current device is responsible for
- * @param[in] row_offset the first row in @p predict_points the current device is responsible for
+ * @param[in] device_num_predict_points the number of predict points the current device is responsible for
+ * @param[in] device_row_offset the first row in @p predict_points the current device is responsible for
  */
-inline void device_kernel_predict_linear(aos_matrix<real_type> &prediction, const soa_matrix<real_type> &w, const std::vector<real_type> &rho, const soa_matrix<real_type> &predict_points, const std::size_t device_specific_num_predict_points, const std::size_t row_offset) {
-    PLSSVM_ASSERT(w.num_rows() == rho.size(), "Size mismatch: {} vs {}!", w.num_rows(), rho.size());
+inline void device_kernel_predict_linear(aos_matrix<real_type> &prediction, const soa_matrix<real_type> &w, const std::vector<real_type> &rho, const soa_matrix<real_type> &predict_points, const std::size_t device_num_predict_points, const std::size_t device_row_offset) {
+    PLSSVM_ASSERT(w.num_rows() == rho.size() - PADDING_SIZE, "Size mismatch: {} vs {}!", w.num_rows(), rho.size() - PADDING_SIZE);
     PLSSVM_ASSERT(w.num_cols() == predict_points.num_cols(), "Size mismatch: {} vs {}!", w.num_cols(), predict_points.num_cols());
     PLSSVM_ASSERT(prediction.shape() == (plssvm::shape{ predict_points.num_rows(), w.num_rows() }), "Shape mismatch: {} vs {}!", prediction.shape(), (plssvm::shape{ predict_points.num_rows(), w.num_rows() }));
-    PLSSVM_ASSERT(predict_points.num_rows() >= device_specific_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_specific_num_predict_points, predict_points.num_rows());
-    PLSSVM_ASSERT(predict_points.num_rows() >= row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", row_offset, predict_points.num_rows());
+    PLSSVM_ASSERT(predict_points.num_rows() >= device_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_num_predict_points, predict_points.num_rows());
+    PLSSVM_ASSERT(predict_points.num_rows() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", device_row_offset, predict_points.num_rows());
 
     // calculate constants
-    const auto blocked_device_specific_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_predict_points) / INTERNAL_BLOCK_SIZE));
     const std::size_t num_classes = prediction.num_cols();
-    const auto blocked_num_classes = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_classes) / INTERNAL_BLOCK_SIZE));
     const std::size_t num_features = predict_points.num_cols();
+    const auto blocked_device_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_predict_points) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_num_classes = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_classes) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
 
-    // define range over which should be iterated
-    std::vector<std::size_t> range(blocked_device_specific_num_predict_points * blocked_num_classes);
+    // define the range over which should be iterated
+    std::vector<std::size_t> range(blocked_device_num_predict_points * blocked_num_classes);
     std::iota(range.begin(), range.end(), 0);
 
     ::hpx::for_each(::hpx::execution::par_unseq, range.cbegin(), range.cend(), [&](const std::size_t idx) {
         // calculate the indices used in the current thread
-        const std::size_t pp = idx / blocked_num_classes;
-        const std::size_t c = idx % blocked_num_classes;
-
-        const std::size_t pp_idx = pp * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t class_idx = c * INTERNAL_BLOCK_SIZE_uz;
+        const std::size_t pp_idx = (idx / blocked_num_classes) * INTERNAL_BLOCK_SIZE_uz;     // num_predict_points
+        const std::size_t class_idx = (idx % blocked_num_classes) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
 
         // create a thread private array used for internal caching
         std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-        // iterate over all features
-        for (std::size_t dim = 0; dim < num_features; ++dim) {
-            // perform the feature reduction calculation
+        // iterate over all features using blocking
+        for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+            // perform the dot product calculation
             for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                 for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    const std::size_t global_pp_idx = row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
-                    const std::size_t global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
-
-                    temp[internal_pp][internal_class] += w(global_class_idx, dim) * predict_points(global_pp_idx, dim);
+                    // calculate the indices to access the global data
+                    const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                    const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                    real_type sum{ 0.0 };
+                    for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                        sum += predict_points(global_pp_idx, feature_block + feature) *  // SoA
+                               w(global_class_idx, feature_block + feature);             // SoA
+                    }
+                    temp[internal_class][internal_pp] += sum;
                 }
             }
         }
 
-        // perform the dot product calculation
+        // update the global array with the local one
         for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
             for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                const std::size_t device_global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
-                const std::size_t global_pp_idx = row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
-                const std::size_t global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+                // calculate the indices to access the global data
+                const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                if (device_global_pp_idx < device_specific_num_predict_points && global_class_idx < num_classes) {
-                    prediction(global_pp_idx, global_class_idx) = temp[internal_pp][internal_class] - rho[global_class_idx];
-                }
+                prediction(global_pp_idx, global_class_idx) = temp[internal_class][internal_pp] - rho[global_class_idx];  // AoS
             }
         }
     });
@@ -166,61 +173,64 @@ inline void device_kernel_predict_linear(aos_matrix<real_type> &prediction, cons
 
 /**
  * @brief Predict the @p predict_points_d using the @p kernel_function.
- * @tparam kernel the type of the used kernel function
+ * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
  * @param[out] prediction the predicted values
  * @param[in] alpha the previously learned weights
  * @param[in] rho the previously learned bias
  * @param[in] support_vectors the support vectors
  * @param[in] predict_points the data points to predict
- * @param[in] device_specific_num_predict_points the number of predict points the current device is responsible for
- * @param[in] row_offset the first row in @p predict_points the current device is responsible for
+ * @param[in] device_num_predict_points the number of predict points the current device is responsible for
+ * @param[in] device_row_offset the first row in @p predict_points the current device is responsible for
  * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
  */
-template <kernel_function_type kernel, typename... Args>
-inline void device_kernel_predict(aos_matrix<real_type> &prediction, const aos_matrix<real_type> &alpha, const std::vector<real_type> &rho, const soa_matrix<real_type> &support_vectors, const soa_matrix<real_type> &predict_points, const std::size_t device_specific_num_predict_points, const std::size_t row_offset, Args... kernel_function_parameter) {
+template <kernel_function_type kernel_function, typename... Args>
+inline void device_kernel_predict(aos_matrix<real_type> &prediction, const aos_matrix<real_type> &alpha, const std::vector<real_type> &rho, const soa_matrix<real_type> &support_vectors, const soa_matrix<real_type> &predict_points, const std::size_t device_num_predict_points, const std::size_t device_row_offset, Args... kernel_function_parameter) {
     PLSSVM_ASSERT(alpha.num_rows() == rho.size(), "Size mismatch: {} vs {}!", alpha.num_rows(), rho.size());
     PLSSVM_ASSERT(alpha.num_cols() == support_vectors.num_rows(), "Size mismatch: {} vs {}!", alpha.num_cols(), support_vectors.num_rows());
     PLSSVM_ASSERT(support_vectors.num_cols() == predict_points.num_cols(), "Size mismatch: {} vs {}!", support_vectors.num_cols(), predict_points.num_cols());
     PLSSVM_ASSERT(prediction.shape() == (plssvm::shape{ predict_points.num_rows(), alpha.num_rows() }), "Shape mismatch: {} vs {}!", prediction.shape(), (plssvm::shape{ predict_points.num_rows(), alpha.num_rows() }));
-    PLSSVM_ASSERT(predict_points.num_rows() >= device_specific_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_specific_num_predict_points, predict_points.num_rows());
-    PLSSVM_ASSERT(predict_points.num_rows() >= row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", row_offset, predict_points.num_rows());
+    PLSSVM_ASSERT(predict_points.num_rows() >= device_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_num_predict_points, predict_points.num_rows());
+    PLSSVM_ASSERT(predict_points.num_rows() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", device_row_offset, predict_points.num_rows());
 
     // calculate constants
     const std::size_t num_classes = alpha.num_rows();
     const std::size_t num_support_vectors = support_vectors.num_rows();
-    const auto blocked_num_support_vectors = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_support_vectors) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_predict_points) / INTERNAL_BLOCK_SIZE));
     const std::size_t num_features = predict_points.num_cols();
+    const auto blocked_num_support_vectors = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_support_vectors) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_device_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_predict_points) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
 
-    // define range over which should be iterated
-    std::vector<std::size_t> range(blocked_device_specific_num_predict_points * blocked_num_support_vectors);
+    // define the range over which should be iterated
+    std::vector<std::size_t> range(blocked_device_num_predict_points * blocked_num_support_vectors);
     std::iota(range.begin(), range.end(), 0);
 
     ::hpx::for_each(::hpx::execution::par_unseq, range.cbegin(), range.cend(), [&](const std::size_t idx) {
         // calculate the indices used in the current thread
-        const std::size_t pp = idx / blocked_num_support_vectors;
-        const std::size_t sv = idx % blocked_num_support_vectors;
-
-        const std::size_t pp_idx = pp * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t sv_idx = sv * INTERNAL_BLOCK_SIZE_uz;
+        const std::size_t pp_idx = (idx % blocked_num_support_vectors) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
+        const std::size_t sv_idx = (idx / blocked_num_support_vectors) * INTERNAL_BLOCK_SIZE_uz;  // num_support_vectors
 
         // create a thread private array used for internal caching
         std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-        // iterate over all features
-        for (std::size_t dim = 0; dim < num_features; ++dim) {
+        // iterate over all features using blocking
+        for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
             // perform the feature reduction calculation
             for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                 for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                    const std::size_t global_pp_idx = row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
-                    const std::size_t global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
-
-                    temp[internal_pp][internal_sv] += detail::feature_reduce<kernel>(support_vectors(global_sv_idx, dim),
-                                                                                     predict_points(global_pp_idx, dim));
+                    // calculate the indices to access the global data
+                    const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                    const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
+
+                    real_type sum{ 0.0 };
+                    for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                        sum += detail::feature_reduce<kernel_function>(predict_points(global_pp_idx, feature_block + feature),    // SoA
+                                                                       support_vectors(global_sv_idx, feature_block + feature));  // SoA
+                    }
+                    temp[internal_sv][internal_pp] += sum;
                 }
             }
         }
@@ -228,25 +238,24 @@ inline void device_kernel_predict(aos_matrix<real_type> &prediction, const aos_m
         // update temp using the respective kernel function
         for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
             for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                temp[internal_pp][internal_sv] = detail::apply_kernel_function<kernel>(temp[internal_pp][internal_sv], kernel_function_parameter...);
+                temp[internal_sv][internal_pp] = detail::apply_kernel_function<kernel_function>(temp[internal_sv][internal_pp], kernel_function_parameter...);
             }
         }
 
-        // add results to prediction
-        for (std::size_t a = 0; a < num_classes; ++a) {
+        // atomically add the results to the prediction
+        for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
             for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                 for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                    const std::size_t device_global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
-                    const std::size_t global_pp_idx = row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
-                    const std::size_t global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                    const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
 
-                    // be sure to not perform out of bounds accesses
-                    if (device_global_pp_idx < device_specific_num_predict_points && global_sv_idx < num_support_vectors) {
+                    for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
                         if (global_sv_idx == 0) {
-                            atomic_ref<real_type>{ prediction(global_pp_idx, a) } += -rho[a];
+                            atomic_ref<real_type>{ prediction(global_pp_idx, class_block + class_idx) } += -rho[class_block + class_idx];
                         }
-                        atomic_ref<real_type>{ prediction(global_pp_idx, a) } +=
-                            temp[internal_pp][internal_sv] * alpha(a, global_sv_idx);
+                        atomic_ref<real_type>{ prediction(global_pp_idx, class_block + class_idx) } += alpha(class_block + class_idx, global_sv_idx) *  // AoS
+                                                                                                       temp[internal_sv][internal_pp];
                     }
                 }
             }
diff --git a/include/plssvm/backends/Kokkos/csvm.hpp b/include/plssvm/backends/Kokkos/csvm.hpp
index 5a77ef1e1..86e568c51 100644
--- a/include/plssvm/backends/Kokkos/csvm.hpp
+++ b/include/plssvm/backends/Kokkos/csvm.hpp
@@ -18,7 +18,7 @@
 #include "plssvm/backends/Kokkos/detail/device_ptr.hpp"      // plssvm::kokkos::detail::device_ptr
 #include "plssvm/backends/Kokkos/detail/device_wrapper.hpp"  // plssvm::kokkos::detail::device_wrapper
 #include "plssvm/backends/Kokkos/detail/pinned_memory.hpp"   // plssvm::kokkos::detail::pinned_memory
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::execution_space
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"       // plssvm::kokkos::execution_space
 #include "plssvm/constants.hpp"                              // plssvm::real_type
 #include "plssvm/detail/igor_utility.hpp"                    // plssvm::detail::get_value_from_named_parameter
 #include "plssvm/detail/memory_size.hpp"                     // plssvm::detail::memory_size
@@ -33,6 +33,7 @@
 #include "igor/igor.hpp"  // igor::parser
 
 #include <cstddef>      // std::size_t
+#include <optional>     // std::optional
 #include <type_traits>  // std::true_type
 #include <utility>      // std::forward
 #include <vector>       // std::vector
@@ -69,7 +70,7 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::devic
     template <typename... Args, PLSSVM_REQUIRES(::plssvm::detail::has_only_kokkos_parameter_named_args_v<Args...>)>
     explicit csvm(const target_platform target = target_platform::automatic, Args &&...named_args) {
         // check igor parameter
-        igor::parser parser{ std::forward<Args>(named_args)... };
+        const igor::parser parser{ std::forward<Args>(named_args)... };
 
         // check whether a specific Kokkos execution space has been requested
         if constexpr (parser.has(kokkos_execution_space)) {
@@ -124,6 +125,10 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::devic
      * @copydoc plssvm::csvm::get_max_mem_alloc_size
      */
     [[nodiscard]] std::vector<::plssvm::detail::memory_size> get_max_mem_alloc_size() const final;
+    /**
+     * @copydoc plssvm::csvm::get_local_memory
+     */
+    [[nodiscard]] std::vector<std::optional<::plssvm::detail::memory_size>> get_local_memory() const final;
     /**
      * @copydoc plssvm::detail::gpu_csvm::get_max_work_group_size
      */
diff --git a/include/plssvm/backends/Kokkos/detail/conditional_execution.hpp b/include/plssvm/backends/Kokkos/detail/conditional_execution.hpp
index 559c9e75c..c7efefb3b 100644
--- a/include/plssvm/backends/Kokkos/detail/conditional_execution.hpp
+++ b/include/plssvm/backends/Kokkos/detail/conditional_execution.hpp
@@ -13,8 +13,8 @@
 #define PLSSVM_BACKENDS_KOKKOS_DETAIL_CONDITIONAL_EXECUTION_HPP_
 #pragma once
 
-#include "plssvm/backends/Kokkos/exceptions.hpp"       // plssvm::kokkos::backend_exception
-#include "plssvm/backends/Kokkos/execution_space.hpp"  // plssvm::kokkos::execution_space
+#include "plssvm/backends/Kokkos/exceptions.hpp"        // plssvm::kokkos::backend_exception
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"  // plssvm::kokkos::execution_space
 
 #include "Kokkos_Core.hpp"  // Kokkos macros
 
@@ -42,9 +42,9 @@ namespace plssvm::kokkos::detail {
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_CUDA(func) std::invoke(func)
 #else
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_CUDA(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::cuda) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::cuda) }
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_CUDA(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::cuda) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::cuda) }
 #endif
 
 //***************************************************//
@@ -65,9 +65,9 @@ namespace plssvm::kokkos::detail {
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_HIP(func) std::invoke(func)
 #else
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_HIP(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::hip) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::hip) }
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_HIP(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::hip) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::hip) }
 #endif
 
 //***************************************************//
@@ -88,9 +88,9 @@ namespace plssvm::kokkos::detail {
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_SYCL(func) std::invoke(func)
 #else
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_SYCL(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::sycl) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::sycl) }
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_SYCL(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::sycl) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::sycl) }
 #endif
 
 //***************************************************//
@@ -111,9 +111,9 @@ namespace plssvm::kokkos::detail {
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_HPX(func) std::invoke(func)
 #else
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_HPX(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::hpx) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::hpx) }
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_HPX(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::hpx) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::hpx) }
 #endif
 
 //***************************************************//
@@ -134,9 +134,9 @@ namespace plssvm::kokkos::detail {
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_OPENMP(func) std::invoke(func)
 #else
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_OPENMP(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::openmp) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::openmp) }
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_OPENMP(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::openmp) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::openmp) }
 #endif
 
 //***************************************************//
@@ -157,9 +157,9 @@ namespace plssvm::kokkos::detail {
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_OPENMPTARGET(func) std::invoke(func)
 #else
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_OPENMPTARGET(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::openmp_target) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::openmp_target) }
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_OPENMPTARGET(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::openmp_target) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::openmp_target) }
 #endif
 
 //***************************************************//
@@ -180,9 +180,9 @@ namespace plssvm::kokkos::detail {
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_OPENACC(func) std::invoke(func)
 #else
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_OPENACC(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::openacc) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::openacc) }
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_OPENACC(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::openacc) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::openacc) }
 #endif
 
 //***************************************************//
@@ -203,9 +203,9 @@ namespace plssvm::kokkos::detail {
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_THREADS(func) std::invoke(func)
 #else
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_THREADS(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::threads) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::threads) }
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_THREADS(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::threads) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::threads) }
 #endif
 
 //***************************************************//
@@ -228,9 +228,9 @@ namespace plssvm::kokkos::detail {
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_SERIAL(func) std::invoke(func)
 #else
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_SERIAL(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::serial) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::serial) }
     #define PLSSVM_KOKKOS_BACKEND_INVOKE_IF_SERIAL(func) \
-        throw backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", execution_space::serial) }
+        throw plssvm::kokkos::backend_exception { fmt::format("The Kokkos ExecutionSpace {} is not available!", plssvm::kokkos::execution_space::serial) }
 #endif
 
 }  // namespace plssvm::kokkos::detail
diff --git a/include/plssvm/backends/Kokkos/detail/constexpr_available_execution_spaces.hpp b/include/plssvm/backends/Kokkos/detail/constexpr_available_execution_spaces.hpp
index 80d3f8cd9..2cc771850 100644
--- a/include/plssvm/backends/Kokkos/detail/constexpr_available_execution_spaces.hpp
+++ b/include/plssvm/backends/Kokkos/detail/constexpr_available_execution_spaces.hpp
@@ -12,6 +12,7 @@
 
 #ifndef PLSSVM_BACKENDS_KOKKOS_DETAIL_CONSTEXPR_AVAILABLE_EXECUTION_SPACES_HPP_
 #define PLSSVM_BACKENDS_KOKKOS_DETAIL_CONSTEXPR_AVAILABLE_EXECUTION_SPACES_HPP_
+#pragma once
 
 /**
  * @def PLSSVM_KOKKOS_BACKEND_NUM_AVAILABLE_EXECUTION_SPACES
@@ -22,7 +23,7 @@
     #define PLSSVM_KOKKOS_BACKEND_NUM_AVAILABLE_EXECUTION_SPACES 0
 #endif
 
-#include "plssvm/backends/Kokkos/execution_space.hpp"  // plssvm::kokkos::execution_space
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"  // plssvm::kokkos::execution_space
 
 #include <array>  // std::array
 
@@ -33,7 +34,7 @@ namespace plssvm::kokkos::detail {
  * @details At least one execution space must **always** be available!
  * @return a `std::array` containing all available execution spaces (`[[nodiscard]]`)
  */
-[[nodiscard]] inline constexpr auto constexpr_available_execution_spaces() noexcept {
+[[nodiscard]] constexpr auto constexpr_available_execution_spaces() noexcept {
     // Note: The execution_space::automatic value may NEVER be added here!
     // Note: the trailing comma is explicitly allowed by the standard
     // Note: the order is intentionally chosen this way -> the order of the entries determines the priority when using a backend to run our code
diff --git a/include/plssvm/backends/Kokkos/detail/device_view_wrapper.hpp b/include/plssvm/backends/Kokkos/detail/device_view_wrapper.hpp
index ea60bb1fd..53ec640d4 100644
--- a/include/plssvm/backends/Kokkos/detail/device_view_wrapper.hpp
+++ b/include/plssvm/backends/Kokkos/detail/device_view_wrapper.hpp
@@ -11,11 +11,12 @@
 
 #ifndef PLSSVM_BACKENDS_KOKKOS_DETAIL_DEVICE_VIEW_WRAPPER_HPP_
 #define PLSSVM_BACKENDS_KOKKOS_DETAIL_DEVICE_VIEW_WRAPPER_HPP_
+#pragma once
 
 #include "plssvm/backends/Kokkos/detail/constexpr_available_execution_spaces.hpp"  // plssvm::kokkos::detail::constexpr_available_execution_spaces
 #include "plssvm/backends/Kokkos/detail/device_wrapper.hpp"                        // plssvm::kokkos::detail::device_wrapper
-#include "plssvm/backends/Kokkos/execution_space.hpp"                              // plssvm::kokkos::execution_space
 #include "plssvm/backends/Kokkos/execution_space_type_traits.hpp"                  // plssvm::kokkos::execution_space_to_kokkos_type_t
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"                             // plssvm::kokkos::execution_space
 #include "plssvm/detail/type_traits.hpp"                                           // plssvm::detail::remove_cvref_t
 
 #include "Kokkos_Core.hpp"  // Kokkos::View, Kokkos::ExecutionSpace
@@ -147,7 +148,7 @@ class device_view_wrapper {
      * @param[in] rhs the second device view wrapper
      * @return `true` if both underlying `std::variant`s are equal, otherwise `false` (`[[nodiscard]]`)
      */
-    [[nodiscard]] friend bool operator==(const device_view_wrapper &lhs, const device_view_wrapper &rhs) noexcept {
+    [[nodiscard]] friend bool operator==(const device_view_wrapper &lhs, const device_view_wrapper &rhs) {
         return lhs.v_ == rhs.v_;
     }
 
@@ -157,7 +158,7 @@ class device_view_wrapper {
      * @param[in] rhs the second device view wrapper
      * @return `true` if both underlying `std::variant`s are unequal, otherwise `false` (`[[nodiscard]]`)
      */
-    [[nodiscard]] friend bool operator!=(const device_view_wrapper &lhs, const device_view_wrapper &rhs) noexcept {
+    [[nodiscard]] friend bool operator!=(const device_view_wrapper &lhs, const device_view_wrapper &rhs) {
         return !(lhs == rhs);
     }
 
diff --git a/include/plssvm/backends/Kokkos/detail/device_wrapper.hpp b/include/plssvm/backends/Kokkos/detail/device_wrapper.hpp
index 0ded898c0..4ebaf9339 100644
--- a/include/plssvm/backends/Kokkos/detail/device_wrapper.hpp
+++ b/include/plssvm/backends/Kokkos/detail/device_wrapper.hpp
@@ -11,13 +11,17 @@
 
 #ifndef PLSSVM_BACKENDS_KOKKOS_DETAIL_DEVICE_WRAPPER_HPP_
 #define PLSSVM_BACKENDS_KOKKOS_DETAIL_DEVICE_WRAPPER_HPP_
+#pragma once
 
 #include "plssvm/backends/Kokkos/detail/constexpr_available_execution_spaces.hpp"  // plssvm::kokkos::detail::constexpr_available_execution_spaces
-#include "plssvm/backends/Kokkos/execution_space.hpp"                              // plssvm::kokkos::execution_space
 #include "plssvm/backends/Kokkos/execution_space_type_traits.hpp"                  // plssvm::kokkos::execution_space_to_kokkos_type_t
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"                             // plssvm::kokkos::execution_space
+#include "plssvm/detail/type_traits.hpp"                                           // PLSSVM_REQUIRES
 #include "plssvm/mpi/communicator.hpp"                                             // plssvm::mpi::communicator
 #include "plssvm/target_platforms.hpp"                                             // plssvm::target_platform
 
+#include "Kokkos_Core.hpp"  // Kokkos::is_execution_space_v
+
 #include <array>       // std::array
 #include <cstddef>     // std::size_t
 #include <functional>  // std::invoke
@@ -79,7 +83,7 @@ class device_wrapper {
      * @tparam ExecutionSpace the used Kokkos::ExecutionSpace type
      * @param[in] exec the Kokkos::ExecutionSpace instance
      */
-    template <typename ExecutionSpace>
+    template <typename ExecutionSpace, PLSSVM_REQUIRES(Kokkos::is_execution_space_v<ExecutionSpace>)>
     explicit device_wrapper(ExecutionSpace &&exec) :
         v_{ std::forward<ExecutionSpace>(exec) } { }
 
@@ -97,7 +101,7 @@ class device_wrapper {
      * @copydoc plssvm::kokkos::detail::device_wrapper::get
      */
     template <execution_space space>
-    const execution_space_to_kokkos_type_t<space> &get() const {
+    [[nodiscard]] const execution_space_to_kokkos_type_t<space> &get() const {
         return std::get<execution_space_to_kokkos_type_t<space>>(v_);
     }
 
@@ -168,7 +172,7 @@ class device_wrapper {
      * @param[in] rhs the second device wrapper
      * @return `true` if both underlying `std::variant`s are equal, otherwise `false` (`[[nodiscard]]`)
      */
-    [[nodiscard]] friend bool operator==(const device_wrapper &lhs, const device_wrapper &rhs) noexcept {
+    [[nodiscard]] friend bool operator==(const device_wrapper &lhs, const device_wrapper &rhs) {
         return lhs.v_ == rhs.v_;
     }
 
@@ -178,13 +182,13 @@ class device_wrapper {
      * @param[in] rhs the second device wrapper
      * @return `true` if both underlying `std::variant`s are unequal, otherwise `false` (`[[nodiscard]]`)
      */
-    [[nodiscard]] friend bool operator!=(const device_wrapper &lhs, const device_wrapper &rhs) noexcept {
+    [[nodiscard]] friend bool operator!=(const device_wrapper &lhs, const device_wrapper &rhs) {
         return !(lhs == rhs);
     }
 
   private:
     /// The wrapped `std::variant` type.
-    variant_type v_{};
+    variant_type v_;
 };
 
 /**
diff --git a/include/plssvm/backends/Kokkos/detail/standard_layout_tuple.hpp b/include/plssvm/backends/Kokkos/detail/standard_layout_tuple.hpp
index 5b26f5e98..a2e921c5c 100644
--- a/include/plssvm/backends/Kokkos/detail/standard_layout_tuple.hpp
+++ b/include/plssvm/backends/Kokkos/detail/standard_layout_tuple.hpp
@@ -104,7 +104,7 @@ KOKKOS_INLINE_FUNCTION constexpr auto get(const standard_layout_tuple<Types...>
  * @brief Special case: return an empty tuple if no values have bee provided.
  * @return an empty tuple (`[[nodiscard]]`)
  */
-[[nodiscard]] inline constexpr standard_layout_tuple<> make_standard_layout_tuple() {
+[[nodiscard]] constexpr standard_layout_tuple<> make_standard_layout_tuple() {
     return standard_layout_tuple<>{};
 }
 
@@ -117,14 +117,14 @@ KOKKOS_INLINE_FUNCTION constexpr auto get(const standard_layout_tuple<Types...>
  * @return the constructed tuple (`[[nodiscard]]`)
  */
 template <typename T, typename... Rest>
-[[nodiscard]] inline constexpr standard_layout_tuple<T, Rest...> make_standard_layout_tuple(T &&arg, Rest &&...remaining) {
+[[nodiscard]] constexpr standard_layout_tuple<T, Rest...> make_standard_layout_tuple(T &&arg, Rest &&...remaining) {
     return standard_layout_tuple<T, Rest...>{ std::forward<T>(arg), make_standard_layout_tuple(std::forward<Rest>(remaining)...) };
 }
 
 // sanity checks: be sure that the important use cases are indeed standard layout types!
-static_assert(std::is_standard_layout_v<standard_layout_tuple<>>, "standard_layout_tuple<> has no standard layout!");
-static_assert(std::is_standard_layout_v<standard_layout_tuple<int, real_type, real_type>>, "standard_layout_tuple<int, real_type, real_type> has no standard layout!");
-static_assert(std::is_standard_layout_v<standard_layout_tuple<real_type>>, "standard_layout_tuple<real_type> has no standard layout!");
+static_assert(std::is_standard_layout_v<standard_layout_tuple<>>, "standard_layout_tuple<> must have standard layout!");
+static_assert(std::is_standard_layout_v<standard_layout_tuple<int, real_type, real_type>>, "standard_layout_tuple<int, real_type, real_type> must have standard layout!");
+static_assert(std::is_standard_layout_v<standard_layout_tuple<real_type>>, "standard_layout_tuple<real_type> must have standard layout!");
 
 }  // namespace plssvm::kokkos::detail
 
diff --git a/include/plssvm/backends/Kokkos/detail/utility.hpp b/include/plssvm/backends/Kokkos/detail/utility.hpp
index 9bbc9b172..fdba9f473 100644
--- a/include/plssvm/backends/Kokkos/detail/utility.hpp
+++ b/include/plssvm/backends/Kokkos/detail/utility.hpp
@@ -15,7 +15,7 @@
 
 #include "plssvm/backends/execution_range.hpp"               // plssvm::detail::dim_type
 #include "plssvm/backends/Kokkos/detail/device_wrapper.hpp"  // plssvm::kokkos::detail::device_wrapper
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::execution_space
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"       // plssvm::kokkos::execution_space
 #include "plssvm/detail/type_traits.hpp"                     // PLSSVM_REQUIRES
 #include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
diff --git a/include/plssvm/backends/Kokkos/execution_space_type_traits.hpp b/include/plssvm/backends/Kokkos/execution_space_type_traits.hpp
index aa5e31751..a7076e300 100644
--- a/include/plssvm/backends/Kokkos/execution_space_type_traits.hpp
+++ b/include/plssvm/backends/Kokkos/execution_space_type_traits.hpp
@@ -13,7 +13,7 @@
 #define PLSSVM_BACKENDS_KOKKOS_EXECUTION_SPACE_TYPE_TRAITS_HPP_
 #pragma once
 
-#include "plssvm/backends/Kokkos/execution_space.hpp"  // plssvm::kokkos::execution_space
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"  // plssvm::kokkos::execution_space
 
 #include "Kokkos_Core.hpp"  // Kokkos macros, Kokkos ExecutionSpace types
 
diff --git a/include/plssvm/backends/Kokkos/execution_space.hpp b/include/plssvm/backends/Kokkos/execution_spaces.hpp
similarity index 94%
rename from include/plssvm/backends/Kokkos/execution_space.hpp
rename to include/plssvm/backends/Kokkos/execution_spaces.hpp
index cc9114412..5abf5d667 100644
--- a/include/plssvm/backends/Kokkos/execution_space.hpp
+++ b/include/plssvm/backends/Kokkos/execution_spaces.hpp
@@ -9,8 +9,8 @@
  * @brief Execution space enumeration for the ExecutionSpaces in Kokkos.
  */
 
-#ifndef PLSSVM_BACKENDS_KOKKOS_EXECUTION_SPACE_HPP_
-#define PLSSVM_BACKENDS_KOKKOS_EXECUTION_SPACE_HPP_
+#ifndef PLSSVM_BACKENDS_KOKKOS_EXECUTION_SPACES_HPP_
+#define PLSSVM_BACKENDS_KOKKOS_EXECUTION_SPACES_HPP_
 #pragma once
 
 #include "fmt/base.h"     // fmt::formatter
@@ -79,4 +79,4 @@ struct fmt::formatter<plssvm::kokkos::execution_space> : fmt::ostream_formatter
 
 /// @endcond
 
-#endif  // PLSSVM_BACKENDS_KOKKOS_EXECUTION_SPACE_HPP_
+#endif  // PLSSVM_BACKENDS_KOKKOS_EXECUTION_SPACES_HPP_
diff --git a/include/plssvm/backends/Kokkos/kernel/cg_explicit/blas.hpp b/include/plssvm/backends/Kokkos/kernel/cg_explicit/blas.hpp
index bddadac01..53c498664 100644
--- a/include/plssvm/backends/Kokkos/kernel/cg_explicit/blas.hpp
+++ b/include/plssvm/backends/Kokkos/kernel/cg_explicit/blas.hpp
@@ -9,23 +9,27 @@
  * @brief Functions for explicitly performing a BLAS GEMM like matrix-matrix multiplication using the Kokkos backend.
  */
 
-#ifndef PLSSVM_BACKENDS_KOKKOS_CG_EXPLICIT_BLAS_HPP_
-#define PLSSVM_BACKENDS_KOKKOS_CG_EXPLICIT_BLAS_HPP_
+#ifndef PLSSVM_BACKENDS_KOKKOS_KERNEL_CG_EXPLICIT_BLAS_HPP_
+#define PLSSVM_BACKENDS_KOKKOS_KERNEL_CG_EXPLICIT_BLAS_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"         // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/target_platforms.hpp"  // plssvm::target_platform
 
 #include "Kokkos_Core.hpp"  // KOKKOS_INLINE_FUNCTION, Kokkos::View, Kokkos::TeamPolicy, Kokkos::mdspan, Kokkos::dextents
 
+#include <array>    // std:array
 #include <cstddef>  // std::size_t
+#include <utility>  // std::move
 
 namespace plssvm::kokkos::detail {
 
 /**
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @tparam ExecutionSpace the Kokkos::ExecutionSpace used to execute the kernel
+ * @tparam target the target platform
  */
-template <typename ExecutionSpace>
+template <typename ExecutionSpace, target_platform target>
 class device_kernel_symm {
     /**
      * @brief The type of the used Kokkos::View.
@@ -38,8 +42,8 @@ class device_kernel_symm {
      * @brief Initialize the Kokkos kernel function object.
      * @param[in] num_rows the number of rows in @p A and @p C
      * @param[in] num_rhs the number of columns in @p B and @p C
-     * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
-     * @param[in] row_offset the first row this device is responsible for
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
      * @param[in] alpha the scalar alpha value
      * @param[in] A the matrix @p A
      * @param[in] B the matrix @p B
@@ -49,16 +53,16 @@ class device_kernel_symm {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_size_x the size of the execution grid in x-dimension
      */
-    device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, device_view_type<const real_type> A, device_view_type<const real_type> B, const real_type beta, device_view_type<real_type> C, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x) :
+    device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, device_view_type<const real_type> A, device_view_type<const real_type> B, const real_type beta, device_view_type<real_type> C, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x) :
         num_rows_{ num_rows },
         num_rhs_{ num_rhs },
-        device_specific_num_rows_{ device_specific_num_rows },
-        row_offset_{ row_offset },
+        device_num_rows_{ device_num_rows },
+        device_row_offset_{ device_row_offset },
         alpha_{ alpha },
-        A_{ A },
-        B_{ B },
+        A_{ std::move(A) },
+        B_{ std::move(B) },
         beta_{ beta },
-        C_{ C },
+        C_{ std::move(C) },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
         grid_size_x_{ grid_size_x } { }
@@ -69,79 +73,96 @@ class device_kernel_symm {
      */
     KOKKOS_INLINE_FUNCTION
     void operator()(const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &team) const {
-        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_sz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_sz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_sz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_sz = static_cast<std::size_t>(PADDING_SIZE);
-        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_sz;            // current thread in block x-dimension
-        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_sz;            // current thread in block y-dimension
-        const auto blockDim_x = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block x-dimension
-        const auto blockDim_y = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block y-dimension
-        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
+        // cast values to 32-bit unsigned int values to prevent implicit conversions
+        const auto team_rank_x = static_cast<unsigned>(team.team_rank()) / THREAD_BLOCK_SIZE;
+        const auto team_rank_y = static_cast<unsigned>(team.team_rank()) % THREAD_BLOCK_SIZE;
 
-        // calculate the indices used in the current thread
-        const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_sz;  // # rhs -> num_rhs
-        const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
-        const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_sz;  // # rows -> num_mirror_rows
-        const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
-
-        // create the shared memory arrays used for caching data point features
-        constexpr std::size_t shmem_size = FEATURE_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE;
-        real_type *data_cache_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(2 * shmem_size * sizeof(real_type)));
-        Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> A_cache{ data_cache_ptr, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-        Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> B_cache{ data_cache_ptr + shmem_size, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
+        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_uz;            // current thread in team x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_uz;            // current thread in team y-dimension
+        const auto blockDim_x = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team x-dimension
+        const auto blockDim_y = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current team in league x-dimension + offsets if the league size is too large
+        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current team in league y-dimension + offsets if the league size is too large
+
+        // create two scratchpad memory arrays used for caching
+        constexpr std::size_t scratchpad_size = THREAD_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz * INTERNAL_BLOCK_SIZE_uz;
+        auto *scratchpad_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(std::size_t{ 2 } * scratchpad_size * sizeof(real_type)));
+        const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> A_cache{ scratchpad_ptr, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+        const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> B_cache{ scratchpad_ptr + scratchpad_size, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
 
         // create a thread private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < (num_rows_ - row_offset_); dim += FEATURE_BLOCK_SIZE_sz) {
-            // load data into shared memory
-            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_i = i_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-                const auto global_j = j_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-
-                // determine on which side of the diagonal we are located
-                if (dim + threadIdx_y < global_j) {
-                    A_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = A_[(dim + threadIdx_y) * (num_rows_ - row_offset_ + PADDING_SIZE_sz) + global_j - (dim + threadIdx_y) * (dim + threadIdx_y + std::size_t{ 1 }) / std::size_t{ 2 }];
-                } else {
-                    A_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = A_[global_j * (num_rows_ - row_offset_ + PADDING_SIZE_sz) + dim + threadIdx_y - global_j * (global_j + std::size_t{ 1 }) / std::size_t{ 2 }];
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+        {
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rhs
+            const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
+
+            // iterate over all values using blocking to be able to cache them for faster memory accesses
+            for (std::size_t dim_block = 0; dim_block < (num_rows_ - device_row_offset_); dim_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into scratchpad memory
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the scratchpad memory
+                    // determine on which side of the diagonal we are located
+                    if (dim_block + threadIdx_y < global_j_idx_linear) {
+                        A_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = A_[(dim_block + threadIdx_y) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + global_j_idx_linear - (dim_block + threadIdx_y) * (dim_block + threadIdx_y + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                    } else {
+                        A_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = A_[global_j_idx_linear * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + dim_block + threadIdx_y - global_j_idx_linear * (global_j_idx_linear + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                    }
+
+                    B_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = B_[(dim_block + device_row_offset_ + threadIdx_y) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
                 }
-                // determine on which side of the diagonal we are located
-                if (dim + threadIdx_y + THREAD_BLOCK_SIZE < global_j) {
-                    A_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = A_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_rows_ - row_offset_ + PADDING_SIZE_sz) + global_j - (dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (dim + threadIdx_y + THREAD_BLOCK_SIZE_sz + std::size_t{ 1 }) / std::size_t{ 2 }];
+                team.team_barrier();  // wait until all threads loaded their part of the data
+
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the dim is the fastest moving index
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            real_type sum{ 0.0 };
+                            for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                                sum += A_cache(dim, team_rank_y * INTERNAL_BLOCK_SIZE + internal_j) * B_cache(dim, team_rank_x * INTERNAL_BLOCK_SIZE + internal_i);
+                            }
+                            temp[internal_i][internal_j] += sum;
+                        }
+                    }
                 } else {
-                    A_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = A_[global_j * (num_rows_ - row_offset_ + PADDING_SIZE_sz) + dim + threadIdx_y + THREAD_BLOCK_SIZE_sz - global_j * (global_j + std::size_t{ 1 }) / std::size_t{ 2 }];
-                }
-
-                B_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = B_[(dim + row_offset_ + threadIdx_y) * (num_rhs_ + PADDING_SIZE_sz) + global_i];
-                B_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = B_[(dim + row_offset_ + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_rhs_ + PADDING_SIZE_sz) + global_i];
-            }
-            team.team_barrier();  // wait until all threads loaded their part of the data
-
-            // perform the dot product calculation
-            for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        temp[internal_i][internal_j] += A_cache(block_dim, threadIdx_y * INTERNAL_BLOCK_SIZE + internal_j) * B_cache(block_dim, threadIdx_x * INTERNAL_BLOCK_SIZE + internal_i);
+                    // perform the dot product calculation, the dim is the slowest moving index
+                    for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                temp[internal_i][internal_j] += A_cache(dim, team_rank_y * INTERNAL_BLOCK_SIZE + internal_j) * B_cache(dim, team_rank_x * INTERNAL_BLOCK_SIZE + internal_i);
+                            }
+                        }
                     }
                 }
+                team.team_barrier();  // wait until all threads performed their part of the calculations
             }
-            team.team_barrier();  // wait until all threads performed their part of the calculations
         }
 
+        // calculate the indices used in the current thread
+        const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+        const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
         // apply the (partial) BLAS operation and update C
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto device_global_j = j + static_cast<std::size_t>(internal_j);
-                const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-
-                // be sure to not perform out of bounds accesses
-                if (global_i < num_rhs_ && device_global_j < device_specific_num_rows_) {
-                    C_[global_j * (num_rhs_ + PADDING_SIZE_sz) + global_i] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j * (num_rhs_ + PADDING_SIZE_sz) + global_i];
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses
+                if (global_i_idx < num_rhs_ && device_global_j_idx < device_num_rows_) {
+                    C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
                 }
             }
         }
@@ -151,8 +172,8 @@ class device_kernel_symm {
     /// @cond Doxygen_suppress
     const std::size_t num_rows_;
     const std::size_t num_rhs_;
-    const std::size_t device_specific_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_num_rows_;
+    const std::size_t device_row_offset_;
     const real_type alpha_;
     device_view_type<const real_type> A_;
     device_view_type<const real_type> B_;
@@ -168,8 +189,9 @@ class device_kernel_symm {
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @details In a multi-GPU setting, this function is responsible for mirroring down the columns this device is responsible for!
  * @tparam ExecutionSpace the Kokkos::ExecutionSpace used to execute the kernel
+ * @tparam target the target platform
  */
-template <typename ExecutionSpace>
+template <typename ExecutionSpace, target_platform target>
 class device_kernel_symm_mirror {
     /**
      * @brief The type of the used Kokkos::View.
@@ -183,8 +205,8 @@ class device_kernel_symm_mirror {
      * @param[in] num_rows the number of rows in @p A and @p C
      * @param[in] num_rhs the number of columns in @p B and @p C
      * @param[in] num_mirror_rows the number of rows to mirror down
-     * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
-     * @param[in] row_offset the first row this device is responsible for
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
      * @param[in] alpha the scalar alpha value
      * @param[in] A the matrix @p A
      * @param[in] B the matrix @p B
@@ -194,17 +216,17 @@ class device_kernel_symm_mirror {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_size_x the size of the execution grid in x-dimension
      */
-    device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, device_view_type<const real_type> A, device_view_type<const real_type> B, const real_type beta, device_view_type<real_type> C, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x) :
+    device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, device_view_type<const real_type> A, device_view_type<const real_type> B, const real_type beta, device_view_type<real_type> C, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x) :
         num_rows_{ num_rows },
         num_rhs_{ num_rhs },
         num_mirror_rows_{ num_mirror_rows },
-        device_specific_num_rows_{ device_specific_num_rows },
-        row_offset_{ row_offset },
+        device_num_rows_{ device_num_rows },
+        device_row_offset_{ device_row_offset },
         alpha_{ alpha },
-        A_{ A },
-        B_{ B },
+        A_{ std::move(A) },
+        B_{ std::move(B) },
         beta_{ beta },
-        C_{ C },
+        C_{ std::move(C) },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
         grid_size_x_{ grid_size_x } { }
@@ -215,69 +237,90 @@ class device_kernel_symm_mirror {
      */
     KOKKOS_INLINE_FUNCTION
     void operator()(const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &team) const {
-        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_sz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_sz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_sz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_sz = static_cast<std::size_t>(PADDING_SIZE);
-        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_sz;            // current thread in block x-dimension
-        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_sz;            // current thread in block y-dimension
-        const auto blockDim_x = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block x-dimension
-        const auto blockDim_y = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block y-dimension
-        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
+        // cast values to 32-bit unsigned int values to prevent implicit conversions
+        const auto team_rank_x = static_cast<unsigned>(team.team_rank()) / THREAD_BLOCK_SIZE;
+        const auto team_rank_y = static_cast<unsigned>(team.team_rank()) % THREAD_BLOCK_SIZE;
 
-        // calculate the indices used in the current thread
-        const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_sz;  // # rhs -> num_rhs
-        const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
-        const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_sz;  // # rows -> num_mirror_rows
-        const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
-
-        // create the shared memory arrays used for caching data point features
-        constexpr std::size_t shmem_size = FEATURE_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE;
-        real_type *data_cache_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(2 * shmem_size * sizeof(real_type)));
-        Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> A_cache{ data_cache_ptr, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-        Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> B_cache{ data_cache_ptr + shmem_size, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
+        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_uz;            // current thread in team x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_uz;            // current thread in team y-dimension
+        const auto blockDim_x = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team x-dimension
+        const auto blockDim_y = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current team in league x-dimension + offsets if the league size is too large
+        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current team in league y-dimension + offsets if the league size is too large
+
+        // create two shared memory arrays used for caching
+        constexpr std::size_t scratchpad_size = THREAD_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz * INTERNAL_BLOCK_SIZE_uz;
+        auto *scratchpad_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(std::size_t{ 2 } * scratchpad_size * sizeof(real_type)));
+        const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> A_cache{ scratchpad_ptr, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+        const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> B_cache{ scratchpad_ptr + scratchpad_size, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
 
         // create a thread private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over the remaining features using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < device_specific_num_rows_; dim += FEATURE_BLOCK_SIZE_sz) {
-            // load data into shared memory
-            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_i = i_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-                const auto global_j = j_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                A_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = A_[(dim + threadIdx_y) * (num_rows_ - row_offset_ + PADDING_SIZE_sz) - (dim + threadIdx_y - std::size_t{ 1 }) * (dim + threadIdx_y) / std::size_t{ 2 } + device_specific_num_rows_ - (dim + threadIdx_y) + global_j];
-                A_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = A_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_rows_ - row_offset_ + PADDING_SIZE_sz) - (dim + threadIdx_y + THREAD_BLOCK_SIZE_sz - std::size_t{ 1 }) * (dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) / std::size_t{ 2 } + device_specific_num_rows_ - (dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) + global_j];
-                B_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = B_[(row_offset_ + dim + threadIdx_y) * (num_rhs_ + PADDING_SIZE_sz) + global_i];
-                B_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = B_[(row_offset_ + dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_rhs_ + PADDING_SIZE_sz) + global_i];
-            }
-            team.team_barrier();  // wait until all threads loaded their part of the data
-
-            // perform the feature reduction calculation
-            for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        temp[internal_i][internal_j] += A_cache(block_dim, threadIdx_y * INTERNAL_BLOCK_SIZE + internal_j) * B_cache(block_dim, threadIdx_x * INTERNAL_BLOCK_SIZE + internal_i);
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+        {
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rhs
+            const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_mirror_rows
+
+            // iterate over the remaining values using blocking to be able to cache them for faster memory accesses
+            for (std::size_t dim_block = 0; dim_block < device_num_rows_; dim_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into scratchpad memory
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the scratchpad memory
+                    A_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = A_[(dim_block + threadIdx_y) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - (dim_block + threadIdx_y - std::size_t{ 1 }) * (dim_block + threadIdx_y) / std::size_t{ 2 } + device_num_rows_ - (dim_block + threadIdx_y) + global_j_idx_linear];  // SoA, upper triangular matrix only
+                    B_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = B_[(device_row_offset_ + dim_block + threadIdx_y) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx_linear];                                                                                                                                                // SoA
+                }
+                team.team_barrier();  // wait until all threads loaded their part of the data
+
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the dim is the fastest moving index
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            real_type sum{ 0.0 };
+                            for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                                sum += A_cache(dim, team_rank_y * INTERNAL_BLOCK_SIZE + internal_j) * B_cache(dim, team_rank_x * INTERNAL_BLOCK_SIZE + internal_i);
+                            }
+                            temp[internal_i][internal_j] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the dim is the slowest moving index
+                    for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                temp[internal_i][internal_j] += A_cache(dim, team_rank_y * INTERNAL_BLOCK_SIZE + internal_j) * B_cache(dim, team_rank_x * INTERNAL_BLOCK_SIZE + internal_i);
+                            }
+                        }
                     }
                 }
+                team.team_barrier();  // wait until all threads performed their part of the calculations
             }
-            team.team_barrier();  // wait until all threads performed their part of the calculations
         }
 
+        // calculate the indices used in the current thread
+        const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+        const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
+
         // apply the (remaining) BLAS operation and update C
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto partial_global_j = j + static_cast<std::size_t>(internal_j);
-                const auto global_j = row_offset_ + device_specific_num_rows_ + j + static_cast<std::size_t>(internal_j);
-
-                // be sure to not perform out of bounds accesses
-                if (global_i < num_rhs_ && partial_global_j < num_mirror_rows_) {
-                    C_[global_j * (num_rhs_ + PADDING_SIZE_sz) + global_i] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j * (num_rhs_ + PADDING_SIZE_sz) + global_i];
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto partial_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset_ + device_num_rows_ + partial_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses
+                if (global_i_idx < num_rhs_ && partial_global_j_idx < num_mirror_rows_) {
+                    C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
                 }
             }
         }
@@ -288,8 +331,8 @@ class device_kernel_symm_mirror {
     const std::size_t num_rows_;
     const std::size_t num_rhs_;
     const std::size_t num_mirror_rows_;
-    const std::size_t device_specific_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_num_rows_;
+    const std::size_t device_row_offset_;
     const real_type alpha_;
     device_view_type<const real_type> A_;
     device_view_type<const real_type> B_;
@@ -325,8 +368,8 @@ class device_kernel_inplace_matrix_add {
      */
     device_kernel_inplace_matrix_add(const std::size_t num_cols, device_view_type<real_type> lhs, device_view_type<const real_type> rhs, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x) :
         num_cols_{ num_cols },
-        lhs_{ lhs },
-        rhs_{ rhs },
+        lhs_{ std::move(lhs) },
+        rhs_{ std::move(rhs) },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
         grid_size_x_{ grid_size_x } { }
@@ -338,26 +381,28 @@ class device_kernel_inplace_matrix_add {
     KOKKOS_INLINE_FUNCTION
     void operator()(const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &team) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_sz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_sz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto PADDING_SIZE_sz = static_cast<std::size_t>(PADDING_SIZE);
-        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_sz;            // current thread in block x-dimension
-        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_sz;            // current thread in block y-dimension
-        const auto blockDim_x = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block x-dimension
-        const auto blockDim_y = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block y-dimension
-        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-        // Calculate the indices used in the current thread
-        const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_sz;  // num_rows
-        const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_sz;  // num_rhs
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_uz;            // current thread in team x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_uz;            // current thread in team y-dimension
+        const auto blockDim_x = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team x-dimension
+        const auto blockDim_y = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current team in league x-dimension + offsets if the league size is too large
+        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current team in league y-dimension + offsets if the league size is too large
+
+        // calculate the indices used in the current thread
+        const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+        const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto global_j = j + static_cast<std::size_t>(internal_j);
+                // calculate the indices to access the global data
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-                lhs_[global_i * (num_cols_ + PADDING_SIZE_sz) + global_j] += rhs_[global_i * (num_cols_ + PADDING_SIZE_sz) + global_j];
+                lhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx] += rhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx];  // SoA
             }
         }
     }
@@ -397,7 +442,7 @@ class device_kernel_inplace_matrix_scale {
      */
     device_kernel_inplace_matrix_scale(const std::size_t num_cols, device_view_type<real_type> lhs, const real_type scale, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x) :
         num_cols_{ num_cols },
-        lhs_{ lhs },
+        lhs_{ std::move(lhs) },
         scale_{ scale },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
@@ -410,26 +455,28 @@ class device_kernel_inplace_matrix_scale {
     KOKKOS_INLINE_FUNCTION
     void operator()(const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &team) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_sz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_sz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto PADDING_SIZE_sz = static_cast<std::size_t>(PADDING_SIZE);
-        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_sz;            // current thread in block x-dimension
-        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_sz;            // current thread in block y-dimension
-        const auto blockDim_x = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block x-dimension
-        const auto blockDim_y = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block y-dimension
-        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-        // Calculate the indices used in the current thread
-        const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_sz;  // num_rows
-        const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_sz;  // num_rhs
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_uz;            // current thread in team x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_uz;            // current thread in team y-dimension
+        const auto blockDim_x = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team x-dimension
+        const auto blockDim_y = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current team in league x-dimension + offsets if the league size is too large
+        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current team in league y-dimension + offsets if the league size is too large
+
+        // calculate the indices used in the current thread
+        const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+        const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto global_j = j + static_cast<std::size_t>(internal_j);
+                // calculate the indices to access the global data
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-                lhs_[global_i * (num_cols_ + PADDING_SIZE_sz) + global_j] *= scale_;
+                lhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx] *= scale_;  // SoA
             }
         }
     }
@@ -447,4 +494,4 @@ class device_kernel_inplace_matrix_scale {
 
 }  // namespace plssvm::kokkos::detail
 
-#endif  // PLSSVM_BACKENDS_KOKKOS_CG_EXPLICIT_BLAS_HPP_
+#endif  // PLSSVM_BACKENDS_KOKKOS_KERNEL_CG_EXPLICIT_BLAS_HPP_
diff --git a/include/plssvm/backends/Kokkos/kernel/cg_explicit/kernel_matrix_assembly.hpp b/include/plssvm/backends/Kokkos/kernel/cg_explicit/kernel_matrix_assembly.hpp
index 8e42e8b41..f4a6c3f14 100644
--- a/include/plssvm/backends/Kokkos/kernel/cg_explicit/kernel_matrix_assembly.hpp
+++ b/include/plssvm/backends/Kokkos/kernel/cg_explicit/kernel_matrix_assembly.hpp
@@ -9,28 +9,32 @@
  * @brief Functions for explicitly assembling the kernel matrix using the Kokkos backend.
  */
 
-#ifndef PLSSVM_BACKENDS_KOKKOS_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HPP_
-#define PLSSVM_BACKENDS_KOKKOS_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HPP_
+#ifndef PLSSVM_BACKENDS_KOKKOS_KERNEL_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HPP_
+#define PLSSVM_BACKENDS_KOKKOS_KERNEL_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HPP_
 #pragma once
 
 #include "plssvm/backends/Kokkos/detail/standard_layout_tuple.hpp"  // plssvm::kokkos::detail::standard_layout_tuple
 #include "plssvm/backends/Kokkos/kernel/kernel_functions.hpp"       // plssvm::kokkos::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                                     // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                                     // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                         // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                              // plssvm::target_platform
 
 #include "Kokkos_Core.hpp"  // KOKKOS_INLINE_FUNCTION, Kokkos::View, Kokkos::TeamPolicy, Kokkos::mdspan, Kokkos::dextents
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
+#include <utility>  // std::move
 
 namespace plssvm::kokkos::detail {
 
 /**
  * @brief Create the explicit kernel matrix using the @p kernel_function.
  * @tparam ExecutionSpace the Kokkos::ExecutionSpace used to execute the kernel
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function; stored in a `standard_layout_tuple`
  */
-template <typename ExecutionSpace, kernel_function_type kernel_function, typename... Args>
+template <typename ExecutionSpace, target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_assembly {
     /**
      * @brief The type of the used Kokkos::View.
@@ -41,11 +45,11 @@ class device_kernel_assembly {
   public:
     /**
      * @brief Initialize the Kokkos kernel function object.
-     * @param[out] kernel_matrix_d the calculated kernel matrix
-     * @param[in] data_d the data points to calculate the kernel matrix from
+     * @param[out] kernel_matrix the calculated kernel matrix
+     * @param[in] data the data points to calculate the kernel matrix from
      * @param[in] num_rows the number of data points
      * @param[in] device_num_rows the number of rows the current device is responsible for
-     * @param[in] row_offset the first row in @p data_d the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data_d the current device is responsible for
      * @param[in] num_features the number of features per data point
      * @param[in] q the vector used in the dimensional reduction
      * @param[in] QA_cost the scalar used in the dimensional reduction
@@ -55,14 +59,14 @@ class device_kernel_assembly {
      * @param[in] grid_size_x the size of the execution grid in x-dimension
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_assembly(device_view_type<real_type> kernel_matrix_d, device_view_type<real_type> data_d, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t row_offset, const std::size_t num_features, device_view_type<real_type> q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x, Args... kernel_function_parameter) :
-        kernel_matrix_d_{ kernel_matrix_d },
-        data_d_{ data_d },
+    device_kernel_assembly(device_view_type<real_type> kernel_matrix, device_view_type<real_type> data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, device_view_type<real_type> q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x, Args... kernel_function_parameter) :
+        kernel_matrix_{ std::move(kernel_matrix) },
+        data_{ std::move(data) },
         num_rows_{ num_rows },
         device_num_rows_{ device_num_rows },
-        row_offset_{ row_offset },
+        device_row_offset_{ device_row_offset },
         num_features_{ num_features },
-        q_{ q },
+        q_{ std::move(q) },
         QA_cost_{ QA_cost },
         cost_{ cost },
         grid_x_offset_{ grid_x_offset },
@@ -77,81 +81,103 @@ class device_kernel_assembly {
      */
     KOKKOS_INLINE_FUNCTION
     void operator()(const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &team) const {
+        // cast values to 32-bit unsigned int values to prevent implicit conversions
+        const auto team_rank_x = static_cast<unsigned>(team.team_rank()) / THREAD_BLOCK_SIZE;
+        const auto team_rank_y = static_cast<unsigned>(team.team_rank()) % THREAD_BLOCK_SIZE;
+
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_sz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_sz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_sz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_sz = static_cast<std::size_t>(PADDING_SIZE);
-        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_sz;            // current thread in block x-dimension
-        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_sz;            // current thread in block y-dimension
-        const auto blockDim_x = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block x-dimension
-        const auto blockDim_y = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block y-dimension
-        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-        // calculate the indices used in the current thread
-        const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_sz;  // # rhs -> num_rhs
-        const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
-        const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_sz;  // # rows -> num_mirror_rows
-        const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
-
-        // create the shared memory arrays used for caching data point features
-        constexpr std::size_t shmem_size = FEATURE_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE;
-        real_type *data_cache_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(2 * shmem_size));
-        Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_cache_i{ data_cache_ptr, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-        Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_cache_j{ data_cache_ptr + shmem_size, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-
-        // only calculate the upper triangular matrix -> can't use threadIdx since all threads in a warp must progress further
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_uz;            // current thread in team x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_uz;            // current thread in team y-dimension
+        const auto blockDim_x = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team x-dimension
+        const auto blockDim_y = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current team in league x-dimension + offsets if the league size is too large
+        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current team in league y-dimension + offsets if the league size is too large
+
+        // create two scratchpad memory arrays used for caching
+        constexpr std::size_t scratchpad_size = THREAD_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz * INTERNAL_BLOCK_SIZE_uz;
+        auto *scratchpad_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(std::size_t{ 2 } * scratchpad_size * sizeof(real_type)));
+        const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_i_cache{ scratchpad_ptr, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+        const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_j_cache{ scratchpad_ptr + scratchpad_size, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+
+        // only calculate the upper triangular matrix -> can't use team.team_rank() since all threads in a team must progress further
         if (blockIdx_x >= blockIdx_y) {
             // create a thread private array used for internal caching
-            real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-            // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (std::size_t dim = 0; dim < num_features_; dim += FEATURE_BLOCK_SIZE_sz) {
-                // load data into shared memory
-                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_i = row_offset_ + i_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-                    const auto global_j = row_offset_ + j_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    data_cache_i(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = data_d_[(dim + threadIdx_y) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_sz) + global_i];
-                    data_cache_i(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = data_d_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_sz) + global_i];
-                    data_cache_j(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = data_d_[(dim + threadIdx_y) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_sz) + global_j];
-                    data_cache_j(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = data_d_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_sz) + global_j];
-                }
-                team.team_barrier();  // wait until all threads loaded their part of the data
-
-                // perform the feature reduction calculation
-                for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i(block_dim, threadIdx_x * INTERNAL_BLOCK_SIZE + internal_i),
-                                                                                                    data_cache_j(block_dim, threadIdx_y * INTERNAL_BLOCK_SIZE + internal_j));
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+            {
+                // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+                const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rows - device_row_offset
+                const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
+
+                // iterate over all features using blocking to be able to cache them for faster memory accesses
+                for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
+                    // load data into scratchpad memory
+                    for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_i_idx_linear = device_row_offset_ + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                        const auto global_j_idx_linear = device_row_offset_ + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                        // store the values in the scratchpad memory
+                        data_i_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = data_[(feature_block + threadIdx_y) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                        data_j_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = data_[(feature_block + threadIdx_y) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
+                    }
+                    team.team_barrier();  // wait until all threads loaded their part of the data
+
+                    if constexpr (target == target_platform::cpu) {
+                        // perform the feature reduction calculation, the feature is the fastest moving index
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                real_type sum{ 0.0 };
+                                for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                    sum += detail::feature_reduce<kernel_function>(data_i_cache(feature, team_rank_x * INTERNAL_BLOCK_SIZE + internal_i),
+                                                                                   data_j_cache(feature, team_rank_y * INTERNAL_BLOCK_SIZE + internal_j));
+                                }
+                                temp[internal_i][internal_j] += sum;
+                            }
+                        }
+                    } else {
+                        // perform the feature reduction calculation, the feature is the slowest moving index
+                        for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                    temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache(feature, team_rank_x * INTERNAL_BLOCK_SIZE + internal_i),
+                                                                                                            data_j_cache(feature, team_rank_y * INTERNAL_BLOCK_SIZE + internal_j));
+                                }
+                            }
                         }
                     }
+                    team.team_barrier();  // wait until all threads performed their part of the calculations
                 }
-                team.team_barrier();  // wait until all threads performed their part of the calculations
             }
 
+            // calculate the indices used in the current thread
+            const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+            const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
             // apply the remaining part of the kernel function and store the value in the output kernel matrix
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    // calculate the indices to access the kernel matrix (the part stored on the current device)
-                    const auto device_global_i = i + static_cast<std::size_t>(internal_i);
-                    const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal_i);
-                    const auto device_global_j = j + static_cast<std::size_t>(internal_j);
-                    const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-
-                    // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                    if (device_global_i < (num_rows_ - row_offset_) && device_global_j < device_num_rows_ && global_i >= global_j) {
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_i_idx = device_row_offset_ + device_global_i_idx;
+                    const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                    if (device_global_i_idx < (num_rows_ - device_row_offset_) && device_global_j_idx < device_num_rows_ && global_i_idx >= global_j_idx) {
                         real_type temp_ij = temp[internal_i][internal_j];
-                        temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i] - q_[global_j];
+                        // apply the final kernel function
+                        temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i_idx] - q_[global_j_idx];
                         // apply the cost on the diagonal
-                        if (global_i == global_j) {
+                        if (global_i_idx == global_j_idx) {
                             temp_ij += cost_;
                         }
-                        // update the kernel matrix
-                        kernel_matrix_d_[device_global_j * (num_rows_ - row_offset_ + PADDING_SIZE_sz) - device_global_j * (device_global_j + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i] = temp_ij;
+                        // update the upper triangular kernel matrix
+                        kernel_matrix_[device_global_j_idx * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i_idx] = temp_ij;
                     }
                 }
             }
@@ -160,11 +186,11 @@ class device_kernel_assembly {
 
   private:
     /// @cond Doxygen_suppress
-    device_view_type<real_type> kernel_matrix_d_;
-    device_view_type<const real_type> data_d_;
+    device_view_type<real_type> kernel_matrix_;
+    device_view_type<const real_type> data_;
     const std::size_t num_rows_;
     const std::size_t device_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_row_offset_;
     const std::size_t num_features_;
     device_view_type<const real_type> q_;
     const real_type QA_cost_;
@@ -178,4 +204,4 @@ class device_kernel_assembly {
 
 }  // namespace plssvm::kokkos::detail
 
-#endif  // PLSSVM_BACKENDS_KOKKOS_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HPP_
+#endif  // PLSSVM_BACKENDS_KOKKOS_KERNEL_CG_EXPLICIT_KERNEL_MATRIX_ASSEMBLY_HPP_
diff --git a/include/plssvm/backends/Kokkos/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp b/include/plssvm/backends/Kokkos/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
index b22f69885..0fa591317 100644
--- a/include/plssvm/backends/Kokkos/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
+++ b/include/plssvm/backends/Kokkos/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
@@ -9,28 +9,32 @@
  * @brief Functions for implicitly assembling the kernel matrix using the Kokkos backend.
  */
 
-#ifndef PLSSVM_BACKENDS_KOKKOS_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
-#define PLSSVM_BACKENDS_KOKKOS_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#ifndef PLSSVM_BACKENDS_KOKKOS_KERNEL_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#define PLSSVM_BACKENDS_KOKKOS_KERNEL_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
 #pragma once
 
 #include "plssvm/backends/Kokkos/detail/standard_layout_tuple.hpp"  // plssvm::kokkos::detail::standard_layout_tuple
 #include "plssvm/backends/Kokkos/kernel/kernel_functions.hpp"       // plssvm::kokkos::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                                     // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                                     // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                         // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                              // plssvm::target_platform
 
 #include "Kokkos_Core.hpp"  // KOKKOS_INLINE_FUNCTION, Kokkos::View, Kokkos::TeamPolicy, Kokkos::mdspan, Kokkos::dextents, Kokkos::atomic_add
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
+#include <utility>  // std::move
 
 namespace plssvm::kokkos::detail {
 
 /**
  * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel_function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
  * @tparam ExecutionSpace the Kokkos::ExecutionSpace used to execute the kernel
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
  */
-template <typename ExecutionSpace, kernel_function_type kernel_function, typename... Args>
+template <typename ExecutionSpace, target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_assembly_symm {
     /**
      * @brief The type of the used Kokkos::View.
@@ -43,10 +47,10 @@ class device_kernel_assembly_symm {
      * @brief Initialize the Kokkos kernel function object.
      * @param[in] alpha the scalar alpha value
      * @param[in] q the vector used in the dimensional reduction
-     * @param[in] data_d the data points to calculate the implicit kernel matrix from
+     * @param[in] data the data points to calculate the implicit kernel matrix from
      * @param[in] num_rows the total number of data points (= total number of rows)
      * @param[in] device_num_rows the number of rows the current device is responsible for
-     * @param[in] row_offset the first row in @p data_d the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data the current device is responsible for
      * @param[in] num_features the number of features per data point
      * @param[in] QA_cost the scalar used in the dimensional reduction
      * @param[in] cost the cost factor the diagonal is scaled with
@@ -58,18 +62,18 @@ class device_kernel_assembly_symm {
      * @param[in] grid_size_x the size of the execution grid in x-dimension
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_assembly_symm(const real_type alpha, device_view_type<const real_type> q, device_view_type<const real_type> data_d, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, device_view_type<const real_type> B, device_view_type<real_type> C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x, Args... kernel_function_parameter) :
+    device_kernel_assembly_symm(const real_type alpha, device_view_type<const real_type> q, device_view_type<const real_type> data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, device_view_type<const real_type> B, device_view_type<real_type> C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x, Args... kernel_function_parameter) :
         alpha_{ alpha },
-        q_{ q },
-        data_d_{ data_d },
+        q_{ std::move(q) },
+        data_{ std::move(data) },
         num_rows_{ num_rows },
         device_num_rows_{ device_num_rows },
-        row_offset_{ row_offset },
+        device_row_offset_{ device_row_offset },
         num_features_{ num_features },
         QA_cost_{ QA_cost },
         cost_{ cost },
-        B_{ B },
-        C_{ C },
+        B_{ std::move(B) },
+        C_{ std::move(C) },
         num_classes_{ num_classes },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
@@ -82,59 +86,81 @@ class device_kernel_assembly_symm {
      */
     KOKKOS_INLINE_FUNCTION
     void operator()(const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &team) const {
+        // cast values to 32-bit unsigned int values to prevent implicit conversions
+        const auto team_rank_x = static_cast<unsigned>(team.team_rank()) / THREAD_BLOCK_SIZE;
+        const auto team_rank_y = static_cast<unsigned>(team.team_rank()) % THREAD_BLOCK_SIZE;
+
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_sz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_sz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_sz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_sz = static_cast<std::size_t>(PADDING_SIZE);
-        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_sz;            // current thread in block x-dimension
-        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_sz;            // current thread in block y-dimension
-        const auto blockDim_x = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block x-dimension
-        const auto blockDim_y = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block y-dimension
-        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_uz;            // current thread in team x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_uz;            // current thread in team y-dimension
+        const auto blockDim_x = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team x-dimension
+        const auto blockDim_y = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current team in league x-dimension + offsets if the league size is too large
+        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current team in league y-dimension + offsets if the league size is too large
 
         // calculate the indices used in the current thread
-        const auto i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_sz;  // # rhs -> num_rhs
-        const auto i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
-        const auto j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_sz;  // # rows -> num_mirror_rows
-        const auto j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
+        const auto i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+        const auto j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const auto i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rows - device_row_offset
+        const auto j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
 
-        // only calculate the upper triangular matrix -> can't use threadIdx since all threads in a warp must progress further
+        // get the scratchpad memory pointer for later usage
+        constexpr std::size_t scratchpad_size = THREAD_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz * INTERNAL_BLOCK_SIZE_uz;
+        auto *scratchpad_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(std::size_t{ 2 } * scratchpad_size * sizeof(real_type)));
+
+        // only calculate the upper triangular matrix -> can't use team.team_rank() since all threads in a team must progress further
         if (blockIdx_x >= blockIdx_y) {
             // create a thread private array used for internal caching
-            real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-            // create the shared memory arrays used for caching data point features
-            constexpr std::size_t shmem_size = FEATURE_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE;
-            real_type *data_cache_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(2 * shmem_size));
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
+            //*************************************************************************//
+            //                   inplace kernel matrix construction                    //
+            //*************************************************************************//
             {
-                // create the shared memory arrays used for caching data point features
-                Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_cache_i{ data_cache_ptr, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-                Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_cache_j{ data_cache_ptr + shmem_size, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
+                // reinterpret the scratchpad memory to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+                const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_i_cache{ scratchpad_ptr, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+                const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_j_cache{ scratchpad_ptr + scratchpad_size, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
 
                 // iterate over all features using blocking to be able to cache them for faster memory accesses
-                for (std::size_t dim = 0; dim < num_features_; dim += FEATURE_BLOCK_SIZE_sz) {
-                    // load data into shared memory
+                for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
+                    // load data into scratchpad memory
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_i = row_offset_ + i_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-                        const auto global_j = row_offset_ + j_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-
-                        // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                        data_cache_i(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = data_d_[(dim + threadIdx_y) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_sz) + global_i];
-                        data_cache_i(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = data_d_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_sz) + global_i];
-                        data_cache_j(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = data_d_[(dim + threadIdx_y) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_sz) + global_j];
-                        data_cache_j(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = data_d_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_sz) + global_j];
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_i_idx_linear = device_row_offset_ + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                        const auto global_j_idx_linear = device_row_offset_ + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                        // store the values in the scratchpad memory
+                        data_i_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = data_[(feature_block + threadIdx_y) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                        data_j_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = data_[(feature_block + threadIdx_y) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
                     }
                     team.team_barrier();  // wait until all threads loaded their part of the data
 
-                    // perform the feature reduction calculation
-                    for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                    if constexpr (target == target_platform::cpu) {
+                        // perform the feature reduction calculation, the feature is the fastest moving index
                         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i(block_dim, threadIdx_x * INTERNAL_BLOCK_SIZE + internal_i),
-                                                                                                        data_cache_j(block_dim, threadIdx_y * INTERNAL_BLOCK_SIZE + internal_j));
+                                real_type sum{ 0.0 };
+                                for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                    sum += detail::feature_reduce<kernel_function>(data_i_cache(feature, team_rank_x * INTERNAL_BLOCK_SIZE + internal_i),
+                                                                                   data_j_cache(feature, team_rank_y * INTERNAL_BLOCK_SIZE + internal_j));
+                                }
+                                temp[internal_i][internal_j] += sum;
+                            }
+                        }
+                    } else {
+                        // perform the feature reduction calculation, the feature is the slowest moving index
+                        for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                    temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache(feature, team_rank_x * INTERNAL_BLOCK_SIZE + internal_i),
+                                                                                                            data_j_cache(feature, team_rank_y * INTERNAL_BLOCK_SIZE + internal_j));
+                                }
                             }
                         }
                     }
@@ -145,16 +171,18 @@ class device_kernel_assembly_symm {
             // apply the remaining part of the kernel function and store the value in the output kernel matrix
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal_i);
-                    const auto device_global_i = i + static_cast<std::size_t>(internal_i);
-                    const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-                    const auto device_global_j = j + static_cast<std::size_t>(internal_j);
-
-                    // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                    if ((device_global_i < (num_rows_ - row_offset_) && device_global_j < device_num_rows_ && global_i >= global_j)) {
-                        temp[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp[internal_i][internal_j], kernel_function_parameter_) + QA_cost_ - q_[global_i] - q_[global_j];
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_i_idx = device_row_offset_ + device_global_i_idx;
+                    const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                    if (device_global_i_idx < (num_rows_ - device_row_offset_) && device_global_j_idx < device_num_rows_ && global_i_idx >= global_j_idx) {
+                        // apply the final kernel function
+                        temp[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp[internal_i][internal_j], kernel_function_parameter_) + QA_cost_ - q_[global_i_idx] - q_[global_j_idx];
                         // apply the cost on the diagonal
-                        if (global_i == global_j) {
+                        if (global_i_idx == global_j_idx) {
                             temp[internal_i][internal_j] += cost_;
                         }
                     } else {
@@ -164,42 +192,44 @@ class device_kernel_assembly_symm {
                 }
             }
 
-            // calculate C += alpha * temp * B for the UPPER triangular matrix
+            //*************************************************************************//
+            //     calculate C += alpha * temp * B for the UPPER triangular matrix     //
+            //*************************************************************************//
             {
-                // same shared memory size but with different dimensions
-                Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> B_cache{ data_cache_ptr, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE, FEATURE_BLOCK_SIZE };
-                Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> C_out_cache{ data_cache_ptr + shmem_size, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE, FEATURE_BLOCK_SIZE };
+                // reinterpret the scratchpad memory to be of shape [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][THREAD_BLOCK_SIZE]
+                const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> B_cache{ scratchpad_ptr, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz, THREAD_BLOCK_SIZE_uz };
+                const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> C_out_cache{ scratchpad_ptr + scratchpad_size, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz, THREAD_BLOCK_SIZE_uz };
 
                 // iterate over all classes using blocking to be able to cache them for faster memory accesses
-                for (std::size_t dim = 0; dim < num_classes_; dim += FEATURE_BLOCK_SIZE_sz) {
-                    // load data into shared memory
+                for (std::size_t class_block = 0; class_block < num_classes_; class_block += THREAD_BLOCK_SIZE_uz) {
+                    // load data into scratchpad memory
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_i = row_offset_ + i_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_i_idx_linear = device_row_offset_ + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                        // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                        B_cache(internal * THREAD_BLOCK_SIZE + threadIdx_x, threadIdx_y) = alpha_ * B_[global_i * (num_classes_ + PADDING_SIZE_sz) + dim + threadIdx_y];
-                        B_cache(internal * THREAD_BLOCK_SIZE + threadIdx_x, threadIdx_y + THREAD_BLOCK_SIZE) = alpha_ * B_[global_i * (num_classes_ + PADDING_SIZE_sz) + dim + threadIdx_y + THREAD_BLOCK_SIZE_sz];
-                        C_out_cache(internal * THREAD_BLOCK_SIZE + threadIdx_x, threadIdx_y) = real_type{ 0.0 };
-                        C_out_cache(internal * THREAD_BLOCK_SIZE + threadIdx_x, threadIdx_y + THREAD_BLOCK_SIZE) = real_type{ 0.0 };
+                        // store the values in the scratchpad memory
+                        B_cache(internal * THREAD_BLOCK_SIZE + team_rank_x, team_rank_y) = alpha_ * B_[global_i_idx_linear * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_y];  // SoA
+                        C_out_cache(internal * THREAD_BLOCK_SIZE + team_rank_x, team_rank_y) = real_type{ 0.0 };                                                                             // SoA
                     }
                     team.team_barrier();  // wait until all threads loaded their part of the data
 
-                    // calculate intermediate results and store them in shared memory
-                    for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                    // calculate intermediate results and store them in scratchpad memory
+                    for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                C_out_cache(threadIdx_y * INTERNAL_BLOCK_SIZE + internal_j, (class_idx + threadIdx_x) % FEATURE_BLOCK_SIZE) +=
-                                    temp[internal_i][internal_j] * B_cache(threadIdx_x * INTERNAL_BLOCK_SIZE + internal_i, (class_idx + threadIdx_x) % FEATURE_BLOCK_SIZE);
+                                C_out_cache(team_rank_y * INTERNAL_BLOCK_SIZE + internal_j, (class_idx + team_rank_x) % THREAD_BLOCK_SIZE) +=
+                                    temp[internal_i][internal_j] * B_cache(team_rank_x * INTERNAL_BLOCK_SIZE + internal_i, (class_idx + team_rank_x) % THREAD_BLOCK_SIZE);
                             }
                         }
                         team.team_barrier();  // wait until all threads performed their part of the calculations
                     }
 
-                    // add intermediate cached results to C
+                    // atomically add intermediate cached results to the C matrix
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal);
-                        Kokkos::atomic_add(&C_[global_j * (num_classes_ + PADDING_SIZE_sz) + dim + threadIdx_x], C_out_cache(threadIdx_y * INTERNAL_BLOCK_SIZE + internal, threadIdx_x));
-                        Kokkos::atomic_add(&C_[global_j * (num_classes_ + PADDING_SIZE_sz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_sz], C_out_cache(threadIdx_y * INTERNAL_BLOCK_SIZE + internal, threadIdx_x + THREAD_BLOCK_SIZE));
+                        // calculate the indices to access the global data
+                        const auto global_j_idx = device_row_offset_ + j_idx + static_cast<std::size_t>(internal);
+
+                        Kokkos::atomic_add(&C_[global_j_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x], C_out_cache(team_rank_y * INTERNAL_BLOCK_SIZE + internal, team_rank_x));  // SoA
                     }
                     team.team_barrier();  // wai until all threads updated C with their values
                 }
@@ -208,51 +238,54 @@ class device_kernel_assembly_symm {
             // set potential diagonal entries in temp to 0.0 such that we don't apply the main diagonal twice to C
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal_i);
-                    const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
+                    // calculate the indices to access the global data
+                    const auto global_i_idx = device_row_offset_ + i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_j_idx = device_row_offset_ + j_idx + static_cast<std::size_t>(internal_j);
 
-                    if (global_i == global_j) {
+                    if (global_i_idx == global_j_idx) {
                         temp[internal_i][internal_j] = real_type{ 0.0 };
                     }
                 }
             }
 
-            // calculate C += alpha * temp * B for the LOWER triangular matrix
+            //*************************************************************************//
+            //     calculate C += alpha * temp * B for the LOWER triangular matrix     //
+            //*************************************************************************//
             {
-                // same shared memory size but with different dimensions
-                Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> B_cache{ data_cache_ptr, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-                Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> C_out_cache{ data_cache_ptr + shmem_size, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
+                // reinterpret the scratchpad memory to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+                const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> B_cache{ scratchpad_ptr, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+                const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> C_out_cache{ scratchpad_ptr + scratchpad_size, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
 
                 // iterate over all classes using blocking to be able to cache them for faster memory accesses
-                for (std::size_t dim = 0; dim < num_classes_; dim += FEATURE_BLOCK_SIZE_sz) {
-                    // load data into shared memory
+                for (std::size_t class_block = 0; class_block < num_classes_; class_block += THREAD_BLOCK_SIZE_uz) {
+                    // load data into scratchpad memory
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_j = row_offset_ + j_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_j_idx_linear = device_row_offset_ + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                        // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                        B_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = alpha_ * B_[global_j * (num_classes_ + PADDING_SIZE_sz) + dim + threadIdx_y];
-                        B_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = alpha_ * B_[global_j * (num_classes_ + PADDING_SIZE_sz) + dim + threadIdx_y + THREAD_BLOCK_SIZE_sz];
-                        C_out_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = real_type{ 0.0 };
-                        C_out_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = real_type{ 0.0 };
+                        // store the values in the scratchpad memory
+                        B_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = alpha_ * B_[global_j_idx_linear * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_y];  // SoA
+                        C_out_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = real_type{ 0.0 };
                     }
                     team.team_barrier();  // wait until all threads loaded their part of the data
 
-                    // calculate intermediate results and store them in shared memory
-                    for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                    // calculate intermediate results and store them in scratchpad memory
+                    for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                C_out_cache((class_idx + threadIdx_y) % FEATURE_BLOCK_SIZE, internal_i * THREAD_BLOCK_SIZE + threadIdx_x) +=
-                                    temp[internal_i][internal_j] * B_cache((class_idx + threadIdx_y) % FEATURE_BLOCK_SIZE, threadIdx_y * INTERNAL_BLOCK_SIZE + internal_j);
+                                C_out_cache((class_idx + team_rank_y) % THREAD_BLOCK_SIZE, internal_i * THREAD_BLOCK_SIZE + team_rank_x) +=
+                                    temp[internal_i][internal_j] * B_cache((class_idx + team_rank_y) % THREAD_BLOCK_SIZE, team_rank_y * INTERNAL_BLOCK_SIZE + internal_j);
                             }
                         }
                         team.team_barrier();  // wait until all threads performed their part of the calculations
                     }
 
-                    // add intermediate cached results to C
+                    // atomically add the intermediate cached results to the C matrix
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal);
-                        Kokkos::atomic_add(&C_[global_i * (num_classes_ + PADDING_SIZE_sz) + dim + threadIdx_y], C_out_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x));
-                        Kokkos::atomic_add(&C_[global_i * (num_classes_ + PADDING_SIZE_sz) + dim + threadIdx_y + THREAD_BLOCK_SIZE_sz], C_out_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x));
+                        // calculate the indices to access the global data
+                        const auto global_i_idx = device_row_offset_ + i_idx + static_cast<std::size_t>(internal);
+
+                        Kokkos::atomic_add(&C_[global_i_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_y], C_out_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x));  // SoA
                     }
                     team.team_barrier();  // wait until all threads updated C with their values
                 }
@@ -264,10 +297,10 @@ class device_kernel_assembly_symm {
     /// @cond Doxygen_suppress
     const real_type alpha_;
     device_view_type<const real_type> q_;
-    device_view_type<const real_type> data_d_;
+    device_view_type<const real_type> data_;
     const std::size_t num_rows_;
     const std::size_t device_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_row_offset_;
     const std::size_t num_features_;
     const real_type QA_cost_;
     const real_type cost_;
@@ -283,4 +316,4 @@ class device_kernel_assembly_symm {
 
 }  // namespace plssvm::kokkos::detail
 
-#endif  // PLSSVM_BACKENDS_KOKKOS_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#endif  // PLSSVM_BACKENDS_KOKKOS_KERNEL_CG_IMPLICIT_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
diff --git a/include/plssvm/backends/Kokkos/kernel/kernel_functions.hpp b/include/plssvm/backends/Kokkos/kernel/kernel_functions.hpp
index a2859a294..e7db76bc7 100644
--- a/include/plssvm/backends/Kokkos/kernel/kernel_functions.hpp
+++ b/include/plssvm/backends/Kokkos/kernel/kernel_functions.hpp
@@ -11,6 +11,7 @@
 
 #ifndef PLSSVM_BACKENDS_KOKKOS_KERNEL_KERNEL_FUNCTIONS_HPP_
 #define PLSSVM_BACKENDS_KOKKOS_KERNEL_KERNEL_FUNCTIONS_HPP_
+#pragma once
 
 #include "plssvm/backends/Kokkos/detail/standard_layout_tuple.hpp"  // plssvm::kokkos::detail::standard_layout_tuple
 #include "plssvm/constants.hpp"                                     // plssvm::real_type
@@ -45,42 +46,17 @@ template <typename T>
 
 /**
  * @brief Fast integer power function. Computes base^exponent and takes advantage of the fact that degree may only be positive integer values.
- * @details Hardcodes the power function for degree <= 6, uses a simple for loop otherwise.
  * @param[in] base the base
  * @param[in] exponent the exponent
  * @return base^exponent (`[[nodiscard]]`)
  */
 [[nodiscard]] KOKKOS_INLINE_FUNCTION real_type powi(const real_type base, const int exponent) {
-    switch (exponent) {
-        case 0: return real_type{ 1.0 };
-        case 1: return base;
-        case 2: return base * base;
-        case 3: return base * base * base;
-        case 4:
-            {
-                const real_type temp = base * base;
-                return temp * temp;
-            }
-        case 5:
-            {
-                const real_type temp = base * base;
-                return temp * temp * base;
-            }
-        case 6:
-            {
-                const real_type temp = base * base * base;
-                return temp * temp;
-            }
-        default:
-            {
-                // generic integer power function
-                real_type result{ 1.0 };
-                for (int i = 0; i < exponent; ++i) {
-                    result *= base;
-                }
-                return result;
-            }
+    // generic integer power function
+    real_type result{ 1.0 };
+    for (int i = 0; i < exponent; ++i) {
+        result *= base;
     }
+    return result;
 }
 
 //***************************************************//
diff --git a/include/plssvm/backends/Kokkos/kernel/predict_kernel.hpp b/include/plssvm/backends/Kokkos/kernel/predict_kernel.hpp
index 767bfc958..aa251807d 100644
--- a/include/plssvm/backends/Kokkos/kernel/predict_kernel.hpp
+++ b/include/plssvm/backends/Kokkos/kernel/predict_kernel.hpp
@@ -9,25 +9,30 @@
  * @brief Defines the functions used for prediction for the C-SVM using the Kokkos backend.
  */
 
-#ifndef PLSSVM_BACKENDS_KOKKOS_PREDICT_KERNEL_HPP_
-#define PLSSVM_BACKENDS_KOKKOS_PREDICT_KERNEL_HPP_
+#ifndef PLSSVM_BACKENDS_KOKKOS_KERNEL_PREDICT_KERNEL_HPP_
+#define PLSSVM_BACKENDS_KOKKOS_KERNEL_PREDICT_KERNEL_HPP_
 #pragma once
 
-#include "plssvm/backends/Kokkos/kernel/kernel_functions.hpp"  // plssvm::kokkos::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                                // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
-#include "plssvm/kernel_function_types.hpp"                    // plssvm::kernel_function_type
+#include "plssvm/backends/Kokkos/detail/standard_layout_tuple.hpp"  // plssvm::kokkos::detail::standard_layout_tuple
+#include "plssvm/backends/Kokkos/kernel/kernel_functions.hpp"       // plssvm::kokkos::detail::{feature_reduce, apply_kernel_function}
+#include "plssvm/constants.hpp"                                     // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/kernel_function_types.hpp"                         // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                              // plssvm::target_platform
 
 #include "Kokkos_Core.hpp"  // KOKKOS_INLINE_FUNCTION, Kokkos::View, Kokkos::TeamPolicy, Kokkos::mdspan, Kokkos::dextents, Kokkos::atomic_add
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
+#include <utility>  // std::move
 
 namespace plssvm::kokkos::detail {
 
 /**
- * @brief Calculate the `q` vector used to speedup the prediction using the linear kernel function.
+ * @brief Calculate the `w` vector used to speedup the prediction using the linear kernel function.
  * @tparam ExecutionSpace the Kokkos::ExecutionSpace used to execute the kernel
+ * @tparam target the target platform
  */
-template <typename ExecutionSpace>
+template <typename ExecutionSpace, target_platform target>
 class device_kernel_w_linear {
     /**
      * @brief The type of the used Kokkos::View.
@@ -38,25 +43,25 @@ class device_kernel_w_linear {
   public:
     /**
      * @brief Initialize the Kokkos kernel function object.
-     * @param[in,out] w_d the vector to speedup the linear prediction
-     * @param[in] alpha_d the previously learned weights
-     * @param[in] sv_d the support vectors
+     * @param[in,out] w the vector to speedup the linear prediction
+     * @param[in] alpha the previously learned weights
+     * @param[in] support_vectors the support vectors
      * @param[in] num_classes the number of classes
      * @param[in] num_sv the number of support vectors
-     * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
-     * @param[in] sv_offset the first support vector (row in @p alpha_d) the current device is responsible for
+     * @param[in] device_num_sv the number of support vectors the current device is responsible for
+     * @param[in] device_sv_offset the first support vector (row in @p alpha) the current device is responsible for
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_size_x the size of the execution grid in x-dimension
      */
-    device_kernel_w_linear(device_view_type<real_type> w_d, device_view_type<const real_type> alpha_d, device_view_type<const real_type> sv_d, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_specific_num_sv, const std::size_t sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x) :
-        w_d_{ w_d },
-        alpha_d_{ alpha_d },
-        sv_d_{ sv_d },
+    device_kernel_w_linear(device_view_type<real_type> w, device_view_type<const real_type> alpha, device_view_type<const real_type> support_vectors, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_num_sv, const std::size_t device_sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x) :
+        w_{ std::move(w) },
+        alpha_{ std::move(alpha) },
+        support_vectors_{ std::move(support_vectors) },
         num_classes_{ num_classes },
         num_sv_{ num_sv },
-        device_specific_num_sv_{ device_specific_num_sv },
-        sv_offset_{ sv_offset },
+        device_num_sv_{ device_num_sv },
+        device_sv_offset_{ device_sv_offset },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
         grid_size_x_{ grid_size_x } { }
@@ -67,75 +72,100 @@ class device_kernel_w_linear {
      */
     KOKKOS_INLINE_FUNCTION
     void operator()(const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &team) const {
-        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_sz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_sz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto PADDING_SIZE_sz = static_cast<std::size_t>(PADDING_SIZE);
-        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_sz;            // current thread in block x-dimension
-        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_sz;            // current thread in block y-dimension
-        const auto blockDim_x = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block x-dimension
-        const auto blockDim_y = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block y-dimension
-        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-        // calculate the indices used in the current thread
-        const auto feature_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_sz;
-        const auto feature_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
-        const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_sz;
-        const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
+        // cast values to 32-bit unsigned int values to prevent implicit conversions
+        const auto team_rank_x = static_cast<unsigned>(team.team_rank()) / THREAD_BLOCK_SIZE;
+        const auto team_rank_y = static_cast<unsigned>(team.team_rank()) % THREAD_BLOCK_SIZE;
 
-        // create the shared memory arrays used for caching data point features
-        constexpr std::size_t shmem_size = THREAD_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE;
-        real_type *data_cache_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(2 * shmem_size));
-        Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_cache_feature{ data_cache_ptr, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-        Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_cache_alpha{ data_cache_ptr + shmem_size, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
+        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_uz;            // current thread in team x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_uz;            // current thread in team y-dimension
+        const auto blockDim_x = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team x-dimension
+        const auto blockDim_y = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current team in league x-dimension + offsets if the league size is too large
+        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current team in league y-dimension + offsets if the league size is too large
+
+        // create two scratchpad memory arrays used for caching
+        constexpr std::size_t scratchpad_size = THREAD_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz * INTERNAL_BLOCK_SIZE_uz;
+        auto *scratchpad_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(std::size_t{ 2 } * scratchpad_size * sizeof(real_type)));
+        const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> feature_cache{ scratchpad_ptr, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+        const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> alpha_cache{ scratchpad_ptr + scratchpad_size, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
 
         // create a thread private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-        // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-        for (std::size_t sv = 0; sv < device_specific_num_sv_; sv += THREAD_BLOCK_SIZE_sz) {
-            // load data into shared memory
-            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_feature_idx = feature_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-                const auto global_class_idx = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
+        {
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto feature_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_features
+            const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;    // num_classes
 
-                data_cache_feature(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = sv_d_[global_feature_idx * (device_specific_num_sv_ + PADDING_SIZE_sz) + sv + threadIdx_y];  // SoA
-                data_cache_alpha(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = alpha_d_[global_class_idx * (num_sv_ + PADDING_SIZE_sz) + sv + sv_offset_ + threadIdx_y];      // AoS
-            }
-            team.team_barrier();  // wait until all threads loaded their part of the data
+            // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
+            for (std::size_t sv_block = 0; sv_block < device_num_sv_; sv_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into scratchpad memory
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_feature_idx_linear = feature_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-            // perform the dot product calculation
-            for (unsigned block_dim = 0; block_dim < THREAD_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
-                    for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                        temp[internal_feature][internal_class] += data_cache_alpha(block_dim, threadIdx_y * INTERNAL_BLOCK_SIZE + internal_class) * data_cache_feature(block_dim, threadIdx_x * INTERNAL_BLOCK_SIZE + internal_feature);
+                    // store the values in the scratchpad memory
+                    feature_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = support_vectors_[global_feature_idx_linear * (device_num_sv_ + PADDING_SIZE_uz) + sv_block + threadIdx_y];  // SoA
+                    alpha_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = alpha_[global_class_idx_linear * (num_sv_ + PADDING_SIZE_uz) + sv_block + device_sv_offset_ + threadIdx_y];   // AoS
+                }
+                team.team_barrier();  // wait until all threads loaded their part of the data
+
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the sv is the fastest moving index
+                    for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                            real_type sum{ 0.0 };
+                            for (unsigned sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                                sum += alpha_cache(sv, team_rank_y * INTERNAL_BLOCK_SIZE + internal_class) * feature_cache(sv, team_rank_x * INTERNAL_BLOCK_SIZE + internal_feature);
+                            }
+                            temp[internal_feature][internal_class] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the sv is the slowest moving index
+                    for (unsigned sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                        for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                temp[internal_feature][internal_class] += alpha_cache(sv, team_rank_y * INTERNAL_BLOCK_SIZE + internal_class) * feature_cache(sv, team_rank_x * INTERNAL_BLOCK_SIZE + internal_feature);
+                            }
+                        }
                     }
                 }
+                team.team_barrier();  // wait until all threads performed their part of the calculations
             }
-            team.team_barrier();  // wait until all threads performed their part of the calculations
         }
 
-        // update global array with local one
+        // calculate the indices used in the current thread
+        const auto feature_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+        const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;    // num_classes
+
+        // update the global w-vector with the locally cached values
         for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
             for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                // calculate the indices to access the global data
                 const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
                 const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                w_d_[global_feature_idx * (num_classes_ + PADDING_SIZE_sz) + global_class_idx] = temp[internal_feature][internal_class];
+                w_[global_feature_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp[internal_feature][internal_class];  // SoA
             }
         }
     }
 
   private:
     /// @cond Doxygen_suppress
-    device_view_type<real_type> w_d_;
-    device_view_type<const real_type> alpha_d_;
-    device_view_type<const real_type> sv_d_;
+    device_view_type<real_type> w_;
+    device_view_type<const real_type> alpha_;
+    device_view_type<const real_type> support_vectors_;
     const std::size_t num_classes_;
     const std::size_t num_sv_;
-    const std::size_t device_specific_num_sv_;
-    const std::size_t sv_offset_;
+    const std::size_t device_num_sv_;
+    const std::size_t device_sv_offset_;
     const std::size_t grid_x_offset_;
     const std::size_t grid_y_offset_;
     const std::size_t grid_size_x_;
@@ -143,10 +173,11 @@ class device_kernel_w_linear {
 };
 
 /**
- * @brief Predict the @p predict_points_d using the linear kernel speeding up the calculation using the @p w_d vector.
+ * @brief Predict the @p predict_points using the linear kernel speeding up the calculation using the @p w vector.
  * @tparam ExecutionSpace the Kokkos::ExecutionSpace used to execute the kernel
+ * @tparam target the target platform
  */
-template <typename ExecutionSpace>
+template <typename ExecutionSpace, target_platform target>
 class device_kernel_predict_linear {
     /**
      * @brief The type of the used Kokkos::View.
@@ -157,10 +188,10 @@ class device_kernel_predict_linear {
   public:
     /**
      * @brief Initialize the Kokkos kernel function object.
-     * @param[out] prediction_d the predicted values
-     * @param[in] w_d the vector to speedup the calculations
-     * @param[in] rho_d the previously learned bias
-     * @param[in] predict_points_d the data points to predict
+     * @param[out] prediction the predicted values
+     * @param[in] w the vector to speedup the calculations
+     * @param[in] rho the previously learned bias
+     * @param[in] predict_points the data points to predict
      * @param[in] num_classes the number of classes
      * @param[in] num_predict_points the number of data points to predict
      * @param[in] num_features the number of features per data point
@@ -168,11 +199,11 @@ class device_kernel_predict_linear {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_size_x the size of the execution grid in x-dimension
      */
-    device_kernel_predict_linear(device_view_type<real_type> prediction_d, device_view_type<const real_type> w_d, device_view_type<const real_type> rho_d, device_view_type<const real_type> predict_points_d, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x) :
-        prediction_d_{ prediction_d },
-        w_d_{ w_d },
-        rho_d_{ rho_d },
-        predict_points_d_{ predict_points_d },
+    device_kernel_predict_linear(device_view_type<real_type> prediction, device_view_type<const real_type> w, device_view_type<const real_type> rho, device_view_type<const real_type> predict_points, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x) :
+        prediction_{ std::move(prediction) },
+        w_{ std::move(w) },
+        rho_{ std::move(rho) },
+        predict_points_{ std::move(predict_points) },
         num_classes_{ num_classes },
         num_predict_points_{ num_predict_points },
         num_features_{ num_features },
@@ -186,76 +217,97 @@ class device_kernel_predict_linear {
      */
     KOKKOS_INLINE_FUNCTION
     void operator()(const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &team) const {
+        // cast values to 32-bit unsigned int values to prevent implicit conversions
+        const auto team_rank_x = static_cast<unsigned>(team.team_rank()) / THREAD_BLOCK_SIZE;
+        const auto team_rank_y = static_cast<unsigned>(team.team_rank()) % THREAD_BLOCK_SIZE;
+
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_sz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_sz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_sz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_sz = static_cast<std::size_t>(PADDING_SIZE);
-        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_sz;            // current thread in block x-dimension
-        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_sz;            // current thread in block y-dimension
-        const auto blockDim_x = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block x-dimension
-        const auto blockDim_y = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block y-dimension
-        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_uz;            // current thread in team x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_uz;            // current thread in team y-dimension
+        const auto blockDim_x = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team x-dimension
+        const auto blockDim_y = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current team in league x-dimension + offsets if the league size is too large
+        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current team in league y-dimension + offsets if the league size is too large
+
+        // create two scratchpad memory arrays used for caching
+        constexpr std::size_t scratchpad_size = THREAD_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz * INTERNAL_BLOCK_SIZE_uz;
+        auto *scratchpad_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(std::size_t{ 2 } * scratchpad_size * sizeof(real_type)));
+        const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> pp_cache{ scratchpad_ptr, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+        const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> w_cache{ scratchpad_ptr + scratchpad_size, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
 
-        // calculate the indices used in the current thread
-        const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_sz;
-        const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
-        const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_sz;
-        const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
+        // create a thread private array used for internal caching
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-        // create the shared memory arrays used for caching data point features
-        constexpr std::size_t shmem_size = FEATURE_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE;
-        real_type *data_cache_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(2 * shmem_size));
-        Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_cache_pp{ data_cache_ptr, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-        Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_cache_w{ data_cache_ptr + shmem_size, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
+        {
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;     // num_predict_points
+            const auto class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_classes
 
-        // create a thread private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < num_features_; dim += FEATURE_BLOCK_SIZE_sz) {
-            // load data into shared memory
-            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_pp_idx = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-                const auto global_class_idx = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_sz;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                data_cache_pp(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = predict_points_d_[(dim + threadIdx_y) * (num_predict_points_ + PADDING_SIZE_sz) + global_pp_idx];
-                data_cache_pp(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = predict_points_d_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_predict_points_ + PADDING_SIZE_sz) + global_pp_idx];
-                data_cache_w(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = w_d_[(dim + threadIdx_y) * (num_classes_ + PADDING_SIZE_sz) + global_class_idx];
-                data_cache_w(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = w_d_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_classes_ + PADDING_SIZE_sz) + global_class_idx];
-            }
-            team.team_barrier();  // wait until all threads loaded their part of the data
+            // iterate over all features using blocking to be able to cache them for faster memory accesses
+            for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into scratchpad memory
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the scratchpad memory
+                    pp_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = predict_points_[(feature_block + threadIdx_y) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                    w_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = w_[(feature_block + threadIdx_y) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx_linear];                    // SoA
+                }
+                team.team_barrier();  // wait until all threads loaded their part of the data
 
-            // perform the dot product calculation
-            for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
-                    for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                        temp[internal_pd][internal_class] += data_cache_w(block_dim, threadIdx_y * INTERNAL_BLOCK_SIZE + internal_class) * data_cache_pp(block_dim, threadIdx_x * INTERNAL_BLOCK_SIZE + internal_pd);
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the feature is the fastest moving index
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                            real_type sum{ 0.0 };
+                            for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                sum += w_cache(feature, team_rank_y * INTERNAL_BLOCK_SIZE + internal_class) * pp_cache(feature, team_rank_x * INTERNAL_BLOCK_SIZE + internal_pp);
+                            }
+                            temp[internal_pp][internal_class] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the feature is the slowest moving index
+                    for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                temp[internal_pp][internal_class] += w_cache(feature, team_rank_y * INTERNAL_BLOCK_SIZE + internal_class) * pp_cache(feature, team_rank_x * INTERNAL_BLOCK_SIZE + internal_pp);
+                            }
+                        }
                     }
                 }
+                team.team_barrier();  // wait until all threads performed their part of the calculations
             }
-            team.team_barrier();  // wait until all threads performed their part of the calculations
         }
 
-        // update global array with local one
-        for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+        // calculate the indices used in the current thread
+        const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;     // num_predict_points
+        const auto class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
+
+        // update the global array with the local one
+        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
             for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pd);
+                // calculate the indices to access the global data
+                const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
                 const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_sz) + global_class_idx] = temp[internal_pd][internal_class] - rho_d_[global_class_idx];
+                prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp[internal_pp][internal_class] - rho_[global_class_idx];  // AoS
             }
         }
     }
 
   private:
     /// @cond Doxygen_suppress
-    device_view_type<real_type> prediction_d_;
-    device_view_type<const real_type> w_d_;
-    device_view_type<const real_type> rho_d_;
-    device_view_type<const real_type> predict_points_d_;
+    device_view_type<real_type> prediction_;
+    device_view_type<const real_type> w_;
+    device_view_type<const real_type> rho_;
+    device_view_type<const real_type> predict_points_;
     const std::size_t num_classes_;
     const std::size_t num_predict_points_;
     const std::size_t num_features_;
@@ -266,12 +318,13 @@ class device_kernel_predict_linear {
 };
 
 /**
- * @brief Predict the @p predict_points_d using the @p kernel_function.
+ * @brief Predict the @p predict_points using the @p kernel_function.
  * @tparam ExecutionSpace the Kokkos::ExecutionSpace used to execute the kernel
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
  */
-template <typename ExecutionSpace, kernel_function_type kernel_function, typename... Args>
+template <typename ExecutionSpace, target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_predict {
     /**
      * @brief The type of the used Kokkos::View.
@@ -282,11 +335,11 @@ class device_kernel_predict {
   public:
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[in] prediction_d the predicted values
-     * @param[in] alpha_d the previously learned weights
-     * @param[in] rho_d the previously learned biases
-     * @param[in] sv_d the support vectors
-     * @param[in] predict_points_d the data points to predict
+     * @param[in] prediction the predicted values
+     * @param[in] alpha the previously learned weights
+     * @param[in] rho the previously learned biases
+     * @param[in] support_vectors the support vectors
+     * @param[in] predict_points the data points to predict
      * @param[in] num_classes the number of classes
      * @param[in] num_sv the number of support vectors
      * @param[in] num_predict_points the number of data points to predict
@@ -296,12 +349,12 @@ class device_kernel_predict {
      * @param[in] grid_size_x the size of the execution grid in x-dimension
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_predict(device_view_type<real_type> prediction_d, device_view_type<const real_type> alpha_d, device_view_type<const real_type> rho_d, device_view_type<const real_type> sv_d, device_view_type<const real_type> predict_points_d, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x, Args... kernel_function_parameter) :
-        prediction_d_{ prediction_d },
-        alpha_d_{ alpha_d },
-        rho_d_{ rho_d },
-        sv_d_{ sv_d },
-        predict_points_d_{ predict_points_d },
+    device_kernel_predict(device_view_type<real_type> prediction, device_view_type<const real_type> alpha, device_view_type<const real_type> rho, device_view_type<const real_type> support_vectors, device_view_type<const real_type> predict_points, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, const std::size_t grid_size_x, Args... kernel_function_parameter) :
+        prediction_{ std::move(prediction) },
+        alpha_{ std::move(alpha) },
+        rho_{ std::move(rho) },
+        support_vectors_{ std::move(support_vectors) },
+        predict_points_{ std::move(predict_points) },
         num_classes_{ num_classes },
         num_sv_{ num_sv },
         num_predict_points_{ num_predict_points },
@@ -317,55 +370,72 @@ class device_kernel_predict {
      */
     KOKKOS_INLINE_FUNCTION
     void operator()(const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &team) const {
+        // cast values to 32-bit unsigned int values to prevent implicit conversions
+        const auto team_rank_x = static_cast<unsigned>(team.team_rank()) / THREAD_BLOCK_SIZE;
+        const auto team_rank_y = static_cast<unsigned>(team.team_rank()) % THREAD_BLOCK_SIZE;
+
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_sz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_sz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_sz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_sz = static_cast<std::size_t>(PADDING_SIZE);
-        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_sz;            // current thread in block x-dimension
-        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_sz;            // current thread in block y-dimension
-        const auto blockDim_x = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block x-dimension
-        const auto blockDim_y = THREAD_BLOCK_SIZE_sz;                                                          // number of threads in block y-dimension
-        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-        // calculate the indices used in the current thread
-        const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_sz;
-        const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
-        const auto sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_sz + threadIdx_x;
+        const auto threadIdx_x = static_cast<std::size_t>(team.team_rank()) / THREAD_BLOCK_SIZE_uz;            // current thread in team x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(team.team_rank()) % THREAD_BLOCK_SIZE_uz;            // current thread in team y-dimension
+        const auto blockDim_x = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team x-dimension
+        const auto blockDim_y = THREAD_BLOCK_SIZE_uz;                                                          // number of threads in team y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(team.league_rank()) % grid_size_x_ + grid_x_offset_;  // current team in league x-dimension + offsets if the league size is too large
+        const auto blockIdx_y = static_cast<std::size_t>(team.league_rank()) / grid_size_x_ + grid_y_offset_;  // current team in league y-dimension + offsets if the league size is too large
 
-        constexpr std::size_t shmem_size = FEATURE_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE;
-        real_type *data_cache_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(2 * shmem_size));
+        // get the scratchpad memory pointer for later usage
+        constexpr std::size_t scratchpad_size = THREAD_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz * INTERNAL_BLOCK_SIZE_uz;
+        auto *scratchpad_ptr = static_cast<real_type *>(team.team_shmem().get_shmem(std::size_t{ 2 } * scratchpad_size * sizeof(real_type)));
 
         // create a thread private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
         {
-            // create the shared memory arrays used for caching data point features
-            Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_cache_pp{ data_cache_ptr, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-            Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> data_cache_sv{ data_cache_ptr + shmem_size, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
+            // reinterpret the scratchpad memory to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+            const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> pp_cache{ scratchpad_ptr, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+            const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> sv_cache{ scratchpad_ptr + scratchpad_size, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_predict_points
+            const auto sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_support_vectors
 
             // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (std::size_t dim = 0; dim < num_features_; dim += FEATURE_BLOCK_SIZE_sz) {
-                // load data into shared memory
+            for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into scratchpad memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_pp_idx = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE;
-                    const auto global_sv_idx = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE;
-
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    data_cache_pp(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = predict_points_d_[(dim + threadIdx_y) * (num_predict_points_ + PADDING_SIZE_sz) + global_pp_idx];
-                    data_cache_pp(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = predict_points_d_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_predict_points_ + PADDING_SIZE_sz) + global_pp_idx];
-                    data_cache_sv(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = sv_d_[(dim + threadIdx_y) * (num_sv_ + PADDING_SIZE_sz) + global_sv_idx];
-                    data_cache_sv(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = sv_d_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_sv_ + PADDING_SIZE_sz) + global_sv_idx];
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the scratchpad memory
+                    pp_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = predict_points_[(feature_block + threadIdx_y) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                    sv_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = support_vectors_[(feature_block + threadIdx_y) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx_linear];             // SoA
                 }
                 team.team_barrier();  // wait until all threads loaded their part of the data
 
-                // perform the feature reduction calculation
-                for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                    for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the feature reduction calculation, the feature is the fastest moving index
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                         for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                            temp[internal_pd][internal_sv] += detail::feature_reduce<kernel_function>(data_cache_sv(block_dim, threadIdx_y * INTERNAL_BLOCK_SIZE + internal_sv),
-                                                                                                      data_cache_pp(block_dim, threadIdx_x * INTERNAL_BLOCK_SIZE + internal_pd));
+                            real_type sum{ 0.0 };
+                            for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                sum += detail::feature_reduce<kernel_function>(sv_cache(feature, team_rank_y * INTERNAL_BLOCK_SIZE + internal_sv),
+                                                                               pp_cache(feature, team_rank_x * INTERNAL_BLOCK_SIZE + internal_pp));
+                            }
+                            temp[internal_pp][internal_sv] += sum;
+                        }
+                    }
+                } else {
+                    // perform the feature reduction calculation, the feature is the slowest moving index
+                    for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                            for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                                temp[internal_pp][internal_sv] += detail::feature_reduce<kernel_function>(sv_cache(feature, team_rank_y * INTERNAL_BLOCK_SIZE + internal_sv),
+                                                                                                          pp_cache(feature, team_rank_x * INTERNAL_BLOCK_SIZE + internal_pp));
+                            }
                         }
                     }
                 }
@@ -374,55 +444,57 @@ class device_kernel_predict {
         }
 
         // update temp using the respective kernel function
-        for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
             for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                temp[internal_pd][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pd][internal_sv], kernel_function_parameter_);
+                temp[internal_pp][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pp][internal_sv], kernel_function_parameter_);
             }
         }
 
         {
-            // create the shared memory arrays used for caching data point features
-            Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> alpha_cache{ data_cache_ptr, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-            Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> out_cache{ data_cache_ptr + shmem_size, FEATURE_BLOCK_SIZE, INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE };
-
-            // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (std::size_t dim = 0; dim < num_classes_; dim += FEATURE_BLOCK_SIZE_sz) {
-                // load data into shared memory
+            // reinterpret the scratchpad memory to be of shape [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][THREAD_BLOCK_SIZE]
+            const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> alpha_cache{ scratchpad_ptr, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+            const Kokkos::mdspan<real_type, Kokkos::dextents<std::size_t, 2>> out_cache{ scratchpad_ptr + scratchpad_size, THREAD_BLOCK_SIZE_uz, INTERNAL_BLOCK_SIZE_uz * THREAD_BLOCK_SIZE_uz };
+
+            // calculate the indices used in the current thread
+            const auto pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_support_vectors
+
+            // iterate over all classes using blocking to be able to cache them for faster memory accesses
+            for (std::size_t class_block = 0; class_block < num_classes_; class_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into scratchpad memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const std::size_t global_sv_idx = sv_idx_linear + internal * THREAD_BLOCK_SIZE;
-
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    alpha_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = alpha_d_[(dim + threadIdx_y) * (num_sv_ + PADDING_SIZE_sz) + global_sv_idx];
-                    alpha_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = alpha_d_[(dim + threadIdx_y + THREAD_BLOCK_SIZE_sz) * (num_sv_ + PADDING_SIZE_sz) + global_sv_idx];
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
+                    // store the values in the scratchpad memory
+                    alpha_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = alpha_[(class_block + threadIdx_y) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx_linear];  // AoS
                     // the bias (rho) must only be applied once for all support vectors
                     if (blockIdx_y == std::size_t{ 0 }) {
-                        out_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = -rho_d_[dim + threadIdx_y];
-                        out_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = -rho_d_[dim + threadIdx_y + THREAD_BLOCK_SIZE_sz];
+                        out_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = -rho_[class_block + threadIdx_y];
                     } else {
-                        out_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x) = real_type{ 0.0 };
-                        out_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x) = real_type{ 0.0 };
+                        out_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x) = real_type{ 0.0 };
                     }
                 }
                 team.team_barrier();  // wait until all threads loaded their part of the data
 
-                // calculate intermediate results and store them in shared memory
-                for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
-                    for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                // calculate intermediate results and store them in scratchpad memory
+                for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                         for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                            out_cache((class_idx + threadIdx_y) % FEATURE_BLOCK_SIZE, internal_pd * THREAD_BLOCK_SIZE + threadIdx_x) +=
-                                temp[internal_pd][internal_sv] * alpha_cache((class_idx + threadIdx_y) % FEATURE_BLOCK_SIZE, threadIdx_y * INTERNAL_BLOCK_SIZE + internal_sv);
+                            out_cache((class_idx + team_rank_y) % THREAD_BLOCK_SIZE, internal_pp * THREAD_BLOCK_SIZE + team_rank_x) +=
+                                temp[internal_pp][internal_sv] * alpha_cache((class_idx + team_rank_y) % THREAD_BLOCK_SIZE, team_rank_y * INTERNAL_BLOCK_SIZE + internal_sv);
                         }
                     }
                     team.team_barrier();  // wait until all threads performed their part of the calculations
                 }
 
-                // add intermediate cached results to prediction_d
+                // atomically add the intermediate cached results to the prediction
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data
                     const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal);
 
-                    Kokkos::atomic_add(&prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_sz) + dim + threadIdx_y], out_cache(threadIdx_y, internal * THREAD_BLOCK_SIZE + threadIdx_x));
-                    Kokkos::atomic_add(&prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_sz) + dim + threadIdx_y + THREAD_BLOCK_SIZE_sz], out_cache(threadIdx_y + THREAD_BLOCK_SIZE, internal * THREAD_BLOCK_SIZE + threadIdx_x));
+                    Kokkos::atomic_add(&prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_y], out_cache(team_rank_y, internal * THREAD_BLOCK_SIZE + team_rank_x));
                 }
                 team.team_barrier();  // wait until all threads updated their part of the prediction
             }
@@ -431,11 +503,11 @@ class device_kernel_predict {
 
   private:
     /// @cond Doxygen_suppress
-    device_view_type<real_type> prediction_d_;
-    device_view_type<const real_type> alpha_d_;
-    device_view_type<const real_type> rho_d_;
-    device_view_type<const real_type> sv_d_;
-    device_view_type<const real_type> predict_points_d_;
+    device_view_type<real_type> prediction_;
+    device_view_type<const real_type> alpha_;
+    device_view_type<const real_type> rho_;
+    device_view_type<const real_type> support_vectors_;
+    device_view_type<const real_type> predict_points_;
     const std::size_t num_classes_;
     const std::size_t num_sv_;
     const std::size_t num_predict_points_;
@@ -449,4 +521,4 @@ class device_kernel_predict {
 
 }  // namespace plssvm::kokkos::detail
 
-#endif  // PLSSVM_BACKENDS_KOKKOS_PREDICT_KERNEL_HPP_
+#endif  // PLSSVM_BACKENDS_KOKKOS_KERNEL_PREDICT_KERNEL_HPP_
diff --git a/include/plssvm/backends/OpenCL/csvm.hpp b/include/plssvm/backends/OpenCL/csvm.hpp
index f52ec29cd..21bd057c4 100644
--- a/include/plssvm/backends/OpenCL/csvm.hpp
+++ b/include/plssvm/backends/OpenCL/csvm.hpp
@@ -30,6 +30,7 @@
 #include "plssvm/target_platforms.hpp"                      // plssvm::target_platform
 
 #include <cstddef>      // std::size_t
+#include <optional>     // std::optional
 #include <type_traits>  // std::true_type
 #include <utility>      // std::forward
 #include <vector>       // std::vector
@@ -96,6 +97,10 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::comma
      * @copydoc plssvm::csvm::get_max_mem_alloc_size
      */
     [[nodiscard]] std::vector<::plssvm::detail::memory_size> get_max_mem_alloc_size() const final;
+    /**
+     * @copydoc plssvm::csvm::get_local_memory
+     */
+    [[nodiscard]] std::vector<std::optional<::plssvm::detail::memory_size>> get_local_memory() const final;
     /**
      * @copydoc plssvm::detail::gpu_csvm::get_max_work_group_size
      */
@@ -143,7 +148,7 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::comma
     [[nodiscard]] device_ptr_type run_predict_kernel(std::size_t device_id, const ::plssvm::detail::execution_range &exec, const parameter &params, const device_ptr_type &alpha_d, const device_ptr_type &rho_d, const device_ptr_type &sv_or_w_d, const device_ptr_type &predict_points_d) const final;
 
     /// The available OpenCL contexts for the current target platform with the associated devices.
-    std::vector<detail::context> contexts_{};
+    std::vector<detail::context> contexts_;
 };
 
 /**
@@ -159,8 +164,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvc(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::opencl::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVC using the OpenCL backend with the parameters given through @p params.
@@ -169,8 +173,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     csvc(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::opencl::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVC using the OpenCL backend on the @p target platform with the parameters given through @p params.
@@ -251,8 +254,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvr(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::opencl::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVR using the OpenCL backend with the parameters given through @p params.
@@ -261,8 +263,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     csvr(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::opencl::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVR using the OpenCL backend on the @p target platform with the parameters given through @p params.
diff --git a/include/plssvm/backends/OpenCL/detail/command_queue.hpp b/include/plssvm/backends/OpenCL/detail/command_queue.hpp
index acb87caf1..bbdd55e4c 100644
--- a/include/plssvm/backends/OpenCL/detail/command_queue.hpp
+++ b/include/plssvm/backends/OpenCL/detail/command_queue.hpp
@@ -67,13 +67,13 @@ class command_queue {
      * @brief Implicitly convert a command_queue wrapper to an OpenCL cl_command_queue.
      * @return the wrapped OpenCL cl_command_queue (`[[nodiscard]]`)
      */
-    [[nodiscard]] operator cl_command_queue &() noexcept { return queue; }
+    [[nodiscard]] operator cl_command_queue &() noexcept { return queue; }  // NOLINT: overload is intentional to reduce explicit casts in OpenCL interfaces
 
     /**
      * @brief Implicitly convert a command_queue wrapper to an OpenCL cl_command_queue.
      * @return the wrapped OpenCL cl_command_queue (`[[nodiscard]]`)
      */
-    [[nodiscard]] operator const cl_command_queue &() const noexcept { return queue; }
+    [[nodiscard]] operator const cl_command_queue &() const noexcept { return queue; }  // NOLINT: overload is intentional to reduce explicit casts in OpenCL interfaces
 
     /**
      * @brief Add a new OpenCL @p compute_kernel used for @p name to this command queue.
@@ -93,7 +93,7 @@ class command_queue {
     /// The wrapped cl_command_queue.
     cl_command_queue queue{};
     /// All OpenCL device kernel associated with the device corresponding to this command queue.
-    std::map<compute_kernel_name, kernel> kernels{};
+    std::map<compute_kernel_name, kernel> kernels;
 };
 
 }  // namespace plssvm::opencl::detail
diff --git a/include/plssvm/backends/OpenCL/detail/context.hpp b/include/plssvm/backends/OpenCL/detail/context.hpp
index 9290e958f..c6b6a39f2 100644
--- a/include/plssvm/backends/OpenCL/detail/context.hpp
+++ b/include/plssvm/backends/OpenCL/detail/context.hpp
@@ -65,13 +65,13 @@ class context {
      * @brief Implicitly convert a context wrapper to an OpenCL cl_context.
      * @return the wrapped OpenCL cl_context (`[[nodiscard]]`)
      */
-    [[nodiscard]] operator cl_context &() noexcept { return device_context; }
+    [[nodiscard]] operator cl_context &() noexcept { return device_context; }  // NOLINT: overload is intentional to reduce explicit casts in OpenCL interfaces
 
     /**
      * @brief Implicitly convert a context wrapper to an OpenCL cl_context.
      * @return the wrapped OpenCL cl_context (`[[nodiscard]]`)
      */
-    [[nodiscard]] operator const cl_context &() const noexcept { return device_context; }
+    [[nodiscard]] operator const cl_context &() const noexcept { return device_context; }  // NOLINT: overload is intentional to reduce explicit casts in OpenCL interfaces
 
     /// The OpenCL context associated with the platform containing the respective devices.
     cl_context device_context{};
diff --git a/include/plssvm/backends/OpenCL/detail/error_code.hpp b/include/plssvm/backends/OpenCL/detail/error_code.hpp
index 275a22db5..3090a4b64 100644
--- a/include/plssvm/backends/OpenCL/detail/error_code.hpp
+++ b/include/plssvm/backends/OpenCL/detail/error_code.hpp
@@ -13,7 +13,8 @@
 #define PLSSVM_BACKENDS_OPENCL_DETAIL_ERROR_CODE_HPP_
 #pragma once
 
-#include "CL/cl.h"  // cl_int, CL_SUCCESS
+#include "CL/cl.h"           // CL_SUCCESS
+#include "CL/cl_platform.h"  // cl_int
 
 #include "fmt/base.h"     // fmt::formatter
 #include "fmt/ostream.h"  // fmt::ostream_formatter
@@ -37,7 +38,7 @@ class error_code {
      * @brief Construct a new error code wrapping the OpenCL @p error code.
      * @param[in] error the OpenCL error code
      */
-    error_code(cl_int error) noexcept;
+    error_code(cl_int error) noexcept;  // NOLINT: implicit conversions are explicitly wanted
 
     /**
      * @brief Assign the OpenCL @p error code to `*this`.
@@ -75,7 +76,7 @@ class error_code {
      * @brief Overloads the addressof operator to be able to set the wrapped error code value using an out-parameter in calls to OpenCL functions.
      * @return pointer to the wrapped OpenCL error code (`[[nodiscard]]`)
      */
-    [[nodiscard]] cl_int *operator&() noexcept;
+    [[nodiscard]] cl_int *operator&() noexcept;  // NOLINT(google-runtime-operator): overload is intentional to reduce explicit casts in OpenCL interfaces
 
   private:
     /// The wrapped OpenCL error code.
diff --git a/include/plssvm/backends/OpenCL/detail/jit_info.hpp b/include/plssvm/backends/OpenCL/detail/jit_info.hpp
index edd425c96..f28379d7d 100644
--- a/include/plssvm/backends/OpenCL/detail/jit_info.hpp
+++ b/include/plssvm/backends/OpenCL/detail/jit_info.hpp
@@ -11,6 +11,7 @@
 
 #ifndef PLSSVM_BACKENDS_OPENCL_DETAIL_JIT_INFO_HPP_
 #define PLSSVM_BACKENDS_OPENCL_DETAIL_JIT_INFO_HPP_
+#pragma once
 
 #include "fmt/base.h"     // fmt::formatter
 #include "fmt/ostream.h"  // fmt::ostream_formatter
@@ -42,7 +43,7 @@ struct jit_info {
     /// The state of the kernel cache.
     caching_status cache_state{ caching_status::success };
     /// The kernel cache dir.
-    std::string cache_dir{};
+    std::string cache_dir;
     /// The duration of the JIT compilation.
     std::chrono::milliseconds duration{};
 };
diff --git a/include/plssvm/backends/OpenCL/detail/kernel.hpp b/include/plssvm/backends/OpenCL/detail/kernel.hpp
index 2a54c5769..3ffc14927 100644
--- a/include/plssvm/backends/OpenCL/detail/kernel.hpp
+++ b/include/plssvm/backends/OpenCL/detail/kernel.hpp
@@ -22,6 +22,14 @@ namespace plssvm::opencl::detail {
  * @details Used to distinguish kernels in the plssvm::opencl::detail::command_queue class.
  */
 enum class compute_kernel_name {
+    /// The kernel to fill a float device pointer with a provided value.
+    fill_kernel_float,
+    /// The kernel to fill a double device pointer with a provided value.
+    fill_kernel_double,
+    /// The kernel to memset a float device pointer with a provided pattern.
+    memset_kernel_float,
+    /// The kernel to memset a double device pointer with a provided pattern.
+    memset_kernel_double,
     /// The kernels to explicitly assemble the kernel matrix.
     assemble_kernel_matrix_explicit,
     /// The kernel performing a explicit BLAS SYMM calculation.
@@ -94,13 +102,13 @@ class kernel {
      * @brief Implicitly convert a kernel wrapper to an OpenCL cl_kernel.
      * @return the wrapped OpenCL cl_kernel (`[[nodiscard]]`)
      */
-    [[nodiscard]] operator cl_kernel &() noexcept { return compute_kernel; }
+    [[nodiscard]] operator cl_kernel &() noexcept { return compute_kernel; }  // NOLINT: overload is intentional to reduce explicit casts in OpenCL interfaces
 
     /**
      * @brief Implicitly convert a kernel wrapper to an OpenCL cl_kernel.
      * @return the wrapped OpenCL cl_kernel (`[[nodiscard]]`)
      */
-    [[nodiscard]] operator const cl_kernel &() const noexcept { return compute_kernel; }
+    [[nodiscard]] operator const cl_kernel &() const noexcept { return compute_kernel; }  // NOLINT: overload is intentional to reduce explicit casts in OpenCL interfaces
 
     /// The wrapped OpenCL cl_kernel.
     cl_kernel compute_kernel;
diff --git a/include/plssvm/backends/OpenCL/detail/utility.hpp b/include/plssvm/backends/OpenCL/detail/utility.hpp
index f2d30947c..52c50fa9e 100644
--- a/include/plssvm/backends/OpenCL/detail/utility.hpp
+++ b/include/plssvm/backends/OpenCL/detail/utility.hpp
@@ -21,6 +21,7 @@
 #include "plssvm/backends/OpenCL/detail/kernel.hpp"         // plssvm::opencl::detail::compute_kernel_name
 #include "plssvm/backends/OpenCL/exceptions.hpp"            // plssvm::opencl::backend_exception
 #include "plssvm/detail/assert.hpp"                         // PLSSVM_ASSERT
+#include "plssvm/detail/type_traits.hpp"                    // plssvm::detail::always_false_non_type_v
 #include "plssvm/kernel_function_types.hpp"                 // plssvm::kernel_function_type
 #include "plssvm/mpi/communicator.hpp"                      // plssvm::mpi::communicator
 #include "plssvm/target_platforms.hpp"                      // plssvm::target_platform
@@ -65,7 +66,7 @@ template <std::size_t I>
     } else if constexpr (I == 3) {
         return { static_cast<std::size_t>(dims.x), static_cast<std::size_t>(dims.y), static_cast<std::size_t>(dims.z) };
     } else {
-        static_assert(I != I, "Invalid number of native OpenCL range dimension!");
+        static_assert(::plssvm::detail::always_false_non_type_v<I>, "Invalid number of native OpenCL range dimension!");
     }
 }
 
@@ -73,6 +74,7 @@ template <std::size_t I>
  * @brief Returns the context listing all devices matching the target platform @p target and the actually used target platform
  *        (only interesting if the provided @p target was automatic).
  * @details If the selected target platform is plssvm::target_platform::automatic the selector tries to find devices according to plssvm::determine_default_target_platform.
+ * @note The environment variable `PLSSVM_OPENCL_DEVICE_FILTER` can be used to filter the available devices. Syntax: `target_platform:device_id;...`, e.g., `gpu_nvidia:1;cpu:0`.
  * @param[in] target the target platform for which the devices must match
  * @return the command queues and used target platform (`[[nodiscard]]`)
  */
@@ -126,11 +128,12 @@ void device_synchronize(const command_queue &queue);
  *
  * @param[in] comm the MPI communicator
  * @param[in] contexts the used OpenCL contexts
+ * @param[in] target the target platform to create the kernel binaries for
  * @param[in] kernel_function the kernel function
  * @throws plssvm::invalid_file_format_exception if the file couldn't be read using [`std::ifstream::read`](https://en.cppreference.com/w/cpp/io/basic_istream/read)
  * @return [the command queues with all necessary kernels; information regarding the JIT compilation] (`[[nodiscard]]`)
  */
-[[nodiscard]] std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi::communicator &comm, const std::vector<context> &contexts, kernel_function_type kernel_function);
+[[nodiscard]] std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi::communicator &comm, const std::vector<context> &contexts, target_platform target, kernel_function_type kernel_function);
 
 /**
  * @brief Set all arguments in the parameter pack @p args for the kernel @p kernel.
@@ -143,7 +146,7 @@ inline void set_kernel_args(cl_kernel kernel, Args... args) {
     cl_uint i = 0;
     // iterate over parameter pack and set OpenCL kernel
     ([&](auto &arg) {
-        const error_code ec = clSetKernelArg(kernel, i++, sizeof(decltype(arg)), &arg);
+        const error_code ec = clSetKernelArg(kernel, i++, sizeof(decltype(arg)), static_cast<const void *>(&arg));
         PLSSVM_OPENCL_ERROR_CHECK(ec, fmt::format("error setting OpenCL kernel argument {}", i - 1))
     }(args),
      ...);
diff --git a/include/plssvm/backends/OpenCL/kernel/cg_explicit/blas.cl b/include/plssvm/backends/OpenCL/kernel/cg_explicit/blas.cl
index 0f1ac247a..8b474df77 100644
--- a/include/plssvm/backends/OpenCL/kernel/cg_explicit/blas.cl
+++ b/include/plssvm/backends/OpenCL/kernel/cg_explicit/blas.cl
@@ -16,8 +16,8 @@
  * @details In a multi-GPU setting, this function is only responsible for the rows this device is responsible for!
  * @param[in] num_rows the number of rows in @p A and @p C
  * @param[in] num_rhs the number of columns in @p B and @p C
- * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
- * @param[in] row_offset the first row this device is responsible for
+ * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+ * @param[in] device_row_offset the first row this device is responsible for
  * @param[in] alpha the scalar alpha value
  * @param[in] A the matrix @p A
  * @param[in] B the matrix @p B
@@ -26,78 +26,90 @@
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__kernel void device_kernel_symm(const ulong num_rows, const ulong num_rhs, const ulong device_specific_num_rows, const ulong row_offset, const real_type alpha, const __global real_type *A, const __global real_type *B, const real_type beta, __global real_type *C, const ulong grid_x_offset, const ulong grid_y_offset) {
+__kernel void device_kernel_symm(const ulong num_rows, const ulong num_rhs, const ulong device_num_rows, const ulong device_row_offset, const real_type alpha, const __global real_type *A, const __global real_type *B, const real_type beta, __global real_type *C, const ulong grid_x_offset, const ulong grid_y_offset) {
     // cast values to 32-bit unsigned int values to prevent implicit conversions
     const uint local_id_0 = get_local_id(0);
     const uint local_id_1 = get_local_id(1);
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const ulong threadIdx_x = get_local_id(0);                 // current thread in block x-dimension
-    const ulong threadIdx_y = get_local_id(1);                 // current thread in block y-dimension
-    const ulong blockDim_x = get_local_size(0);                // number of threads in block x-dimension
-    const ulong blockDim_y = get_local_size(1);                // number of threads in block y-dimension
-    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
+    const ulong threadIdx_x = get_local_id(0);                 // current work-item in work-group x-dimension
+    const ulong threadIdx_y = get_local_id(1);                 // current work-item in work-group y-dimension
+    const ulong blockDim_x = get_local_size(0);                // number of work-items in work-group x-dimension
+    const ulong blockDim_y = get_local_size(1);                // number of work-items in work-group y-dimension
+    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current work-group in global range x-dimension + offsets if the global range is too large
+    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current work-group in global range y-dimension + offsets if the global range is too large
 
-    // calculate the indices used in the current work-item
-    const ulong i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ul;  // #rhs
-    const ulong i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-    const ulong j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ul;  // # row
-    const ulong j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-
-    // create the local memory arrays used for caching data point features
-    __local real_type A_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __local real_type B_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    // create two local memory arrays used for caching
+    __local real_type A_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __local real_type B_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
-    // create a thread private array used for internal caching
+    // create a work-item private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE] = { (real_type) 0.0 };
 
-    // iterate over all features using blocking to be able to cache them for faster memory accesses
-    for (ulong dim = 0; dim < (num_rows - row_offset); dim += FEATURE_BLOCK_SIZE_ul) {
-        // load data into local memory
-        for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const ulong global_i = i_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-            const ulong global_j = j_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-
-            // determine on which side of the diagonal we are located
-            if (dim + get_local_id(1) < global_j) {
-                A_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = A[(dim + threadIdx_y) * (num_rows - row_offset + PADDING_SIZE_ul) + global_j - (dim + threadIdx_y) * (dim + threadIdx_y + (ulong) 1) / (ulong) 2];
-            } else {
-                A_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = A[global_j * (num_rows - row_offset + PADDING_SIZE_ul) + dim + threadIdx_y - global_j * (global_j + (ulong) 1) / (ulong) 2];
-            }
-            // determine on which side of the diagonal we are located
-            if (dim + get_local_id(1) + THREAD_BLOCK_SIZE < global_j) {
-                A_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = A[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_rows - row_offset + PADDING_SIZE_ul) + global_j - (dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (dim + threadIdx_y + THREAD_BLOCK_SIZE_ul + (ulong) 1) / (ulong) 2];
-            } else {
-                A_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = A[global_j * (num_rows - row_offset + PADDING_SIZE_ul) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ul - global_j * (global_j + (ulong) 1) / (ulong) 2];
-            }
+    {
+        // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+        const ulong i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rhs
+        const ulong j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
 
-            B_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = B[(dim + row_offset + threadIdx_y) * (num_rhs + PADDING_SIZE_ul) + global_i];
-            B_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = B[(dim + row_offset + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_rhs + PADDING_SIZE_ul) + global_i];
-        }
-        barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
+        // iterate over all values using blocking to be able to cache them for faster memory accesses
+        for (ulong dim_block = 0; dim_block < (num_rows - device_row_offset); dim_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into local memory
+            for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const ulong global_i_idx_linear = i_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+                const ulong global_j_idx_linear = j_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the local memory
+                // determine on which side of the diagonal we are located
+                if (dim_block + get_local_id(1) < global_j_idx_linear) {
+                    A_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = A[(dim_block + threadIdx_y) * (num_rows - device_row_offset + PADDING_SIZE_uz) + global_j_idx_linear - (dim_block + threadIdx_y) * (dim_block + threadIdx_y + (ulong) 1) / (ulong) 2];  // SoA, upper triangular matrix only
+                } else {
+                    A_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = A[global_j_idx_linear * (num_rows - device_row_offset + PADDING_SIZE_uz) + dim_block + threadIdx_y - global_j_idx_linear * (global_j_idx_linear + (ulong) 1) / (ulong) 2];  // SoA, upper triangular matrix only
+                }
+                B_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = B[(dim_block + device_row_offset + threadIdx_y) * (num_rhs + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+            }
+            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
 
-        // perform the dot product calculation
-        for (uint block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+#if defined(PLSSVM_OPENCL_TARGET_CPUS)
+            // perform the dot product calculation, the dim is the fastest moving index
             for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    temp[internal_i][internal_j] += A_cache[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i];
+                    real_type sum = 0.0;
+                    for (uint dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                        sum += A_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i];
+                    }
+                    temp[internal_i][internal_j] += sum;
+                }
+            }
+#else
+            // perform the dot product calculation, the dim is the slowest moving index
+            for (uint dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        temp[internal_i][internal_j] += A_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i];
+                    }
                 }
             }
+#endif
+            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
         }
-        barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
     }
 
+    // calculate the indices used in the current work-item
+    const ulong i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+    const ulong j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
     // apply the (partial) BLAS operation and update C
     for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const ulong global_i = i + (ulong) internal_i;
-            const ulong device_global_j = j + (ulong) internal_j;
-            const ulong global_j = row_offset + j + (ulong) internal_j;
+            // calculate the indices to access the global data and the data with respect to the current device
+            const ulong global_i_idx = i_idx + (ulong) internal_i;
+            const ulong device_global_j_idx = j_idx + (ulong) internal_j;
+            const ulong global_j_idx = device_row_offset + device_global_j_idx;
 
-            // be sure to not perform out of bounds accesses
-            if (global_i < num_rhs && device_global_j < device_specific_num_rows) {
-                C[global_j * (num_rhs + PADDING_SIZE_ul) + global_i] = alpha * temp[internal_i][internal_j] + beta * C[global_j * (num_rhs + PADDING_SIZE_ul) + global_i];
+            // be sure to not perform out-of-bounds accesses
+            if (global_i_idx < num_rhs && device_global_j_idx < device_num_rows) {
+                C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx] = alpha * temp[internal_i][internal_j] + beta * C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx];  // SoA
             }
         }
     }
@@ -109,8 +121,8 @@ __kernel void device_kernel_symm(const ulong num_rows, const ulong num_rhs, cons
  * @param[in] num_rows the number of rows in @p A and @p C
  * @param[in] num_rhs the number of columns in @p B and @p C
  * @param[in] num_mirror_rows the number of rows to mirror down
- * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
- * @param[in] row_offset the first row this device is responsible for
+ * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+ * @param[in] device_row_offset the first row this device is responsible for
  * @param[in] alpha the scalar alpha value
  * @param[in] A the matrix @p A
  * @param[in] B the matrix @p B
@@ -119,68 +131,85 @@ __kernel void device_kernel_symm(const ulong num_rows, const ulong num_rhs, cons
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__kernel void device_kernel_symm_mirror(const ulong num_rows, const ulong num_rhs, const ulong num_mirror_rows, const ulong device_specific_num_rows, const ulong row_offset, const real_type alpha, const __global real_type *A, const __global real_type *B, const real_type beta, __global real_type *C, const ulong grid_x_offset, const ulong grid_y_offset) {
+__kernel void device_kernel_symm_mirror(const ulong num_rows, const ulong num_rhs, const ulong num_mirror_rows, const ulong device_num_rows, const ulong device_row_offset, const real_type alpha, const __global real_type *A, const __global real_type *B, const real_type beta, __global real_type *C, const ulong grid_x_offset, const ulong grid_y_offset) {
     // cast values to 32-bit unsigned int values to prevent implicit conversions
     const uint local_id_0 = get_local_id(0);
     const uint local_id_1 = get_local_id(1);
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const ulong threadIdx_x = get_local_id(0);                 // current thread in block x-dimension
-    const ulong threadIdx_y = get_local_id(1);                 // current thread in block y-dimension
-    const ulong blockDim_x = get_local_size(0);                // number of threads in block x-dimension
-    const ulong blockDim_y = get_local_size(1);                // number of threads in block y-dimension
-    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
+    const ulong threadIdx_x = get_local_id(0);                 // current work-item in work-group x-dimension
+    const ulong threadIdx_y = get_local_id(1);                 // current work-item in work-group y-dimension
+    const ulong blockDim_x = get_local_size(0);                // number of work-items in work-group x-dimension
+    const ulong blockDim_y = get_local_size(1);                // number of work-items in work-group y-dimension
+    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current work-group in global range x-dimension + offsets if the global range is too large
+    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current work-group in global range y-dimension + offsets if the global range is too large
 
-    // calculate the indices used in the current work-item
-    const ulong i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ul;  // #rhs
-    const ulong i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-    const ulong j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ul;  // # row
-    const ulong j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-
-    // create the local memory arrays used for caching data point features
-    __local real_type A_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __local real_type B_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    // create two local memory arrays used for caching
+    __local real_type A_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __local real_type B_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
-    // create a thread private array used for internal caching
+    // create a work-item private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE] = { (real_type) 0.0 };
 
-    // iterate over all features using blocking to be able to cache them for faster memory accesses
-    for (ulong dim = 0; dim < device_specific_num_rows; dim += FEATURE_BLOCK_SIZE_ul) {
-        // load data into local memory
-        for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const ulong global_i = i_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-            const ulong global_j = j_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-
-            // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-            A_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = A[(dim + threadIdx_y) * (num_rows - row_offset + PADDING_SIZE_ul) - (dim + threadIdx_y - (ulong) 1) * (dim + threadIdx_y) / (ulong) 2 + device_specific_num_rows - (dim + get_local_id(1)) + global_j];
-            A_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = A[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_rows - row_offset + PADDING_SIZE_ul) - (dim + threadIdx_y + THREAD_BLOCK_SIZE_ul - (ulong) 1) * (dim + get_local_id(1) + THREAD_BLOCK_SIZE_ul) / (ulong) 2 + device_specific_num_rows - (dim + get_local_id(1) + THREAD_BLOCK_SIZE_ul) + global_j];
-            B_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = B[(dim + row_offset + threadIdx_y) * (num_rhs + PADDING_SIZE_ul) + global_i];
-            B_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = B[(dim + row_offset + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_rhs + PADDING_SIZE_ul) + global_i];
-        }
-        barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
+    {
+        // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+        const ulong i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rhs
+        const ulong j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_mirror_rows
+
+        // iterate over the remaining values using blocking to be able to cache them for faster memory accesses
+        for (ulong dim_block = 0; dim_block < device_num_rows; dim_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into local memory
+            for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const ulong global_i_idx_linear = i_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+                const ulong global_j_idx_linear = j_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the local memory
+                A_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = A[(dim_block + threadIdx_y) * (num_rows - device_row_offset + PADDING_SIZE_uz) - (dim_block + threadIdx_y - (ulong) 1) * (dim_block + threadIdx_y) / (ulong) 2 + device_num_rows - (dim_block + threadIdx_y) + global_j_idx_linear];  // SoA, upper triangular matrix only
+                B_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = B[(device_row_offset + dim_block + threadIdx_y) * (num_rhs + PADDING_SIZE_uz) + global_i_idx_linear];                                                                                                                                 // SoA
+            }
+            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
 
-        // perform the feature reduction calculation
-        for (uint block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+#if defined(PLSSVM_OPENCL_TARGET_CPUS)
+            // perform the dot product calculation, the dim is the fastest moving index
             for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    temp[internal_i][internal_j] += A_cache[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i];
+                    real_type sum = 0.0;
+                    for (uint dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                        sum += A_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i];
+                    }
+                    temp[internal_i][internal_j] += sum;
                 }
             }
+#else
+            // perform the dot product calculation, the dim is the slowest moving index
+            for (uint dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        temp[internal_i][internal_j] += A_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i];
+                    }
+                }
+            }
+#endif
+            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
         }
-        barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
     }
 
+    // calculate the indices used in the current work-item
+    const ulong i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+    const ulong j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
+
     // apply the (remaining) BLAS operation and update C
     for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const ulong global_i = i + (ulong) internal_i;
-            const ulong partial_global_j = j + (ulong) internal_j;
-            const ulong global_j = row_offset + device_specific_num_rows + j + (ulong) internal_j;
+            // calculate the indices to access the global data and the data with respect to the current device
+            const ulong global_i_idx = i_idx + (ulong) internal_i;
+            const ulong partial_global_j_idx = j_idx + (ulong) internal_j;
+            const ulong global_j_idx = device_row_offset + device_num_rows + partial_global_j_idx;
 
-            // be sure to not perform out of bounds accesses
-            if (global_i < num_rhs && partial_global_j < num_mirror_rows) {
-                C[global_j * (num_rhs + PADDING_SIZE_ul) + global_i] = alpha * temp[internal_i][internal_j] + beta * C[global_j * (num_rhs + PADDING_SIZE_ul) + global_i];
+            // be sure to not perform out-of-bounds accesses
+            if (global_i_idx < num_rhs && partial_global_j_idx < num_mirror_rows) {
+                C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx] = alpha * temp[internal_i][internal_j] + beta * C[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx];  // SoA
             }
         }
     }
@@ -196,23 +225,24 @@ __kernel void device_kernel_symm_mirror(const ulong num_rows, const ulong num_rh
  */
 __kernel void device_kernel_inplace_matrix_add(const ulong num_cols, real_type __global *lhs, const real_type __global *rhs, const ulong grid_x_offset, const ulong grid_y_offset) {
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const ulong threadIdx_x = get_local_id(0);                 // current thread in block x-dimension
-    const ulong threadIdx_y = get_local_id(1);                 // current thread in block y-dimension
-    const ulong blockDim_x = get_local_size(0);                // number of threads in block x-dimension
-    const ulong blockDim_y = get_local_size(1);                // number of threads in block y-dimension
-    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
+    const ulong threadIdx_x = get_local_id(0);                 // current work-item in work-group x-dimension
+    const ulong threadIdx_y = get_local_id(1);                 // current work-item in work-group y-dimension
+    const ulong blockDim_x = get_local_size(0);                // number of work-items in work-group x-dimension
+    const ulong blockDim_y = get_local_size(1);                // number of work-items in work-group y-dimension
+    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current work-group in global range x-dimension + offsets if the global range is too large
+    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current work-group in global range y-dimension + offsets if the global range is too large
 
-    // calculate the indices used in the current thread
-    const ulong i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ul;  // # num_rows
-    const ulong j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ul;  // # num_rhs
+    // calculate the indices used in the current work-item
+    const ulong i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+    const ulong j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
     for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const ulong global_i = i + (ulong) internal_i;
-            const ulong global_j = j + (ulong) internal_j;
+            // calculate the indices to access the global data
+            const ulong global_i_idx = i_idx + (ulong) internal_i;
+            const ulong global_j_idx = j_idx + (ulong) internal_j;
 
-            lhs[global_i * (num_cols + PADDING_SIZE_ul) + global_j] += rhs[global_i * (num_cols + PADDING_SIZE_ul) + global_j];
+            lhs[global_i_idx * (num_cols + PADDING_SIZE_uz) + global_j_idx] += rhs[global_i_idx * (num_cols + PADDING_SIZE_uz) + global_j_idx];  // SoA
         }
     }
 }
@@ -227,23 +257,24 @@ __kernel void device_kernel_inplace_matrix_add(const ulong num_cols, real_type _
  */
 __kernel void device_kernel_inplace_matrix_scale(const ulong num_cols, real_type __global *lhs, const real_type scale, const ulong grid_x_offset, const ulong grid_y_offset) {
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const ulong threadIdx_x = get_local_id(0);                 // current thread in block x-dimension
-    const ulong threadIdx_y = get_local_id(1);                 // current thread in block y-dimension
-    const ulong blockDim_x = get_local_size(0);                // number of threads in block x-dimension
-    const ulong blockDim_y = get_local_size(1);                // number of threads in block y-dimension
-    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
+    const ulong threadIdx_x = get_local_id(0);                 // current work-item in work-group x-dimension
+    const ulong threadIdx_y = get_local_id(1);                 // current work-item in work-group y-dimension
+    const ulong blockDim_x = get_local_size(0);                // number of work-items in work-group x-dimension
+    const ulong blockDim_y = get_local_size(1);                // number of work-items in work-group y-dimension
+    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current work-group in global range x-dimension + offsets if the global range is too large
+    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current work-group in global range y-dimension + offsets if the global range is too large
 
-    // calculate the indices used in the current thread
-    const ulong i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ul;  // # num_rows
-    const ulong j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ul;  // # num_rhs
+    // calculate the indices used in the current work-item
+    const ulong i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+    const ulong j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
     for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
         for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-            const ulong global_i = i + (ulong) internal_i;
-            const ulong global_j = j + (ulong) internal_j;
+            // calculate the indices to access the global data
+            const ulong global_i_idx = i_idx + (ulong) internal_i;
+            const ulong global_j_idx = j_idx + (ulong) internal_j;
 
-            lhs[global_i * (num_cols + PADDING_SIZE_ul) + global_j] *= scale;
+            lhs[global_i_idx * (num_cols + PADDING_SIZE_uz) + global_j_idx] *= scale;  // SoA
         }
     }
 }
diff --git a/include/plssvm/backends/OpenCL/kernel/cg_explicit/kernel_matrix_assembly.cl b/include/plssvm/backends/OpenCL/kernel/cg_explicit/kernel_matrix_assembly.cl
index 481945ca6..55c856d20 100644
--- a/include/plssvm/backends/OpenCL/kernel/cg_explicit/kernel_matrix_assembly.cl
+++ b/include/plssvm/backends/OpenCL/kernel/cg_explicit/kernel_matrix_assembly.cl
@@ -14,11 +14,11 @@
 /**
  * @brief Create the explicit kernel matrix using the kernel function determined at runtime.
  * @details The `PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST`, `PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER`, `PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION`, and `PLSSVM_OPENCL_APPLY_KERNEL_FUNCTION` placeholder will be replaced by the correct values upon kernel construction.
- * @param[out] kernel_matrix_d the calculated kernel matrix
- * @param[in] data_d the data points to calculate the kernel matrix from
+ * @param[out] kernel_matrix the calculated kernel matrix
+ * @param[in] data the data points to calculate the kernel matrix from
  * @param[in] num_rows the total number of data points (= total number of rows)
  * @param[in] device_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data_d the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data_d the current device is responsible for
  * @param[in] num_features the number of features per data point
  * @param[in] q the vector used in the dimensional reduction
  * @param[in] QA_cost the scalar used in the dimensional reduction
@@ -27,78 +27,96 @@
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  * @param[in] PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST a placeholder that is used to string replace the correct kernel parameter (attention: no comma!; Args... only added for Doxygen)
  */
-__kernel void device_kernel_assembly(__global real_type *kernel_matrix_d, const __global real_type *data_d, const ulong num_rows, const ulong device_num_rows, const ulong row_offset, const ulong num_features, const __global real_type *q, const real_type QA_cost, const real_type cost, const ulong grid_x_offset, const ulong grid_y_offset PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST) {
+__kernel void device_kernel_assembly(__global real_type *kernel_matrix, const __global real_type *data, const ulong num_rows, const ulong device_num_rows, const ulong device_row_offset, const ulong num_features, const __global real_type *q, const real_type QA_cost, const real_type cost, const ulong grid_x_offset, const ulong grid_y_offset PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST) {
     // cast values to 32-bit unsigned int values to prevent implicit conversions
     const uint local_id_0 = get_local_id(0);
     const uint local_id_1 = get_local_id(1);
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const ulong threadIdx_x = get_local_id(0);                 // current thread in block x-dimension
-    const ulong threadIdx_y = get_local_id(1);                 // current thread in block y-dimension
-    const ulong blockDim_x = get_local_size(0);                // number of threads in block x-dimension
-    const ulong blockDim_y = get_local_size(1);                // number of threads in block y-dimension
-    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
+    const ulong threadIdx_x = get_local_id(0);                 // current work-item in work-group x-dimension
+    const ulong threadIdx_y = get_local_id(1);                 // current work-item in work-group y-dimension
+    const ulong blockDim_x = get_local_size(0);                // number of work-items in work-group x-dimension
+    const ulong blockDim_y = get_local_size(1);                // number of work-items in work-group y-dimension
+    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current work-group in global range x-dimension + offsets if the global range is too large
+    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current work-group in global range y-dimension + offsets if the global range is too large
 
-    // calculate the indices used in the current thread
-    const ulong i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ul;
-    const ulong i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-    const ulong j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ul;
-    const ulong j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-
-    // create the local memory arrays used for caching data point features
-    __local real_type data_cache_i[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __local real_type data_cache_j[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    // create two local memory arrays used for caching
+    __local real_type data_i_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __local real_type data_j_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
 
     // only calculate the upper triangular matrix -> can't use get_local_id() since all work-items in a work-group must progress further
     if (blockIdx_x >= blockIdx_y) {
-        // create a thread private array used for internal caching
+        // create a private memory array used for internal caching
         real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE] = { (real_type) 0.0 };
 
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (ulong dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ul) {
-            // load data into local memory
-            for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const ulong global_i = row_offset + i_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-                const ulong global_j = row_offset + j_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
+        {
+            // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+            const ulong i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rows - device_row_offset
+            const ulong j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
 
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                data_cache_i[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = data_d[(dim + threadIdx_y) * (num_rows + (ulong) 1 + PADDING_SIZE_ul) + global_i];
-                data_cache_i[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_rows + (ulong) 1 + PADDING_SIZE_ul) + global_i];
-                data_cache_j[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = data_d[(dim + threadIdx_y) * (num_rows + (ulong) 1 + PADDING_SIZE_ul) + global_j];
-                data_cache_j[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_rows + (ulong) 1 + PADDING_SIZE_ul) + global_j];
-            }
-            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
+            // iterate over all features using blocking to be able to cache them for faster memory accesses
+            for (ulong feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into local memory
+                for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const ulong global_i_idx_linear = device_row_offset + i_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+                    const ulong global_j_idx_linear = device_row_offset + j_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the local memory
+                    data_i_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = data[(feature_block + threadIdx_y) * (num_rows + (ulong) 1 + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                    data_j_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = data[(feature_block + threadIdx_y) * (num_rows + (ulong) 1 + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
+                }
+                barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
 
-            // perform the feature reduction calculation
-            for (uint block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+#if defined(PLSSVM_OPENCL_TARGET_CPUS)
+                // perform the feature reduction calculation, the feature is the fastest moving index
                 for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                     for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        temp[internal_i][internal_j] += PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION(data_cache_i[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i], data_cache_j[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j]);
+                        real_type sum = 0.0;
+                        for (uint feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                            sum += PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION(data_i_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i], data_j_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j]);
+                        }
+                        temp[internal_i][internal_j] += sum;
                     }
                 }
+#else
+                // perform the feature reduction calculation, the feature is the slowest moving index
+                for (uint feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                    for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            temp[internal_i][internal_j] += PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION(data_i_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i], data_j_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j]);
+                        }
+                    }
+                }
+#endif
+                barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
             }
-            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
         }
 
+        // calculate the indices used in the current work-item
+        const ulong i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+        const ulong j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
         // apply the remaining part of the kernel function and store the value in the output kernel matrix
         for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const ulong device_global_i = i + (ulong) internal_i;
-                const ulong global_i = row_offset + i + (ulong) internal_i;
-                const ulong device_global_j = j + (ulong) internal_j;
-                const ulong global_j = row_offset + j + (ulong) internal_j;
+                // calculate the indices to access the global data and the data with respect to the current device
+                const ulong device_global_i_idx = i_idx + (ulong) internal_i;
+                const ulong global_i_idx = device_row_offset + device_global_i_idx;
+                const ulong device_global_j_idx = j_idx + (ulong) internal_j;
+                const ulong global_j_idx = device_row_offset + device_global_j_idx;
 
-                // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                if (device_global_i < (num_rows - row_offset) && device_global_j < device_num_rows && global_i >= global_j) {
+                // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
                     real_type temp_ij = temp[internal_i][internal_j];
-                    temp_ij = PLSSVM_OPENCL_APPLY_KERNEL_FUNCTION(temp_ij PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER) + QA_cost - q[global_i] - q[global_j];
+                    // apply the final kernel function
+                    temp_ij = PLSSVM_OPENCL_APPLY_KERNEL_FUNCTION(temp_ij PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER) + QA_cost - q[global_i_idx] - q[global_j_idx];
                     // apply the cost on the diagonal
-                    if (global_i == global_j) {
+                    if (global_i_idx == global_j_idx) {
                         temp_ij += cost;
                     }
-                    // update the kernel matrix
-                    kernel_matrix_d[device_global_j * (num_rows - row_offset + PADDING_SIZE_ul) - device_global_j * (device_global_j + (ulong) 1) / (ulong) 2 + device_global_i] = temp_ij;
+                    // update the upper triangular kernel matrix
+                    kernel_matrix[device_global_j_idx * (num_rows - device_row_offset + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + (ulong) 1) / (ulong) 2 + device_global_i_idx] = temp_ij;
                 }
             }
         }
diff --git a/include/plssvm/backends/OpenCL/kernel/cg_implicit/kernel_matrix_assembly_blas.cl b/include/plssvm/backends/OpenCL/kernel/cg_implicit/kernel_matrix_assembly_blas.cl
index cbcbea498..aecb2ab8b 100644
--- a/include/plssvm/backends/OpenCL/kernel/cg_implicit/kernel_matrix_assembly_blas.cl
+++ b/include/plssvm/backends/OpenCL/kernel/cg_implicit/kernel_matrix_assembly_blas.cl
@@ -19,10 +19,10 @@
  * @note The beta factor is already applied to C before this kernel starts!
  * @param[in] alpha the scalar alpha value
  * @param[in] q the vector used in the dimensional reduction
- * @param[in] data_d the data points to calculate the implicit kernel matrix from
+ * @param[in] data the data points to calculate the implicit kernel matrix from
  * @param[in] num_rows the number of data points
  * @param[in] device_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data_d the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data the current device is responsible for
  * @param[in] num_features the number of features per data point
  * @param[in] QA_cost the scalar used in the dimensional reduction
  * @param[in] cost the cost factor the diagonal is scaled with
@@ -33,172 +33,203 @@
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  * @param[in] PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST a placeholder that is used to string replace the correct kernel parameter (attention: no comma!; Args... only added for Doxygen)
  */
-__kernel void device_kernel_assembly_symm(const real_type alpha, const __global real_type *q, const __global real_type *data_d, const ulong num_rows, const ulong device_num_rows, const ulong row_offset, const ulong num_features, const real_type QA_cost, const real_type cost, const __global real_type *B, __global real_type *C, const ulong num_classes, const ulong grid_x_offset, const ulong grid_y_offset PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST) {
+__kernel void device_kernel_assembly_symm(const real_type alpha, const __global real_type *q, const __global real_type *data, const ulong num_rows, const ulong device_num_rows, const ulong device_row_offset, const ulong num_features, const real_type QA_cost, const real_type cost, const __global real_type *B, __global real_type *C, const ulong num_classes, const ulong grid_x_offset, const ulong grid_y_offset PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST) {
     // cast values to 32-bit unsigned int values to prevent implicit conversions
     const uint local_id_0 = get_local_id(0);
     const uint local_id_1 = get_local_id(1);
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const ulong threadIdx_x = get_local_id(0);                 // current thread in block x-dimension
-    const ulong threadIdx_y = get_local_id(1);                 // current thread in block y-dimension
-    const ulong blockDim_x = get_local_size(0);                // number of threads in block x-dimension
-    const ulong blockDim_y = get_local_size(1);                // number of threads in block y-dimension
-    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-    // calculate the indices used in the current thread
-    const ulong i = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ul;
-    const ulong i_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-    const ulong j = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ul;
-    const ulong j_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-
-    // create the local memory arrays used for caching data point features
-    __local real_type data_cache_i[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __local real_type data_cache_j[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-
-    // only calculate the upper triangular matrix -> can't use threadIdx since all threads in a warp must progress further
+    const ulong threadIdx_x = get_local_id(0);                 // current work-item in work-group x-dimension
+    const ulong threadIdx_y = get_local_id(1);                 // current work-item in work-group y-dimension
+    const ulong blockDim_x = get_local_size(0);                // number of work-items in work-group x-dimension
+    const ulong blockDim_y = get_local_size(1);                // number of work-items in work-group y-dimension
+    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current work-group in global range x-dimension + offsets if the global range is too large
+    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+    // calculate the indices used in the current work-item
+    const ulong i_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+    const ulong j_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
+    // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+    const ulong i_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_rows - device_row_offset
+    const ulong j_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // device_num_rows
+
+    // create two local memory arrays used for caching
+    __local real_type cache_one[THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __local real_type cache_two[THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+
+    // only calculate the upper triangular matrix -> can't use threadIdx since all work-items in a warp must progress further
     if (blockIdx_x >= blockIdx_y) {
         // create a thread private array used for internal caching
         real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE] = { (real_type) 0.0 };
 
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (ulong dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ul) {
-            // load data into local memory
-            for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const ulong global_i = row_offset + i_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-                const ulong global_j = row_offset + j_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                data_cache_i[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = data_d[(dim + threadIdx_y) * (num_rows + (ulong) 1 + PADDING_SIZE_ul) + global_i];
-                data_cache_i[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_rows + (ulong) 1 + PADDING_SIZE_ul) + global_i];
-                data_cache_j[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = data_d[(dim + threadIdx_y) * (num_rows + (ulong) 1 + PADDING_SIZE_ul) + global_j];
-                data_cache_j[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = data_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_rows + (ulong) 1 + PADDING_SIZE_ul) + global_j];
-            }
-            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
+        //*************************************************************************//
+        //                   inplace kernel matrix construction                    //
+        //*************************************************************************//
+        {
+            // reinterpret the local memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+            __local real_type(*data_i_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type(*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) cache_one;
+            __local real_type(*data_j_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type(*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) cache_two;
+
+            // iterate over all features using blocking to be able to cache them for faster memory accesses
+            for (ulong feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into local memory
+                for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const ulong global_i_idx_linear = device_row_offset + i_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+                    const ulong global_j_idx_linear = device_row_offset + j_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
 
-            // perform the feature reduction calculation
-            for (uint block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                    // store the values in the local memory
+                    data_i_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = data[(feature_block + threadIdx_y) * (num_rows + (ulong) 1 + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                    data_j_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = data[(feature_block + threadIdx_y) * (num_rows + (ulong) 1 + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
+                }
+                barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
+
+#if defined(PLSSVM_OPENCL_TARGET_CPUS)
+                // perform the feature reduction calculation, the feature is the fastest moving index
                 for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                     for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        temp[internal_i][internal_j] += PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION(data_cache_i[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i], data_cache_j[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j]);
+                        real_type sum = 0.0;
+                        for (uint feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                            sum += PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION(data_i_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i], data_j_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j]);
+                        }
+                        temp[internal_i][internal_j] += sum;
                     }
                 }
+#else
+                // perform the feature reduction calculation, the feature is the slowest moving index
+                for (uint feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                    for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            temp[internal_i][internal_j] += PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION(data_i_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_i], data_j_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j]);
+                        }
+                    }
+                }
+#endif
+                barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
             }
-            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
         }
 
         // apply the remaining part of the kernel function and store the value in the output kernel matrix
         for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const ulong global_i = row_offset + i + (ulong) internal_i;
-                const ulong device_global_i = i + (ulong) internal_i;
-                const ulong global_j = row_offset + j + (ulong) internal_j;
-                const ulong device_global_j = j + (ulong) internal_j;
-
-                // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                if ((device_global_i < (num_rows - row_offset) && device_global_j < device_num_rows && global_i >= global_j)) {
-                    temp[internal_i][internal_j] = PLSSVM_OPENCL_APPLY_KERNEL_FUNCTION(temp[internal_i][internal_j] PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER) + QA_cost - q[global_i] - q[global_j];
+                // calculate the indices to access the global data and the data with respect to the current device
+                const ulong device_global_i_idx = i_idx + (ulong) internal_i;
+                const ulong global_i_idx = device_row_offset + device_global_i_idx;
+                const ulong device_global_j_idx = j_idx + (ulong) internal_j;
+                const ulong global_j_idx = device_row_offset + device_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
+                    // apply the final kernel function
+                    temp[internal_i][internal_j] = PLSSVM_OPENCL_APPLY_KERNEL_FUNCTION(temp[internal_i][internal_j] PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER) + QA_cost - q[global_i_idx] - q[global_j_idx];
                     // apply the cost on the diagonal
-                    if (global_i == global_j) {
+                    if (global_i_idx == global_j_idx) {
                         temp[internal_i][internal_j] += cost;
                     }
                 } else {
+                    // be sure to set the value to zero otherwise
                     temp[internal_i][internal_j] = (real_type) 0.0;
                 }
             }
         }
 
-        // calculate C += alpha * temp * B for the UPPER triangular matrix
+        //*************************************************************************//
+        //     calculate C += alpha * temp * B for the UPPER triangular matrix     //
+        //*************************************************************************//
         {
-            // reinterpret cache arrays with interchanged dimensions
-            __local real_type (*B_cache)[FEATURE_BLOCK_SIZE] = (__local real_type (*)[FEATURE_BLOCK_SIZE]) data_cache_i;
-            __local real_type (*C_out_cache)[FEATURE_BLOCK_SIZE] = (__local real_type (*)[FEATURE_BLOCK_SIZE]) data_cache_j;
+            // reinterpret the local memory arrays to be of shape [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][THREAD_BLOCK_SIZE]
+            __local real_type(*B_cache)[THREAD_BLOCK_SIZE] = (__local real_type(*)[THREAD_BLOCK_SIZE]) cache_one;
+            __local real_type(*C_out_cache)[THREAD_BLOCK_SIZE] = (__local real_type(*)[THREAD_BLOCK_SIZE]) cache_two;
 
             // iterate over all classes using blocking to be able to cache them for faster memory accesses
-            for (ulong dim = 0; dim < num_classes; dim += FEATURE_BLOCK_SIZE_ul) {
+            for (ulong class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
                 // load data into local memory
                 for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const ulong global_i = row_offset + i_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const ulong global_i_idx_linear = device_row_offset + i_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
 
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    B_cache[internal * THREAD_BLOCK_SIZE + local_id_0][local_id_1] = alpha * B[global_i * (num_classes + PADDING_SIZE_ul) + dim + threadIdx_y];
-                    B_cache[internal * THREAD_BLOCK_SIZE + local_id_0][local_id_1 + THREAD_BLOCK_SIZE] = alpha * B[global_i * (num_classes + PADDING_SIZE_ul) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ul];
-                    C_out_cache[internal * THREAD_BLOCK_SIZE + local_id_0][local_id_1] = (real_type) 0.0;
-                    C_out_cache[internal * THREAD_BLOCK_SIZE + local_id_0][local_id_1 + THREAD_BLOCK_SIZE] = (real_type) 0.0;
+                    // store the values in the local memory
+                    B_cache[internal * THREAD_BLOCK_SIZE + local_id_0][local_id_1] = alpha * B[global_i_idx_linear * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y];  // SoA
+                    C_out_cache[internal * THREAD_BLOCK_SIZE + local_id_0][local_id_1] = (real_type) 0.0;                                                                           // SoA
                 }
                 barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
 
                 // calculate intermediate results and store them in local memory
-                for (uint class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                for (uint class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                     for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            C_out_cache[local_id_1 * INTERNAL_BLOCK_SIZE + internal_j][(class_idx + local_id_0) % FEATURE_BLOCK_SIZE] +=
-                                temp[internal_i][internal_j] * B_cache[local_id_0 * INTERNAL_BLOCK_SIZE + internal_i][(class_idx + local_id_0) % FEATURE_BLOCK_SIZE];
+                            C_out_cache[local_id_1 * INTERNAL_BLOCK_SIZE + internal_j][(class_idx + local_id_0) % THREAD_BLOCK_SIZE] +=
+                                temp[internal_i][internal_j] * B_cache[local_id_0 * INTERNAL_BLOCK_SIZE + internal_i][(class_idx + local_id_0) % THREAD_BLOCK_SIZE];
                         }
                     }
                     barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
                 }
 
-                // add intermediate cached results to C
+                // atomically add the intermediate cached results to the C matrix
                 for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const ulong global_j = row_offset + j + (ulong) internal;
-                    atomicAdd(&C[global_j * (num_classes + PADDING_SIZE_ul) + dim + threadIdx_x], C_out_cache[local_id_1 * INTERNAL_BLOCK_SIZE + internal][local_id_0]);
-                    atomicAdd(&C[global_j * (num_classes + PADDING_SIZE_ul) + dim + threadIdx_x + THREAD_BLOCK_SIZE_ul], C_out_cache[local_id_1 * INTERNAL_BLOCK_SIZE + internal][local_id_0 + THREAD_BLOCK_SIZE]);
+                    // calculate the indices to access the global data
+                    const ulong global_j_idx = device_row_offset + j_idx + (ulong) internal;
+
+                    atomicAdd(&C[global_j_idx * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_x], C_out_cache[local_id_1 * INTERNAL_BLOCK_SIZE + internal][local_id_0]);  // SoA
                 }
-                barrier(CLK_LOCAL_MEM_FENCE);  // wai until all threads updated C with their values
+                barrier(CLK_LOCAL_MEM_FENCE);  // wai until all work-items updated C with their values
             }
         }
 
         // set potential diagonal entries in temp to 0.0 such that we don't apply the main diagonal twice to C
         for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const ulong global_i = row_offset + i + (ulong) internal_i;
-                const ulong global_j = row_offset + j + (ulong) internal_j;
+                // calculate the indices to access the global data
+                const ulong global_i_idx = device_row_offset + i_idx + (ulong) internal_i;
+                const ulong global_j_idx = device_row_offset + j_idx + (ulong) internal_j;
 
-                if (global_i == global_j) {
+                if (global_i_idx == global_j_idx) {
                     temp[internal_i][internal_j] = (real_type) 0.0;
                 }
             }
         }
 
-        // calculate C += alpha * temp * B for the LOWER triangular matrix
+        //*************************************************************************//
+        //     calculate C += alpha * temp * B for the LOWER triangular matrix     //
+        //*************************************************************************//
         {
-            // reinterpret cache arrays with interchanged dimensions
-            __local real_type (*B_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type (*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) data_cache_i;
-            __local real_type (*C_out_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type (*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) data_cache_j;
+            // reinterpret the local memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+            __local real_type(*B_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type(*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) cache_one;
+            __local real_type(*C_out_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type(*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) cache_two;
 
             // iterate over all classes using blocking to be able to cache them for faster memory accesses
-            for (ulong dim = 0; dim < num_classes; dim += FEATURE_BLOCK_SIZE_ul) {
+            for (ulong class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
                 // load data into local memory
                 for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const ulong global_j = row_offset + j_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const ulong global_j_idx_linear = device_row_offset + j_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
 
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    B_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = alpha * B[global_j * (num_classes + PADDING_SIZE_ul) + dim + threadIdx_y];
-                    B_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = alpha * B[global_j * (num_classes + PADDING_SIZE_ul) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ul];
+                    // store the values in the local memory
+                    B_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = alpha * B[global_j_idx_linear * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y];  // SoA
                     C_out_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = (real_type) 0.0;
-                    C_out_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = (real_type) 0.0;
                 }
                 barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
 
-                // calculate intermediate results and store them in shared memory
-                for (uint class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                // calculate intermediate results and store them in local memory
+                for (uint class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                     for (uint internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (uint internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            C_out_cache[(class_idx + local_id_1) % FEATURE_BLOCK_SIZE][internal_i * THREAD_BLOCK_SIZE + local_id_0] +=
-                                temp[internal_i][internal_j] * B_cache[(class_idx + local_id_1) % FEATURE_BLOCK_SIZE][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j];
+                            C_out_cache[(class_idx + local_id_1) % THREAD_BLOCK_SIZE][internal_i * THREAD_BLOCK_SIZE + local_id_0] +=
+                                temp[internal_i][internal_j] * B_cache[(class_idx + local_id_1) % THREAD_BLOCK_SIZE][local_id_1 * INTERNAL_BLOCK_SIZE + internal_j];
                         }
                     }
                     barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
                 }
 
-                // add intermediate cached results to C
+                // atomically add the intermediate cached results to the C matrix
                 for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const ulong global_i = row_offset + i + (ulong) internal;
-                    atomicAdd(&C[global_i * (num_classes + PADDING_SIZE_ul) + dim + threadIdx_y], C_out_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0]);
-                    atomicAdd(&C[global_i * (num_classes + PADDING_SIZE_ul) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ul], C_out_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0]);
+                    // calculate the indices to access the global data
+                    const ulong global_i_idx = device_row_offset + i_idx + (ulong) internal;
+
+                    atomicAdd(&C[global_i_idx * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y], C_out_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0]);  // SoA
                 }
-                barrier(CLK_LOCAL_MEM_FENCE);   // wait until all threads updated C with their values
+                barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items updated C with their values
             }
         }
     }
diff --git a/include/plssvm/backends/OpenCL/kernel/detail/fill_kernel.cl b/include/plssvm/backends/OpenCL/kernel/detail/fill_kernel.cl
new file mode 100644
index 000000000..76c0ba424
--- /dev/null
+++ b/include/plssvm/backends/OpenCL/kernel/detail/fill_kernel.cl
@@ -0,0 +1,40 @@
+/**
+ * @file
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Implement a fill kernel using OpenCL.
+ */
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+/**
+ * @brief Fill the float data pointer @p data with the @p value.
+ * @param[out] data the pointer to fill with values
+ * @param[in] value the value used to fill @p data
+ * @param[in] pos the start position for filling @p data
+ * @param[in] size the number of elements in @p data
+ */
+__kernel void device_fill_kernel_float(__global float *data, const float value, const ulong pos, const ulong size) {
+    const ulong idx = get_global_id(0);
+    if (idx < size) {
+        data[pos + idx] = value;
+    }
+}
+
+/**
+ * @brief Fill the double data pointer @p data with the @p value.
+ * @param[out] data the pointer to fill with values
+ * @param[in] value the value used to fill @p data
+ * @param[in] pos the start position for filling @p data
+ * @param[in] size the number of elements in @p data
+ */
+__kernel void device_fill_kernel_double(__global double *data, const double value, const ulong pos, const ulong size) {
+    const ulong idx = get_global_id(0);
+    if (idx < size) {
+        data[pos + idx] = value;
+    }
+}
diff --git a/include/plssvm/backends/OpenCL/kernel/detail/memset_kernel.cl b/include/plssvm/backends/OpenCL/kernel/detail/memset_kernel.cl
new file mode 100644
index 000000000..88b4f67e1
--- /dev/null
+++ b/include/plssvm/backends/OpenCL/kernel/detail/memset_kernel.cl
@@ -0,0 +1,46 @@
+/**
+ * @file
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Implement a memset kernel using OpenCL.
+ */
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+/**
+ * @brief Memset the float data pointer @p data with the @p value.
+ * @param[out] data the pointer to memset with the pattern
+ * @param[in] pattern the pattern used to memset @p data
+ * @param[in] pos the start position for the memset operation on @p data
+ * @param[in] size the number of elements in @p data
+ */
+__kernel void device_memset_kernel_float(__global float *data, const uchar pattern, const ulong pos, const ulong size) {
+    const ulong idx = get_global_id(0);
+    if (idx < size) {
+        // pack the 1-Byte pattern into a 4-Byte uint
+        const uint packed_pattern = (pattern << 24) | (pattern << 16) | (pattern << 8) | pattern;
+        // bitwise cast the uint to a float
+        data[pos + idx] = as_float(packed_pattern);
+    }
+}
+
+/**
+ * @brief Memset the double data pointer @p data with the @p value.
+ * @param[out] data the pointer to memset with the pattern
+ * @param[in] pattern the pattern used to memset @p data
+ * @param[in] pos the start position for the memset operation on @p data
+ * @param[in] size the number of elements in @p data
+ */
+__kernel void device_memset_kernel_double(__global double *data, const uchar pattern, const ulong pos, const ulong size) {
+    const ulong idx = get_global_id(0);
+    if (idx < size) {
+        // pack the 1-Byte pattern into an 8-Byte ulong
+        const ulong packed_pattern = ((ulong) pattern << 56) | ((ulong) pattern << 48) | ((ulong) pattern << 40) | ((ulong) pattern << 32) | ((ulong) pattern << 24) | ((ulong) pattern << 16) | ((ulong) pattern << 8) | ((ulong) pattern);
+        // bitwise cast th ulong to a double
+        data[pos + idx] = as_double(packed_pattern);
+    }
+}
diff --git a/include/plssvm/backends/OpenCL/kernel/kernel_functions.cl b/include/plssvm/backends/OpenCL/kernel/kernel_functions.cl
index 286c9db05..70b66e305 100644
--- a/include/plssvm/backends/OpenCL/kernel/kernel_functions.cl
+++ b/include/plssvm/backends/OpenCL/kernel/kernel_functions.cl
@@ -75,7 +75,7 @@ real_type apply_linear_kernel_function(const real_type value) {
 
 /**
  * @brief Compute the polynomial kernel function using @p value.
- * @details Uses a custom power implementation taking advantage of the fact that degree can only be a positive integer. Hardcodes the power function for degrees <= 6.
+ * @details Uses a custom power implementation taking advantage of the fact that degree can only be a positive integer.
  * @param[in] value the value to apply the polynomial kernel function to
  * @param[in] degree the degree parameter of the polynomial kernel function
  * @param[in] gamma the gamma parameter of the polynomial kernel function
@@ -84,36 +84,12 @@ real_type apply_linear_kernel_function(const real_type value) {
  */
 real_type apply_polynomial_kernel_function(const real_type value, const int degree, const real_type gamma, const real_type coef0) {
     const real_type base = gamma * value + coef0;
-    switch (degree) {
-        case 0: return (real_type) 1.0;
-        case 1: return base;
-        case 2: return base * base;
-        case 3: return base * base * base;
-        case 4:
-            {
-                const real_type temp = base * base;
-                return temp * temp;
-            }
-        case 5:
-            {
-                const real_type temp = base * base;
-                return temp * temp * base;
-            }
-        case 6:
-            {
-                const real_type temp = base * base * base;
-                return temp * temp;
-            }
-        default:
-            {
-                // generic integer power function
-                real_type result = 1.0;
-                for (int i = 0; i < degree; ++i) {
-                    result *= base;
-                }
-                return result;
-            }
+    // generic integer power function
+    real_type result = 1.0;
+    for (int i = 0; i < degree; ++i) {
+        result *= base;
     }
+    return result;
 }
 
 /**
diff --git a/include/plssvm/backends/OpenCL/kernel/predict_kernel.cl b/include/plssvm/backends/OpenCL/kernel/predict_kernel.cl
index e37c1dbfb..42edc442f 100644
--- a/include/plssvm/backends/OpenCL/kernel/predict_kernel.cl
+++ b/include/plssvm/backends/OpenCL/kernel/predict_kernel.cl
@@ -14,13 +14,13 @@
 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
 
 /**
- * @brief Predict the @p predict_points_d using the kernel function determined at runtime.
+ * @brief Predict the @p predict_points using the kernel function determined at runtime.
  * @details The `PLSSVM_DEVICE_KERNEL_PREDICT_NAME`, `PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST`, `PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER`, `PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION`, and `PLSSVM_OPENCL_APPLY_KERNEL_FUNCTION` placeholder will be replaced by the correct values upon kernel construction.
- * @param[in] prediction_d the predicted values
- * @param[in] alpha_d the previously learned weights
- * @param[in] rho_d the previously learned biases
- * @param[in] sv_d the support vectors
- * @param[in] predict_points_d the data points to predict
+ * @param[in] prediction the predicted values
+ * @param[in] alpha the previously learned weights
+ * @param[in] rho the previously learned biases
+ * @param[in] support_vectors the support vectors
+ * @param[in] predict_points the data points to predict
  * @param[in] num_classes the number of classes
  * @param[in] num_sv the number of support vectors
  * @param[in] num_predict_points the number of data points to predict
@@ -29,107 +29,126 @@
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  * @param[in] PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST a placeholder that is used to string replace the correct kernel parameter (attention: no comma!; Args... only added for Doxygen)
  */
-__kernel void PLSSVM_DEVICE_KERNEL_PREDICT_NAME(__global real_type *prediction_d, const __global real_type *alpha_d, const __global real_type *rho_d, const __global real_type *sv_d, const __global real_type *predict_points_d, const ulong num_classes, const ulong num_sv, const ulong num_predict_points, const ulong num_features, const ulong grid_x_offset, const ulong grid_y_offset PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST) {
+__kernel void PLSSVM_DEVICE_KERNEL_PREDICT_NAME(__global real_type *prediction, const __global real_type *alpha, const __global real_type *rho, const __global real_type *support_vectors, const __global real_type *predict_points, const ulong num_classes, const ulong num_sv, const ulong num_predict_points, const ulong num_features, const ulong grid_x_offset, const ulong grid_y_offset PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER_LIST) {
     // cast values to 32-bit unsigned int values to prevent implicit conversions
     const uint local_id_0 = get_local_id(0);
     const uint local_id_1 = get_local_id(1);
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const ulong threadIdx_x = get_local_id(0);                 // current thread in block x-dimension
-    const ulong threadIdx_y = get_local_id(1);                 // current thread in block y-dimension
-    const ulong blockDim_x = get_local_size(0);                // number of threads in block x-dimension
-    const ulong blockDim_y = get_local_size(1);                // number of threads in block y-dimension
-    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-    // calculate the indices used in the current thread
-    const ulong pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ul;
-    const ulong pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-    const ulong sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-
-    // create the local memory arrays used for caching data point features
-    __local real_type data_cache_pp[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __local real_type data_cache_sv[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-
-    // create a thread private array used for internal caching
+    const ulong threadIdx_x = get_local_id(0);                 // current work-item in work-group x-dimension
+    const ulong threadIdx_y = get_local_id(1);                 // current work-item in work-group y-dimension
+    const ulong blockDim_x = get_local_size(0);                // number of work-items in work-group x-dimension
+    const ulong blockDim_y = get_local_size(1);                // number of work-items in work-group y-dimension
+    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current work-group in global range x-dimension + offsets if the global range is too large
+    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+    // create two local memory arrays used for caching
+    __local real_type cache_one[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __local real_type cache_two[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+
+    // create a work-item private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE] = { (real_type) 0.0 };
 
-    // iterate over all features using blocking to be able to cache them for faster memory accesses
-    for (ulong dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ul) {
-        // load data into local memory
-        for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const ulong global_pp_idx = pp_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-            const ulong global_sv_idx = sv_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-
-            // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-            data_cache_pp[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = predict_points_d[(dim + threadIdx_y) * (num_predict_points + PADDING_SIZE_ul) + global_pp_idx];
-            data_cache_pp[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = predict_points_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_predict_points + PADDING_SIZE_ul) + global_pp_idx];
-            data_cache_sv[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = sv_d[(dim + threadIdx_y) * (num_sv + PADDING_SIZE_ul) + global_sv_idx];
-            data_cache_sv[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = sv_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_sv + PADDING_SIZE_ul) + global_sv_idx];
-        }
-        barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
+    {
+        // reinterpret the local memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+        __local real_type(*pp_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type(*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) cache_one;
+        __local real_type(*sv_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type(*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) cache_two;
+
+        // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+        const ulong pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_predict_points
+        const ulong sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_support_vectors
+
+        // iterate over all features using blocking to be able to cache them for faster memory accesses
+        for (ulong feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into local memory
+            for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const ulong global_pp_idx_linear = pp_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+                const ulong global_sv_idx_linear = sv_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the local memory
+                pp_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = predict_points[(feature_block + threadIdx_y) * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                sv_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = support_vectors[(feature_block + threadIdx_y) * (num_sv + PADDING_SIZE_uz) + global_sv_idx_linear];             // SoA
+            }
+            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
 
-        // perform the feature reduction calculation
-        for (uint block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-            for (uint internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+#if defined(PLSSVM_OPENCL_TARGET_CPUS)
+            // perform the feature reduction calculation, the feature is the fastest moving index
+            for (uint internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                 for (uint internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                    temp[internal_pd][internal_sv] += PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION(data_cache_sv[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_sv], data_cache_pp[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_pd]);
+                    real_type sum = 0.0;
+                    for (uint feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                        sum += PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION(sv_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_sv], pp_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_pp]);
+                    }
+                    temp[internal_pp][internal_sv] += sum;
                 }
             }
+#else
+            // perform the feature reduction calculation, the feature is the slowest moving index
+            for (uint feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                for (uint internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                    for (uint internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                        temp[internal_pp][internal_sv] += PLSSVM_OPENCL_FEATURE_REDUCE_FUNCTION(sv_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_sv], pp_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_pp]);
+                    }
+                }
+            }
+#endif
+            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
         }
-        barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
     }
 
     // update temp using the respective kernel function
-    for (uint internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+    for (uint internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
         for (uint internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-            temp[internal_pd][internal_sv] = PLSSVM_OPENCL_APPLY_KERNEL_FUNCTION(temp[internal_pd][internal_sv] PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER);
+            temp[internal_pp][internal_sv] = PLSSVM_OPENCL_APPLY_KERNEL_FUNCTION(temp[internal_pp][internal_sv] PLSSVM_OPENCL_KERNEL_FUNCTION_PARAMETER);
         }
     }
 
     {
-        // reinterpret cache arrays with interchanged dimensions
-        __local real_type(*alpha_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type(*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) data_cache_pp;
-        __local real_type(*out_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type(*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) data_cache_sv;
+        // reinterpret the local memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+        __local real_type(*alpha_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type(*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) cache_one;
+        __local real_type(*out_cache)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE] = (__local real_type(*)[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]) cache_two;
 
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (ulong dim = 0; dim < num_classes; dim += FEATURE_BLOCK_SIZE_ul) {
+        // calculate the indices used in the current thread
+        const ulong pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
+        // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+        const ulong sv_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_support_vectors
+
+        // iterate over all classes using blocking to be able to cache them for faster memory accesses
+        for (ulong class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
             // load data into local memory
             for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const ulong global_sv_idx = sv_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                alpha_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = alpha_d[(dim + threadIdx_y) * (num_sv + PADDING_SIZE_ul) + global_sv_idx];
-                alpha_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = alpha_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_sv + PADDING_SIZE_ul) + global_sv_idx];
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const ulong global_sv_idx_linear = sv_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
 
+                // store the values in the local memory
+                alpha_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = alpha[(class_block + threadIdx_y) * (num_sv + PADDING_SIZE_uz) + global_sv_idx_linear];  // AoS
                 // the bias (rho) must only be applied once for all support vectors
                 if (blockIdx_y == (ulong) 0) {
-                    out_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = -rho_d[dim + threadIdx_y];
-                    out_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = -rho_d[dim + threadIdx_y + THREAD_BLOCK_SIZE_ul];
+                    out_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = -rho[class_block + threadIdx_y];
                 } else {
                     out_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = (real_type) 0.0;
-                    out_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = (real_type) 0.0;
                 }
             }
             barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
 
             // calculate intermediate results and store them in shared memory
-            for (uint class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
-                for (uint internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+            for (uint class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
+                for (uint internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                     for (uint internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                        out_cache[(class_idx + local_id_1) % FEATURE_BLOCK_SIZE][internal_pd * THREAD_BLOCK_SIZE + local_id_0] +=
-                            temp[internal_pd][internal_sv] * alpha_cache[(class_idx + local_id_1) % FEATURE_BLOCK_SIZE][local_id_1 * INTERNAL_BLOCK_SIZE + internal_sv];
+                        out_cache[(class_idx + local_id_1) % THREAD_BLOCK_SIZE][internal_pp * THREAD_BLOCK_SIZE + local_id_0] +=
+                            temp[internal_pp][internal_sv] * alpha_cache[(class_idx + local_id_1) % THREAD_BLOCK_SIZE][local_id_1 * INTERNAL_BLOCK_SIZE + internal_sv];
                     }
                 }
                 barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
             }
 
-            // add intermediate cached results to prediction_d
+            // atomically add the intermediate cached results to the prediction
             for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data
                 const ulong global_pp_idx = pp_idx + (ulong) internal;
 
-                atomicAdd(&prediction_d[global_pp_idx * (num_classes + PADDING_SIZE_ul) + dim + threadIdx_y], out_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0]);
-                atomicAdd(&prediction_d[global_pp_idx * (num_classes + PADDING_SIZE_ul) + dim + threadIdx_y + THREAD_BLOCK_SIZE_ul], out_cache[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0]);
+                atomicAdd(&prediction[global_pp_idx * (num_classes + PADDING_SIZE_uz) + class_block + threadIdx_y], out_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0]);
             }
             barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items updated their part of the prediction
         }
diff --git a/include/plssvm/backends/OpenCL/kernel/predict_kernel_linear.cl b/include/plssvm/backends/OpenCL/kernel/predict_kernel_linear.cl
index 5844b3a3a..1d579b40d 100644
--- a/include/plssvm/backends/OpenCL/kernel/predict_kernel_linear.cl
+++ b/include/plssvm/backends/OpenCL/kernel/predict_kernel_linear.cl
@@ -14,148 +14,185 @@
 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
 
 /**
- * @brief Calculate the `q` vector used to speedup the prediction using the linear kernel function.
- * @param[in,out] w_d the vector to speedup the linear prediction
- * @param[in] alpha_d the previously learned weights
- * @param[in] sv_d the support vectors
+ * @brief Calculate the `w` vector used to speedup the prediction using the linear kernel function.
+ * @param[in,out] w the vector to speedup the linear prediction
+ * @param[in] alpha the previously learned weights
+ * @param[in] support_vectors the support vectors
  * @param[in] num_classes the number of classes
  * @param[in] num_sv the number of support vectors
- * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
- * @param[in] sv_offset the first support vector (row in @p alpha_d) the current device is responsible for
+ * @param[in] device_num_sv the number of support vectors the current device is responsible for
+ * @param[in] device_sv_offset the first support vector (row in @p alpha) the current device is responsible for
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__kernel void device_kernel_w_linear(__global real_type *w_d, const __global real_type *alpha_d, const __global real_type *sv_d, const ulong num_classes, const ulong num_sv, const ulong device_specific_num_sv, const ulong sv_offset, const ulong grid_x_offset, const ulong grid_y_offset) {
+__kernel void device_kernel_w_linear(__global real_type *w, const __global real_type *alpha, const __global real_type *support_vectors, const ulong num_classes, const ulong num_sv, const ulong device_num_sv, const ulong device_sv_offset, const ulong grid_x_offset, const ulong grid_y_offset) {
     // cast values to 32-bit unsigned int values to prevent implicit conversions
     const uint local_id_0 = get_local_id(0);
     const uint local_id_1 = get_local_id(1);
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const ulong threadIdx_x = get_local_id(0);                 // current thread in block x-dimension
-    const ulong threadIdx_y = get_local_id(1);                 // current thread in block y-dimension
-    const ulong blockDim_x = get_local_size(0);                // number of threads in block x-dimension
-    const ulong blockDim_y = get_local_size(1);                // number of threads in block y-dimension
-    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-    // calculate the indices used in the current thread
-    const ulong feature_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ul;
-    const ulong feature_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-    const ulong class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ul;
-    const ulong class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-
-    // create the local memory arrays used for caching data point features
-    __local real_type data_cache_feature[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __local real_type data_cache_alpha[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-
-    // create a thread private array used for internal caching
+    const ulong threadIdx_x = get_local_id(0);                 // current work-item in work-group x-dimension
+    const ulong threadIdx_y = get_local_id(1);                 // current work-item in work-group y-dimension
+    const ulong blockDim_x = get_local_size(0);                // number of work-items in work-group x-dimension
+    const ulong blockDim_y = get_local_size(1);                // number of work-items in work-group y-dimension
+    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current work-group in global range x-dimension + offsets if the global range is too large
+    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+    // create two local memory arrays used for caching
+    __local real_type feature_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __local real_type alpha_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+
+    // create a work-item private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE] = { (real_type) 0.0 };
 
-    // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-    for (ulong sv = 0; sv < device_specific_num_sv; sv += THREAD_BLOCK_SIZE_ul) {
-        // load data into local memory
-        for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const ulong global_feature_idx = feature_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-            const ulong global_class_idx = class_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_ul;
-
-            data_cache_feature[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = sv_d[global_feature_idx * (device_specific_num_sv + PADDING_SIZE_ul) + sv + threadIdx_y];  // SoA
-            data_cache_alpha[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = alpha_d[global_class_idx * (num_sv + PADDING_SIZE_ul) + sv + sv_offset + threadIdx_y];       // AoS
-        }
-        barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
+    {
+        // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+        const ulong feature_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_features
+        const ulong class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;    // num_classes
+
+        // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
+        for (ulong sv_block = 0; sv_block < device_num_sv; sv_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into local memory
+            for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const ulong global_feature_idx_linear = feature_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+                const ulong global_class_idx_linear = class_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the local memory
+                feature_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = support_vectors[global_feature_idx_linear * (device_num_sv + PADDING_SIZE_uz) + sv_block + threadIdx_y];  // SoA
+                alpha_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = alpha[global_class_idx_linear * (num_sv + PADDING_SIZE_uz) + sv_block + device_sv_offset + threadIdx_y];    // AoS
+            }
+            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
 
-        // perform the dot product calculation
-        for (uint block_dim = 0; block_dim < THREAD_BLOCK_SIZE; ++block_dim) {
+#if defined(PLSSVM_OPENCL_TARGET_CPUS)
+            // perform the dot product calculation, the sv is the fastest moving index
             for (uint internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
                 for (uint internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    temp[internal_feature][internal_class] += data_cache_alpha[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_feature[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_feature];
+                    real_type sum = 0.0;
+                    for (uint sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                        sum += alpha_cache[sv][local_id_1 * INTERNAL_BLOCK_SIZE + internal_class] * feature_cache[sv][local_id_0 * INTERNAL_BLOCK_SIZE + internal_feature];
+                    }
+                    temp[internal_feature][internal_class] += sum;
                 }
             }
+#else
+            // perform the dot product calculation, the sv is the slowest moving index
+            for (uint sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                for (uint internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                    for (uint internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                        temp[internal_feature][internal_class] += alpha_cache[sv][local_id_1 * INTERNAL_BLOCK_SIZE + internal_class] * feature_cache[sv][local_id_0 * INTERNAL_BLOCK_SIZE + internal_feature];
+                    }
+                }
+            }
+#endif
+            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
         }
-        barrier(CLK_LOCAL_MEM_FENCE);  // wait until all threads performed their part of the calculations
     }
 
-    // update global array with local one
+    // calculate the indices used in the current work-item
+    const ulong feature_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+    const ulong class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;    // num_classes
+
+    // update the global w-vector with the locally cached values
     for (uint internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
         for (uint internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+            // calculate the indices to access the global data
             const ulong global_feature_idx = feature_idx + (ulong) internal_feature;
             const ulong global_class_idx = class_idx + (ulong) internal_class;
 
-            w_d[global_feature_idx * (num_classes + PADDING_SIZE_ul) + global_class_idx] = temp[internal_feature][internal_class];
+            w[global_feature_idx * (num_classes + PADDING_SIZE_uz) + global_class_idx] = temp[internal_feature][internal_class];  // SoA
         }
     }
 }
 
 /**
- * @brief Predict the @p predict_points_d using the linear kernel speeding up the calculation using the @p w_d vector.
- * @param[out] prediction_d the predicted values
- * @param[in] w_d the vector to speedup the calculations
- * @param[in] rho_d the previously learned bias
- * @param[in] predict_points_d the data points to predict
+ * @brief Predict the @p predict_points using the linear kernel speeding up the calculation using the @p w vector.
+ * @param[out] prediction the predicted values
+ * @param[in] w the vector to speedup the calculations
+ * @param[in] rho the previously learned bias
+ * @param[in] predict_points the data points to predict
  * @param[in] num_classes the number of classes
  * @param[in] num_predict_points the number of data points to predict
  * @param[in] num_features the number of features per data point
  * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
  * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
  */
-__kernel void device_kernel_predict_linear(__global real_type *prediction_d, const __global real_type *w_d, const __global real_type *rho_d, const __global real_type *predict_points_d, const ulong num_classes, const ulong num_predict_points, const ulong num_features, const ulong grid_x_offset, const ulong grid_y_offset) {
+__kernel void device_kernel_predict_linear(__global real_type *prediction, const __global real_type *w, const __global real_type *rho, const __global real_type *predict_points, const ulong num_classes, const ulong num_predict_points, const ulong num_features, const ulong grid_x_offset, const ulong grid_y_offset) {
     // cast values to 32-bit unsigned int values to prevent implicit conversions
     const uint local_id_0 = get_local_id(0);
     const uint local_id_1 = get_local_id(1);
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const ulong threadIdx_x = get_local_id(0);                 // current thread in block x-dimension
-    const ulong threadIdx_y = get_local_id(1);                 // current thread in block y-dimension
-    const ulong blockDim_x = get_local_size(0);                // number of threads in block x-dimension
-    const ulong blockDim_y = get_local_size(1);                // number of threads in block y-dimension
-    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current block in grid x-dimension + offsets if the grid size would be too large
-    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-    // calculate the indices used in the current thread
-    const ulong pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_ul;
-    const ulong pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-    const ulong class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_ul;
-    const ulong class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_ul + threadIdx_x;
-
-    // create the local memory arrays used for caching data point features
-    __local real_type data_cache_pp[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-    __local real_type data_cache_w[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-
-    // create a thread private array used for internal caching
+    const ulong threadIdx_x = get_local_id(0);                 // current work-item in work-group x-dimension
+    const ulong threadIdx_y = get_local_id(1);                 // current work-item in work-group y-dimension
+    const ulong blockDim_x = get_local_size(0);                // number of work-items in work-group x-dimension
+    const ulong blockDim_y = get_local_size(1);                // number of work-items in work-group y-dimension
+    const ulong blockIdx_x = get_group_id(0) + grid_x_offset;  // current work-group in global range x-dimension + offsets if the global range is too large
+    const ulong blockIdx_y = get_group_id(1) + grid_y_offset;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+    // create two local memory arrays used for caching
+    __local real_type pp_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+    __local real_type w_cache[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+
+    // create a work-item private array used for internal caching
     real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE] = { (real_type) 0.0 };
 
-    // iterate over all features using blocking to be able to cache them for faster memory accesses
-    for (ulong dim = 0; dim < num_features; dim += FEATURE_BLOCK_SIZE_ul) {
-        // load data into local memory
-        for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-            const ulong global_pp_idx = pp_idx_linear + internal * THREAD_BLOCK_SIZE;
-            const ulong global_class_idx = class_idx_linear + internal * THREAD_BLOCK_SIZE;
-
-            // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-            data_cache_pp[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = predict_points_d[(dim + threadIdx_y) * (num_predict_points + PADDING_SIZE_ul) + global_pp_idx];
-            data_cache_pp[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = predict_points_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_predict_points + PADDING_SIZE_ul) + global_pp_idx];
-            data_cache_w[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = w_d[(dim + threadIdx_y) * (num_classes + PADDING_SIZE_ul) + global_class_idx];
-            data_cache_w[local_id_1 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_0] = w_d[(dim + threadIdx_y + THREAD_BLOCK_SIZE_ul) * (num_classes + PADDING_SIZE_ul) + global_class_idx];
-        }
-        barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
+    {
+        // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+        const ulong pp_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;     // num_predict_points
+        const ulong class_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_x;  // num_classes
+
+        // iterate over all features using blocking to be able to cache them for faster memory accesses
+        for (ulong feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+            // load data into local memory
+            for (uint internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const ulong global_pp_idx_linear = pp_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+                const ulong global_class_idx_linear = class_idx_linear + (ulong) internal * THREAD_BLOCK_SIZE_uz;
+
+                // store the values in the local memory
+                pp_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = predict_points[(feature_block + threadIdx_y) * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                w_cache[local_id_1][internal * THREAD_BLOCK_SIZE + local_id_0] = w[(feature_block + threadIdx_y) * (num_classes + PADDING_SIZE_uz) + global_class_idx_linear];                    // SoA
+            }
+            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items loaded their part of the data
 
-        // perform the dot product calculation
-        for (uint block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-            for (uint internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+#if defined(PLSSVM_OPENCL_TARGET_CPUS)
+            // perform the feature reduction calculation, the feature is the fastest moving index
+            for (uint internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                 for (uint internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    temp[internal_pd][internal_class] += data_cache_w[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_pp[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_pd];
+                    real_type sum = 0.0;
+                    for (uint feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                        sum += w_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_class] * pp_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_pp];
+                    }
+                    temp[internal_pp][internal_class] += sum;
                 }
             }
+#else
+            // perform the feature reduction calculation, the feature is the slowest moving index
+            for (uint feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                for (uint internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                    for (uint internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                        temp[internal_pp][internal_class] += w_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_class] * pp_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_pp];
+                    }
+                }
+            }
+#endif
+            barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
         }
-        barrier(CLK_LOCAL_MEM_FENCE);  // wait until all work-items performed their part of the calculations
     }
 
-    // update global array with local one
-    for (uint internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+    // calculate the indices used in the current work-item
+    const ulong pp_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;     // num_predict_points
+    const ulong class_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
+
+    // update the global array with the local one
+    for (uint internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
         for (uint internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-            const ulong global_pp_idx = pp_idx + (ulong) internal_pd;
+            // calculate the indices to access the global data
+            const ulong global_pp_idx = pp_idx + (ulong) internal_pp;
             const ulong global_class_idx = class_idx + (ulong) internal_class;
 
-            prediction_d[global_pp_idx * (num_classes + PADDING_SIZE_ul) + global_class_idx] = temp[internal_pd][internal_class] - rho_d[global_class_idx];
+            prediction[global_pp_idx * (num_classes + PADDING_SIZE_uz) + global_class_idx] = temp[internal_pp][internal_class] - rho[global_class_idx];  // AoS
         }
     }
 }
diff --git a/include/plssvm/backends/OpenMP/csvm.hpp b/include/plssvm/backends/OpenMP/csvm.hpp
index 6dd02835f..168558c00 100644
--- a/include/plssvm/backends/OpenMP/csvm.hpp
+++ b/include/plssvm/backends/OpenMP/csvm.hpp
@@ -28,6 +28,7 @@
 
 #include <cstddef>      // std::size_t
 #include <memory>       // std::addressof
+#include <optional>     // std::optional
 #include <type_traits>  // std::true_type
 #include <utility>      // std::forward, std::pair
 #include <vector>       // std::vector
@@ -98,6 +99,10 @@ class csvm : virtual public ::plssvm::csvm {
      * @copydoc plssvm::csvm::get_max_mem_alloc_size
      */
     [[nodiscard]] std::vector<::plssvm::detail::memory_size> get_max_mem_alloc_size() const final;
+    /**
+     * @copydoc plssvm::csvm::get_local_memory
+     */
+    [[nodiscard]] std::vector<std::optional<::plssvm::detail::memory_size>> get_local_memory() const final;
 
     //***************************************************//
     //                        fit                        //
@@ -133,8 +138,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvc(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::openmp::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVC using the OpenMP backend with the parameters given through @p params.
@@ -143,8 +147,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvc(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::openmp::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVC using the OpenMP backend on the @p target platform with the parameters given through @p params.
@@ -225,8 +228,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvr(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::openmp::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVR using the OpenMP backend with the parameters given through @p params.
@@ -235,8 +237,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     csvr(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::openmp::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVR using the OpenMP backend on the @p target platform with the parameters given through @p params.
diff --git a/include/plssvm/backends/OpenMP/kernel/cg_explicit/blas.hpp b/include/plssvm/backends/OpenMP/kernel/cg_explicit/blas.hpp
index e1041024a..52efa6a14 100644
--- a/include/plssvm/backends/OpenMP/kernel/cg_explicit/blas.hpp
+++ b/include/plssvm/backends/OpenMP/kernel/cg_explicit/blas.hpp
@@ -21,7 +21,6 @@
 #include <array>    // std::array
 #include <cmath>    // std::ceil
 #include <cstddef>  // std::size_t
-#include <vector>   // std::vector
 
 namespace plssvm::openmp::detail {
 
@@ -29,60 +28,65 @@ namespace plssvm::openmp::detail {
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @param[in] num_rows the number of rows and columns in @p A
  * @param[in] num_rhs the number of rows in @p B and @p C
- * @param[in] device_specific_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data the current device is responsible for
+ * @param[in] device_num_rows the number of rows the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data the current device is responsible for
  * @param[in] alpha the scalar alpha value
  * @param[in] A the matrix @p A
  * @param[in] B the matrix @p B
  * @param[in] beta the scalar beta value
  * @param[in,out] C the matrix @p C, also used as result matrix
  */
-inline void device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const std::vector<real_type> &A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
+inline void device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
     // compute: C = alpha * A * B + beta * C with A in m x k, B in n x k, and C in n x m, alpha, beta as scalar
-    PLSSVM_ASSERT(!A.empty(), "A matrix may not be empty!");
+    PLSSVM_ASSERT(A != nullptr, "The A matrix result pointer must be valid!");
     PLSSVM_ASSERT(B.shape() == (plssvm::shape{ num_rhs, num_rows }), "B matrix sizes mismatch!: {} != [{}, {}]", B.shape(), num_rhs, num_rows);
     PLSSVM_ASSERT(C.shape() == (plssvm::shape{ num_rhs, num_rows }), "C matrix sizes mismatch!: {} != [{}, {}]", C.shape(), num_rhs, num_rows);
-    PLSSVM_ASSERT(num_rows >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, num_rows);
-    PLSSVM_ASSERT(num_rows >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, num_rows);
+    PLSSVM_ASSERT(num_rows >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, num_rows);
+    PLSSVM_ASSERT(num_rows >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, num_rows);
 
     // calculate constants
     const auto blocked_num_rhs = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rhs) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_rows) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_device_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_rows) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
 #pragma omp parallel for collapse(2)
-    for (std::size_t rhs = 0; rhs < blocked_num_rhs; rhs += THREAD_BLOCK_SIZE_uz) {
-        for (std::size_t row = 0; row < blocked_device_specific_num_rows; row += THREAD_BLOCK_SIZE_uz) {
+    for (std::size_t rhs_block = 0; rhs_block < blocked_num_rhs; rhs_block += THREAD_BLOCK_SIZE_uz) {
+        for (std::size_t row_block = 0; row_block < blocked_device_num_rows; row_block += THREAD_BLOCK_SIZE_uz) {
             // perform operations on the current block
-            for (std::size_t rhs_block = 0; rhs_block < THREAD_BLOCK_SIZE_uz; ++rhs_block) {
-                for (std::size_t row_block = 0; row_block < THREAD_BLOCK_SIZE_uz; ++row_block) {
+            for (std::size_t rhs_thread = 0; rhs_thread < THREAD_BLOCK_SIZE_uz; ++rhs_thread) {
+                for (std::size_t row_thread = 0; row_thread < THREAD_BLOCK_SIZE_uz; ++row_thread) {
                     // calculate the indices used in the current thread
-                    const std::size_t rhs_idx = (rhs + rhs_block) * INTERNAL_BLOCK_SIZE_uz;
-                    const std::size_t row_idx = (row + row_block) * INTERNAL_BLOCK_SIZE_uz;
+                    const std::size_t i_idx = (rhs_block + rhs_thread) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+                    const std::size_t j_idx = (row_block + row_thread) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
                     // create a thread private array used for internal caching
                     std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-                    // iterate over all features
-                    for (std::size_t dim = 0; dim < (num_rows - row_offset); ++dim) {
+                    // iterate over all values using blocking
+                    for (std::size_t dim_block = 0; dim_block < (num_rows - device_row_offset); dim_block += THREAD_BLOCK_SIZE_uz) {
                         // perform the dot product calculation
                         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                                const std::size_t global_row = row_idx + static_cast<std::size_t>(internal_j);
-
-                                real_type A_val = 0.0;
-                                // determine on which side of the diagonal we are located
-                                if (dim < global_row) {
-                                    A_val = A[dim * (num_rows - row_offset + PADDING_SIZE_uz) + global_row - dim * (dim + std::size_t{ 1 }) / std::size_t{ 2 }];
-                                } else {
-                                    A_val = A[global_row * (num_rows - row_offset + PADDING_SIZE_uz) + dim - global_row * (global_row + std::size_t{ 1 }) / std::size_t{ 2 }];
+                                // calculate the indices to access the global data
+                                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                                const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                                real_type sum{ 0.0 };
+                                for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE_uz; ++dim) {
+                                    real_type A_cache = 0.0;
+                                    // determine on which side of the diagonal we are located
+                                    if (dim_block + dim < global_j_idx) {
+                                        A_cache = A[(dim_block + dim) * (num_rows - device_row_offset + PADDING_SIZE_uz) + global_j_idx - (dim_block + dim) * (dim_block + dim + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                                    } else {
+                                        A_cache = A[global_j_idx * (num_rows - device_row_offset + PADDING_SIZE_uz) + dim_block + dim - global_j_idx * (global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                                    }
+                                    sum += A_cache * B(global_i_idx, dim_block + dim + device_row_offset);
                                 }
-                                temp[internal_i][internal_j] += A_val * B(global_rhs, dim + row_offset);
+                                temp[internal_j][internal_i] += sum;
                             }
                         }
                     }
@@ -90,13 +94,14 @@ inline void device_kernel_symm(const std::size_t num_rows, const std::size_t num
                     // apply the (partial) BLAS operation and update C
                     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                            const std::size_t device_global_row = row_idx + static_cast<std::size_t>(internal_j);
-                            const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_j);
-
-                            // be sure to not perform out of bounds accesses
-                            if (global_rhs < num_rhs && device_global_row < device_specific_num_rows) {
-                                C(global_rhs, global_row) = alpha * temp[internal_i][internal_j] + beta * C(global_rhs, global_row);
+                            // calculate the indices to access the global data and the data with respect to the current device
+                            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                            const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                            const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                            // be sure to not perform out-of-bounds accesses
+                            if (global_i_idx < num_rhs && device_global_j_idx < device_num_rows) {
+                                C(global_i_idx, global_j_idx) = alpha * temp[internal_j][internal_i] + beta * C(global_i_idx, global_j_idx);  // SoA
                             }
                         }
                     }
@@ -111,69 +116,75 @@ inline void device_kernel_symm(const std::size_t num_rows, const std::size_t num
  * @param[in] num_rows the number of rows in @p A and @p C
  * @param[in] num_rhs the number of columns in @p B and @p C
  * @param[in] num_mirror_rows the number of rows to mirror down
- * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
- * @param[in] row_offset the first row this device is responsible for
+ * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+ * @param[in] device_row_offset the first row this device is responsible for
  * @param[in] alpha the scalar alpha value
  * @param[in] A the matrix @p A
  * @param[in] B the matrix @p B
  * @param[in] beta the scalar beta value
  * @param[in,out] C the matrix @p C, also used as result matrix
  */
-inline void device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const std::vector<real_type> &A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
+inline void device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
     // compute: C = alpha * A * B + beta * C with A in m x k, B in n x k, and C in n x m, alpha, beta as scalar
-    PLSSVM_ASSERT(!A.empty(), "A matrix may not be empty!");
+    PLSSVM_ASSERT(A != nullptr, "The A matrix result pointer must be valid!");
     PLSSVM_ASSERT(B.shape() == (plssvm::shape{ num_rhs, num_rows }), "B matrix sizes mismatch!: {} != [{}, {}]", B.shape(), num_rhs, num_rows);
     PLSSVM_ASSERT(C.shape() == (plssvm::shape{ num_rhs, num_rows }), "C matrix sizes mismatch!: {} != [{}, {}]", C.shape(), num_rhs, num_rows);
-    PLSSVM_ASSERT(num_rows >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, num_rows);
+    PLSSVM_ASSERT(num_rows >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, num_rows);
     PLSSVM_ASSERT(num_rows >= num_mirror_rows, "The number of mirror rows ({}) cannot be greater the the total number of rows ({})!", num_mirror_rows, num_rows);
-    PLSSVM_ASSERT(num_rows >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, num_rows);
+    PLSSVM_ASSERT(num_rows >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, num_rows);
 
     // calculate constants
     const auto blocked_num_rhs = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rhs) / INTERNAL_BLOCK_SIZE));
     const auto blocked_num_mirror_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_mirror_rows) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
 #pragma omp parallel for collapse(2)
-    for (std::size_t rhs = 0; rhs < blocked_num_rhs; rhs += THREAD_BLOCK_SIZE_uz) {
-        for (std::size_t row = 0; row < blocked_num_mirror_rows; row += THREAD_BLOCK_SIZE_uz) {
+    for (std::size_t rhs_block = 0; rhs_block < blocked_num_rhs; rhs_block += THREAD_BLOCK_SIZE_uz) {
+        for (std::size_t row_block = 0; row_block < blocked_num_mirror_rows; row_block += THREAD_BLOCK_SIZE_uz) {
             // perform operations on the current block
-            for (std::size_t rhs_block = 0; rhs_block < THREAD_BLOCK_SIZE_uz; ++rhs_block) {
-                for (std::size_t row_block = 0; row_block < THREAD_BLOCK_SIZE_uz; ++row_block) {
+            for (std::size_t rhs_thread = 0; rhs_thread < THREAD_BLOCK_SIZE_uz; ++rhs_thread) {
+                for (std::size_t row_thread = 0; row_thread < THREAD_BLOCK_SIZE_uz; ++row_thread) {
                     // calculate the indices used in the current thread
-                    const std::size_t rhs_idx = (rhs + rhs_block) * INTERNAL_BLOCK_SIZE_uz;
-                    const std::size_t row_idx = (row + row_block) * INTERNAL_BLOCK_SIZE_uz;
+                    const std::size_t i_idx = (rhs_block + rhs_thread) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+                    const std::size_t j_idx = (row_block + row_thread) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
 
                     // create a thread private array used for internal caching
                     std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-                    // iterate over all features
-                    for (std::size_t dim = 0; dim < device_specific_num_rows; ++dim) {
+                    // iterate over the remaining values using blocking
+                    for (std::size_t dim_block = 0; dim_block < device_num_rows; dim_block += THREAD_BLOCK_SIZE_uz) {
                         // perform the dot product calculation
                         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                                const std::size_t global_row = row_idx + static_cast<std::size_t>(internal_j);
-
-                                const real_type A_val = A[dim * (num_rows - row_offset + PADDING_SIZE_uz) - (dim - std::size_t{ 1 }) * dim / std::size_t{ 2 } + device_specific_num_rows - dim + global_row];
-                                temp[internal_i][internal_j] += A_val * B(global_rhs, row_offset + dim);
+                                // calculate the indices to access the global data
+                                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                                const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                                real_type sum{ 0.0 };
+                                for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE_uz; ++dim) {
+                                    sum += A[(dim_block + dim) * (num_rows - device_row_offset + PADDING_SIZE_uz) - (dim_block + dim - std::size_t{ 1 }) * (dim_block + dim) / std::size_t{ 2 } + device_num_rows - (dim_block + dim) + global_j_idx] *  // SoA, upper triangular matrix only
+                                           B(global_i_idx, dim_block + dim + device_row_offset);                                                                                                                                                         // SoA
+                                }
+                                temp[internal_j][internal_i] += sum;
                             }
                         }
                     }
 
-                    // apply the (partial) BLAS operation and update C
+                    // apply the (remaining) BLAS operation and update C
                     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                            const std::size_t partial_global_row = row_idx + static_cast<std::size_t>(internal_j);
-                            const std::size_t global_row = row_offset + device_specific_num_rows + row_idx + static_cast<std::size_t>(internal_j);
-
-                            // be sure to not perform out of bounds accesses
-                            if (global_rhs < num_rhs && partial_global_row < num_mirror_rows) {
-                                C(global_rhs, global_row) = alpha * temp[internal_i][internal_j] + beta * C(global_rhs, global_row);
+                            // calculate the indices to access the global data and the data with respect to the current device
+                            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                            const auto partial_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                            const auto global_j_idx = device_row_offset + device_num_rows + partial_global_j_idx;
+
+                            // be sure to not perform out-of-bounds accesses
+                            if (global_i_idx < num_rhs && partial_global_j_idx < num_mirror_rows) {
+                                C(global_i_idx, global_j_idx) = alpha * temp[internal_j][internal_i] + beta * C(global_i_idx, global_j_idx);  // SoA
                             }
                         }
                     }
diff --git a/include/plssvm/backends/OpenMP/kernel/cg_explicit/kernel_matrix_assembly.hpp b/include/plssvm/backends/OpenMP/kernel/cg_explicit/kernel_matrix_assembly.hpp
index 9403b12a1..e330c15de 100644
--- a/include/plssvm/backends/OpenMP/kernel/cg_explicit/kernel_matrix_assembly.hpp
+++ b/include/plssvm/backends/OpenMP/kernel/cg_explicit/kernel_matrix_assembly.hpp
@@ -28,83 +28,90 @@ namespace plssvm::openmp::detail {
 
 /**
  * @brief Assemble the kernel matrix using the @p kernel function.
- * @tparam kernel the compile-time kernel function to use
+ * @tparam kernel_function the compile-time kernel function to use
  * @tparam Args the types of the potential additional arguments for the @p kernel function
  * @param[out] kernel_matrix the resulting kernel matrix
  * @param[in] data the data matrix
- * @param[in] device_specific_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data the current device is responsible for
+ * @param[in] device_num_rows the number of rows the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data the current device is responsible for
  * @param[in] q the `q` vector
  * @param[in] QA_cost he bottom right matrix entry multiplied by cost
  * @param[in] cost 1 / the cost parameter in the C-SVM
  * @param[in] kernel_function_parameter the potential additional arguments for the @p kernel function
  */
-template <kernel_function_type kernel, typename... Args>
-void device_kernel_assembly(std::vector<real_type> &kernel_matrix, const soa_matrix<real_type> &data, const std::size_t device_specific_num_rows, const std::size_t row_offset, const std::vector<real_type> &q, const real_type QA_cost, const real_type cost, Args... kernel_function_parameter) {
+template <kernel_function_type kernel_function, typename... Args>
+void device_kernel_assembly(real_type *kernel_matrix, const soa_matrix<real_type> &data, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::vector<real_type> &q, const real_type QA_cost, const real_type cost, Args... kernel_function_parameter) {
+    PLSSVM_ASSERT(kernel_matrix != nullptr, "The kernel matrix result pointer must be valid!");
     PLSSVM_ASSERT(q.size() == data.num_rows() - 1, "Sizes mismatch!: {} != {}", q.size(), data.num_rows() - 1);
-    PLSSVM_ASSERT(!kernel_matrix.empty(), "A matrix may not be empty!");
-    PLSSVM_ASSERT(q.size() >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, q.size());
-    PLSSVM_ASSERT(q.size() >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, q.size());
+    PLSSVM_ASSERT(q.size() >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, q.size());
+    PLSSVM_ASSERT(q.size() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, q.size());
     PLSSVM_ASSERT(cost != real_type{ 0.0 }, "cost must not be 0.0 since it is 1 / plssvm::cost!");
 
     // calculate constants
     const std::size_t num_rows = data.num_rows() - 1;
     const std::size_t num_features = data.num_cols();
-    const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - row_offset) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_rows) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - device_row_offset) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_device_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_rows) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
 #pragma omp parallel for collapse(2) schedule(dynamic)
-    for (std::size_t row = 0; row < blocked_row_range; row += THREAD_BLOCK_SIZE_uz) {
-        for (std::size_t col = 0; col < blocked_device_specific_num_rows; col += THREAD_BLOCK_SIZE_uz) {
+    for (std::size_t row_block = 0; row_block < blocked_row_range; row_block += THREAD_BLOCK_SIZE_uz) {
+        for (std::size_t col_block = 0; col_block < blocked_device_num_rows; col_block += THREAD_BLOCK_SIZE_uz) {
             // perform operations on the current block
-            for (std::size_t row_block = 0; row_block < THREAD_BLOCK_SIZE_uz; ++row_block) {
-                for (std::size_t col_block = 0; col_block < THREAD_BLOCK_SIZE_uz; ++col_block) {
+            for (std::size_t row_thread = 0; row_thread < THREAD_BLOCK_SIZE_uz; ++row_thread) {
+                for (std::size_t col_thread = 0; col_thread < THREAD_BLOCK_SIZE_uz; ++col_thread) {
                     // calculate the indices used in the current thread
-                    const std::size_t row_idx = (row + row_block) * INTERNAL_BLOCK_SIZE_uz;
-                    const std::size_t col_idx = (col + col_block) * INTERNAL_BLOCK_SIZE_uz;
+                    const std::size_t i_idx = (row_block + row_thread) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+                    const std::size_t j_idx = (col_block + col_thread) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
                     // only calculate the upper triangular matrix
-                    if (row_idx >= col_idx) {
+                    if (i_idx >= j_idx) {
                         // create a thread private array used for internal caching
                         std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
                         // iterate over all features
-                        for (std::size_t dim = 0; dim < num_features; ++dim) {
+                        for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
                             // perform the feature reduction calculation
-                            for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                                for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                                    const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                                    const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
+                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                    // calculate the indices to access the global data
+                                    const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                                    const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
 
-                                    temp[internal_row][internal_col] += detail::feature_reduce<kernel>(data(global_row, dim), data(global_col, dim));
+                                    real_type sum{ 0.0 };
+                                    for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                                        sum += detail::feature_reduce<kernel_function>(data(global_i_idx, feature_block + feature),   // SoA
+                                                                                       data(global_j_idx, feature_block + feature));  // SoA
+                                    }
+                                    temp[internal_j][internal_i] += sum;
                                 }
                             }
                         }
 
                         // apply the remaining part of the kernel function and store the value in the output kernel matrix
-                        for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                            for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                                // calculate the indices to access the kernel matrix (the part stored on the current device)
-                                const std::size_t device_global_row = row_idx + static_cast<std::size_t>(internal_row);
-                                const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                                const std::size_t device_global_col = col_idx + static_cast<std::size_t>(internal_col);
-                                const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                // calculate the indices to access the global data and the data with respect to the current device
+                                const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                                const auto global_i_idx = device_row_offset + device_global_i_idx;
+                                const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                                const auto global_j_idx = device_row_offset + device_global_j_idx;
 
-                                // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                                if (device_global_row < (num_rows - row_offset) && device_global_col < device_specific_num_rows && global_row >= global_col) {
-                                    real_type temp_ij = temp[internal_row][internal_col];
-                                    temp_ij = detail::apply_kernel_function<kernel>(temp_ij, kernel_function_parameter...) + QA_cost - q[global_row] - q[global_col];
+                                // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                                if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
+                                    real_type temp_ij = temp[internal_j][internal_i];
+                                    // apply the final kernel function
+                                    temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter...) + QA_cost - q[global_i_idx] - q[global_j_idx];
                                     // apply the cost on the diagonal
-                                    if (global_row == global_col) {
+                                    if (global_i_idx == global_j_idx) {
                                         temp_ij += cost;
                                     }
-                                    // update the kernel matrix
-                                    kernel_matrix[device_global_col * (num_rows - row_offset + PADDING_SIZE_uz) - device_global_col * (device_global_col + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_row] = temp_ij;
+                                    // update the upper triangular kernel matrix
+                                    kernel_matrix[device_global_j_idx * (num_rows - device_row_offset + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i_idx] = temp_ij;
                                 }
                             }
                         }
diff --git a/include/plssvm/backends/OpenMP/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp b/include/plssvm/backends/OpenMP/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
index 771689209..6fde9ef91 100644
--- a/include/plssvm/backends/OpenMP/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
+++ b/include/plssvm/backends/OpenMP/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
@@ -26,25 +26,25 @@
 namespace plssvm::openmp::detail {
 
 /**
- * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
- * @tparam kernel the compile-time kernel function to use
- * @tparam Args the types of the potential additional arguments for the @p kernel function
+ * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel_function function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
+ * @tparam kernel_function the compile-time kernel function to use
+ * @tparam Args the types of the potential additional arguments for the @p kernel_function function
  * @param[in] alpha the scalar alpha value
  * @param[in] q the `q` vector
  * @param[in] data the data matrix
- * @param[in] device_specific_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data the current device is responsible for
+ * @param[in] device_num_rows the number of rows the current device is responsible for
+ * @param[in] device_row_offset the first row in @p data the current device is responsible for
  * @param[in] QA_cost he bottom right matrix entry multiplied by cost
  * @param[in] cost 1 / the cost parameter in the C-SVM
  * @param[in] B the matrix @p B
  * @param[in,out] C the matrix @p C
- * @param[in] kernel_function_parameter the potential additional arguments for the @p kernel function
+ * @param[in] kernel_function_parameter the potential additional arguments for the @p kernel_function function
  */
-template <kernel_function_type kernel, typename... Args>
-inline void device_kernel_assembly_symm(const real_type alpha, const std::vector<real_type> &q, const soa_matrix<real_type> &data, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type QA_cost, const real_type cost, const soa_matrix<real_type> &B, soa_matrix<real_type> &C, Args... kernel_function_parameter) {
+template <kernel_function_type kernel_function, typename... Args>
+inline void device_kernel_assembly_symm(const real_type alpha, const std::vector<real_type> &q, const soa_matrix<real_type> &data, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type QA_cost, const real_type cost, const soa_matrix<real_type> &B, soa_matrix<real_type> &C, Args... kernel_function_parameter) {
     PLSSVM_ASSERT(q.size() == data.num_rows() - 1, "Sizes mismatch!: {} != {}", q.size(), data.num_rows() - 1);
-    PLSSVM_ASSERT(q.size() >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, q.size());
-    PLSSVM_ASSERT(q.size() >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, q.size());
+    PLSSVM_ASSERT(q.size() >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, q.size());
+    PLSSVM_ASSERT(q.size() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, q.size());
     PLSSVM_ASSERT(cost != real_type{ 0.0 }, "cost must not be 0.0 since it is 1 / plssvm::cost!");
     PLSSVM_ASSERT(B.shape() == C.shape(), "The matrices B and C must have the same shape!");
     PLSSVM_ASSERT(B.num_cols() == q.size(), "The number of columns in B ({}) must be the same as the values in q ({})!", B.num_cols(), q.size());
@@ -53,68 +53,97 @@ inline void device_kernel_assembly_symm(const real_type alpha, const std::vector
     const std::size_t num_rows = data.num_rows() - 1;
     const std::size_t num_features = data.num_cols();
     const std::size_t num_classes = B.num_rows();
-    const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - row_offset) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_rows) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - device_row_offset) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_device_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_rows) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
 
 #pragma omp parallel for collapse(2) schedule(dynamic)
-    for (std::size_t row = 0; row < blocked_row_range; row += THREAD_BLOCK_SIZE_uz) {
-        for (std::size_t col = 0; col < blocked_device_specific_num_rows; col += THREAD_BLOCK_SIZE_uz) {
+    for (std::size_t row_block = 0; row_block < blocked_row_range; row_block += THREAD_BLOCK_SIZE_uz) {
+        for (std::size_t col_block = 0; col_block < blocked_device_num_rows; col_block += THREAD_BLOCK_SIZE_uz) {
             // perform operations on the current block
-            for (std::size_t row_block = 0; row_block < THREAD_BLOCK_SIZE_uz; ++row_block) {
-                for (std::size_t col_block = 0; col_block < THREAD_BLOCK_SIZE_uz; ++col_block) {
+            for (std::size_t row_thread = 0; row_thread < THREAD_BLOCK_SIZE_uz; ++row_thread) {
+                for (std::size_t col_thread = 0; col_thread < THREAD_BLOCK_SIZE_uz; ++col_thread) {
                     // calculate the indices used in the current thread
-                    const std::size_t row_idx = (row + row_block) * INTERNAL_BLOCK_SIZE_uz;
-                    const std::size_t col_idx = (col + col_block) * INTERNAL_BLOCK_SIZE_uz;
+                    const std::size_t i_idx = (row_block + row_thread) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+                    const std::size_t j_idx = (col_block + col_thread) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
                     // only calculate the upper triangular matrix
-                    if (row_idx >= col_idx) {
+                    if (i_idx >= j_idx) {
                         // create a thread private array used for internal caching
                         std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-                        // iterate over all features
-                        for (std::size_t dim = 0; dim < num_features; ++dim) {
-                            for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                                for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                                    const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                                    const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
+                        //*************************************************************************//
+                        //                   inplace kernel matrix construction                    //
+                        //*************************************************************************//
+                        // iterate over all features using blocking
+                        for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                    // calculate the indices to access the global data
+                                    const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                                    const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
 
-                                    temp[internal_row][internal_col] += detail::feature_reduce<kernel>(data(global_row, dim), data(global_col, dim));
+                                    real_type sum{ 0.0 };
+                                    for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                                        sum += detail::feature_reduce<kernel_function>(data(global_i_idx, feature_block + feature),   // SoA
+                                                                                       data(global_j_idx, feature_block + feature));  // SoA
+                                    }
+                                    temp[internal_j][internal_i] += sum;
                                 }
                             }
                         }
 
                         // apply the remaining part of the kernel function and store the value in the output kernel matrix
-                        for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                            for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                                const std::size_t device_global_row = row_idx + static_cast<std::size_t>(internal_row);
-                                const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                                const std::size_t device_global_col = col_idx + static_cast<std::size_t>(internal_col);
-                                const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
-
-                                // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                                if (device_global_row < (num_rows - row_offset) && device_global_col < device_specific_num_rows && global_row >= global_col) {
-                                    real_type temp_ij = temp[internal_row][internal_col];
-                                    temp_ij = detail::apply_kernel_function<kernel>(temp_ij, kernel_function_parameter...) + QA_cost - q[global_row] - q[global_col];
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                // calculate the indices to access the global data and the data with respect to the current device
+                                const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                                const auto global_i_idx = device_row_offset + device_global_i_idx;
+                                const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                                const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                                // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                                if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
+                                    // apply the final kernel function
+                                    temp[internal_j][internal_i] = detail::apply_kernel_function<kernel_function>(temp[internal_j][internal_i], kernel_function_parameter...) + QA_cost - q[global_i_idx] - q[global_j_idx];
                                     // apply the cost on the diagonal
-                                    if (global_row == global_col) {
-                                        temp_ij += cost;
-                                        // calculate the values of alpha * A * B
-                                        for (std::size_t class_idx = 0; class_idx < num_classes; ++class_idx) {
+                                    if (global_i_idx == global_j_idx) {
+                                        temp[internal_j][internal_i] += cost;
+                                    }
+                                } else {
+                                    // be sure to set the value to zero otherwise
+                                    temp[internal_j][internal_i] = real_type{ 0.0 };
+                                }
+                            }
+                        }
+
+                        //*************************************************************************//
+                        //                     calculate C += alpha * temp * B                     //
+                        //*************************************************************************//
+                        for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
+                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                    // calculate the indices to access the global data
+                                    const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                                    const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
+
+                                    if (global_i_idx == global_j_idx) {
+                                        // only apply once to the diagonal
+                                        for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
 #pragma omp atomic
-                                            C(class_idx, global_row) += alpha * temp_ij * B(class_idx, global_row);
+                                            C(class_block + class_idx, global_i_idx) += alpha * temp[internal_j][internal_i] * B(class_block + class_idx, global_i_idx);
                                         }
                                     } else {
-                                        // calculate the values of alpha * A * B
-                                        for (std::size_t class_idx = 0; class_idx < num_classes; ++class_idx) {
+                                        // apply it for the upper and lower triangular matrix
+                                        for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
 #pragma omp atomic
-                                            C(class_idx, global_row) += alpha * temp_ij * B(class_idx, global_col);
-// symmetry
+                                            C(class_block + class_idx, global_i_idx) += alpha * temp[internal_j][internal_i] * B(class_block + class_idx, global_j_idx);
+                                            // symmetry
 #pragma omp atomic
-                                            C(class_idx, global_col) += alpha * temp_ij * B(class_idx, global_row);
+                                            C(class_block + class_idx, global_j_idx) += alpha * temp[internal_j][internal_i] * B(class_block + class_idx, global_i_idx);
                                         }
                                     }
                                 }
diff --git a/include/plssvm/backends/OpenMP/kernel/kernel_functions.hpp b/include/plssvm/backends/OpenMP/kernel/kernel_functions.hpp
index 59fd0f43c..359e2f8ff 100644
--- a/include/plssvm/backends/OpenMP/kernel/kernel_functions.hpp
+++ b/include/plssvm/backends/OpenMP/kernel/kernel_functions.hpp
@@ -27,42 +27,17 @@ namespace plssvm::openmp::detail {
 
 /**
  * @brief Fast integer power function. Computes base^exponent and takes advantage of the fact that degree may only be positive integer values.
- * @details Hardcodes the power function for degree <= 6, uses a simple for loop otherwise.
  * @param[in] base the base
  * @param[in] exponent the exponent
  * @return base^exponent (`[[nodiscard]]`)
  */
 [[nodiscard]] inline real_type powi(const real_type base, const int exponent) {
-    switch (exponent) {
-        case 0: return real_type{ 1.0 };
-        case 1: return base;
-        case 2: return base * base;
-        case 3: return base * base * base;
-        case 4:
-            {
-                const real_type temp = base * base;
-                return temp * temp;
-            }
-        case 5:
-            {
-                const real_type temp = base * base;
-                return temp * temp * base;
-            }
-        case 6:
-            {
-                const real_type temp = base * base * base;
-                return temp * temp;
-            }
-        default:
-            {
-                // generic integer power function
-                real_type result{ 1.0 };
-                for (int i = 0; i < exponent; ++i) {
-                    result *= base;
-                }
-                return result;
-            }
+    // generic integer power function
+    real_type result{ 1.0 };
+    for (int i = 0; i < exponent; ++i) {
+        result *= base;
     }
+    return result;
 }
 
 //***************************************************//
diff --git a/include/plssvm/backends/OpenMP/kernel/predict_kernel.hpp b/include/plssvm/backends/OpenMP/kernel/predict_kernel.hpp
index 407096055..d75f9389f 100644
--- a/include/plssvm/backends/OpenMP/kernel/predict_kernel.hpp
+++ b/include/plssvm/backends/OpenMP/kernel/predict_kernel.hpp
@@ -13,7 +13,7 @@
 #define PLSSVM_BACKENDS_OPENMP_KERNEL_PREDICT_KERNEL_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"              // plssvm::real_type
+#include "plssvm/constants.hpp"              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/detail/assert.hpp"          // PLSSVM_ASSERT
 #include "plssvm/kernel_function_types.hpp"  // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                 // plssvm::aos_matrix, plssvm::matrix
@@ -31,28 +31,69 @@ namespace plssvm::openmp::detail {
  * @param[out] w the vector to speedup the linear prediction
  * @param[in] alpha the previously learned weights
  * @param[in] support_vectors the support vectors
- * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
- * @param[in] sv_offset the first row in @p support_vectors the current device is responsible for
+ * @param[in] device_num_sv the number of support vectors the current device is responsible for
+ * @param[in] device_sv_offset the first row in @p support_vectors the current device is responsible for
  */
-inline void device_kernel_w_linear(soa_matrix<real_type> &w, const aos_matrix<real_type> &alpha, const soa_matrix<real_type> &support_vectors, const std::size_t device_specific_num_sv, const std::size_t sv_offset) {
+inline void device_kernel_w_linear(soa_matrix<real_type> &w, const aos_matrix<real_type> &alpha, const soa_matrix<real_type> &support_vectors, const std::size_t device_num_sv, const std::size_t device_sv_offset) {
     PLSSVM_ASSERT(alpha.num_cols() == support_vectors.num_rows(), "Size mismatch: {} vs {}!", alpha.num_cols(), support_vectors.num_rows());
     PLSSVM_ASSERT(w.shape() == (plssvm::shape{ alpha.num_rows(), support_vectors.num_cols() }), "Shape mismatch: {} vs {}!", w.shape(), (plssvm::shape{ alpha.num_rows(), support_vectors.num_cols() }));
-    PLSSVM_ASSERT(support_vectors.num_rows() >= device_specific_num_sv, "The number of place specific sv ({}) cannot be greater the the total number of sv ({})!", device_specific_num_sv, support_vectors.num_rows());
-    PLSSVM_ASSERT(support_vectors.num_rows() >= sv_offset, "The sv offset ({}) cannot be greater the the total number of sv ({})!", sv_offset, support_vectors.num_rows());
+    PLSSVM_ASSERT(support_vectors.num_rows() >= device_num_sv, "The number of place specific sv ({}) cannot be greater the the total number of sv ({})!", device_num_sv, support_vectors.num_rows());
+    PLSSVM_ASSERT(support_vectors.num_rows() >= device_sv_offset, "The sv offset ({}) cannot be greater the the total number of sv ({})!", device_sv_offset, support_vectors.num_rows());
 
     // calculate constants
     const std::size_t num_classes = alpha.num_rows();
     const std::size_t num_features = support_vectors.num_cols();
+    const auto blocked_num_features = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_features) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_num_classes = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_classes) / INTERNAL_BLOCK_SIZE));
 
-#pragma omp parallel for collapse(2) default(none) shared(w, support_vectors, alpha) firstprivate(num_classes, num_features, device_specific_num_sv, sv_offset)
-    for (std::size_t a = 0; a < num_classes; ++a) {
-        for (std::size_t dim = 0; dim < num_features; ++dim) {
-            real_type temp{ 0.0 };
-#pragma omp simd reduction(+ : temp)
-            for (std::size_t idx = 0; idx < device_specific_num_sv; ++idx) {
-                temp = std::fma(alpha(a, sv_offset + idx), support_vectors(sv_offset + idx, dim), temp);
+    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+
+#pragma omp parallel for collapse(2) default(none) shared(w, support_vectors, alpha) firstprivate(blocked_num_classes, blocked_num_features, num_classes, num_features, device_num_sv, device_sv_offset)
+    for (std::size_t feature_block = 0; feature_block < blocked_num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+        for (std::size_t class_block = 0; class_block < blocked_num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
+            // perform operations on the current block
+            for (std::size_t feature_thread = 0; feature_thread < THREAD_BLOCK_SIZE_uz; ++feature_thread) {
+                for (std::size_t class_thread = 0; class_thread < THREAD_BLOCK_SIZE_uz; ++class_thread) {
+                    // calculate the indices used in the current thread
+                    const std::size_t feature_idx = (feature_block + feature_thread) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+                    const std::size_t class_idx = (class_block + class_thread) * INTERNAL_BLOCK_SIZE_uz;        // num_classes
+
+                    // create a thread private array used for internal caching
+                    std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+                    // iterate over all support vectors using blocking
+                    for (std::size_t sv_block = 0; sv_block < device_num_sv; sv_block += THREAD_BLOCK_SIZE_uz) {
+                        // perform the dot product calculation
+                        for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                // calculate the indices to access the global data
+                                const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                                const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                                real_type sum{ 0.0 };
+                                for (std::size_t sv = 0; sv < THREAD_BLOCK_SIZE_uz; ++sv) {
+                                    sum += support_vectors(device_sv_offset + sv_block + sv, global_feature_idx) *  // SoA
+                                           alpha(global_class_idx, device_sv_offset + sv_block + sv);               // AoS
+                                }
+                                temp[internal_class][internal_feature] += sum;
+                            }
+                        }
+                    }
+
+                    // store the result back to the w vector
+                    for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                            // calculate the indices to access the global data
+                            const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                            const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                            w(global_class_idx, global_feature_idx) = temp[internal_class][internal_feature];  // SoA
+                        }
+                    }
+                }
             }
-            w(a, dim) = temp;
         }
     }
 }
@@ -63,29 +104,70 @@ inline void device_kernel_w_linear(soa_matrix<real_type> &w, const aos_matrix<re
  * @param[in] w the vector to speedup the calculations
  * @param[in] rho the previously learned bias
  * @param[in] predict_points the data points to predict
- * @param[in] device_specific_num_predict_points the number of predict points the current device is responsible for
- * @param[in] row_offset the first row in @p predict_points the current device is responsible for
+ * @param[in] device_num_predict_points the number of predict points the current device is responsible for
+ * @param[in] device_row_offset the first row in @p predict_points the current device is responsible for
  */
-inline void device_kernel_predict_linear(aos_matrix<real_type> &prediction, const soa_matrix<real_type> &w, const std::vector<real_type> &rho, const soa_matrix<real_type> &predict_points, const std::size_t device_specific_num_predict_points, const std::size_t row_offset) {
-    PLSSVM_ASSERT(w.num_rows() == rho.size(), "Size mismatch: {} vs {}!", w.num_rows(), rho.size());
+inline void device_kernel_predict_linear(aos_matrix<real_type> &prediction, const soa_matrix<real_type> &w, const std::vector<real_type> &rho, const soa_matrix<real_type> &predict_points, const std::size_t device_num_predict_points, const std::size_t device_row_offset) {
+    PLSSVM_ASSERT(w.num_rows() == rho.size() - PADDING_SIZE, "Size mismatch: {} vs {}!", w.num_rows(), rho.size() - PADDING_SIZE);
     PLSSVM_ASSERT(w.num_cols() == predict_points.num_cols(), "Size mismatch: {} vs {}!", w.num_cols(), predict_points.num_cols());
     PLSSVM_ASSERT(prediction.shape() == (plssvm::shape{ predict_points.num_rows(), w.num_rows() }), "Shape mismatch: {} vs {}!", prediction.shape(), (plssvm::shape{ predict_points.num_rows(), w.num_rows() }));
-    PLSSVM_ASSERT(predict_points.num_rows() >= device_specific_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_specific_num_predict_points, predict_points.num_rows());
-    PLSSVM_ASSERT(predict_points.num_rows() >= row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", row_offset, predict_points.num_rows());
+    PLSSVM_ASSERT(predict_points.num_rows() >= device_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_num_predict_points, predict_points.num_rows());
+    PLSSVM_ASSERT(predict_points.num_rows() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", device_row_offset, predict_points.num_rows());
 
     // calculate constants
     const std::size_t num_classes = prediction.num_cols();
     const std::size_t num_features = predict_points.num_cols();
+    const auto blocked_device_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_predict_points) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_num_classes = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_classes) / INTERNAL_BLOCK_SIZE));
 
-#pragma omp parallel for collapse(2) default(none) shared(prediction, w, rho, predict_points) firstprivate(num_classes, num_features, device_specific_num_predict_points, row_offset)
-    for (std::size_t point_index = 0; point_index < device_specific_num_predict_points; ++point_index) {
-        for (std::size_t a = 0; a < num_classes; ++a) {
-            real_type temp{ 0.0 };
-#pragma omp simd reduction(+ : temp)
-            for (std::size_t dim = 0; dim < num_features; ++dim) {
-                temp = std::fma(w(a, dim), predict_points(row_offset + point_index, dim), temp);
+    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+
+#pragma omp parallel for collapse(2) default(none) shared(prediction, w, rho, predict_points) firstprivate(blocked_device_num_predict_points, blocked_num_classes, device_num_predict_points, num_classes, num_features, device_row_offset)
+    for (std::size_t pp_block = 0; pp_block < blocked_device_num_predict_points; pp_block += THREAD_BLOCK_SIZE_uz) {
+        for (std::size_t class_block = 0; class_block < blocked_num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
+            // perform operations on the current block
+            for (std::size_t pp_thread = 0; pp_thread < THREAD_BLOCK_SIZE_uz; ++pp_thread) {
+                for (std::size_t class_thread = 0; class_thread < THREAD_BLOCK_SIZE_uz; ++class_thread) {
+                    // calculate the indices used in the current thread
+                    const std::size_t pp_idx = (pp_block + pp_thread) * INTERNAL_BLOCK_SIZE_uz;           // num_predict_points
+                    const std::size_t class_idx = (class_block + class_thread) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
+
+                    // create a thread private array used for internal caching
+                    std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+                    // iterate over all features using blocking
+                    for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                        // perform the dot product calculation
+                        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                // calculate the indices to access the global data
+                                const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                                const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                                real_type sum{ 0.0 };
+                                for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                                    sum += predict_points(global_pp_idx, feature_block + feature) *  // SoA
+                                           w(global_class_idx, feature_block + feature);             // SoA
+                                }
+                                temp[internal_class][internal_pp] += sum;
+                            }
+                        }
+                    }
+
+                    // update the global array with the local one
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                            // calculate the indices to access the global data
+                            const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                            const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                            prediction(global_pp_idx, global_class_idx) = temp[internal_class][internal_pp] - rho[global_class_idx];  // AoS
+                        }
+                    }
+                }
             }
-            prediction(row_offset + point_index, a) = temp - rho[a];
         }
     }
 }
@@ -99,59 +181,65 @@ inline void device_kernel_predict_linear(aos_matrix<real_type> &prediction, cons
  * @param[in] rho the previously learned bias
  * @param[in] support_vectors the support vectors
  * @param[in] predict_points the data points to predict
- * @param[in] device_specific_num_predict_points the number of predict points the current device is responsible for
- * @param[in] row_offset the first row in @p predict_points the current device is responsible for
+ * @param[in] device_num_predict_points the number of predict points the current device is responsible for
+ * @param[in] device_row_offset the first row in @p predict_points the current device is responsible for
  * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
  */
-template <kernel_function_type kernel, typename... Args>
-inline void device_kernel_predict(aos_matrix<real_type> &prediction, const aos_matrix<real_type> &alpha, const std::vector<real_type> &rho, const soa_matrix<real_type> &support_vectors, const soa_matrix<real_type> &predict_points, const std::size_t device_specific_num_predict_points, const std::size_t row_offset, Args... kernel_function_parameter) {
+template <kernel_function_type kernel_function, typename... Args>
+inline void device_kernel_predict(aos_matrix<real_type> &prediction, const aos_matrix<real_type> &alpha, const std::vector<real_type> &rho, const soa_matrix<real_type> &support_vectors, const soa_matrix<real_type> &predict_points, const std::size_t device_num_predict_points, const std::size_t device_row_offset, Args... kernel_function_parameter) {
     PLSSVM_ASSERT(alpha.num_rows() == rho.size(), "Size mismatch: {} vs {}!", alpha.num_rows(), rho.size());
     PLSSVM_ASSERT(alpha.num_cols() == support_vectors.num_rows(), "Size mismatch: {} vs {}!", alpha.num_cols(), support_vectors.num_rows());
     PLSSVM_ASSERT(support_vectors.num_cols() == predict_points.num_cols(), "Size mismatch: {} vs {}!", support_vectors.num_cols(), predict_points.num_cols());
     PLSSVM_ASSERT(prediction.shape() == (plssvm::shape{ predict_points.num_rows(), alpha.num_rows() }), "Shape mismatch: {} vs {}!", prediction.shape(), (plssvm::shape{ predict_points.num_rows(), alpha.num_rows() }));
-    PLSSVM_ASSERT(predict_points.num_rows() >= device_specific_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_specific_num_predict_points, predict_points.num_rows());
-    PLSSVM_ASSERT(predict_points.num_rows() >= row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", row_offset, predict_points.num_rows());
+    PLSSVM_ASSERT(predict_points.num_rows() >= device_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_num_predict_points, predict_points.num_rows());
+    PLSSVM_ASSERT(predict_points.num_rows() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", device_row_offset, predict_points.num_rows());
 
     // calculate constants
     const std::size_t num_classes = alpha.num_rows();
     const std::size_t num_support_vectors = support_vectors.num_rows();
-    const auto blocked_num_support_vectors = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_support_vectors) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_predict_points) / INTERNAL_BLOCK_SIZE));
     const std::size_t num_features = predict_points.num_cols();
+    const auto blocked_num_support_vectors = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_support_vectors) / INTERNAL_BLOCK_SIZE));
+    const auto blocked_device_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_predict_points) / INTERNAL_BLOCK_SIZE));
 
     // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
 
 #pragma omp parallel for collapse(2)
-    for (std::size_t point_index = 0; point_index < device_specific_num_predict_points; ++point_index) {
-        for (std::size_t a = 0; a < num_classes; ++a) {
-            prediction(row_offset + point_index, a) -= rho[a];
+    for (std::size_t pp_idx = 0; pp_idx < device_num_predict_points; ++pp_idx) {
+        for (std::size_t class_idx = 0; class_idx < num_classes; ++class_idx) {
+            prediction(device_row_offset + pp_idx, class_idx) -= rho[class_idx];
         }
     }
 
 #pragma omp parallel for collapse(2)
-    for (std::size_t pp = 0; pp < blocked_device_specific_num_predict_points; pp += THREAD_BLOCK_SIZE_uz) {
-        for (std::size_t sv = 0; sv < blocked_num_support_vectors; sv += THREAD_BLOCK_SIZE_uz) {
+    for (std::size_t pp_block = 0; pp_block < blocked_device_num_predict_points; pp_block += THREAD_BLOCK_SIZE_uz) {
+        for (std::size_t sv_block = 0; sv_block < blocked_num_support_vectors; sv_block += THREAD_BLOCK_SIZE_uz) {
             // perform operations on the current block
-            for (std::size_t pp_block = 0; pp_block < THREAD_BLOCK_SIZE_uz; ++pp_block) {
-                for (std::size_t sv_block = 0; sv_block < THREAD_BLOCK_SIZE_uz; ++sv_block) {
+            for (std::size_t pp_thread = 0; pp_thread < THREAD_BLOCK_SIZE_uz; ++pp_thread) {
+                for (std::size_t sv_thread = 0; sv_thread < THREAD_BLOCK_SIZE_uz; ++sv_thread) {
                     // calculate the indices used in the current thread
-                    const std::size_t pp_idx = (pp + pp_block) * INTERNAL_BLOCK_SIZE_uz;
-                    const std::size_t sv_idx = (sv + sv_block) * INTERNAL_BLOCK_SIZE_uz;
+                    const std::size_t pp_idx = (pp_block + pp_thread) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
+                    const std::size_t sv_idx = (sv_block + sv_thread) * INTERNAL_BLOCK_SIZE_uz;  // num_support_vectors
 
                     // create a thread private array used for internal caching
                     std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
 
-                    // iterate over all features
-                    for (std::size_t dim = 0; dim < num_features; ++dim) {
+                    // iterate over all features using blocking
+                    for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
                         // perform the feature reduction calculation
                         for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                             for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                                const std::size_t global_pp_idx = row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
-                                const std::size_t global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
+                                // calculate the indices to access the global data
+                                const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                                const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
 
-                                temp[internal_pp][internal_sv] += detail::feature_reduce<kernel>(support_vectors(global_sv_idx, dim), predict_points(global_pp_idx, dim));
+                                real_type sum{ 0.0 };
+                                for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                                    sum += detail::feature_reduce<kernel_function>(predict_points(global_pp_idx, feature_block + feature),    // SoA
+                                                                                   support_vectors(global_sv_idx, feature_block + feature));  // SoA
+                                }
+                                temp[internal_sv][internal_pp] += sum;
                             }
                         }
                     }
@@ -159,22 +247,22 @@ inline void device_kernel_predict(aos_matrix<real_type> &prediction, const aos_m
                     // update temp using the respective kernel function
                     for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                         for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                            temp[internal_pp][internal_sv] = detail::apply_kernel_function<kernel>(temp[internal_pp][internal_sv], kernel_function_parameter...);
+                            temp[internal_sv][internal_pp] = detail::apply_kernel_function<kernel_function>(temp[internal_sv][internal_pp], kernel_function_parameter...);
                         }
                     }
 
-                    // add results to prediction
-                    for (std::size_t a = 0; a < num_classes; ++a) {
+                    // atomically add the results to the prediction
+                    for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
                         for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                             for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                                const std::size_t device_global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
-                                const std::size_t global_pp_idx = row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
-                                const std::size_t global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
+                                // calculate the indices to access the global data and the data with respect to the current device
+                                const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                                const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
 
-                                // be sure to not perform out of bounds accesses
-                                if (device_global_pp_idx < device_specific_num_predict_points && global_sv_idx < num_support_vectors) {
+                                for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
 #pragma omp atomic
-                                    prediction(global_pp_idx, a) += alpha(a, global_sv_idx) * temp[internal_pp][internal_sv];
+                                    prediction(global_pp_idx, class_block + class_idx) += alpha(class_block + class_idx, global_sv_idx) *  // AoS
+                                                                                          temp[internal_sv][internal_pp];
                                 }
                             }
                         }
diff --git a/include/plssvm/backends/SYCL/AdaptiveCpp/csvm.hpp b/include/plssvm/backends/SYCL/AdaptiveCpp/csvm.hpp
index 55b6a746b..e6b9e2e85 100644
--- a/include/plssvm/backends/SYCL/AdaptiveCpp/csvm.hpp
+++ b/include/plssvm/backends/SYCL/AdaptiveCpp/csvm.hpp
@@ -18,7 +18,7 @@
 #include "plssvm/backends/SYCL/AdaptiveCpp/detail/device_ptr.hpp"     // plssvm::adaptivecpp::detail::device_ptr
 #include "plssvm/backends/SYCL/AdaptiveCpp/detail/pinned_memory.hpp"  // plssvm::adaptivecpp::detail::pinned_memory
 #include "plssvm/backends/SYCL/AdaptiveCpp/detail/queue.hpp"          // plssvm::adaptivecpp::detail::queue (PImpl)
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"           // plssvm::sycl::kernel_invocation_type
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"             // plssvm::sycl::data_parallel_kernel
 #include "plssvm/constants.hpp"                                       // plssvm::real_type
 #include "plssvm/detail/igor_utility.hpp"                             // plssvm::detail::get_value_from_named_parameter
 #include "plssvm/detail/memory_size.hpp"                              // plssvm::detail::memory_size
@@ -34,6 +34,7 @@
 #include "igor/igor.hpp"  // igor::parser
 
 #include <cstddef>      // std::size_t
+#include <optional>     // std::optional
 #include <type_traits>  // std::is_same_v, std::true_type
 #include <utility>      // std::forward
 #include <vector>       // std::vector
@@ -42,6 +43,8 @@ namespace plssvm {
 
 namespace adaptivecpp {
 
+using namespace plssvm::sycl;  // NOLINT(google-build-using-namespace): necessary to make general SYCL functionality available in the AdaptiveCpp specific namespace
+
 /**
  * @brief A C-SVM implementation using AdaptiveCpp as SYCL backend.
  */
@@ -61,7 +64,7 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::queue
 
     /**
      * @brief Construct a new C-SVM using the SYCL backend on the @p target platform and the optionally provided @p named_args.
-     * @details Additionally sets the SYCL specific kernel invocation type.
+     * @details Additionally sets the SYCL specific data parallel kernel.
      * @param[in] target the target platform used for this C-SVM
      * @param[in] named_args the additional optional named arguments
      * @throws plssvm::exception all exceptions thrown in the base class constructor
@@ -71,18 +74,19 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::queue
     template <typename... Args, PLSSVM_REQUIRES(::plssvm::detail::has_only_sycl_parameter_named_args_v<Args...>)>
     explicit csvm(const target_platform target = target_platform::automatic, Args &&...named_args) {
         // check igor parameter
-        igor::parser parser{ std::forward<Args>(named_args)... };
+        const igor::parser parser{ std::forward<Args>(named_args)... };
 
-        // check whether a specific SYCL kernel invocation type has been requested
-        if constexpr (parser.has(sycl_kernel_invocation_type)) {
+        // check whether a specific SYCL data parallel kernel has been requested
+        if constexpr (parser.has(sycl_data_parallel_kernel)) {
             // compile time check: the value must have the correct type
-            invocation_type_ = ::plssvm::detail::get_value_from_named_parameter<sycl::kernel_invocation_type>(parser, sycl_kernel_invocation_type);
+            data_parallel_kernel_type_ = ::plssvm::detail::get_value_from_named_parameter<sycl::data_parallel_kernel>(parser, sycl_data_parallel_kernel);
 
 #if !defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-            if (invocation_type_ == sycl::kernel_invocation_type::hierarchical) {
-                throw ::plssvm::invalid_parameter_exception{ "The provided sycl::kernel_invocation_type::hierarchical is disabled for the AdaptiveCpp SYCL backend!" };
-            } else if (invocation_type_ == sycl::kernel_invocation_type::scoped) {
-                throw ::plssvm::invalid_parameter_exception{ "he provided sycl::kernel_invocation_type::scoped is disabled for the AdaptiveCpp SYCL backend!" };
+            if (data_parallel_kernel_type_ == sycl::data_parallel_kernel::hierarchical) {
+                throw ::plssvm::invalid_parameter_exception{ "The provided sycl::data_parallel_kernel::hierarchical is disabled for the AdaptiveCpp SYCL backend!" };
+            }
+            if (data_parallel_kernel_type_ == sycl::data_parallel_kernel::scoped) {
+                throw ::plssvm::invalid_parameter_exception{ "he provided sycl::data_parallel_kernel::scoped is disabled for the AdaptiveCpp SYCL backend!" };
             }
 #endif
         }
@@ -112,10 +116,10 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::queue
     ~csvm() override = 0;
 
     /**
-     * @brief Return the kernel invocation type used in this SYCL SVM.
-     * @return the SYCL kernel invocation type (`[[nodiscard]]`)
+     * @brief Return the data parallel kernel used in this SYCL SVM.
+     * @return the SYCL data parallel kernel (`[[nodiscard]]`)
      */
-    [[nodiscard]] sycl::kernel_invocation_type get_kernel_invocation_type() const noexcept { return invocation_type_; }
+    [[nodiscard]] sycl::data_parallel_kernel get_data_parallel_kernel() const noexcept { return data_parallel_kernel_type_; }
 
   protected:
     /**
@@ -134,6 +138,10 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::queue
      * @copydoc plssvm::csvm::get_max_mem_alloc_size
      */
     [[nodiscard]] std::vector<::plssvm::detail::memory_size> get_max_mem_alloc_size() const final;
+    /**
+     * @copydoc plssvm::csvm::get_local_memory
+     */
+    [[nodiscard]] std::vector<std::optional<::plssvm::detail::memory_size>> get_local_memory() const final;
     /**
      * @copydoc plssvm::detail::gpu_csvm::get_max_work_group_size
      */
@@ -180,8 +188,8 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::queue
      */
     [[nodiscard]] device_ptr_type run_predict_kernel(std::size_t device_id, const ::plssvm::detail::execution_range &exec, const parameter &params, const device_ptr_type &alpha_d, const device_ptr_type &rho_d, const device_ptr_type &sv_or_w_d, const device_ptr_type &predict_points_d) const final;
 
-    /// The SYCL kernel invocation type for the svm kernel.
-    sycl::kernel_invocation_type invocation_type_{ sycl::kernel_invocation_type::automatic };
+    /// The used SYCL data parallel kernel.
+    sycl::data_parallel_kernel data_parallel_kernel_type_{ sycl::data_parallel_kernel::automatic };
 };
 
 /**
diff --git a/include/plssvm/backends/SYCL/AdaptiveCpp/detail/queue.hpp b/include/plssvm/backends/SYCL/AdaptiveCpp/detail/queue.hpp
index d9654ec34..88cd70318 100644
--- a/include/plssvm/backends/SYCL/AdaptiveCpp/detail/queue.hpp
+++ b/include/plssvm/backends/SYCL/AdaptiveCpp/detail/queue.hpp
@@ -25,7 +25,7 @@ class queue {
     /// The struct used in the PImpl idiom (encapsulates the actual SYCL queue).
     struct queue_impl;
     /// A pointer to the implementation hidden in a private header.
-    std::shared_ptr<queue_impl> impl{};
+    std::shared_ptr<queue_impl> impl;
 };
 
 }  // namespace plssvm::adaptivecpp::detail
diff --git a/include/plssvm/backends/SYCL/AdaptiveCpp/detail/queue_impl.hpp b/include/plssvm/backends/SYCL/AdaptiveCpp/detail/queue_impl.hpp
index bfc5f8414..2f08c8bc7 100644
--- a/include/plssvm/backends/SYCL/AdaptiveCpp/detail/queue_impl.hpp
+++ b/include/plssvm/backends/SYCL/AdaptiveCpp/detail/queue_impl.hpp
@@ -31,7 +31,7 @@ struct queue::queue_impl {
      * @param[in] args the parameters to construct a SYCL queue
      */
     template <typename... Args>
-    explicit queue_impl(Args... args) :
+    explicit queue_impl(Args &&...args) :
         sycl_queue{ std::forward<Args>(args)... } { }
 
     /// The wrapped SYCL queue.
diff --git a/include/plssvm/backends/SYCL/AdaptiveCpp/detail/utility.hpp b/include/plssvm/backends/SYCL/AdaptiveCpp/detail/utility.hpp
index 23ffb1872..3be1ec7ab 100644
--- a/include/plssvm/backends/SYCL/AdaptiveCpp/detail/utility.hpp
+++ b/include/plssvm/backends/SYCL/AdaptiveCpp/detail/utility.hpp
@@ -15,7 +15,8 @@
 
 #include "plssvm/backends/execution_range.hpp"                // plssvm::detail::dim_type
 #include "plssvm/backends/SYCL/AdaptiveCpp/detail/queue.hpp"  // plssvm::adaptivecpp::detail::queue (PImpl)
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"   // plssvm::sycl::kernel_invocation_type
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"     // plssvm::sycl::data_parallel_kernel
+#include "plssvm/detail/type_traits.hpp"                      // plssvm::detail::always_false_non_type_v
 #include "plssvm/detail/utility.hpp"                          // plssvm::detail::unreachable
 #include "plssvm/target_platforms.hpp"                        // plssvm::target_platform
 
@@ -44,27 +45,27 @@ template <std::size_t I>
     } else if constexpr (I == 3) {
         return ::sycl::range<I>{ static_cast<std::size_t>(dims.z), static_cast<std::size_t>(dims.y), static_cast<std::size_t>(dims.x) };
     } else {
-        static_assert(I != I, "Invalid number of native sycl::range dimension!");
+        static_assert(::plssvm::detail::always_false_non_type_v<I>, "Invalid number of native sycl::range dimension!");
     }
 }
 
 /**
  * @brief Convert the provided @p grid and @p block to the final SYCL execution range.
- * @tparam invocation_type the SYCL kernel invocation type
+ * @tparam kernel_type the SYCL data parallel kernel
  * @param[in] grid the execution grid
  * @param[in] block the execution block
  * @return the SYCL native execution range
  */
-template <sycl::kernel_invocation_type invocation_type>
+template <sycl::data_parallel_kernel kernel_type>
 auto get_execution_range(const ::plssvm::detail::dim_type &grid, const ::plssvm::detail::dim_type &block) {
     const ::sycl::range native_grid = detail::dim_type_to_native<2>(grid);
     const ::sycl::range native_block = detail::dim_type_to_native<2>(block);
 
-    if constexpr (invocation_type == sycl::kernel_invocation_type::basic) {
+    if constexpr (kernel_type == sycl::data_parallel_kernel::basic) {
         return ::sycl::range<2>{ native_grid * native_block };
-    } else if constexpr (invocation_type == sycl::kernel_invocation_type::work_group) {
+    } else if constexpr (kernel_type == sycl::data_parallel_kernel::work_group) {
         return ::sycl::nd_range<2>{ native_grid * native_block, native_block };
-    } else if constexpr (invocation_type == sycl::kernel_invocation_type::hierarchical || invocation_type == sycl::kernel_invocation_type::scoped) {
+    } else if constexpr (kernel_type == sycl::data_parallel_kernel::hierarchical || kernel_type == sycl::data_parallel_kernel::scoped) {
         return ::sycl::nd_range<2>{ native_grid, native_block };
     } else {
         // can't be reached
@@ -99,11 +100,19 @@ void device_synchronize(const queue &q);
  */
 [[nodiscard]] queue get_default_queue();
 
+/**
+ * @brief Get the name of the compute device associated with @p q.
+ * @param[in] q the SYCL queue representing the compute device
+ * @return the compute device name (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::string get_device_name(const queue &q);
+
 /**
  * @brief Return the short AdaptiveCpp version, i.e., major.minor.patch.
  * @return the short AdaptiveCpp version (`[[nodiscard]]`)
  */
 [[nodiscard]] std::string get_adaptivecpp_version_short();
+
 /**
  * @brief Return the full AdaptiveCpp version including git information.
  * @return the full AdaptiveCpp version (`[[nodiscard]]`)
diff --git a/include/plssvm/backends/SYCL/DPCPP/csvm.hpp b/include/plssvm/backends/SYCL/DPCPP/csvm.hpp
index 4b1a6b570..14f84996a 100644
--- a/include/plssvm/backends/SYCL/DPCPP/csvm.hpp
+++ b/include/plssvm/backends/SYCL/DPCPP/csvm.hpp
@@ -15,10 +15,10 @@
 
 #include "plssvm/backends/execution_range.hpp"                  // plssvm::detail::{dim_type, execution_range}
 #include "plssvm/backends/gpu_csvm.hpp"                         // plssvm::detail::gpu_csvm
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"       // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/DPCPP/detail/device_ptr.hpp"     // plssvm::dpcpp::detail::device_ptr
 #include "plssvm/backends/SYCL/DPCPP/detail/pinned_memory.hpp"  // plssvm::dpcpp::detail::pinned_memory
 #include "plssvm/backends/SYCL/DPCPP/detail/queue.hpp"          // plssvm::dpcpp::detail::queue (PImpl)
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"     // plssvm::sycl::kernel_invocation_type
 #include "plssvm/constants.hpp"                                 // plssvm::real_type
 #include "plssvm/detail/igor_utility.hpp"                       // plssvm::detail::get_value_from_named_parameter
 #include "plssvm/detail/memory_size.hpp"                        // plssvm::detail::memory_size
@@ -34,6 +34,7 @@
 #include "igor/igor.hpp"  // igor::parser
 
 #include <cstddef>      // std::size_t
+#include <optional>     // std::optional
 #include <type_traits>  // std::is_same_v, std::true_type
 #include <utility>      // std::forward
 #include <vector>       // std::vector
@@ -42,6 +43,8 @@ namespace plssvm {
 
 namespace dpcpp {
 
+using namespace plssvm::sycl;  // NOLINT(google-build-using-namespace): necessary to make general SYCL functionality available in the DPC++ specific namespace
+
 /**
  * @brief A C-SVM implementation using DPC++ as SYCL backend.
  */
@@ -64,27 +67,27 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::queue
      * @param[in] target the target platform used for this C-SVM
      * @param[in] named_args the additional optional named arguments
      * @throws plssvm::exception all exceptions thrown in the base class constructor
-     * @throws plssvm::invalid_parameter_exception the provided SYCL kernel invocation type is "scoped"
+     * @throws plssvm::invalid_parameter_exception the provided SYCL data parallel kernel is "scoped"
      * @throws plssvm::dpcpp::backend_exception if the requested target is not available
      * @throws plssvm::dpcpp::backend_exception if no device for the requested target was found
      */
     template <typename... Args, PLSSVM_REQUIRES(::plssvm::detail::has_only_sycl_parameter_named_args_v<Args...>)>
     explicit csvm(const target_platform target = target_platform::automatic, Args &&...named_args) {
         // check igor parameter
-        igor::parser parser{ std::forward<Args>(named_args)... };
+        const igor::parser parser{ std::forward<Args>(named_args)... };
 
-        // check whether a specific SYCL kernel invocation type has been requested
-        if constexpr (parser.has(sycl_kernel_invocation_type)) {
+        // check whether a specific SYCL data parallel kernel has been requested
+        if constexpr (parser.has(sycl_data_parallel_kernel)) {
             // compile time check: the value must have the correct type
-            invocation_type_ = ::plssvm::detail::get_value_from_named_parameter<sycl::kernel_invocation_type>(parser, sycl_kernel_invocation_type);
-            // the invocation type "scoped" isn't supported by DPC++
-            if (invocation_type_ == sycl::kernel_invocation_type::scoped) {
-                throw ::plssvm::invalid_parameter_exception{ "The provided sycl::kernel_invocation_type::scoped isn't supported by DPC++!" };
+            data_parallel_kernel_type_ = ::plssvm::detail::get_value_from_named_parameter<sycl::data_parallel_kernel>(parser, sycl_data_parallel_kernel);
+            // the data parallel kernel "scoped" isn't supported by DPC++
+            if (data_parallel_kernel_type_ == sycl::data_parallel_kernel::scoped) {
+                throw ::plssvm::invalid_parameter_exception{ "The provided sycl::data_parallel_kernel::scoped isn't supported by DPC++!" };
             }
 
 #if !defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-            if (invocation_type_ == sycl::kernel_invocation_type::hierarchical) {
-                throw ::plssvm::invalid_parameter_exception{ "The provided sycl::kernel_invocation_type::hierarchical is disabled for the DPC++ SYCL backend!" };
+            if (data_parallel_kernel_type_ == sycl::data_parallel_kernel::hierarchical) {
+                throw ::plssvm::invalid_parameter_exception{ "The provided sycl::data_parallel_kernel::hierarchical is disabled for the DPC++ SYCL backend!" };
             }
 #endif
         }
@@ -114,10 +117,10 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::queue
     ~csvm() override = 0;
 
     /**
-     * @brief Return the kernel invocation type used in this SYCL SVM.
-     * @return the SYCL kernel invocation type (`[[nodiscard]]`)
+     * @brief Return the data parallel kernel used in this SYCL SVM.
+     * @return the SYCL data parallel kernel (`[[nodiscard]]`)
      */
-    [[nodiscard]] sycl::kernel_invocation_type get_kernel_invocation_type() const noexcept { return invocation_type_; }
+    [[nodiscard]] sycl::data_parallel_kernel get_data_parallel_kernel() const noexcept { return data_parallel_kernel_type_; }
 
   protected:
     /**
@@ -136,6 +139,10 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::queue
      * @copydoc plssvm::csvm::get_max_mem_alloc_size
      */
     [[nodiscard]] std::vector<::plssvm::detail::memory_size> get_max_mem_alloc_size() const final;
+    /**
+     * @copydoc plssvm::csvm::get_local_memory
+     */
+    [[nodiscard]] std::vector<std::optional<::plssvm::detail::memory_size>> get_local_memory() const final;
     /**
      * @copydoc plssvm::detail::gpu_csvm::get_max_work_group_size
      */
@@ -183,8 +190,8 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::queue
      */
     [[nodiscard]] device_ptr_type run_predict_kernel(std::size_t device_id, const ::plssvm::detail::execution_range &exec, const parameter &params, const device_ptr_type &alpha_d, const device_ptr_type &rho_d, const device_ptr_type &sv_or_w_d, const device_ptr_type &predict_points_d) const final;
 
-    /// The SYCL kernel invocation type for the svm kernel.
-    sycl::kernel_invocation_type invocation_type_{ sycl::kernel_invocation_type::automatic };
+    /// The used SYCL data parallel kernel.
+    sycl::data_parallel_kernel data_parallel_kernel_type_{ sycl::data_parallel_kernel::automatic };
 };
 
 /**
diff --git a/include/plssvm/backends/SYCL/DPCPP/detail/queue.hpp b/include/plssvm/backends/SYCL/DPCPP/detail/queue.hpp
index de8d62600..e223f843c 100644
--- a/include/plssvm/backends/SYCL/DPCPP/detail/queue.hpp
+++ b/include/plssvm/backends/SYCL/DPCPP/detail/queue.hpp
@@ -25,7 +25,7 @@ class queue {
     /// The struct used in the PImpl idiom (encapsulates the actual SYCL queue).
     struct queue_impl;
     /// A pointer to the implementation hidden in a private header.
-    std::shared_ptr<queue_impl> impl{};
+    std::shared_ptr<queue_impl> impl;
 };
 
 }  // namespace plssvm::dpcpp::detail
diff --git a/include/plssvm/backends/SYCL/DPCPP/detail/queue_impl.hpp b/include/plssvm/backends/SYCL/DPCPP/detail/queue_impl.hpp
index 83724e46d..8bbca6518 100644
--- a/include/plssvm/backends/SYCL/DPCPP/detail/queue_impl.hpp
+++ b/include/plssvm/backends/SYCL/DPCPP/detail/queue_impl.hpp
@@ -31,7 +31,7 @@ struct queue::queue_impl {
      * @param[in] args the parameters to construct a SYCL queue
      */
     template <typename... Args>
-    explicit queue_impl(Args... args) :
+    explicit queue_impl(Args &&...args) :
         sycl_queue{ std::forward<Args>(args)... } { }
 
     /// The wrapped SYCL queue.
diff --git a/include/plssvm/backends/SYCL/DPCPP/detail/utility.hpp b/include/plssvm/backends/SYCL/DPCPP/detail/utility.hpp
index d61a73407..025ba4c14 100644
--- a/include/plssvm/backends/SYCL/DPCPP/detail/utility.hpp
+++ b/include/plssvm/backends/SYCL/DPCPP/detail/utility.hpp
@@ -13,11 +13,12 @@
 #define PLSSVM_BACKENDS_SYCL_DPCPP_DETAIL_UTILITY_HPP_
 #pragma once
 
-#include "plssvm/backends/execution_range.hpp"               // plssvm::detail::dim_type
-#include "plssvm/backends/SYCL/DPCPP/detail/queue.hpp"       // plssvm::dpcpp::detail::queue (PImpl)
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/detail/utility.hpp"                         // plssvm::detail::unreachable
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
+#include "plssvm/backends/execution_range.hpp"             // plssvm::detail::dim_type
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/DPCPP/detail/queue.hpp"     // plssvm::dpcpp::detail::queue (PImpl)
+#include "plssvm/detail/type_traits.hpp"                   // plssvm::detail::always_false_non_type_v
+#include "plssvm/detail/utility.hpp"                       // plssvm::detail::unreachable
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::range, sycl::nd_range
 
@@ -45,27 +46,27 @@ template <std::size_t I>
     } else if constexpr (I == 3) {
         return ::sycl::range<I>{ static_cast<std::size_t>(dims.z), static_cast<std::size_t>(dims.y), static_cast<std::size_t>(dims.x) };
     } else {
-        static_assert(I != I, "Invalid number of native sycl::range dimension!");
+        static_assert(::plssvm::detail::always_false_non_type_v<I>, "Invalid number of native sycl::range dimension!");
     }
 }
 
 /**
  * @brief Convert the provided @p grid and @p block to the final SYCL execution range.
- * @tparam invocation_type the SYCL kernel invocation type
+ * @tparam kernel_type the SYCL data parallel kernel
  * @param[in] grid the execution grid
  * @param[in] block the execution block
  * @return the SYCL native execution range
  */
-template <sycl::kernel_invocation_type invocation_type>
+template <sycl::data_parallel_kernel kernel_type>
 auto get_execution_range(const ::plssvm::detail::dim_type &grid, const ::plssvm::detail::dim_type &block) {
     const ::sycl::range native_grid = detail::dim_type_to_native<2>(grid);
     const ::sycl::range native_block = detail::dim_type_to_native<2>(block);
 
-    if constexpr (invocation_type == sycl::kernel_invocation_type::basic) {
+    if constexpr (kernel_type == sycl::data_parallel_kernel::basic) {
         return ::sycl::range<2>{ native_grid * native_block };
-    } else if constexpr (invocation_type == sycl::kernel_invocation_type::work_group) {
+    } else if constexpr (kernel_type == sycl::data_parallel_kernel::work_group) {
         return ::sycl::nd_range<2>{ native_grid * native_block, native_block };
-    } else if constexpr (invocation_type == sycl::kernel_invocation_type::hierarchical) {
+    } else if constexpr (kernel_type == sycl::data_parallel_kernel::hierarchical) {
         return ::sycl::nd_range<2>{ native_grid, native_block };
     } else {
         // can't be reached
@@ -100,11 +101,19 @@ void device_synchronize(const queue &q);
  */
 [[nodiscard]] queue get_default_queue();
 
+/**
+ * @brief Get the name of the compute device associated with @p q.
+ * @param[in] q the SYCL queue representing the compute device
+ * @return the compute device name (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::string get_device_name(const queue &q);
+
 /**
  * @brief Get the DPC++ version as pretty string.
  * @return the DPC++ version (`[[nodiscard]]`)
  */
 [[nodiscard]] std::string get_dpcpp_version();
+
 /**
  * @brief Get the time (version) when the used DPC++ version was built.
  * @return the DPC++ built date (`[[nodiscard]]`)
diff --git a/include/plssvm/backends/SYCL/kernel_invocation_types.hpp b/include/plssvm/backends/SYCL/data_parallel_kernels.hpp
similarity index 54%
rename from include/plssvm/backends/SYCL/kernel_invocation_types.hpp
rename to include/plssvm/backends/SYCL/data_parallel_kernels.hpp
index d7cec1924..ede8ee3fb 100644
--- a/include/plssvm/backends/SYCL/kernel_invocation_types.hpp
+++ b/include/plssvm/backends/SYCL/data_parallel_kernels.hpp
@@ -6,11 +6,11 @@
  * @license This file is part of the PLSSVM project which is released under the MIT license.
  *          See the LICENSE.md file in the project root for full license information.
  *
- * @brief Defines an enumeration holding all possible SYCL kernel invocation types.
+ * @brief Defines an enumeration holding all possible SYCL data parallel kernels.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_INVOCATION_TYPE_HPP_
-#define PLSSVM_BACKENDS_SYCL_KERNEL_INVOCATION_TYPE_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_DATA_PARALLEL_KERNELS_HPP_
+#define PLSSVM_BACKENDS_SYCL_DATA_PARALLEL_KERNELS_HPP_
 #pragma once
 
 #include "fmt/base.h"     // fmt::formatter
@@ -22,10 +22,10 @@
 namespace plssvm::sycl {
 
 /**
- * @brief Enum class for all possible SYCL kernel invocation types.
+ * @brief Enum class for all possible SYCL data parallel kernels.
  */
-enum class kernel_invocation_type {
-    /** Use the best kernel invocation type for the current SYCL implementation and target hardware platform. */
+enum class data_parallel_kernel {
+    /** Use the best data parallel kernel for the current SYCL implementation and target hardware platform. In practice, will nearly always map to work-group data parallel kernels. */
     automatic,
     /** Use the [`basic` data parallel kernels](https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html#_basic_data_parallel_kernels). */
     basic,
@@ -38,35 +38,35 @@ enum class kernel_invocation_type {
 };
 
 /**
- * @brief Return a list of all currently available SYCL kernel invocation types.
- * @details SYCL's hierarchical and AdaptiveCpp's scoped kernel invocation type can be disabled during the CMake configuration.
- * @return the available SYCL kernel invocation types (`[[nodiscard]]`)
+ * @brief Return a list of all currently available SYCL data parallel kernels.
+ * @details SYCL's hierarchical data parallel kernels and AdaptiveCpp's scoped parallelism can be disabled during the CMake configuration.
+ * @return the available SYCL data parallel kernels (`[[nodiscard]]`)
  */
-[[nodiscard]] std::vector<kernel_invocation_type> list_available_sycl_kernel_invocation_types();
+[[nodiscard]] std::vector<data_parallel_kernel> list_available_sycl_data_parallel_kernels();
 
 /**
- * @brief Output the @p invocation type to the given output-stream @p out.
+ * @brief Output the @p kernel_type type to the given output-stream @p out.
  * @param[in,out] out the output-stream to write the backend type to
- * @param[in] invocation the SYCL kernel invocation type
+ * @param[in] kernel_type the SYCL data parallel kernel
  * @return the output-stream
  */
-std::ostream &operator<<(std::ostream &out, kernel_invocation_type invocation);
+std::ostream &operator<<(std::ostream &out, data_parallel_kernel kernel_type);
 
 /**
- * @brief Use the input-stream @p in to initialize the @p invocation type.
+ * @brief Use the input-stream @p in to initialize the @p kernel_type type.
  * @param[in,out] in input-stream to extract the backend type from
- * @param[in] invocation the SYCL kernel invocation type
+ * @param[in] kernel_type the SYCL data parallel kernel
  * @return the input-stream
  */
-std::istream &operator>>(std::istream &in, kernel_invocation_type &invocation);
+std::istream &operator>>(std::istream &in, data_parallel_kernel &kernel_type);
 
 }  // namespace plssvm::sycl
 
 /// @cond Doxygen_suppress
 
 template <>
-struct fmt::formatter<plssvm::sycl::kernel_invocation_type> : fmt::ostream_formatter { };
+struct fmt::formatter<plssvm::sycl::data_parallel_kernel> : fmt::ostream_formatter { };
 
 /// @endcond
 
-#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_INVOCATION_TYPE_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_DATA_PARALLEL_KERNELS_HPP_
diff --git a/include/plssvm/backends/SYCL/detail/constants.hpp b/include/plssvm/backends/SYCL/detail/constants.hpp
index 81f8ca2ee..72c4117b4 100644
--- a/include/plssvm/backends/SYCL/detail/constants.hpp
+++ b/include/plssvm/backends/SYCL/detail/constants.hpp
@@ -16,14 +16,14 @@
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
 // define the default used SYCL implementation
 namespace plssvm::sycl {
-using namespace plssvm::PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION;
+using namespace plssvm::PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION;  // NOLINT: set default SYCL implementation
 }
 #else
 // define dpcpp as default SYCL namespace if no SYCL backend is available (to prevent compiler errors)
 namespace plssvm::dpcpp { }  // namespace plssvm::dpcpp
 
 namespace plssvm::sycl {
-using namespace plssvm::dpcpp;
+using namespace plssvm::dpcpp;  // NOLINT: set default SYCL implementation
 }
 #endif
 
diff --git a/include/plssvm/backends/SYCL/exceptions.hpp b/include/plssvm/backends/SYCL/exceptions.hpp
index 9d752aa61..45b327b21 100644
--- a/include/plssvm/backends/SYCL/exceptions.hpp
+++ b/include/plssvm/backends/SYCL/exceptions.hpp
@@ -9,8 +9,8 @@
  * @brief Implements custom exception classes specific to the SYCL backend.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CSVM_HPP_
-#define PLSSVM_BACKENDS_SYCL_CSVM_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_EXCEPTIONS_HPP_
+#define PLSSVM_BACKENDS_SYCL_EXCEPTIONS_HPP_
 #pragma once
 
 #include "plssvm/exceptions/exceptions.hpp"       // plssvm::exception
@@ -81,4 +81,4 @@ class backend_exception : public sycl::backend_exception {
 
 }  // namespace plssvm
 
-#endif  // PLSSVM_BACKENDS_SYCL_CSVM_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_EXCEPTIONS_HPP_
diff --git a/include/plssvm/backends/SYCL/implementation_types.hpp b/include/plssvm/backends/SYCL/implementation_types.hpp
index 3c4158c59..29c9d1285 100644
--- a/include/plssvm/backends/SYCL/implementation_types.hpp
+++ b/include/plssvm/backends/SYCL/implementation_types.hpp
@@ -9,8 +9,8 @@
  * @brief Defines an enumeration holding all possible SYCL implementations.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_IMPLEMENTATION_TYPE_HPP_
-#define PLSSVM_BACKENDS_SYCL_IMPLEMENTATION_TYPE_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_IMPLEMENTATION_TYPES_HPP_
+#define PLSSVM_BACKENDS_SYCL_IMPLEMENTATION_TYPES_HPP_
 #pragma once
 
 #include "fmt/base.h"     // fmt::formatter
@@ -65,4 +65,4 @@ struct fmt::formatter<plssvm::sycl::implementation_type> : fmt::ostream_formatte
 
 /// @endcond
 
-#endif  // PLSSVM_BACKENDS_SYCL_IMPLEMENTATION_TYPE_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_IMPLEMENTATION_TYPES_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_explicit/basic/blas.hpp b/include/plssvm/backends/SYCL/kernel/cg_explicit/basic/blas.hpp
index 2e528149c..b886ef250 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_explicit/basic/blas.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_explicit/basic/blas.hpp
@@ -9,14 +9,17 @@
  * @brief Functions for explicitly performing a BLAS GEMM like matrix-matrix multiplication using the SYCL backend and the basic data parallel kernels.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_BASIC_BLAS_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_BASIC_BLAS_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_BASIC_BLAS_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_BASIC_BLAS_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/constants.hpp"                            // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 
 namespace plssvm::sycl::detail::basic {
@@ -24,15 +27,20 @@ namespace plssvm::sycl::detail::basic {
 /**
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @details Uses SYCL's basic data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_symm {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::basic;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_rows the number of rows in @p A and @p C
      * @param[in] num_rhs the number of columns in @p B and @p C
-     * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
-     * @param[in] row_offset the first row this device is responsible for
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
      * @param[in] alpha the scalar alpha value
      * @param[in] A the matrix @p A
      * @param[in] B the matrix @p B
@@ -41,11 +49,11 @@ class device_kernel_symm {
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+    device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
         num_rows_{ num_rows },
         num_rhs_{ num_rhs },
-        device_specific_num_rows_{ device_specific_num_rows },
-        row_offset_{ row_offset },
+        device_num_rows_{ device_num_rows },
+        device_row_offset_{ device_row_offset },
         alpha_{ alpha },
         A_{ A },
         B_{ B },
@@ -59,33 +67,63 @@ class device_kernel_symm {
      * @param[in] idx indices representing the current point in the execution space
      */
     void operator()(::sycl::item<2> idx) const {
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
         // calculate the indices used in the current work-item
-        const std::size_t i = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t j = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
+        const auto i_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+        const auto j_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
         // create a work-item private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (unsigned long long dim = 0; dim < (num_rows_ - row_offset_); ++dim) {
-            // perform the dot product calculation
-            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const auto global_i = i + static_cast<std::size_t>(internal_i);
-                    const auto global_j = j + static_cast<std::size_t>(internal_j);
-
-                    real_type A_val = 0.0;
-                    // determine on which side of the diagonal we are located
-                    if (dim < global_j) {
-                        A_val = A_[dim * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + global_j - dim * (dim + std::size_t{ 1 }) / std::size_t{ 2 }];
-                    } else {
-                        A_val = A_[global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + dim - global_j * (global_j + std::size_t{ 1 }) / std::size_t{ 2 }];
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+        // iterate over all values using blocking
+        for (std::size_t dim_block = 0; dim_block < (num_rows_ - device_row_offset_); dim_block += THREAD_BLOCK_SIZE_uz) {
+            if constexpr (target == target_platform::cpu) {
+                // perform the dot product calculation, the dim is the fastest moving index
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        // calculate the indices to access the global data
+                        const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                        const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                        real_type sum{ 0.0 };
+                        for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE_uz; ++dim) {
+                            real_type A_cache = 0.0;
+                            // determine on which side of the diagonal we are located
+                            if (dim_block + dim < global_j_idx) {
+                                A_cache = A_[(dim_block + dim) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + global_j_idx - (dim_block + dim) * (dim_block + dim + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                            } else {
+                                A_cache = A_[global_j_idx * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + dim_block + dim - global_j_idx * (global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                            }
+
+                            sum += A_cache * B_[((dim_block + dim) + device_row_offset_) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
+                        }
+                        temp[internal_i][internal_j] += sum;
+                    }
+                }
+            } else {
+                // perform the dot product calculation, the dim is the slowest moving index
+                for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE_uz; ++dim) {
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            // calculate the indices to access the global data
+                            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                            const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                            real_type A_cache = 0.0;
+                            // determine on which side of the diagonal we are located
+                            if (dim_block + dim < global_j_idx) {
+                                A_cache = A_[(dim_block + dim) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + global_j_idx - (dim_block + dim) * (dim_block + dim + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                            } else {
+                                A_cache = A_[global_j_idx * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + dim_block + dim - global_j_idx * (global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                            }
+
+                            temp[internal_i][internal_j] += A_cache * B_[(dim_block + dim + device_row_offset_) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
+                        }
                     }
-
-                    temp[internal_i][internal_j] += A_val * B_[(dim + row_offset_) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
                 }
             }
         }
@@ -93,13 +131,14 @@ class device_kernel_symm {
         // apply the (partial) BLAS operation and update C
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto device_global_j = j + static_cast<std::size_t>(internal_j);
-                const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-
-                // be sure to not perform out of bounds accesses
-                if (global_i < num_rhs_ && device_global_j < device_specific_num_rows_) {
-                    C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses
+                if (global_i_idx < num_rhs_ && device_global_j_idx < device_num_rows_) {
+                    C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
                 }
             }
         }
@@ -109,8 +148,8 @@ class device_kernel_symm {
     /// @cond Doxygen_suppress
     const std::size_t num_rows_;
     const std::size_t num_rhs_;
-    const std::size_t device_specific_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_num_rows_;
+    const std::size_t device_row_offset_;
     const real_type alpha_;
     const real_type *A_;
     const real_type *B_;
@@ -125,16 +164,21 @@ class device_kernel_symm {
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @details In a multi-GPU setting, this function is responsible for mirroring down the columns this device is responsible for!
  *          Uses SYCL's basic data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_symm_mirror {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::basic;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_rows the number of rows in @p A and @p C
      * @param[in] num_rhs the number of columns in @p B and @p C
      * @param[in] num_mirror_rows the number of rows to mirror down
-     * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
-     * @param[in] row_offset the first row this device is responsible for
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
      * @param[in] alpha the scalar alpha value
      * @param[in] A the matrix @p A
      * @param[in] B the matrix @p B
@@ -143,12 +187,12 @@ class device_kernel_symm_mirror {
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+    device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
         num_rows_{ num_rows },
         num_rhs_{ num_rhs },
         num_mirror_rows_{ num_mirror_rows },
-        device_specific_num_rows_{ device_specific_num_rows },
-        row_offset_{ row_offset },
+        device_num_rows_{ device_num_rows },
+        device_row_offset_{ device_row_offset },
         alpha_{ alpha },
         A_{ A },
         B_{ B },
@@ -162,25 +206,49 @@ class device_kernel_symm_mirror {
      * @param[in] idx indices representing the current point in the execution space
      */
     void operator()(::sycl::item<2> idx) const {
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
         // calculate the indices used in the current work-item
-        const std::size_t i = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t j = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
+        const auto i_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+        const auto j_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
 
         // create a work-item private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over the remaining features using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < device_specific_num_rows_; ++dim) {
-            // perform the feature reduction calculation
-            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const auto global_i = i + static_cast<std::size_t>(internal_i);
-                    const auto global_j = j + static_cast<std::size_t>(internal_j);
-
-                    temp[internal_i][internal_j] += A_[(dim) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - (dim - std::size_t{ 1 }) * dim / std::size_t{ 2 } + device_specific_num_rows_ - dim + global_j] * B_[(dim + row_offset_) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+        // iterate over the remaining values using blocking to be able to cache them for faster memory accesses
+        for (std::size_t dim_block = 0; dim_block < device_num_rows_; dim_block += THREAD_BLOCK_SIZE_uz) {
+            if constexpr (target == target_platform::cpu) {
+                // perform the dot product calculation, the dim is the fastest moving index
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        // calculate the indices to access the global data
+                        const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                        const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                        real_type sum{ 0.0 };
+                        for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                            sum += A_[(dim_block + dim) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - (dim_block + dim - std::size_t{ 1 }) * (dim_block + dim) / std::size_t{ 2 } + device_num_rows_ - (dim_block + dim) + global_j_idx] *  // SoA, upper triangular matrix only
+                                   B_[(dim_block + dim + device_row_offset_) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];                                                                                                                         // SoA
+                        }
+                        temp[internal_i][internal_j] += sum;
+                    }
+                }
+            } else {
+                // perform the dot product calculation, the dim is the slowest moving index
+                for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            // calculate the indices to access the global data
+                            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                            const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                            temp[internal_i][internal_j] += A_[(dim_block + dim) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - (dim_block + dim - std::size_t{ 1 }) * (dim_block + dim) / std::size_t{ 2 } + device_num_rows_ - (dim_block + dim) + global_j_idx] *  // SoA, upper triangular matrix only
+                                                            B_[(dim_block + dim + device_row_offset_) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];                                                                                                                         // SoA
+                        }
+                    }
                 }
             }
         }
@@ -188,13 +256,14 @@ class device_kernel_symm_mirror {
         // apply the (remaining) BLAS operation and update C
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto partial_global_j = j + static_cast<std::size_t>(internal_j);
-                const auto global_j = row_offset_ + device_specific_num_rows_ + j + static_cast<std::size_t>(internal_j);
-
-                // be sure to not perform out of bounds accesses
-                if (global_i < num_rhs_ && partial_global_j < num_mirror_rows_) {
-                    C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto partial_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset_ + device_num_rows_ + partial_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses
+                if (global_i_idx < num_rhs_ && partial_global_j_idx < num_mirror_rows_) {
+                    C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
                 }
             }
         }
@@ -205,8 +274,8 @@ class device_kernel_symm_mirror {
     const std::size_t num_rows_;
     const std::size_t num_rhs_;
     const std::size_t num_mirror_rows_;
-    const std::size_t device_specific_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_num_rows_;
+    const std::size_t device_row_offset_;
     const real_type alpha_;
     const real_type *A_;
     const real_type *B_;
@@ -223,6 +292,9 @@ class device_kernel_symm_mirror {
  */
 class device_kernel_inplace_matrix_add {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::basic;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_cols the number of columns in both matrices
@@ -244,19 +316,21 @@ class device_kernel_inplace_matrix_add {
      */
     void operator()(::sycl::item<2> idx) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
         // calculate the indices used in the current work-item
-        const std::size_t i = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t j = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
+        const auto i_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+        const auto j_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto global_j = j + static_cast<std::size_t>(internal_j);
+                // calculate the indices to access the global data
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-                lhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j] += rhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j];
+                lhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx] += rhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx];  // SoA
             }
         }
     }
@@ -277,6 +351,9 @@ class device_kernel_inplace_matrix_add {
  */
 class device_kernel_inplace_matrix_scale {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::basic;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_cols the number of columns in the matrix
@@ -298,19 +375,21 @@ class device_kernel_inplace_matrix_scale {
      */
     void operator()(::sycl::item<2> idx) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
         // calculate the indices used in the current work-item
-        const std::size_t i = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t j = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
+        const auto i_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+        const auto j_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto global_j = j + static_cast<std::size_t>(internal_j);
+                // calculate the indices to access the global data
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-                lhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j] *= scale_;
+                lhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx] *= scale_;  // SoA
             }
         }
     }
@@ -327,4 +406,4 @@ class device_kernel_inplace_matrix_scale {
 
 }  // namespace plssvm::sycl::detail::basic
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_BASIC_BLAS_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_BASIC_BLAS_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_explicit/basic/kernel_matrix_assembly.hpp b/include/plssvm/backends/SYCL/kernel/cg_explicit/basic/kernel_matrix_assembly.hpp
index 65587ddaa..61ff29e10 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_explicit/basic/kernel_matrix_assembly.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_explicit/basic/kernel_matrix_assembly.hpp
@@ -9,16 +9,19 @@
  * @brief Functions for explicitly assembling the kernel matrix using the SYCL backend and the basic data parallel kernels.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
@@ -27,19 +30,23 @@ namespace plssvm::sycl::detail::basic {
 /**
  * @brief Create the explicit kernel matrix using the @p kernel_function.
  * @details Uses SYCL's basic data parallel kernels.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function; stored in a `std::tuple`
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_assembly {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::basic;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[out] kernel_matrix_d the calculated kernel matrix
-     * @param[in] data_d the data points to calculate the kernel matrix from
+     * @param[out] kernel_matrix the calculated kernel matrix
+     * @param[in] data the data points to calculate the kernel matrix from
      * @param[in] num_rows the number of data points
      * @param[in] device_num_rows the number of rows the current device is responsible for
-     * @param[in] row_offset the first row in @p data_d the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data_d the current device is responsible for
      * @param[in] num_features the number of features per data point
      * @param[in] q the vector used in the dimensional reduction
      * @param[in] QA_cost the scalar used in the dimensional reduction
@@ -48,19 +55,19 @@ class device_kernel_assembly {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_assembly(real_type *kernel_matrix_d, const real_type *data_d, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t row_offset, const std::size_t num_features, const real_type *q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
-        kernel_matrix_d_{ kernel_matrix_d },
-        data_d_{ data_d },
+    device_kernel_assembly(real_type *kernel_matrix, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type *q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+        kernel_matrix_{ kernel_matrix },
+        data_{ data },
         num_rows_{ num_rows },
         device_num_rows_{ device_num_rows },
-        row_offset_{ row_offset },
+        device_row_offset_{ device_row_offset },
         num_features_{ num_features },
         q_{ q },
         QA_cost_{ QA_cost },
         cost_{ cost },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } {
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } {
     }
 
     /**
@@ -69,25 +76,50 @@ class device_kernel_assembly {
      */
     void operator()(::sycl::item<2> idx) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
         // calculate the indices used in the current work-item
-        const std::size_t i = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t j = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
-
-        if (i >= j) {
-            // create a work-item private array used for internal caching
-            real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-            for (std::size_t dim = 0; dim < num_features_; ++dim) {
-                // perform the feature reduction calculation
-                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal_i);
-                        const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-                        temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_d_[dim * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i],
-                                                                                                data_d_[dim * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j]);
+        const auto i_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+        const auto j_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
+        // only calculate the upper triangular matrix
+        if (i_idx >= j_idx) {
+            // create a private memory array used for internal caching
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+            // iterate over all features using blocking
+            for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the feature reduction calculation, the feature is the fastest moving index
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            // calculate the indices to access the global data
+                            const auto global_i_idx = device_row_offset_ + i_idx + static_cast<std::size_t>(internal_i);
+                            const auto global_j_idx = device_row_offset_ + j_idx + static_cast<std::size_t>(internal_j);
+
+                            real_type sum{ 0.0 };
+                            for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                                sum += detail::feature_reduce<kernel_function>(data_[(feature_block + feature) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx],   // SoA
+                                                                               data_[(feature_block + feature) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx]);  // SoA
+                            }
+                            temp[internal_i][internal_j] += sum;
+                        }
+                    }
+                } else {
+                    // perform the feature reduction calculation, the feature is the slowest moving index
+                    for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                // calculate the indices to access the global data
+                                const auto global_i_idx = device_row_offset_ + i_idx + static_cast<std::size_t>(internal_i);
+                                const auto global_j_idx = device_row_offset_ + j_idx + static_cast<std::size_t>(internal_j);
+
+                                temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_[(feature_block + feature) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx],   // SoA
+                                                                                                        data_[(feature_block + feature) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx]);  // SoA
+                            }
+                        }
                     }
                 }
             }
@@ -95,22 +127,23 @@ class device_kernel_assembly {
             // apply the remaining part of the kernel function and store the value in the output kernel matrix
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    // calculate the indices to access the kernel matrix (the part stored on the current device)
-                    const auto device_global_i = i + static_cast<std::size_t>(internal_i);
-                    const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal_i);
-                    const auto device_global_j = j + static_cast<std::size_t>(internal_j);
-                    const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-
-                    // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                    if (device_global_i < (num_rows_ - row_offset_) && device_global_j < device_num_rows_ && global_i >= global_j) {
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_i_idx = device_row_offset_ + device_global_i_idx;
+                    const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                    if (device_global_i_idx < (num_rows_ - device_row_offset_) && device_global_j_idx < device_num_rows_ && global_i_idx >= global_j_idx) {
                         real_type temp_ij = temp[internal_i][internal_j];
-                        temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i] - q_[global_j];
+                        // apply the final kernel function
+                        temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i_idx] - q_[global_j_idx];
                         // apply the cost on the diagonal
-                        if (global_i == global_j) {
+                        if (global_i_idx == global_j_idx) {
                             temp_ij += cost_;
                         }
-                        // update the kernel matrix
-                        kernel_matrix_d_[device_global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - device_global_j * (device_global_j + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i] = temp_ij;
+                        // update the upper triangular kernel matrix
+                        kernel_matrix_[device_global_j_idx * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i_idx] = temp_ij;
                     }
                 }
             }
@@ -119,11 +152,11 @@ class device_kernel_assembly {
 
   private:
     /// @cond Doxygen_suppress
-    real_type *kernel_matrix_d_;
-    const real_type *data_d_;
+    real_type *kernel_matrix_;
+    const real_type *data_;
     const std::size_t num_rows_;
     const std::size_t device_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_row_offset_;
     const std::size_t num_features_;
     const real_type *q_;
     const real_type QA_cost_;
@@ -136,4 +169,4 @@ class device_kernel_assembly {
 
 }  // namespace plssvm::sycl::detail::basic
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_explicit/hierarchical/blas.hpp b/include/plssvm/backends/SYCL/kernel/cg_explicit/hierarchical/blas.hpp
index de6358ec8..9fff2ef67 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_explicit/hierarchical/blas.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_explicit/hierarchical/blas.hpp
@@ -9,14 +9,17 @@
  * @brief Functions for explicitly performing a BLAS GEMM like matrix-matrix multiplication using the SYCL backend and the hierarchical data parallel kernels.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_HIERARCHICAL_BLAS_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_HIERARCHICAL_BLAS_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_HIERARCHICAL_BLAS_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_HIERARCHICAL_BLAS_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/constants.hpp"                            // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::group, sycl::private_memory, sycl::h_item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 
 namespace plssvm::sycl::detail::hierarchical {
@@ -24,15 +27,20 @@ namespace plssvm::sycl::detail::hierarchical {
 /**
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @details Uses SYCL's hierarchical data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_symm {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::hierarchical;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_rows the number of rows in @p A and @p C
      * @param[in] num_rhs the number of columns in @p B and @p C
-     * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
-     * @param[in] row_offset the first row this device is responsible for
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
      * @param[in] alpha the scalar alpha value
      * @param[in] A the matrix @p A
      * @param[in] B the matrix @p B
@@ -41,11 +49,11 @@ class device_kernel_symm {
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+    device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
         num_rows_{ num_rows },
         num_rhs_{ num_rhs },
-        device_specific_num_rows_{ device_specific_num_rows },
-        row_offset_{ row_offset },
+        device_num_rows_{ device_num_rows },
+        device_row_offset_{ device_row_offset },
         alpha_{ alpha },
         A_{ A },
         B_{ B },
@@ -59,36 +67,15 @@ class device_kernel_symm {
      * @param[in] group indices representing the current point in the execution space
      */
     void operator()(::sycl::group<2> group) const {
-        // allocate shared memory
-        real_type A_cache_[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-        real_type B_cache_[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-
-        // calculate the indices used in the current work-item
-        ::sycl::private_memory<std::size_t, 2> i{ group };
-        ::sycl::private_memory<std::size_t, 2> i_linear{ group };
-        ::sycl::private_memory<std::size_t, 2> j{ group };
-        ::sycl::private_memory<std::size_t, 2> j_linear{ group };
+        // create two local memory arrays used for caching
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> A_cache{};
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> B_cache{};
 
-        ::sycl::private_memory<real_type[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE], 2> temp{ group };
+        // create a private memory array used for internal caching
+        ::sycl::private_memory<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, 2> temp{ group };
 
-        // initialize private and local variables
+        // initialize private temp matrix to zero
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-            const std::size_t threadIdx_x = idx.get_local_id(0);       // current thread in block x-dimension
-            const std::size_t threadIdx_y = idx.get_local_id(1);       // current thread in block y-dimension
-            const std::size_t blockDim_x = idx.get_local_range(0);     // number of threads in block x-dimension
-            const std::size_t blockDim_y = idx.get_local_range(1);     // number of threads in block y-dimension
-            const std::size_t blockIdx_x = group[0] + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-            const std::size_t blockIdx_y = group[1] + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-            const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-            // indices
-            i(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-            i_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-            j(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-            j_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-
             // initialize private temp matrix to zero
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
@@ -97,37 +84,44 @@ class device_kernel_symm {
             }
         });
 
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < (num_rows_ - row_offset_); dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+        // iterate over all values using blocking to be able to cache them for faster memory accesses
+        for (std::size_t dim_block = 0; dim_block < (num_rows_ - device_row_offset_); dim_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
             // load data into local memory
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                // cast values to 32-bit unsigned int values to prevent implicit conversions
                 const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                 const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                const std::size_t threadIdx_x = idx.get_local_id(0);
+                // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+                const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+                const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+                const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+                const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+                const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto i_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_rhs
+                const auto j_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // device_num_rows
 
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_i = i_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                    const auto global_j = j_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
+                    // store the values in the local memory
                     // determine on which side of the diagonal we are located
-                    if (dim + threadIdx_x < global_j) {
-                        A_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + global_j - (dim + threadIdx_x) * (dim + threadIdx_x + std::size_t{ 1 }) / std::size_t{ 2 }];
-                    } else {
-                        A_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + dim + threadIdx_x - global_j * (global_j + std::size_t{ 1 }) / std::size_t{ 2 }];
-                    }
-                    // determine on which side of the diagonal we are located
-                    if (dim + threadIdx_x + THREAD_BLOCK_SIZE < global_j) {
-                        A_cache_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + global_j - (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz + std::size_t{ 1 }) / std::size_t{ 2 }];
+                    if (dim_block + threadIdx_x < global_j_idx_linear) {
+                        A_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim_block + threadIdx_x) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + global_j_idx_linear - (dim_block + threadIdx_x) * (dim_block + threadIdx_x + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
                     } else {
-                        A_cache_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz - global_j * (global_j + std::size_t{ 1 }) / std::size_t{ 2 }];
+                        A_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[global_j_idx_linear * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + dim_block + threadIdx_x - global_j_idx_linear * (global_j_idx_linear + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
                     }
 
-                    B_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
-                    B_cache_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                    B_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim_block + device_row_offset_ + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
                 }
             });
 
@@ -135,13 +129,28 @@ class device_kernel_symm {
 
             // perform the dot product calculation
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                // cast values to 32-bit unsigned int values to prevent implicit conversions
                 const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                 const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the dim is the fastest moving index
                     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            temp(idx)[internal_i][internal_j] += A_cache_[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache_[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                            real_type sum{ 0.0 };
+                            for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                                sum += A_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                            }
+                            temp(idx)[internal_i][internal_j] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the dim is the slowest moving index
+                    for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                temp(idx)[internal_i][internal_j] += A_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                            }
                         }
                     }
                 }
@@ -152,17 +161,31 @@ class device_kernel_symm {
 
         // apply the (partial) BLAS operation and update C
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+            // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+            constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+            constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+            const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+            const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+            const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+            const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+            const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+            const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+            // calculate the indices to access the global data, pays attention to coalesced memory accesses
+            const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+            const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const auto global_i = i(idx) + static_cast<std::size_t>(internal_i);
-                    const auto device_global_j = j(idx) + static_cast<std::size_t>(internal_j);
-                    const auto global_j = row_offset_ + j(idx) + static_cast<std::size_t>(internal_j);
-
-                    // be sure to not perform out of bounds accesses
-                    if (global_i < num_rhs_ && device_global_j < device_specific_num_rows_) {
-                        C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i] = alpha_ * temp(idx)[internal_i][internal_j] + beta_ * C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses
+                    if (global_i_idx < num_rhs_ && device_global_j_idx < device_num_rows_) {
+                        C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx] = alpha_ * temp(idx)[internal_i][internal_j] + beta_ * C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
                     }
                 }
             }
@@ -173,8 +196,8 @@ class device_kernel_symm {
     /// @cond Doxygen_suppress
     const std::size_t num_rows_;
     const std::size_t num_rhs_;
-    const std::size_t device_specific_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_num_rows_;
+    const std::size_t device_row_offset_;
     const real_type alpha_;
     const real_type *A_;
     const real_type *B_;
@@ -189,16 +212,21 @@ class device_kernel_symm {
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @details In a multi-GPU setting, this function is responsible for mirroring down the columns this device is responsible for!
  *          Uses SYCL's hierarchical data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_symm_mirror {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::hierarchical;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_rows the number of rows in @p A and @p C
      * @param[in] num_rhs the number of columns in @p B and @p C
      * @param[in] num_mirror_rows the number of rows to mirror down
-     * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
-     * @param[in] row_offset the first row this device is responsible for
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
      * @param[in] alpha the scalar alpha value
      * @param[in] A the matrix @p A
      * @param[in] B the matrix @p B
@@ -207,12 +235,12 @@ class device_kernel_symm_mirror {
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+    device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
         num_rows_{ num_rows },
         num_rhs_{ num_rhs },
         num_mirror_rows_{ num_mirror_rows },
-        device_specific_num_rows_{ device_specific_num_rows },
-        row_offset_{ row_offset },
+        device_num_rows_{ device_num_rows },
+        device_row_offset_{ device_row_offset },
         alpha_{ alpha },
         A_{ A },
         B_{ B },
@@ -226,36 +254,15 @@ class device_kernel_symm_mirror {
      * @param[in] group indices representing the current point in the execution space
      */
     void operator()(::sycl::group<2> group) const {
-        // allocate shared memory
-        real_type A_cache_[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-        real_type B_cache_[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-
-        // calculate the indices used in the current work-item
-        ::sycl::private_memory<std::size_t, 2> i{ group };
-        ::sycl::private_memory<std::size_t, 2> i_linear{ group };
-        ::sycl::private_memory<std::size_t, 2> j{ group };
-        ::sycl::private_memory<std::size_t, 2> j_linear{ group };
+        // create two local memory arrays used for caching
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> A_cache{};
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> B_cache{};
 
-        ::sycl::private_memory<real_type[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE], 2> temp{ group };
+        // create a private memory array used for internal caching
+        ::sycl::private_memory<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, 2> temp{ group };
 
-        // initialize private and local variables
+        // initialize private temp matrix to zero
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            const std::size_t threadIdx_x = idx.get_local_id(0);       // current thread in block x-dimension
-            const std::size_t threadIdx_y = idx.get_local_id(1);       // current thread in block y-dimension
-            const std::size_t blockDim_x = idx.get_local_range(0);     // number of threads in block x-dimension
-            const std::size_t blockDim_y = idx.get_local_range(1);     // number of threads in block y-dimension
-            const std::size_t blockIdx_x = group[0] + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-            const std::size_t blockIdx_y = group[1] + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-            const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-            // indices and diagonal condition
-            i(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-            i_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-            j(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-            j_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-
-            // initialize private temp matrix to zero
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
                     temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
@@ -263,42 +270,67 @@ class device_kernel_symm_mirror {
             }
         });
 
-        // iterate over the remaining features using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < device_specific_num_rows_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
-            // load data into shared memory
+        // iterate over the remaining values using blocking to be able to cache them for faster memory accesses
+        for (std::size_t dim_block = 0; dim_block < device_num_rows_; dim_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
+            // load data into local memory
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                // cast values to 32-bit unsigned int values to prevent implicit conversions
                 const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                 const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                const std::size_t threadIdx_x = idx.get_local_id(0);
+                // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+                const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+                const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+                const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+                const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+                const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
-                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_i = i_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                    const auto global_j = j_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                const auto i_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_rhs
+                const auto j_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_mirror_rows
 
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                    A_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - (dim + threadIdx_x - std::size_t{ 1 }) * (dim + threadIdx_x) / std::size_t{ 2 } + device_specific_num_rows_ - (dim + threadIdx_x) + global_j];
-                    A_cache_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz - std::size_t{ 1 }) * (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) / std::size_t{ 2 } + device_specific_num_rows_ - (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) + global_j];
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                    B_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
-                    B_cache_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                    // store the values in the local memory
+                    A_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim_block + threadIdx_x) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - (dim_block + threadIdx_x - std::size_t{ 1 }) * (dim_block + threadIdx_x) / std::size_t{ 2 } + device_num_rows_ - (dim_block + threadIdx_x) + global_j_idx_linear];  // SoA, upper triangular matrix only
+                    B_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(device_row_offset_ + dim_block + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx_linear];                                                                                                                                                // SoA
                 }
             });
 
             // implicit barrier
 
-            // perform the feature reduction calculation
+            // perform the dot product calculation
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                // cast values to 32-bit unsigned int values to prevent implicit conversions
                 const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                 const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the dim is the fastest moving index
                     for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                         for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            temp(idx)[internal_i][internal_j] += A_cache_[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache_[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                            real_type sum{ 0.0 };
+                            for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                                sum += A_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                            }
+                            temp(idx)[internal_i][internal_j] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the dim is the slowest moving index
+                    for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                temp(idx)[internal_i][internal_j] += A_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                            }
                         }
                     }
                 }
@@ -309,17 +341,31 @@ class device_kernel_symm_mirror {
 
         // apply the (remaining) BLAS operation and update C
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+            // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+            constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+            constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+            const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+            const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+            const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+            const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+            const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+            const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+            // calculate the indices to access the global data
+            const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+            const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
 
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const auto global_i = i(idx) + static_cast<std::size_t>(internal_i);
-                    const auto partial_global_j = j(idx) + static_cast<std::size_t>(internal_j);
-                    const auto global_j = row_offset_ + device_specific_num_rows_ + j(idx) + static_cast<std::size_t>(internal_j);
-
-                    // be sure to not perform out of bounds accesses
-                    if (global_i < num_rhs_ && partial_global_j < num_mirror_rows_) {
-                        C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i] = alpha_ * temp(idx)[internal_i][internal_j] + beta_ * C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto partial_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset_ + device_num_rows_ + partial_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses
+                    if (global_i_idx < num_rhs_ && partial_global_j_idx < num_mirror_rows_) {
+                        C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx] = alpha_ * temp(idx)[internal_i][internal_j] + beta_ * C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
                     }
                 }
             }
@@ -331,8 +377,8 @@ class device_kernel_symm_mirror {
     const std::size_t num_rows_;
     const std::size_t num_rhs_;
     const std::size_t num_mirror_rows_;
-    const std::size_t device_specific_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_num_rows_;
+    const std::size_t device_row_offset_;
     const real_type alpha_;
     const real_type *A_;
     const real_type *B_;
@@ -349,6 +395,9 @@ class device_kernel_symm_mirror {
  */
 class device_kernel_inplace_matrix_add {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::hierarchical;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_cols the number of columns in both matrices
@@ -371,25 +420,27 @@ class device_kernel_inplace_matrix_add {
     void operator()(::sycl::group<2> group) const {
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
             // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-            const std::size_t threadIdx_x = idx.get_local_id(0);
-            const std::size_t threadIdx_y = idx.get_local_id(1);
-            const std::size_t blockDim_x = idx.get_local_range(0);
-            const std::size_t blockDim_y = idx.get_local_range(1);
-            const std::size_t blockIdx_x = group[0] + grid_x_offset_;
-            const std::size_t blockIdx_y = group[1] + grid_y_offset_;
-            const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-            const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-            // indices
-            const std::size_t i = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-            const std::size_t j = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-
-            for (std::size_t internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE_uz; ++internal_i) {
-                for (std::size_t internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE_uz; ++internal_j) {
-                    const std::size_t global_i = i + internal_i;
-                    const std::size_t global_j = j + internal_j;
-
-                    lhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j] += rhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j];
+            constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+            constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+            const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+            const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+            const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+            const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+            const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+            const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+            // calculate the indices used in the current work-item
+            const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+            const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+
+            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                    // calculate the indices to access the global data
+                    const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                    lhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx] += rhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx];  // SoA
                 }
             }
         });
@@ -411,6 +462,9 @@ class device_kernel_inplace_matrix_add {
  */
 class device_kernel_inplace_matrix_scale {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::hierarchical;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_cols the number of columns in the matrix
@@ -433,25 +487,27 @@ class device_kernel_inplace_matrix_scale {
     void operator()(::sycl::group<2> group) const {
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
             // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-            const std::size_t threadIdx_x = idx.get_local_id(0);
-            const std::size_t threadIdx_y = idx.get_local_id(1);
-            const std::size_t blockDim_x = idx.get_local_range(0);
-            const std::size_t blockDim_y = idx.get_local_range(1);
-            const std::size_t blockIdx_x = group[0] + grid_x_offset_;
-            const std::size_t blockIdx_y = group[1] + grid_y_offset_;
-            const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-            const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-            // indices
-            const std::size_t i = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-            const std::size_t j = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-
-            for (std::size_t internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE_uz; ++internal_i) {
-                for (std::size_t internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE_uz; ++internal_j) {
-                    const std::size_t global_i = i + internal_i;
-                    const std::size_t global_j = j + internal_j;
-
-                    lhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j] *= scale_;
+            constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+            constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+            const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+            const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+            const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+            const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+            const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+            const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+            // calculate the indices used in the current work-item
+            const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+            const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+
+            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                    // calculate the indices to access the global data
+                    const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                    lhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx] *= scale_;  // SoA
                 }
             }
         });
@@ -469,4 +525,4 @@ class device_kernel_inplace_matrix_scale {
 
 }  // namespace plssvm::sycl::detail::hierarchical
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_HIERARCHICAL_BLAS_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_HIERARCHICAL_BLAS_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_explicit/hierarchical/kernel_matrix_assembly.hpp b/include/plssvm/backends/SYCL/kernel/cg_explicit/hierarchical/kernel_matrix_assembly.hpp
index b09fef0f8..71d7ffbba 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_explicit/hierarchical/kernel_matrix_assembly.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_explicit/hierarchical/kernel_matrix_assembly.hpp
@@ -9,16 +9,19 @@
  * @brief Functions for explicitly assembling the kernel matrix using the SYCL backend and the hierarchical data parallel kernels.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::group, sycl::private_memory, sycl::h_item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
@@ -27,19 +30,23 @@ namespace plssvm::sycl::detail::hierarchical {
 /**
  * @brief Create the explicit kernel matrix using the @p kernel_function.
  * @details Uses SYCL's hierarchical data parallel kernels.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function; stored in a `std::tuple`
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_assembly {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::hierarchical;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[out] kernel_matrix_d the calculated kernel matrix
-     * @param[in] data_d the data points to calculate the kernel matrix from
+     * @param[out] kernel_matrix the calculated kernel matrix
+     * @param[in] data the data points to calculate the kernel matrix from
      * @param[in] num_rows the number of data points
      * @param[in] device_num_rows the number of rows the current device is responsible for
-     * @param[in] row_offset the first row in @p data_d the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data_d the current device is responsible for
      * @param[in] num_features the number of features per data point
      * @param[in] q the vector used in the dimensional reduction
      * @param[in] QA_cost the scalar used in the dimensional reduction
@@ -48,19 +55,19 @@ class device_kernel_assembly {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_assembly(real_type *kernel_matrix_d, const real_type *data_d, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t row_offset, const std::size_t num_features, const real_type *q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
-        kernel_matrix_d_{ kernel_matrix_d },
-        data_d_{ data_d },
+    device_kernel_assembly(real_type *kernel_matrix, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type *q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+        kernel_matrix_{ kernel_matrix },
+        data_{ data },
         num_rows_{ num_rows },
         device_num_rows_{ device_num_rows },
-        row_offset_{ row_offset },
+        device_row_offset_{ device_row_offset },
         num_features_{ num_features },
         q_{ q },
         QA_cost_{ QA_cost },
         cost_{ cost },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } {
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } {
     }
 
     /**
@@ -68,67 +75,56 @@ class device_kernel_assembly {
      * @param[in] group indices representing the current point in the execution space
      */
     void operator()(::sycl::group<2> group) const {
-        // allocate shared memory
-        real_type data_cache_i[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-        real_type data_cache_j[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-
-        // calculate the indices used in the current work-item
-        ::sycl::private_memory<std::size_t, 2> i{ group };
-        ::sycl::private_memory<std::size_t, 2> i_linear{ group };
-        ::sycl::private_memory<std::size_t, 2> j{ group };
-        ::sycl::private_memory<std::size_t, 2> j_linear{ group };
-
-        ::sycl::private_memory<real_type[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE], 2> temp{ group };
-
-        // initialize private and local variables
-        group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            const std::size_t threadIdx_x = idx.get_local_id(0);       // current thread in block x-dimension
-            const std::size_t threadIdx_y = idx.get_local_id(1);       // current thread in block y-dimension
-            const std::size_t blockDim_x = idx.get_local_range(0);     // number of threads in block x-dimension
-            const std::size_t blockDim_y = idx.get_local_range(1);     // number of threads in block y-dimension
-            const std::size_t blockIdx_x = group[0] + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-            const std::size_t blockIdx_y = group[1] + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-            const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-            // indices
-            i(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-            i_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-            j(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-            j_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+        // create two local memory arrays used for caching
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> data_i_cache{};
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> data_j_cache{};
+
+        // create a private memory array used for internal caching
+        ::sycl::private_memory<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, 2> temp{ group };
 
+        // only calculate the upper triangular matrix -> can't use get_local_id() since all work-items in a work-group must progress further
+        if (group[1] >= group[0]) {
             // initialize private temp matrix to zero
-            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
+            group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
+                    }
                 }
-            }
-        });
-
-        // implicit group barrier
+            });
 
-        // exploit symmetry
-        if (group[1] >= group[0]) {
-            for (std::size_t dim = 0; dim < num_features_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
-                // load data into shared memory
+            // iterate over all features using blocking to be able to cache them for faster memory accesses
+            for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
+                // load data into local memory
                 group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                    // cast values to 32-bit unsigned int values to prevent implicit conversions
                     const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                     const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                    const std::size_t threadIdx_x = idx.get_local_id(0);
+                    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                    const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                    const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+                    const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+                    const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+                    const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+                    const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+                    const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+                    // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+                    const auto i_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_rows - device_row_offset
+                    const auto j_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // device_num_rows
 
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_i = row_offset_ + i_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                        const auto global_j = row_offset_ + j_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                        // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                        data_cache_i[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                        data_cache_i[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                        data_cache_j[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
-                        data_cache_j[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_i_idx_linear = device_row_offset_ + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                        const auto global_j_idx_linear = device_row_offset_ + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                        // store the values in the local memory
+                        data_i_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                        data_j_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
                     }
                 });
 
@@ -136,14 +132,30 @@ class device_kernel_assembly {
 
                 // perform the feature reduction calculation
                 group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                    // cast values to 32-bit unsigned int values to prevent implicit conversions
                     const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                     const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                    for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                    if constexpr (target == target_platform::cpu) {
+                        // perform the feature reduction calculation, the feature is the fastest moving index
                         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                temp(idx)[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
-                                                                                                             data_cache_j[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                real_type sum{ 0.0 };
+                                for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                    sum += detail::feature_reduce<kernel_function>(data_i_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                   data_j_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                }
+                                temp(idx)[internal_i][internal_j] += sum;
+                            }
+                        }
+                    } else {
+                        // perform the feature reduction calculation, the feature is the slowest moving index
+                        for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                    temp(idx)[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                                 data_j_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                }
                             }
                         }
                     }
@@ -154,26 +166,40 @@ class device_kernel_assembly {
 
             // apply the remaining part of the kernel function and store the value in the output kernel matrix
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-                const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+                const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+                const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+                const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+                const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+                const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+                // calculate the indices used in the current work-item
+                const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+                const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
                 for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                     for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        // calculate the indices to access the kernel matrix (the part stored on the current device)
-                        const auto device_global_i = i(idx) + static_cast<std::size_t>(internal_i);
-                        const auto global_i = row_offset_ + i(idx) + static_cast<std::size_t>(internal_i);
-                        const auto device_global_j = j(idx) + static_cast<std::size_t>(internal_j);
-                        const auto global_j = row_offset_ + j(idx) + static_cast<std::size_t>(internal_j);
-
-                        // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                        if (device_global_i < (num_rows_ - row_offset_) && device_global_j < device_num_rows_ && global_i >= global_j) {
+                        // calculate the indices to access the global data and the data with respect to the current device
+                        const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                        const auto global_i_idx = device_row_offset_ + device_global_i_idx;
+                        const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                        const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                        // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                        if (device_global_i_idx < (num_rows_ - device_row_offset_) && device_global_j_idx < device_num_rows_ && global_i_idx >= global_j_idx) {
                             real_type temp_ij = temp(idx)[internal_i][internal_j];
-                            temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i] - q_[global_j];
+                            // apply the final kernel function
+                            temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i_idx] - q_[global_j_idx];
                             // apply the cost on the diagonal
-                            if (global_i == global_j) {
+                            if (global_i_idx == global_j_idx) {
                                 temp_ij += cost_;
                             }
-                            // update the kernel matrix
-                            kernel_matrix_d_[device_global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - device_global_j * (device_global_j + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i] = temp_ij;
+                            // update the upper triangular kernel matrix
+                            kernel_matrix_[device_global_j_idx * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i_idx] = temp_ij;
                         }
                     }
                 }
@@ -183,11 +209,11 @@ class device_kernel_assembly {
 
   private:
     /// @cond Doxygen_suppress
-    real_type *kernel_matrix_d_;
-    const real_type *data_d_;
+    real_type *kernel_matrix_;
+    const real_type *data_;
     const std::size_t num_rows_;
     const std::size_t device_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_row_offset_;
     const std::size_t num_features_;
     const real_type *q_;
     const real_type QA_cost_;
@@ -200,4 +226,4 @@ class device_kernel_assembly {
 
 }  // namespace plssvm::sycl::detail::hierarchical
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_explicit/scoped/blas.hpp b/include/plssvm/backends/SYCL/kernel/cg_explicit/scoped/blas.hpp
index 9e8500d73..81fe53a12 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_explicit/scoped/blas.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_explicit/scoped/blas.hpp
@@ -9,11 +9,13 @@
  * @brief Functions for explicitly performing a BLAS GEMM like matrix-matrix multiplication using the SYCL backend and AdaptiveCpp's scoped parallelism.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_SCOPED_BLAS_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_SCOPED_BLAS_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_SCOPED_BLAS_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_SCOPED_BLAS_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/constants.hpp"                            // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::memory_environment, sycl::require_local_mem, sycl::require_private_mem, sycl::distribute_items_and_wait, sycl::s_item
 
@@ -24,15 +26,20 @@ namespace plssvm::sycl::detail::scoped {
 /**
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @details Uses AdaptiveCpp's scoped parallelism.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_symm {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::scoped;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_rows the number of rows in @p A and @p C
      * @param[in] num_rhs the number of columns in @p B and @p C
-     * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
-     * @param[in] row_offset the first row this device is responsible for
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
      * @param[in] alpha the scalar alpha value
      * @param[in] A the matrix @p A
      * @param[in] B the matrix @p B
@@ -41,11 +48,11 @@ class device_kernel_symm {
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+    device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
         num_rows_{ num_rows },
         num_rhs_{ num_rhs },
-        device_specific_num_rows_{ device_specific_num_rows },
-        row_offset_{ row_offset },
+        device_num_rows_{ device_num_rows },
+        device_row_offset_{ device_row_offset },
         alpha_{ alpha },
         A_{ A },
         B_{ B },
@@ -62,92 +69,121 @@ class device_kernel_symm {
     template <typename T>
     void operator()(T group) const {
         ::sycl::memory_environment(group,
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE>>({}),
-                                   [&](auto &A_cache, auto &B_cache, auto &i, auto &i_linear, auto &j, auto &j_linear, auto &temp) {
-                                       // initialize private and local variables
+                                   // the indices used in the current work-item
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // A_cache
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // B_cache
+
+                                   // create two local memory arrays used for caching
+                                   ::sycl::require_private_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>>(),
+                                   [&](auto &A_cache, auto &B_cache, auto &temp) {
+                                       // initialize private temp matrix to zero
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const std::size_t threadIdx_x = idx.get_local_id(group, 0);       // current thread in block x-dimension
-                                           const std::size_t threadIdx_y = idx.get_local_id(group, 1);       // current thread in block y-dimension
-                                           const std::size_t blockDim_x = group.get_logical_local_range(0);  // number of threads in block x-dimension
-                                           const std::size_t blockDim_y = group.get_logical_local_range(1);  // number of threads in block y-dimension
-                                           const std::size_t blockIdx_x = group[0] + grid_x_offset_;         // current block in grid x-dimension + offsets if the grid size would be too large
-                                           const std::size_t blockIdx_y = group[1] + grid_y_offset_;         // current block in grid y-dimension + offsets if the grid size would be too large
-
-                                           const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-                                           // indices
-                                           i(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-                                           i_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-                                           j(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-                                           j_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+                                           // initialize private temp matrix to zero
+                                           for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                               for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                   temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
+                                               }
+                                           }
                                        });
 
-                                       for (std::size_t dim = 0; dim < (num_rows_ - row_offset_); dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
-                                           // load data into shared memory
+                                       // iterate over all values using blocking to be able to cache them for faster memory accesses
+                                       for (std::size_t dim_block = 0; dim_block < (num_rows_ - device_row_offset_); dim_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
+                                           // load data into local memory
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                               // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                               const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                               // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                               constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                                               constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                               constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                                               const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                               const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                               const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                               const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                               const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                               const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                               const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                               const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
+
+                                               // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                               const auto i_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_rhs
+                                               const auto j_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // device_num_rows
 
                                                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                   const auto global_i = i_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                                                   const auto global_j = j_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                   // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                                   const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                   const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
+                                                   // store the values in the local memory
                                                    // determine on which side of the diagonal we are located
-                                                   if (dim + threadIdx_x < global_j) {
-                                                       A_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + global_j - (dim + threadIdx_x) * (dim + threadIdx_x + std::size_t{ 1 }) / std::size_t{ 2 }];
+                                                   if (dim_block + threadIdx_x < global_j_idx_linear) {
+                                                       A_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim_block + threadIdx_x) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + global_j_idx_linear - (dim_block + threadIdx_x) * (dim_block + threadIdx_x + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
                                                    } else {
-                                                       A_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + dim + threadIdx_x - global_j * (global_j + std::size_t{ 1 }) / std::size_t{ 2 }];
-                                                   }
-                                                   // determine on which side of the diagonal we are located
-                                                   if (dim + threadIdx_x + THREAD_BLOCK_SIZE < global_j) {
-                                                       A_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + global_j - (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz + std::size_t{ 1 }) / std::size_t{ 2 }];
-                                                   } else {
-                                                       A_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz - global_j * (global_j + std::size_t{ 1 }) / std::size_t{ 2 }];
+                                                       A_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[global_j_idx_linear * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + dim_block + threadIdx_x - global_j_idx_linear * (global_j_idx_linear + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
                                                    }
 
-                                                   B_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
-                                                   B_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                                                   B_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim_block + device_row_offset_ + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
                                                }
                                            });
 
-                                           // perform calculations
+                                           // perform the dot product calculation
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                               // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                               for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                                               if constexpr (target == target_platform::cpu) {
+                                                   // perform the dot product calculation, the dim is the fastest moving index
                                                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                           temp(idx)[internal_i][internal_j] += A_cache[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                                                           real_type sum{ 0.0 };
+                                                           for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                                                               sum += A_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                                                           }
+                                                           temp(idx)[internal_i][internal_j] += sum;
+                                                       }
+                                                   }
+                                               } else {
+                                                   // perform the dot product calculation, the dim is the slowest moving index
+                                                   for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                                                       for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                                           for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                               temp(idx)[internal_i][internal_j] += A_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                                                           }
                                                        }
                                                    }
                                                }
                                            });
                                        }
 
+                                       // apply the (partial) BLAS operation and update C
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                           // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                           constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                           constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                                           const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                           const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                           const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                           const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                           const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                           const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
+
+                                           // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                           const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+                                           const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
                                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                   const auto global_i = i(idx) + static_cast<std::size_t>(internal_i);
-                                                   const auto device_global_j = j(idx) + static_cast<std::size_t>(internal_j);
-                                                   const auto global_j = row_offset_ + j(idx) + static_cast<std::size_t>(internal_j);
-
-                                                   // be sure to not perform out of bounds accesses
-                                                   if (global_i < num_rhs_ && device_global_j < device_specific_num_rows_) {
-                                                       C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i] = alpha_ * temp(idx)[internal_i][internal_j] + beta_ * C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                                                   // calculate the indices to access the global data and the data with respect to the current device
+                                                   const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                                                   const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                                                   const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                                                   // be sure to not perform out-of-bounds accesses
+                                                   if (global_i_idx < num_rhs_ && device_global_j_idx < device_num_rows_) {
+                                                       C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx] = alpha_ * temp(idx)[internal_i][internal_j] + beta_ * C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
                                                    }
                                                }
                                            }
@@ -159,8 +195,8 @@ class device_kernel_symm {
     /// @cond Doxygen_suppress
     const std::size_t num_rows_;
     const std::size_t num_rhs_;
-    const std::size_t device_specific_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_num_rows_;
+    const std::size_t device_row_offset_;
     const real_type alpha_;
     const real_type *A_;
     const real_type *B_;
@@ -175,16 +211,21 @@ class device_kernel_symm {
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @details In a multi-GPU setting, this function is responsible for mirroring down the columns this device is responsible for!
  *          Uses AdaptiveCpp's scoped parallelism.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_symm_mirror {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::scoped;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_rows the number of rows in @p A and @p C
      * @param[in] num_rhs the number of columns in @p B and @p C
      * @param[in] num_mirror_rows the number of rows to mirror down
-     * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
-     * @param[in] row_offset the first row this device is responsible for
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
      * @param[in] alpha the scalar alpha value
      * @param[in] A the matrix @p A
      * @param[in] B the matrix @p B
@@ -193,12 +234,12 @@ class device_kernel_symm_mirror {
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+    device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
         num_rows_{ num_rows },
         num_rhs_{ num_rhs },
         num_mirror_rows_{ num_mirror_rows },
-        device_specific_num_rows_{ device_specific_num_rows },
-        row_offset_{ row_offset },
+        device_num_rows_{ device_num_rows },
+        device_row_offset_{ device_row_offset },
         alpha_{ alpha },
         A_{ A },
         B_{ B },
@@ -215,83 +256,115 @@ class device_kernel_symm_mirror {
     template <typename T>
     void operator()(T group) const {
         ::sycl::memory_environment(group,
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE>>({}),
-                                   [&](auto &A_cache, auto &B_cache, auto &i, auto &i_linear, auto &j, auto &j_linear, auto &temp) {
-                                       // initialize private and local variables
+                                   // the indices used in the current work-item
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // A_cache
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // B_cache
+
+                                   // create a private memory array used for internal caching
+                                   ::sycl::require_private_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>>(),
+                                   [&](auto &A_cache, auto &B_cache, auto &temp) {
+                                       // initialize private temp matrix to zero
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const std::size_t threadIdx_x = idx.get_local_id(group, 0);       // current thread in block x-dimension
-                                           const std::size_t threadIdx_y = idx.get_local_id(group, 1);       // current thread in block y-dimension
-                                           const std::size_t blockDim_x = group.get_logical_local_range(0);  // number of threads in block x-dimension
-                                           const std::size_t blockDim_y = group.get_logical_local_range(1);  // number of threads in block y-dimension
-                                           const std::size_t blockIdx_x = group[0] + grid_x_offset_;         // current block in grid x-dimension + offsets if the grid size would be too large
-                                           const std::size_t blockIdx_y = group[1] + grid_y_offset_;         // current block in grid y-dimension + offsets if the grid size would be too large
-
-                                           const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-                                           // indices
-                                           i(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-                                           i_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-                                           j(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-                                           j_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+                                           // initialize private temp matrix to zero
+                                           for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                               for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                   temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
+                                               }
+                                           }
                                        });
 
-                                       for (std::size_t dim = 0; dim < device_specific_num_rows_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
-                                           // load data into shared memory
+                                       // iterate over the remaining values using blocking to be able to cache them for faster memory accesses
+                                       for (std::size_t dim_block = 0; dim_block < device_num_rows_; dim_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
+                                           // load data into local memory
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                               // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                               const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                               // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                               constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                               constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                                               constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                                               const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                               const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                               const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                               const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                               const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                               const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                               const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                               const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
 
-                                               for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                   const auto global_i = i_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                                                   const auto global_j = j_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                               // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                               const auto i_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_rhs
+                                               const auto j_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_mirror_rows
 
-                                                   // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                                                   A_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - (dim + threadIdx_x - std::size_t{ 1 }) * (dim + threadIdx_x) / std::size_t{ 2 } + device_specific_num_rows_ - (dim + threadIdx_x) + global_j];
-                                                   A_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz - std::size_t{ 1 }) * (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) / std::size_t{ 2 } + device_specific_num_rows_ - (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) + global_j];
+                                               for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                                                   // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                                   const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                   const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                                                   B_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
-                                                   B_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                                                   // store the values in the local memory
+                                                   A_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim_block + threadIdx_x) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - (dim_block + threadIdx_x - std::size_t{ 1 }) * (dim_block + threadIdx_x) / std::size_t{ 2 } + device_num_rows_ - (dim_block + threadIdx_x) + global_j_idx_linear];  // SoA, upper triangular matrix only
+                                                   B_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(device_row_offset_ + dim_block + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx_linear];                                                                                                                                                // SoA
                                                }
                                            });
 
-                                           // perform calculations
+                                           // perform the dot product calculation
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                               // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                               for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                                               if constexpr (target == target_platform::cpu) {
+                                                   // perform the dot product calculation, the dim is the fastest moving index
                                                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                           temp(idx)[internal_i][internal_j] += A_cache[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                                                           real_type sum{ 0.0 };
+                                                           for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                                                               sum += A_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                                                           }
+                                                           temp(idx)[internal_i][internal_j] += sum;
+                                                       }
+                                                   }
+                                               } else {
+                                                   // perform the dot product calculation, the dim is the slowest moving index
+                                                   for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                                                       for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                                           for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                               temp(idx)[internal_i][internal_j] += A_cache[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                                                           }
                                                        }
                                                    }
                                                }
                                            });
                                        }
 
+                                       // apply the (remaining) BLAS operation and update C
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                           // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                           constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                           constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                                           const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                           const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                           const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                           const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                           const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                           const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
+
+                                           // calculate the indices to access the global data
+                                           const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+                                           const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
 
                                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                   const auto global_i = i(idx) + static_cast<std::size_t>(internal_i);
-                                                   const auto partial_global_j = j(idx) + static_cast<std::size_t>(internal_j);
-                                                   const auto global_j = row_offset_ + device_specific_num_rows_ + j(idx) + static_cast<std::size_t>(internal_j);
-
-                                                   // be sure to not perform out of bounds accesses
-                                                   if (global_i < num_rhs_ && partial_global_j < num_mirror_rows_) {
-                                                       C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i] = alpha_ * temp(idx)[internal_i][internal_j] + beta_ * C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                                                   // calculate the indices to access the global data and the data with respect to the current device
+                                                   const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                                                   const auto partial_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                                                   const auto global_j_idx = device_row_offset_ + device_num_rows_ + partial_global_j_idx;
+
+                                                   // be sure to not perform out-of-bounds accesses
+                                                   if (global_i_idx < num_rhs_ && partial_global_j_idx < num_mirror_rows_) {
+                                                       C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx] = alpha_ * temp(idx)[internal_i][internal_j] + beta_ * C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
                                                    }
                                                }
                                            }
@@ -304,8 +377,8 @@ class device_kernel_symm_mirror {
     const std::size_t num_rows_;
     const std::size_t num_rhs_;
     const std::size_t num_mirror_rows_;
-    const std::size_t device_specific_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_num_rows_;
+    const std::size_t device_row_offset_;
     const real_type alpha_;
     const real_type *A_;
     const real_type *B_;
@@ -322,6 +395,9 @@ class device_kernel_symm_mirror {
  */
 class device_kernel_inplace_matrix_add {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::scoped;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_cols the number of columns in both matrices
@@ -346,28 +422,29 @@ class device_kernel_inplace_matrix_add {
     void operator()(T group) const {
         ::sycl::memory_environment(group,
                                    [&]() {
-                                       // scale
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
                                            // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-                                           const std::size_t threadIdx_x = idx.get_local_id(group, 0);
-                                           const std::size_t threadIdx_y = idx.get_local_id(group, 1);
-                                           const std::size_t blockDim_x = group.get_logical_local_range(0);
-                                           const std::size_t blockDim_y = group.get_logical_local_range(1);
-                                           const std::size_t blockIdx_x = group[0] + grid_x_offset_;
-                                           const std::size_t blockIdx_y = group[1] + grid_y_offset_;
-                                           const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-                                           const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-                                           // indices
-                                           const std::size_t i = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-                                           const std::size_t j = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
+                                           constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                           constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                                           const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                           const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                           const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                           const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                           const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                           const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
+
+                                           // calculate the indices used in the current work-item
+                                           const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+                                           const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
                                            for (std::size_t internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE_uz; ++internal_i) {
                                                for (std::size_t internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE_uz; ++internal_j) {
-                                                   const std::size_t global_i = i + internal_i;
-                                                   const std::size_t global_j = j + internal_j;
+                                                   // calculate the indices to access the global data
+                                                   const auto global_i_idx = i_idx + internal_i;
+                                                   const auto global_j_idx = j_idx + internal_j;
 
-                                                   lhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j] += rhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j];
+                                                   lhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx] += rhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx];  // SoA
                                                }
                                            }
                                        });
@@ -390,6 +467,9 @@ class device_kernel_inplace_matrix_add {
  */
 class device_kernel_inplace_matrix_scale {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::scoped;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_cols the number of columns in the matrix
@@ -414,28 +494,29 @@ class device_kernel_inplace_matrix_scale {
     void operator()(T group) const {
         ::sycl::memory_environment(group,
                                    [&]() {
-                                       // scale
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
                                            // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-                                           const std::size_t threadIdx_x = idx.get_local_id(group, 0);
-                                           const std::size_t threadIdx_y = idx.get_local_id(group, 1);
-                                           const std::size_t blockDim_x = group.get_logical_local_range(0);
-                                           const std::size_t blockDim_y = group.get_logical_local_range(1);
-                                           const std::size_t blockIdx_x = group[0] + grid_x_offset_;
-                                           const std::size_t blockIdx_y = group[1] + grid_y_offset_;
-                                           const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-                                           const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-                                           // indices
-                                           const std::size_t i = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-                                           const std::size_t j = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
+                                           constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                           constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                                           for (std::size_t internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE_uz; ++internal_i) {
-                                               for (std::size_t internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE_uz; ++internal_j) {
-                                                   const std::size_t global_i = i + internal_i;
-                                                   const std::size_t global_j = j + internal_j;
+                                           const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                           const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                           const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                           const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                           const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                           const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
+
+                                           // calculate the indices used in the current work-item
+                                           const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+                                           const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+
+                                           for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                               for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                   // calculate the indices to access the global data
+                                                   const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                                                   const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-                                                   lhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j] *= scale_;
+                                                   lhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx] *= scale_;  // SoA
                                                }
                                            }
                                        });
@@ -454,4 +535,4 @@ class device_kernel_inplace_matrix_scale {
 
 }  // namespace plssvm::sycl::detail::scoped
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_SCOPED_BLAS_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_SCOPED_BLAS_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_explicit/scoped/kernel_matrix_assembly.hpp b/include/plssvm/backends/SYCL/kernel/cg_explicit/scoped/kernel_matrix_assembly.hpp
index 4ed3764ce..114d7c5c3 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_explicit/scoped/kernel_matrix_assembly.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_explicit/scoped/kernel_matrix_assembly.hpp
@@ -9,16 +9,19 @@
  * @brief Functions for explicitly assembling the kernel matrix using the SYCL backend and AdaptiveCpp's scoped parallelism.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::memory_environment, sycl::require_local_mem, sycl::require_private_mem, sycl::distribute_items_and_wait, sycl::s_item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
@@ -27,19 +30,23 @@ namespace plssvm::sycl::detail::scoped {
 /**
  * @brief Create the explicit kernel matrix using the @p kernel_function.
  * @details Uses AdaptiveCpp's scoped parallelism.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function; stored in a `std::tuple`
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_assembly {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::scoped;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[out] kernel_matrix_d the calculated kernel matrix
-     * @param[in] data_d the data points to calculate the kernel matrix from
+     * @param[out] kernel_matrix the calculated kernel matrix
+     * @param[in] data the data points to calculate the kernel matrix from
      * @param[in] num_rows the number of data points
      * @param[in] device_num_rows the number of rows the current device is responsible for
-     * @param[in] row_offset the first row in @p data_d the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data_d the current device is responsible for
      * @param[in] num_features the number of features per data point
      * @param[in] q the vector used in the dimensional reduction
      * @param[in] QA_cost the scalar used in the dimensional reduction
@@ -48,19 +55,19 @@ class device_kernel_assembly {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_assembly(real_type *kernel_matrix_d, const real_type *data_d, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t row_offset, const std::size_t num_features, const real_type *q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
-        kernel_matrix_d_{ kernel_matrix_d },
-        data_d_{ data_d },
+    device_kernel_assembly(real_type *kernel_matrix, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type *q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+        kernel_matrix_{ kernel_matrix },
+        data_{ data },
         num_rows_{ num_rows },
         device_num_rows_{ device_num_rows },
-        row_offset_{ row_offset },
+        device_row_offset_{ device_row_offset },
         num_features_{ num_features },
         q_{ q },
         QA_cost_{ QA_cost },
         cost_{ cost },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } {
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } {
     }
 
     /**
@@ -71,94 +78,127 @@ class device_kernel_assembly {
     template <typename T>
     void operator()(T group) const {
         ::sycl::memory_environment(group,
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE>>({}),
-                                   [&](auto &data_cache_i, auto &data_cache_j, auto &i, auto &i_linear, auto &j, auto &j_linear, auto &temp) {
-                                       // initialize private and local variables
-                                       ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const std::size_t threadIdx_x = idx.get_local_id(group, 0);       // current thread in block x-dimension
-                                           const std::size_t threadIdx_y = idx.get_local_id(group, 1);       // current thread in block y-dimension
-                                           const std::size_t blockDim_x = group.get_logical_local_range(0);  // number of threads in block x-dimension
-                                           const std::size_t blockDim_y = group.get_logical_local_range(1);  // number of threads in block y-dimension
-                                           const std::size_t blockIdx_x = group[0] + grid_x_offset_;         // current block in grid x-dimension + offsets if the grid size would be too large
-                                           const std::size_t blockIdx_y = group[1] + grid_y_offset_;         // current block in grid y-dimension + offsets if the grid size would be too large
-
-                                           const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-                                           // indices
-                                           i(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-                                           i_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-                                           j(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-                                           j_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-                                       });
-
-                                       // exploit symmetry
+                                   // create two local memory arrays used for caching
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // data_i_cache
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // data_j_cache
+
+                                   // create a private memory array used for internal caching
+                                   ::sycl::require_private_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>>(),  // temp
+                                   [&](auto &data_i_cache, auto &data_j_cache, auto &temp) {
+                                       // only calculate the upper triangular matrix -> can't use get_local_id() since all work-items in a work-group must progress further
                                        if (group[1] >= group[0]) {
-                                           for (std::size_t dim = 0; dim < num_features_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
-                                               // load data into shared memory
+                                           // initialize private temp matrix to zero
+                                           ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                               for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                                   for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                       temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
+                                                   }
+                                               }
+                                           });
+
+                                           // iterate over all features using blocking to be able to cache them for faster memory accesses
+                                           for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
+                                               // load data into local memory
                                                ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                   // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                    const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                    const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                                   const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                                   // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                                   constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                                   constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                                                   constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                                                   const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                                   const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                                   const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                                   const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                                   const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                                   const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
 
-                                                   const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                                   const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                                   // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+                                                   const auto i_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_rows - device_row_offset
+                                                   const auto j_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // device_num_rows
 
                                                    for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                       const auto global_i = row_offset_ + i_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                                                       const auto global_j = row_offset_ + j_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                                                       // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                                                       data_cache_i[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                                                       data_cache_i[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                                                       data_cache_j[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
-                                                       data_cache_j[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
+                                                       // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                                       const auto global_i_idx_linear = device_row_offset_ + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                       const auto global_j_idx_linear = device_row_offset_ + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                                                       // store the values in the local memory
+                                                       data_i_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                                                       data_j_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
                                                    }
                                                });
 
-                                               // perform calculations
+                                               // perform the feature reduction calculation
                                                ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                   // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                    const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                    const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                                   for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                                                   if constexpr (target == target_platform::cpu) {
+                                                       // perform the feature reduction calculation, the feature is the fastest moving index
                                                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                               temp(idx)[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
-                                                                                                                                            data_cache_j[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                                               real_type sum{ 0.0 };
+                                                               for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                                                   sum += detail::feature_reduce<kernel_function>(data_i_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                                  data_j_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                                               }
+                                                               temp(idx)[internal_i][internal_j] += sum;
+                                                           }
+                                                       }
+                                                   } else {
+                                                       // perform the feature reduction calculation, the feature is the slowest moving index
+                                                       for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                                           for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                                               for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                                   temp(idx)[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                                                                data_j_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                                               }
                                                            }
                                                        }
                                                    }
                                                });
                                            }
 
+                                           // apply the remaining part of the kernel function and store the value in the output kernel matrix
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                               const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                               // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                               constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                               constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                                               const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                               const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                               const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                               const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                               const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                               const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
+
+                                               // calculate the indices used in the current work-item
+                                               const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+                                               const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
                                                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                       // calculate the indices to access the kernel matrix (the part stored on the current device)
-                                                       const auto device_global_i = i(idx) + static_cast<std::size_t>(internal_i);
-                                                       const auto global_i = row_offset_ + i(idx) + static_cast<std::size_t>(internal_i);
-                                                       const auto device_global_j = j(idx) + static_cast<std::size_t>(internal_j);
-                                                       const auto global_j = row_offset_ + j(idx) + static_cast<std::size_t>(internal_j);
-
-                                                       // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                                                       if (device_global_i < (num_rows_ - row_offset_) && device_global_j < device_num_rows_ && global_i >= global_j) {
+                                                       // calculate the indices to access the global data and the data with respect to the current device
+                                                       const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                                                       const auto global_i_idx = device_row_offset_ + device_global_i_idx;
+                                                       const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                                                       const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                                                       // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                                                       if (device_global_i_idx < (num_rows_ - device_row_offset_) && device_global_j_idx < device_num_rows_ && global_i_idx >= global_j_idx) {
                                                            real_type temp_ij = temp(idx)[internal_i][internal_j];
-                                                           temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i] - q_[global_j];
+                                                           // apply the final kernel function
+                                                           temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i_idx] - q_[global_j_idx];
                                                            // apply the cost on the diagonal
-                                                           if (global_i == global_j) {
+                                                           if (global_i_idx == global_j_idx) {
                                                                temp_ij += cost_;
                                                            }
-                                                           // update the kernel matrix
-                                                           kernel_matrix_d_[device_global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - device_global_j * (device_global_j + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i] = temp_ij;
+                                                           // update the upper triangular kernel matrix
+                                                           kernel_matrix_[device_global_j_idx * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i_idx] = temp_ij;
                                                        }
                                                    }
                                                }
@@ -169,11 +209,11 @@ class device_kernel_assembly {
 
   private:
     /// @cond Doxygen_suppress
-    real_type *kernel_matrix_d_;
-    const real_type *data_d_;
+    real_type *kernel_matrix_;
+    const real_type *data_;
     const std::size_t num_rows_;
     const std::size_t device_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_row_offset_;
     const std::size_t num_features_;
     const real_type *q_;
     const real_type QA_cost_;
@@ -186,4 +226,4 @@ class device_kernel_assembly {
 
 }  // namespace plssvm::sycl::detail::scoped
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_explicit/work_group/blas.hpp b/include/plssvm/backends/SYCL/kernel/cg_explicit/work_group/blas.hpp
index ae07f7ec6..5f3caae29 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_explicit/work_group/blas.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_explicit/work_group/blas.hpp
@@ -9,14 +9,17 @@
  * @brief Functions for explicitly performing a BLAS GEMM like matrix-matrix multiplication using the SYCL backend and the work-group data parallel kernels.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_WORK_GROUP_BLAS_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_WORK_GROUP_BLAS_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_WORK_GROUP_BLAS_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_WORK_GROUP_BLAS_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/constants.hpp"                            // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::handler, sycl::range, sycl::nd_item, sycl::local_accessor
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 
 namespace plssvm::sycl::detail::work_group {
@@ -24,16 +27,21 @@ namespace plssvm::sycl::detail::work_group {
 /**
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @details Uses SYCL's work-group data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_symm {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::work_group;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] cgh the SYCL handler used to allocate the local memory
      * @param[in] num_rows the number of rows in @p A and @p C
      * @param[in] num_rhs the number of columns in @p B and @p C
-     * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
-     * @param[in] row_offset the first row this device is responsible for
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
      * @param[in] alpha the scalar alpha value
      * @param[in] A the matrix @p A
      * @param[in] B the matrix @p B
@@ -42,13 +50,13 @@ class device_kernel_symm {
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_symm(::sycl::handler &cgh, const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
-        A_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
-        B_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+    device_kernel_symm(::sycl::handler &cgh, const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+        A_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+        B_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
         num_rows_{ num_rows },
         num_rhs_{ num_rhs },
-        device_specific_num_rows_{ device_specific_num_rows },
-        row_offset_{ row_offset },
+        device_num_rows_{ device_num_rows },
+        device_row_offset_{ device_row_offset },
         alpha_{ alpha },
         A_{ A },
         B_{ B },
@@ -67,72 +75,85 @@ class device_kernel_symm {
         const auto local_id_1 = static_cast<unsigned>(nd_idx.get_local_id(1));
 
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const std::size_t threadIdx_x = nd_idx.get_local_id(0);               // current thread in block x-dimension
-        const std::size_t threadIdx_y = nd_idx.get_local_id(1);               // current thread in block y-dimension
-        const std::size_t blockDim_x = nd_idx.get_local_range(0);             // number of threads in block x-dimension
-        const std::size_t blockDim_y = nd_idx.get_local_range(1);             // number of threads in block y-dimension
-        const std::size_t blockIdx_x = nd_idx.get_group(0) + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const std::size_t blockIdx_y = nd_idx.get_group(1) + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_uz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-        // calculate the indices used in the current work-item
-        const auto i = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-        const auto i_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-        const auto j = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-        const auto j_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+        const auto threadIdx_x = static_cast<std::size_t>(nd_idx.get_local_id(0));               // current work-item in work-group x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(nd_idx.get_local_id(1));               // current work-item in work-group y-dimension
+        const auto blockDim_x = static_cast<std::size_t>(nd_idx.get_local_range(0));             // number of work-items in work-group x-dimension
+        const auto blockDim_y = static_cast<std::size_t>(nd_idx.get_local_range(1));             // number of work-items in work-group y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(nd_idx.get_group(0)) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+        const auto blockIdx_y = static_cast<std::size_t>(nd_idx.get_group(1)) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
         // create a work-item private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < (num_rows_ - row_offset_); dim += FEATURE_BLOCK_SIZE_uz) {
-            // load data into local memory
-            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_i = i_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                const auto global_j = j_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                // determine on which side of the diagonal we are located
-                if (dim + threadIdx_x < global_j) {
-                    A_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + global_j - (dim + threadIdx_x) * (dim + threadIdx_x + std::size_t{ 1 }) / std::size_t{ 2 }];
-                } else {
-                    A_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + dim + threadIdx_x - global_j * (global_j + std::size_t{ 1 }) / std::size_t{ 2 }];
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+        {
+            // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+            const auto i_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_rhs
+            const auto j_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // device_num_rows
+
+            // iterate over all values using blocking to be able to cache them for faster memory accesses
+            for (std::size_t dim_block = 0; dim_block < (num_rows_ - device_row_offset_); dim_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into local memory
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the local memory
+                    // determine on which side of the diagonal we are located
+                    if (dim_block + threadIdx_x < global_j_idx_linear) {
+                        A_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim_block + threadIdx_x) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + global_j_idx_linear - (dim_block + threadIdx_x) * (dim_block + threadIdx_x + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                    } else {
+                        A_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[global_j_idx_linear * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) + dim_block + threadIdx_x - global_j_idx_linear * (global_j_idx_linear + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                    }
+
+                    B_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim_block + device_row_offset_ + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
                 }
-                // determine on which side of the diagonal we are located
-                if (dim + threadIdx_x + THREAD_BLOCK_SIZE < global_j) {
-                    A_cache_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + global_j - (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz + std::size_t{ 1 }) / std::size_t{ 2 }];
+                nd_idx.barrier();  // wait until all work-items loaded their part of the data
+
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the dim is the fastest moving index
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            real_type sum{ 0.0 };
+                            for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                                sum += A_cache_[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache_[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                            }
+                            temp[internal_i][internal_j] += sum;
+                        }
+                    }
                 } else {
-                    A_cache_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz - global_j * (global_j + std::size_t{ 1 }) / std::size_t{ 2 }];
-                }
-
-                B_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
-                B_cache_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
-            }
-            nd_idx.barrier();  // wait until all work-items loaded their part of the data
-
-            // perform the dot product calculation
-            for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        temp[internal_i][internal_j] += A_cache_[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache_[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                    // perform the dot product calculation, the dim is the slowest moving index
+                    for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                temp[internal_i][internal_j] += A_cache_[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache_[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                            }
+                        }
                     }
                 }
+                nd_idx.barrier();  // wait until all work-items performed their part of the calculations
             }
-            nd_idx.barrier();  // wait until all work-items performed their part of the calculations
         }
 
+        // calculate the indices used in the current thread
+        const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+        const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
         // apply the (partial) BLAS operation and update C
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto device_global_j = j + static_cast<std::size_t>(internal_j);
-                const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-
-                // be sure to not perform out of bounds accesses
-                if (global_i < num_rhs_ && device_global_j < device_specific_num_rows_) {
-                    C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses
+                if (global_i_idx < num_rhs_ && device_global_j_idx < device_num_rows_) {
+                    C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
                 }
             }
         }
@@ -147,8 +168,8 @@ class device_kernel_symm {
     /// @cond Doxygen_suppress
     const std::size_t num_rows_;
     const std::size_t num_rhs_;
-    const std::size_t device_specific_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_num_rows_;
+    const std::size_t device_row_offset_;
     const real_type alpha_;
     const real_type *A_;
     const real_type *B_;
@@ -163,17 +184,22 @@ class device_kernel_symm {
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
  * @details In a multi-GPU setting, this function is responsible for mirroring down the columns this device is responsible for!
  *          Uses SYCL's work-group data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_symm_mirror {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::work_group;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] cgh the SYCL handler used to allocate the local memory
      * @param[in] num_rows the number of rows in @p A and @p C
      * @param[in] num_rhs the number of columns in @p B and @p C
      * @param[in] num_mirror_rows the number of rows to mirror down
-     * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
-     * @param[in] row_offset the first row this device is responsible for
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
      * @param[in] alpha the scalar alpha value
      * @param[in] A the matrix @p A
      * @param[in] B the matrix @p B
@@ -182,14 +208,14 @@ class device_kernel_symm_mirror {
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_symm_mirror(::sycl::handler &cgh, const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
-        A_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
-        B_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+    device_kernel_symm_mirror(::sycl::handler &cgh, const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const real_type *B, const real_type beta, real_type *C, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+        A_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+        B_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
         num_rows_{ num_rows },
         num_rhs_{ num_rhs },
         num_mirror_rows_{ num_mirror_rows },
-        device_specific_num_rows_{ device_specific_num_rows },
-        row_offset_{ row_offset },
+        device_num_rows_{ device_num_rows },
+        device_row_offset_{ device_row_offset },
         alpha_{ alpha },
         A_{ A },
         B_{ B },
@@ -208,63 +234,79 @@ class device_kernel_symm_mirror {
         const auto local_id_1 = static_cast<unsigned>(nd_idx.get_local_id(1));
 
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const std::size_t threadIdx_x = nd_idx.get_local_id(0);               // current thread in block x-dimension
-        const std::size_t threadIdx_y = nd_idx.get_local_id(1);               // current thread in block y-dimension
-        const std::size_t blockDim_x = nd_idx.get_local_range(0);             // number of threads in block x-dimension
-        const std::size_t blockDim_y = nd_idx.get_local_range(1);             // number of threads in block y-dimension
-        const std::size_t blockIdx_x = nd_idx.get_group(0) + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const std::size_t blockIdx_y = nd_idx.get_group(1) + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_uz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-        // calculate the indices used in the current work-item
-        const auto i = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-        const auto i_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-        const auto j = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-        const auto j_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+        const auto threadIdx_x = static_cast<std::size_t>(nd_idx.get_local_id(0));               // current work-item in work-group x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(nd_idx.get_local_id(1));               // current work-item in work-group y-dimension
+        const auto blockDim_x = static_cast<std::size_t>(nd_idx.get_local_range(0));             // number of work-items in work-group x-dimension
+        const auto blockDim_y = static_cast<std::size_t>(nd_idx.get_local_range(1));             // number of work-items in work-group y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(nd_idx.get_group(0)) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+        const auto blockIdx_y = static_cast<std::size_t>(nd_idx.get_group(1)) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
         // create a work-item private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over the remaining features using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < device_specific_num_rows_; dim += FEATURE_BLOCK_SIZE_uz) {
-            // load data into shared memory
-            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_i = i_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                const auto global_j = j_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                A_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - (dim + threadIdx_x - std::size_t{ 1 }) * (dim + threadIdx_x) / std::size_t{ 2 } + device_specific_num_rows_ - (dim + threadIdx_x) + global_j];
-                A_cache_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz - std::size_t{ 1 }) * (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) / std::size_t{ 2 } + device_specific_num_rows_ - (dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) + global_j];
-
-                B_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
-                B_cache_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(dim + row_offset_ + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rhs_ + PADDING_SIZE_uz) + global_i];
-            }
-            nd_idx.barrier();  // wait until all threads loaded their part of the data
-
-            // perform the feature reduction calculation
-            for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        temp[internal_i][internal_j] += A_cache_[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache_[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+        {
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto i_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_rhs
+            const auto j_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_mirror_rows
+
+            // iterate over the remaining values using blocking to be able to cache them for faster memory accesses
+            for (std::size_t dim_block = 0; dim_block < device_num_rows_; dim_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into local memory
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_i_idx_linear = i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_j_idx_linear = j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the local memory
+                    A_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = A_[(dim_block + threadIdx_x) * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - (dim_block + threadIdx_x - std::size_t{ 1 }) * (dim_block + threadIdx_x) / std::size_t{ 2 } + device_num_rows_ - (dim_block + threadIdx_x) + global_j_idx_linear];  // SoA, upper triangular matrix only
+                    B_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = B_[(device_row_offset_ + dim_block + threadIdx_x) * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx_linear];                                                                                                                                                // SoA
+                }
+                nd_idx.barrier();  // wait until all work-items loaded their part of the data
+
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the dim is the fastest moving index
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            real_type sum{ 0.0 };
+                            for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                                sum += A_cache_[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache_[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                            }
+                            temp[internal_i][internal_j] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the dim is the slowest moving index
+                    for (unsigned dim = 0; dim < THREAD_BLOCK_SIZE; ++dim) {
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                temp[internal_i][internal_j] += A_cache_[dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j] * B_cache_[dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i];
+                            }
+                        }
                     }
                 }
+                nd_idx.barrier();  // wait until all work-items performed their part of the calculations
             }
-            nd_idx.barrier();  // wait until all threads performed their part of the calculations
         }
 
+        // calculate the indices used in the current work-item
+        const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+        const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
+
         // apply the (remaining) BLAS operation and update C
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto partial_global_j = j + static_cast<std::size_t>(internal_j);
-                const auto global_j = row_offset_ + device_specific_num_rows_ + j + static_cast<std::size_t>(internal_j);
-
-                // be sure to not perform out of bounds accesses
-                if (global_i < num_rhs_ && partial_global_j < num_mirror_rows_) {
-                    C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j * (num_rhs_ + PADDING_SIZE_uz) + global_i];
+                // calculate the indices to access the global data and the data with respect to the current device
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto partial_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                const auto global_j_idx = device_row_offset_ + device_num_rows_ + partial_global_j_idx;
+
+                // be sure to not perform out-of-bounds accesses
+                if (global_i_idx < num_rhs_ && partial_global_j_idx < num_mirror_rows_) {
+                    C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx] = alpha_ * temp[internal_i][internal_j] + beta_ * C_[global_j_idx * (num_rhs_ + PADDING_SIZE_uz) + global_i_idx];  // SoA
                 }
             }
         }
@@ -280,8 +322,8 @@ class device_kernel_symm_mirror {
     const std::size_t num_rows_;
     const std::size_t num_rhs_;
     const std::size_t num_mirror_rows_;
-    const std::size_t device_specific_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_num_rows_;
+    const std::size_t device_row_offset_;
     const real_type alpha_;
     const real_type *A_;
     const real_type *B_;
@@ -298,6 +340,9 @@ class device_kernel_symm_mirror {
  */
 class device_kernel_inplace_matrix_add {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::work_group;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_cols the number of columns in both matrices
@@ -319,25 +364,27 @@ class device_kernel_inplace_matrix_add {
      */
     void operator()(::sycl::nd_item<2> nd_idx) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const std::size_t threadIdx_x = nd_idx.get_local_id(0);               // current thread in block x-dimension
-        const std::size_t threadIdx_y = nd_idx.get_local_id(1);               // current thread in block y-dimension
-        const std::size_t blockDim_x = nd_idx.get_local_range(0);             // number of threads in block x-dimension
-        const std::size_t blockDim_y = nd_idx.get_local_range(1);             // number of threads in block y-dimension
-        const std::size_t blockIdx_x = nd_idx.get_group(0) + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const std::size_t blockIdx_y = nd_idx.get_group(1) + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(nd_idx.get_local_id(0));               // current work-item in work-group x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(nd_idx.get_local_id(1));               // current work-item in work-group y-dimension
+        const auto blockDim_x = static_cast<std::size_t>(nd_idx.get_local_range(0));             // number of work-items in work-group x-dimension
+        const auto blockDim_y = static_cast<std::size_t>(nd_idx.get_local_range(1));             // number of work-items in work-group y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(nd_idx.get_group(0)) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+        const auto blockIdx_y = static_cast<std::size_t>(nd_idx.get_group(1)) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
         // calculate the indices used in the current work-item
-        const auto i = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // # num_rows
-        const auto j = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // # num_rhs
+        const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+        const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto global_j = j + static_cast<std::size_t>(internal_j);
+                // calculate the indices to access the global data
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-                lhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j] += rhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j];
+                lhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx] += rhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx];  // SoA
             }
         }
     }
@@ -358,6 +405,9 @@ class device_kernel_inplace_matrix_add {
  */
 class device_kernel_inplace_matrix_scale {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::work_group;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] num_cols the number of columns in the matrix
@@ -379,25 +429,27 @@ class device_kernel_inplace_matrix_scale {
      */
     void operator()(::sycl::nd_item<2> nd_idx) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const std::size_t threadIdx_x = nd_idx.get_local_id(0);               // current thread in block x-dimension
-        const std::size_t threadIdx_y = nd_idx.get_local_id(1);               // current thread in block y-dimension
-        const std::size_t blockDim_x = nd_idx.get_local_range(0);             // number of threads in block x-dimension
-        const std::size_t blockDim_y = nd_idx.get_local_range(1);             // number of threads in block y-dimension
-        const std::size_t blockIdx_x = nd_idx.get_group(0) + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const std::size_t blockIdx_y = nd_idx.get_group(1) + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(nd_idx.get_local_id(0));               // current work-item in work-group x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(nd_idx.get_local_id(1));               // current work-item in work-group y-dimension
+        const auto blockDim_x = static_cast<std::size_t>(nd_idx.get_local_range(0));             // number of work-items in work-group x-dimension
+        const auto blockDim_y = static_cast<std::size_t>(nd_idx.get_local_range(1));             // number of work-items in work-group y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(nd_idx.get_group(0)) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+        const auto blockIdx_y = static_cast<std::size_t>(nd_idx.get_group(1)) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
         // calculate the indices used in the current work-item
-        const auto i = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // # num_rows
-        const auto j = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // # num_rhs
+        const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows
+        const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
 
         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const auto global_i = i + static_cast<std::size_t>(internal_i);
-                const auto global_j = j + static_cast<std::size_t>(internal_j);
+                // calculate the indices to access the global data
+                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
 
-                lhs_[global_i * (num_cols_ + PADDING_SIZE_uz) + global_j] *= scale_;
+                lhs_[global_i_idx * (num_cols_ + PADDING_SIZE_uz) + global_j_idx] *= scale_;  // SoA
             }
         }
     }
@@ -414,4 +466,4 @@ class device_kernel_inplace_matrix_scale {
 
 }  // namespace plssvm::sycl::detail::work_group
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_WORK_GROUP_BLAS_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_WORK_GROUP_BLAS_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_explicit/work_group/kernel_matrix_assembly.hpp b/include/plssvm/backends/SYCL/kernel/cg_explicit/work_group/kernel_matrix_assembly.hpp
index 96030fbe7..63636728e 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_explicit/work_group/kernel_matrix_assembly.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_explicit/work_group/kernel_matrix_assembly.hpp
@@ -9,16 +9,19 @@
  * @brief Functions for explicitly assembling the kernel matrix using the SYCL backend and the work-group data parallel kernels.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::handler, sycl::range, sycl::nd_item, sycl::local_accessor
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
@@ -27,20 +30,24 @@ namespace plssvm::sycl::detail::work_group {
 /**
  * @brief Create the explicit kernel matrix using the @p kernel_function.
  * @details Uses SYCL's work-group data parallel kernels.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function; stored in a `std::tuple`
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_assembly {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::work_group;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] cgh the SYCL handler used to allocate the local memory
-     * @param[out] kernel_matrix_d the calculated kernel matrix
-     * @param[in] data_d the data points to calculate the kernel matrix from
+     * @param[out] kernel_matrix the calculated kernel matrix
+     * @param[in] data the data points to calculate the kernel matrix from
      * @param[in] num_rows the number of data points
      * @param[in] device_num_rows the number of rows the current device is responsible for
-     * @param[in] row_offset the first row in @p data_d the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data_d the current device is responsible for
      * @param[in] num_features the number of features per data point
      * @param[in] q the vector used in the dimensional reduction
      * @param[in] QA_cost the scalar used in the dimensional reduction
@@ -49,21 +56,21 @@ class device_kernel_assembly {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_assembly(::sycl::handler &cgh, real_type *kernel_matrix_d, const real_type *data_d, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t row_offset, const std::size_t num_features, const real_type *q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
-        data_cache_i_{ ::sycl::range<2>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
-        data_cache_j_{ ::sycl::range<2>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
-        kernel_matrix_d_{ kernel_matrix_d },
-        data_d_{ data_d },
+    device_kernel_assembly(::sycl::handler &cgh, real_type *kernel_matrix, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type *q, const real_type QA_cost, const real_type cost, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+        data_i_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+        data_j_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+        kernel_matrix_{ kernel_matrix },
+        data_{ data },
         num_rows_{ num_rows },
         device_num_rows_{ device_num_rows },
-        row_offset_{ row_offset },
+        device_row_offset_{ device_row_offset },
         num_features_{ num_features },
         q_{ q },
         QA_cost_{ QA_cost },
         cost_{ cost },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } {
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } {
     }
 
     /**
@@ -76,74 +83,92 @@ class device_kernel_assembly {
         const auto local_id_1 = static_cast<unsigned>(nd_idx.get_local_id(1));
 
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const std::size_t threadIdx_x = nd_idx.get_local_id(0);               // current thread in block x-dimension
-        const std::size_t threadIdx_y = nd_idx.get_local_id(1);               // current thread in block y-dimension
-        const std::size_t blockDim_x = nd_idx.get_local_range(0);             // number of threads in block x-dimension
-        const std::size_t blockDim_y = nd_idx.get_local_range(1);             // number of threads in block y-dimension
-        const std::size_t blockIdx_x = nd_idx.get_group(0) + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const std::size_t blockIdx_y = nd_idx.get_group(1) + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_uz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-        // calculate the indices used in the current work-item
-        const auto i = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-        const auto i_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-        const auto j = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-        const auto j_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(nd_idx.get_local_id(0));               // current work-item in work-group x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(nd_idx.get_local_id(1));               // current work-item in work-group y-dimension
+        const auto blockDim_x = static_cast<std::size_t>(nd_idx.get_local_range(0));             // number of work-items in work-group x-dimension
+        const auto blockDim_y = static_cast<std::size_t>(nd_idx.get_local_range(1));             // number of work-items in work-group y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(nd_idx.get_group(0)) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+        const auto blockIdx_y = static_cast<std::size_t>(nd_idx.get_group(1)) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
         // only calculate the upper triangular matrix -> can't use get_local_id() since all work-items in a work-group must progress further
         if (blockIdx_y >= blockIdx_x) {
-            // create a work-item private array used for internal caching
-            real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-            // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (std::size_t dim = 0; dim < num_features_; dim += FEATURE_BLOCK_SIZE_uz) {
-                // load data into local memory
-                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_i = row_offset_ + i_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                    const auto global_j = row_offset_ + j_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                    data_cache_i_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                    data_cache_i_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                    data_cache_j_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
-                    data_cache_j_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
-                }
-                nd_idx.barrier();  // wait until all work-items loaded their part of the data
-
-                // perform the feature reduction calculation
-                for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                            temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i_[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
-                                                                                                    data_cache_j_[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+            // create a private memory array used for internal caching
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+            {
+                // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+                const auto i_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_rows - device_row_offset
+                const auto j_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // device_num_rows
+
+                // iterate over all features using blocking to be able to cache them for faster memory accesses
+                for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
+                    // load data into local memory
+                    for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_i_idx_linear = device_row_offset_ + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                        const auto global_j_idx_linear = device_row_offset_ + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                        // store the values in the local memory
+                        data_i_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                        data_j_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
+                    }
+                    nd_idx.barrier();  // wait until all work-items loaded their part of the data
+
+                    if constexpr (target == target_platform::cpu) {
+                        // perform the feature reduction calculation, the feature is the fastest moving index
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                real_type sum{ 0.0 };
+                                for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                    sum += detail::feature_reduce<kernel_function>(data_i_cache_[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                   data_j_cache_[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                }
+                                temp[internal_i][internal_j] += sum;
+                            }
+                        }
+                    } else {
+                        // perform the feature reduction calculation, the feature is the slowest moving index
+                        for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                    temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache_[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                            data_j_cache_[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                }
+                            }
                         }
                     }
+                    nd_idx.barrier();  // wait until all work-items performed their part of the calculations
                 }
-                nd_idx.barrier();  // wait until all work-items performed their part of the calculations
             }
 
+            // calculate the indices used in the current work-item
+            const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+            const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
             // apply the remaining part of the kernel function and store the value in the output kernel matrix
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    // calculate the indices to access the kernel matrix (the part stored on the current device)
-                    const auto device_global_i = i + static_cast<std::size_t>(internal_i);
-                    const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal_i);
-                    const auto device_global_j = j + static_cast<std::size_t>(internal_j);
-                    const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-
-                    // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                    if (device_global_i < (num_rows_ - row_offset_) && device_global_j < device_num_rows_ && global_i >= global_j) {
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_i_idx = device_row_offset_ + device_global_i_idx;
+                    const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                    if (device_global_i_idx < (num_rows_ - device_row_offset_) && device_global_j_idx < device_num_rows_ && global_i_idx >= global_j_idx) {
                         real_type temp_ij = temp[internal_i][internal_j];
-                        temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i] - q_[global_j];
+                        // apply the final kernel function
+                        temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i_idx] - q_[global_j_idx];
                         // apply the cost on the diagonal
-                        if (global_i == global_j) {
+                        if (global_i_idx == global_j_idx) {
                             temp_ij += cost_;
                         }
-                        // update the kernel matrix
-                        kernel_matrix_d_[device_global_j * (num_rows_ - row_offset_ + PADDING_SIZE_uz) - device_global_j * (device_global_j + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i] = temp_ij;
+                        // update the upper triangular kernel matrix
+                        kernel_matrix_[device_global_j_idx * (num_rows_ - device_row_offset_ + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i_idx] = temp_ij;
                     }
                 }
             }
@@ -152,16 +177,16 @@ class device_kernel_assembly {
 
   private:
     /// Local memory used for internal memory access optimizations.
-    ::sycl::local_accessor<real_type, 2> data_cache_i_;
+    ::sycl::local_accessor<real_type, 2> data_i_cache_;
     /// Local memory used for internal memory access optimizations.
-    ::sycl::local_accessor<real_type, 2> data_cache_j_;
+    ::sycl::local_accessor<real_type, 2> data_j_cache_;
 
     /// @cond Doxygen_suppress
-    real_type *kernel_matrix_d_;
-    const real_type *data_d_;
+    real_type *kernel_matrix_;
+    const real_type *data_;
     const std::size_t num_rows_;
     const std::size_t device_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_row_offset_;
     const std::size_t num_features_;
     const real_type *q_;
     const real_type QA_cost_;
@@ -174,4 +199,4 @@ class device_kernel_assembly {
 
 }  // namespace plssvm::sycl::detail::work_group
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_EXPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_EXPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_implicit/basic/kernel_matrix_assembly_blas.hpp b/include/plssvm/backends/SYCL/kernel/cg_implicit/basic/kernel_matrix_assembly_blas.hpp
index 7b517a7b1..22ab4cf60 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_implicit/basic/kernel_matrix_assembly_blas.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_implicit/basic/kernel_matrix_assembly_blas.hpp
@@ -9,17 +9,20 @@
  * @brief Functions for implicitly assembling the kernel matrix using the SYCL backend and the basic data parallel kernels.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/detail/atomics.hpp"           // plssvm::sycl::detail::atomic_op
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
@@ -28,20 +31,24 @@ namespace plssvm::sycl::detail::basic {
 /**
  * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel_function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
  * @details Uses SYCL's basic data parallel kernels.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_assembly_symm {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::basic;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] alpha the scalar alpha value
      * @param[in] q the vector used in the dimensional reduction
-     * @param[in] data_d the data points to calculate the implicit kernel matrix from
+     * @param[in] data the data points to calculate the implicit kernel matrix from
      * @param[in] num_rows the total number of data points (= total number of rows)
      * @param[in] device_num_rows the number of rows the current device is responsible for
-     * @param[in] row_offset the first row in @p data_d the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data the current device is responsible for
      * @param[in] num_features the number of features per data point
      * @param[in] QA_cost the scalar used in the dimensional reduction
      * @param[in] cost the cost factor the diagonal is scaled with
@@ -52,13 +59,13 @@ class device_kernel_assembly_symm {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_assembly_symm(const real_type alpha, const real_type *q, const real_type *data_d, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+    device_kernel_assembly_symm(const real_type alpha, const real_type *q, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
         alpha_{ alpha },
         q_{ q },
-        data_d_{ data_d },
+        data_{ data },
         num_rows_{ num_rows },
         device_num_rows_{ device_num_rows },
-        row_offset_{ row_offset },
+        device_row_offset_{ device_row_offset },
         num_features_{ num_features },
         QA_cost_{ QA_cost },
         cost_{ cost },
@@ -67,7 +74,7 @@ class device_kernel_assembly_symm {
         num_classes_{ num_classes },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } { }
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } { }
 
     /**
      * @brief Function call operator overload performing the actual calculation.
@@ -75,28 +82,53 @@ class device_kernel_assembly_symm {
      */
     void operator()(::sycl::item<2> idx) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
         // calculate the indices used in the current work-item
-        const std::size_t i = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t j = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
+        const auto i_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+        const auto j_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
 
         // only calculate the upper triangular matrix
-        if (i >= j) {
+        if (i_idx >= j_idx) {
             // create a work-item private array used for internal caching
-            real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-            // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (std::size_t dim = 0; dim < num_features_; ++dim) {
-                // perform the feature reduction calculation
-                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal_i);
-                        const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-
-                        temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_d_[dim * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i],
-                                                                                                data_d_[dim * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j]);
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+            //*************************************************************************//
+            //                   inplace kernel matrix construction                    //
+            //*************************************************************************//
+            // iterate over all features using blocking
+            for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the feature reduction calculation, the feature is the fastest moving index
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            // calculate the indices to access the global data
+                            const auto global_i_idx = device_row_offset_ + i_idx + static_cast<std::size_t>(internal_i);
+                            const auto global_j_idx = device_row_offset_ + j_idx + static_cast<std::size_t>(internal_j);
+
+                            real_type sum{ 0.0 };
+                            for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                                sum += detail::feature_reduce<kernel_function>(data_[(feature_block + feature) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx],   // SoA
+                                                                               data_[(feature_block + feature) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx]);  // SoA
+                            }
+                            temp[internal_i][internal_j] += sum;
+                        }
+                    }
+                } else {
+                    // perform the feature reduction calculation, the feature is the slowest moving index
+                    for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                // calculate the indices to access the global data
+                                const auto global_i_idx = device_row_offset_ + i_idx + static_cast<std::size_t>(internal_i);
+                                const auto global_j_idx = device_row_offset_ + j_idx + static_cast<std::size_t>(internal_j);
+
+                                temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_[(feature_block + feature) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx],   // SoA
+                                                                                                        data_[(feature_block + feature) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx]);  // SoA
+                            }
+                        }
                     }
                 }
             }
@@ -104,28 +136,48 @@ class device_kernel_assembly_symm {
             // apply the remaining part of the kernel function and store the value in the output kernel matrix
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal_i);
-                    const auto device_global_i = i + static_cast<std::size_t>(internal_i);
-                    const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-                    const auto device_global_j = j + static_cast<std::size_t>(internal_j);
-
-                    // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                    if (device_global_i < (num_rows_ - row_offset_) && device_global_j < device_num_rows_ && global_i >= global_j) {
-                        real_type temp_ij = temp[internal_i][internal_j];
-                        temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter_) + QA_cost_ - q_[global_i] - q_[global_j];
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_i_idx = device_row_offset_ + device_global_i_idx;
+                    const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                    if (device_global_i_idx < (num_rows_ - device_row_offset_) && device_global_j_idx < device_num_rows_ && global_i_idx >= global_j_idx) {
+                        // apply the final kernel function
+                        temp[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp[internal_i][internal_j], kernel_function_parameter_) + QA_cost_ - q_[global_i_idx] - q_[global_j_idx];
                         // apply the cost on the diagonal
-                        if (global_i == global_j) {
-                            temp_ij += cost_;
-                            // calculate the values of alpha * A * B
-                            for (std::size_t class_idx = 0; class_idx < num_classes_; ++class_idx) {
-                                detail::atomic_op<real_type>{ C_[global_i * (num_classes_ + PADDING_SIZE_uz) + class_idx] } += alpha_ * temp_ij * B_[global_i * (num_classes_ + PADDING_SIZE_uz) + class_idx];
+                        if (global_i_idx == global_j_idx) {
+                            temp[internal_i][internal_j] += cost_;
+                        }
+                    } else {
+                        // be sure to set the value to zero otherwise
+                        temp[internal_i][internal_j] = real_type{ 0.0 };
+                    }
+                }
+            }
+
+            //*************************************************************************//
+            //                     calculate C += alpha * temp * B                     //
+            //*************************************************************************//
+            for (std::size_t class_block = 0; class_block < num_classes_; class_block += THREAD_BLOCK_SIZE_uz) {
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        // calculate the indices to access the global data
+                        const auto global_i_idx = device_row_offset_ + i_idx + static_cast<std::size_t>(internal_i);
+                        const auto global_j_idx = device_row_offset_ + j_idx + static_cast<std::size_t>(internal_j);
+
+                        if (global_i_idx == global_j_idx) {
+                            // only apply once to the diagonal
+                            for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
+                                detail::atomic_op<real_type>{ C_[global_i_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + class_idx] } += alpha_ * temp[internal_i][internal_j] * B_[global_i_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + class_idx];
                             }
                         } else {
-                            // calculate the values of alpha * A * B
-                            for (std::size_t class_idx = 0; class_idx < num_classes_; ++class_idx) {
-                                detail::atomic_op<real_type>{ C_[global_i * (num_classes_ + PADDING_SIZE_uz) + class_idx] } += alpha_ * temp_ij * B_[global_j * (num_classes_ + PADDING_SIZE_uz) + class_idx];
+                            // apply it for the upper and lower triangular matrix
+                            for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
+                                detail::atomic_op<real_type>{ C_[global_i_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + class_idx] } += alpha_ * temp[internal_i][internal_j] * B_[global_j_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + class_idx];
                                 // symmetry
-                                detail::atomic_op<real_type>{ C_[global_j * (num_classes_ + PADDING_SIZE_uz) + class_idx] } += alpha_ * temp_ij * B_[global_i * (num_classes_ + PADDING_SIZE_uz) + class_idx];
+                                detail::atomic_op<real_type>{ C_[global_j_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + class_idx] } += alpha_ * temp[internal_i][internal_j] * B_[global_i_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + class_idx];
                             }
                         }
                     }
@@ -137,11 +189,12 @@ class device_kernel_assembly_symm {
   private:
     /// @cond Doxygen_suppress
     const real_type alpha_;
+
     const real_type *q_;
-    const real_type *data_d_;
+    const real_type *data_;
     const std::size_t num_rows_;
     const std::size_t device_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_row_offset_;
     const std::size_t num_features_;
     const real_type QA_cost_;
     const real_type cost_;
@@ -156,4 +209,4 @@ class device_kernel_assembly_symm {
 
 }  // namespace plssvm::sycl::detail::basic
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_BASIC_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_implicit/hierarchical/kernel_matrix_assembly_blas.hpp b/include/plssvm/backends/SYCL/kernel/cg_implicit/hierarchical/kernel_matrix_assembly_blas.hpp
index 1a24024b6..4dce7064c 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_implicit/hierarchical/kernel_matrix_assembly_blas.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_implicit/hierarchical/kernel_matrix_assembly_blas.hpp
@@ -9,17 +9,21 @@
  * @brief Functions for implicitly assembling the kernel matrix using the SYCL backend and the hierarchical data parallel kernels.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
 #pragma once
 
-#include "plssvm/backends/SYCL/detail/atomics.hpp"           // plssvm::sycl::detail::atomic_op
-#include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
-#include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"            // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/detail/atomics.hpp"                   // plssvm::sycl::detail::atomic_op
+#include "plssvm/backends/SYCL/kernel/detail/reinterpret_array.hpp"  // plssvm::sycl::detail::reinterpret_array
+#include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"          // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
+#include "plssvm/constants.hpp"                                      // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/kernel_function_types.hpp"                          // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                               // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::group, sycl::private_memory, sycl::h_item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
@@ -28,20 +32,24 @@ namespace plssvm::sycl::detail::hierarchical {
 /**
  * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel_function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
  * @details Uses SYCL's hierarchical data parallel kernels.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_assembly_symm {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::hierarchical;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] alpha the scalar alpha value
      * @param[in] q the vector used in the dimensional reduction
-     * @param[in] data_d the data points to calculate the implicit kernel matrix from
+     * @param[in] data the data points to calculate the implicit kernel matrix from
      * @param[in] num_rows the total number of data points (= total number of rows)
      * @param[in] device_num_rows the number of rows the current device is responsible for
-     * @param[in] row_offset the first row in @p data_d the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data the current device is responsible for
      * @param[in] num_features the number of features per data point
      * @param[in] QA_cost the scalar used in the dimensional reduction
      * @param[in] cost the cost factor the diagonal is scaled with
@@ -52,13 +60,13 @@ class device_kernel_assembly_symm {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_assembly_symm(const real_type alpha, const real_type *q, const real_type *data_d, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+    device_kernel_assembly_symm(const real_type alpha, const real_type *q, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
         alpha_{ alpha },
         q_{ q },
-        data_d_{ data_d },
+        data_{ data },
         num_rows_{ num_rows },
         device_num_rows_{ device_num_rows },
-        row_offset_{ row_offset },
+        device_row_offset_{ device_row_offset },
         num_features_{ num_features },
         QA_cost_{ QA_cost },
         cost_{ cost },
@@ -67,37 +75,45 @@ class device_kernel_assembly_symm {
         num_classes_{ num_classes },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } { }
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } { }
 
     /**
      * @brief Function call operator overload performing the actual calculation.
      * @param[in] group indices representing the current point in the execution space
      */
     void operator()(::sycl::group<2> group) const {
-        // calculate the indices used in the current work-item
-        ::sycl::private_memory<std::size_t, 2> i{ group };
-        ::sycl::private_memory<std::size_t, 2> i_linear{ group };
-        ::sycl::private_memory<std::size_t, 2> j{ group };
-        ::sycl::private_memory<std::size_t, 2> j_linear{ group };
+        // the indices used in the current work-item
+        ::sycl::private_memory<std::size_t, 2> i_idx{ group };  // num_rows - device_row_offset
+        ::sycl::private_memory<std::size_t, 2> j_idx{ group };  // device_num_rows
 
-        ::sycl::private_memory<real_type[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE], 2> temp{ group };
+        ::sycl::private_memory<std::size_t, 2> i_idx_linear{ group };  // num_rows - device_row_offset
+        ::sycl::private_memory<std::size_t, 2> j_idx_linear{ group };  // device_num_rows
 
-        // initialize private and local variables
-        group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            const std::size_t threadIdx_x = idx.get_local_id(0);       // current thread in block x-dimension
-            const std::size_t threadIdx_y = idx.get_local_id(1);       // current thread in block y-dimension
-            const std::size_t blockDim_x = idx.get_local_range(0);     // number of threads in block x-dimension
-            const std::size_t blockDim_y = idx.get_local_range(1);     // number of threads in block y-dimension
-            const std::size_t blockIdx_x = group[0] + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-            const std::size_t blockIdx_y = group[1] + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
+        // create two local memory arrays used for caching
+        std::array<real_type, static_cast<std::size_t>(THREAD_BLOCK_SIZE) * static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)> cache_one{};
+        std::array<real_type, static_cast<std::size_t>(THREAD_BLOCK_SIZE) * static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)> cache_two{};
 
-            const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        // create a private memory array used for internal caching
+        ::sycl::private_memory<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, 2> temp{ group };
 
-            // indices
-            i(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-            i_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-            j(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-            j_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+        // initialize private and local variables
+        group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+            // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+            constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+
+            const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+            const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+            const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+            const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+            const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+            const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+            // calculate the indices to access the global data
+            i_idx(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
+            j_idx(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
+            // calculate the indices to access the global data, pays attention to coalesced memory accesses
+            i_idx_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+            j_idx_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
 
             // initialize private temp matrix to zero
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
@@ -111,32 +127,36 @@ class device_kernel_assembly_symm {
 
         // only calculate the upper triangular matrix -> can't use get_local_id() since all work-items in a work-group must progress further
         if (group[1] >= group[0]) {
+            //*************************************************************************//
+            //                   inplace kernel matrix construction                    //
+            //*************************************************************************//
             {
-                // allocate shared memory
-                real_type data_cache_i[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-                real_type data_cache_j[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+                // reinterpret the local memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+                auto *data_i_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_one);
+                auto *data_j_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_two);
 
                 // iterate over all features using blocking to be able to cache them for faster memory accesses
-                for (std::size_t dim = 0; dim < num_features_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+                for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
                     // load data into local memory
                     group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                        // cast values to 32-bit unsigned int values to prevent implicit conversions
                         const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                         const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                        const std::size_t threadIdx_x = idx.get_local_id(0);
+                        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                        const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));  // current work-item in work-group x-dimension
 
                         for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                            const auto global_i = row_offset_ + i_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                            const auto global_j = row_offset_ + j_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                            // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                            data_cache_i[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                            data_cache_i[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                            data_cache_j[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
-                            data_cache_j[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
+                            // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                            const auto global_i_idx_linear = device_row_offset_ + i_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                            const auto global_j_idx_linear = device_row_offset_ + j_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                            // store the values in the local memory
+                            data_i_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                            data_j_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
                         }
                     });
 
@@ -144,14 +164,30 @@ class device_kernel_assembly_symm {
 
                     // perform the feature reduction calculation
                     group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                        // cast values to 32-bit unsigned int values to prevent implicit conversions
                         const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                         const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                        for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                        if constexpr (target == target_platform::cpu) {
+                            // perform the feature reduction calculation, the feature is the fastest moving index
                             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                    temp(idx)[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
-                                                                                                                 data_cache_j[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                    real_type sum{ 0.0 };
+                                    for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                        sum += detail::feature_reduce<kernel_function>(data_i_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                       data_j_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                    }
+                                    temp(idx)[internal_i][internal_j] += sum;
+                                }
+                            }
+                        } else {
+                            // perform the feature reduction calculation, the feature is the slowest moving index
+                            for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                        temp(idx)[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                                     data_j_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                    }
                                 }
                             }
                         }
@@ -165,16 +201,18 @@ class device_kernel_assembly_symm {
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
                 for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                     for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        const auto global_i = row_offset_ + i(idx) + static_cast<std::size_t>(internal_i);
-                        const auto device_global_i = i(idx) + static_cast<std::size_t>(internal_i);
-                        const auto global_j = row_offset_ + j(idx) + static_cast<std::size_t>(internal_j);
-                        const auto device_global_j = j(idx) + static_cast<std::size_t>(internal_j);
-
-                        // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                        if (device_global_i < (num_rows_ - row_offset_) && device_global_j < device_num_rows_ && global_i >= global_j) {
-                            temp(idx)[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp(idx)[internal_i][internal_j], kernel_function_parameter_) + QA_cost_ - q_[global_i] - q_[global_j];
+                        // calculate the indices to access the global data and the data with respect to the current device
+                        const auto device_global_i_idx = i_idx(idx) + static_cast<std::size_t>(internal_i);
+                        const auto global_i_idx = device_row_offset_ + device_global_i_idx;
+                        const auto device_global_j_idx = j_idx(idx) + static_cast<std::size_t>(internal_j);
+                        const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                        // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                        if (device_global_i_idx < (num_rows_ - device_row_offset_) && device_global_j_idx < device_num_rows_ && global_i_idx >= global_j_idx) {
+                            // apply the final kernel function
+                            temp(idx)[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp(idx)[internal_i][internal_j], kernel_function_parameter_) + QA_cost_ - q_[global_i_idx] - q_[global_j_idx];
                             // apply the cost on the diagonal
-                            if (global_i == global_j) {
+                            if (global_i_idx == global_j_idx) {
                                 temp(idx)[internal_i][internal_j] += cost_;
                             }
                         } else {
@@ -187,47 +225,51 @@ class device_kernel_assembly_symm {
 
             // implicit group barrier
 
-            // calculate C += alpha * temp * B for the UPPER triangular matrix
+            //*************************************************************************//
+            //     calculate C += alpha * temp * B for the UPPER triangular matrix     //
+            //*************************************************************************//
             {
-                // allocate shared memory
-                real_type B_cache[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][FEATURE_BLOCK_SIZE];
-                real_type C_out_cache[INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][FEATURE_BLOCK_SIZE];
+                // reinterpret the local memory arrays to be of shape [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][THREAD_BLOCK_SIZE]
+                auto *B_cache = reinterpret_array<THREAD_BLOCK_SIZE>(cache_one);
+                auto *C_out_cache = reinterpret_array<THREAD_BLOCK_SIZE>(cache_two);
 
                 // iterate over all classes using blocking to be able to cache them for faster memory accesses
-                for (std::size_t dim = 0; dim < num_classes_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+                for (std::size_t class_block = 0; class_block < num_classes_; class_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
                     // load data into local memory
                     group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                        // cast values to 32-bit unsigned int values to prevent implicit conversions
                         const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                         const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                        const std::size_t threadIdx_x = idx.get_local_id(0);
+                        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                        const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));  // current work-item in work-group x-dimension
 
                         for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                            const std::size_t global_i = row_offset_ + i_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                            // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                            const auto global_i_idx_linear = device_row_offset_ + i_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                            // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                            B_cache[internal * THREAD_BLOCK_SIZE + local_id_1][local_id_0] = alpha_ * B_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x];
-                            B_cache[internal * THREAD_BLOCK_SIZE + local_id_1][local_id_0 + THREAD_BLOCK_SIZE] = alpha_ * B_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz];
-                            C_out_cache[internal * THREAD_BLOCK_SIZE + local_id_1][local_id_0] = real_type{ 0.0 };
-                            C_out_cache[internal * THREAD_BLOCK_SIZE + local_id_1][local_id_0 + THREAD_BLOCK_SIZE] = real_type{ 0.0 };
+                            // store the values in the local memory
+                            B_cache[internal * THREAD_BLOCK_SIZE + local_id_1][local_id_0] = alpha_ * B_[global_i_idx_linear * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x];  // SoA
+                            C_out_cache[internal * THREAD_BLOCK_SIZE + local_id_1][local_id_0] = real_type{ 0.0 };                                                                             // SoA
                         }
                     });
 
                     // implicit group barrier
 
-                    // calculate intermediate results and store them in shared memory
-                    for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                    // calculate intermediate results and store them in local memory
+                    for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                            // cast values to 32-bit unsigned int values to prevent implicit conversions
                             const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                             const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
                             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                    C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE + internal_j][(class_idx + local_id_1) % FEATURE_BLOCK_SIZE] +=
-                                        temp(idx)[internal_i][internal_j] * B_cache[local_id_1 * INTERNAL_BLOCK_SIZE + internal_i][(class_idx + local_id_1) % FEATURE_BLOCK_SIZE];
+                                    C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE + internal_j][(class_idx + local_id_1) % THREAD_BLOCK_SIZE] +=
+                                        temp(idx)[internal_i][internal_j] * B_cache[local_id_1 * INTERNAL_BLOCK_SIZE + internal_i][(class_idx + local_id_1) % THREAD_BLOCK_SIZE];
                                 }
                             }
                         });
@@ -235,20 +277,22 @@ class device_kernel_assembly_symm {
                         // implicit group barrier
                     }
 
-                    // add intermediate cached results to C
+                    // atomically add the intermediate cached results to the C matrix
                     group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                        // cast values to 32-bit unsigned int values to prevent implicit conversions
                         const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                         const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                        const std::size_t threadIdx_y = idx.get_local_id(1);
+                        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                        const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));  // current work-item in work-group y-dimension
 
                         for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                            const auto global_j = row_offset_ + j(idx) + static_cast<std::size_t>(internal);
-                            detail::atomic_op<real_type>{ C_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_y] } += C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE + internal][local_id_1];
-                            detail::atomic_op<real_type>{ C_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_y + THREAD_BLOCK_SIZE_uz] } += C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE + internal][local_id_1 + THREAD_BLOCK_SIZE];
+                            // calculate the indices to access the global data
+                            const auto global_j_idx = device_row_offset_ + j_idx(idx) + static_cast<std::size_t>(internal);
+
+                            detail::atomic_op<real_type>{ C_[global_j_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_y] } += C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE + internal][local_id_1];  // SoA
                         }
                     });
 
@@ -260,10 +304,11 @@ class device_kernel_assembly_symm {
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
                 for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                     for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                        const auto global_i = row_offset_ + i(idx) + static_cast<std::size_t>(internal_i);
-                        const auto global_j = row_offset_ + j(idx) + static_cast<std::size_t>(internal_j);
+                        // calculate the indices to access the global data
+                        const auto global_i_idx = device_row_offset_ + i_idx(idx) + static_cast<std::size_t>(internal_i);
+                        const auto global_j_idx = device_row_offset_ + j_idx(idx) + static_cast<std::size_t>(internal_j);
 
-                        if (global_i == global_j) {
+                        if (global_i_idx == global_j_idx) {
                             temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
                         }
                     }
@@ -272,47 +317,51 @@ class device_kernel_assembly_symm {
 
             // implicit group barrier
 
-            // calculate C += alpha * temp * B for the LOWER triangular matrix
+            //*************************************************************************//
+            //     calculate C += alpha * temp * B for the LOWER triangular matrix     //
+            //*************************************************************************//
             {
-                // allocate shared memory
-                real_type B_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-                real_type C_out_cache[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+                // reinterpret the local memory arrays to be of shape [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+                auto *B_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_one);
+                auto *C_out_cache = reinterpret_array<INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE>(cache_two);
 
                 // iterate over all classes using blocking to be able to cache them for faster memory accesses
-                for (std::size_t dim = 0; dim < num_classes_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+                for (std::size_t class_block = 0; class_block < num_classes_; class_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
                     group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                        // cast values to 32-bit unsigned int values to prevent implicit conversions
                         const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                         const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                        const std::size_t threadIdx_x = idx.get_local_id(0);
+                        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                        const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));  // current work-item in work-group x-dimension
 
                         // load data into local memory
                         for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                            const auto global_j = row_offset_ + j_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                            // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                            const auto global_j_idx_linear = device_row_offset_ + j_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                            // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                            B_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_ * B_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x];
-                            B_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_ * B_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz];
+                            // store the values in the local memory
+                            B_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_ * B_[global_j_idx_linear * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x];  // SoA
                             C_out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
-                            C_out_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
                         }
                     });
 
                     // implicit group barrier
 
-                    // calculate intermediate results and store them in shared memory
-                    for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                    // calculate intermediate results and store them in local memory
+                    for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                            // cast values to 32-bit unsigned int values to prevent implicit conversions
                             const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                             const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
                             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                    C_out_cache[(class_idx + local_id_0) % FEATURE_BLOCK_SIZE][internal_i * THREAD_BLOCK_SIZE + local_id_1] +=
-                                        temp(idx)[internal_i][internal_j] * B_cache[(class_idx + local_id_0) % FEATURE_BLOCK_SIZE][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j];
+                                    C_out_cache[(class_idx + local_id_0) % THREAD_BLOCK_SIZE][internal_i * THREAD_BLOCK_SIZE + local_id_1] +=
+                                        temp(idx)[internal_i][internal_j] * B_cache[(class_idx + local_id_0) % THREAD_BLOCK_SIZE][local_id_0 * INTERNAL_BLOCK_SIZE + internal_j];
                                 }
                             }
                         });
@@ -320,20 +369,22 @@ class device_kernel_assembly_symm {
                         // implicit group barrier
                     }
 
-                    // add intermediate cached results to C
+                    // atomically add the intermediate cached results to the C matrix
                     group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                        // cast values to 32-bit unsigned int values to prevent implicit conversions
                         const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                         const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                        const std::size_t threadIdx_x = idx.get_local_id(0);
+                        // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                        const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));  // current work-item in work-group x-dimension
 
                         for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                            const auto global_i = row_offset_ + i(idx) + static_cast<std::size_t>(internal);
-                            detail::atomic_op<real_type>{ C_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x] } += C_out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1];
-                            detail::atomic_op<real_type>{ C_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz] } += C_out_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1];
+                            // calculate the indices to access the global data
+                            const auto global_i_idx = device_row_offset_ + i_idx(idx) + static_cast<std::size_t>(internal);
+
+                            detail::atomic_op<real_type>{ C_[global_i_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x] } += C_out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1];  // SoA
                         }
                     });
 
@@ -347,10 +398,10 @@ class device_kernel_assembly_symm {
     /// @cond Doxygen_suppress
     const real_type alpha_;
     const real_type *q_;
-    const real_type *data_d_;
+    const real_type *data_;
     const std::size_t num_rows_;
     const std::size_t device_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_row_offset_;
     const std::size_t num_features_;
     const real_type QA_cost_;
     const real_type cost_;
@@ -365,4 +416,4 @@ class device_kernel_assembly_symm {
 
 }  // namespace plssvm::sycl::detail::hierarchical
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_HIERARCHICAL_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_implicit/scoped/kernel_matrix_assembly_blas.hpp b/include/plssvm/backends/SYCL/kernel/cg_implicit/scoped/kernel_matrix_assembly_blas.hpp
index 4391f2f19..202111c06 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_implicit/scoped/kernel_matrix_assembly_blas.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_implicit/scoped/kernel_matrix_assembly_blas.hpp
@@ -9,17 +9,20 @@
  * @brief Functions for implicitly assembling the kernel matrix using the SYCL backend and AdaptiveCpp's scoped parallelism.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/detail/atomics.hpp"           // plssvm::sycl::detail::atomic_op
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::memory_environment, sycl::require_local_mem, sycl::require_private_mem, sycl::distribute_items_and_wait, sycl::s_item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
@@ -28,20 +31,24 @@ namespace plssvm::sycl::detail::scoped {
 /**
  * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel_function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
  * @details Uses AdaptiveCpp's scoped parallelism.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_assembly_symm {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::scoped;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] alpha the scalar alpha value
      * @param[in] q the vector used in the dimensional reduction
-     * @param[in] data_d the data points to calculate the implicit kernel matrix from
+     * @param[in] data the data points to calculate the implicit kernel matrix from
      * @param[in] num_rows the total number of data points (= total number of rows)
      * @param[in] device_num_rows the number of rows the current device is responsible for
-     * @param[in] row_offset the first row in @p data_d the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data the current device is responsible for
      * @param[in] num_features the number of features per data point
      * @param[in] QA_cost the scalar used in the dimensional reduction
      * @param[in] cost the cost factor the diagonal is scaled with
@@ -52,13 +59,13 @@ class device_kernel_assembly_symm {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_assembly_symm(const real_type alpha, const real_type *q, const real_type *data_d, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+    device_kernel_assembly_symm(const real_type alpha, const real_type *q, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
         alpha_{ alpha },
         q_{ q },
-        data_d_{ data_d },
+        data_{ data },
         num_rows_{ num_rows },
         device_num_rows_{ device_num_rows },
-        row_offset_{ row_offset },
+        device_row_offset_{ device_row_offset },
         num_features_{ num_features },
         QA_cost_{ QA_cost },
         cost_{ cost },
@@ -67,7 +74,7 @@ class device_kernel_assembly_symm {
         num_classes_{ num_classes },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } { }
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } { }
 
     /**
      * @brief Function call operator overload performing the actual calculation.
@@ -77,88 +84,131 @@ class device_kernel_assembly_symm {
     template <typename T>
     void operator()(T group) const {
         ::sycl::memory_environment(group,
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE>>({}),
-                                   [&](auto &data_cache_i, auto &data_cache_j, auto &i, auto &i_linear, auto &j, auto &j_linear, auto &temp) {
+                                   // the indices used in the current work-item
+                                   ::sycl::require_private_mem<std::size_t>(),  // num_rows - device_row_offset
+                                   ::sycl::require_private_mem<std::size_t>(),  // device_num_rows
+
+                                   ::sycl::require_private_mem<std::size_t>(),  // num_rows - device_row_offset
+                                   ::sycl::require_private_mem<std::size_t>(),  // device_num_rows
+
+                                   // create two local memory arrays used for caching
+                                   ::sycl::require_local_mem<std::array<real_type, static_cast<std::size_t>(THREAD_BLOCK_SIZE) * static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // cache_one
+                                   ::sycl::require_local_mem<std::array<real_type, static_cast<std::size_t>(THREAD_BLOCK_SIZE) * static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // cache_two
+
+                                   // create a private memory array used for internal caching
+                                   ::sycl::require_private_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>>(),
+                                   [&](auto &i_idx, auto &j_idx, auto &i_idx_linear, auto &j_idx_linear, auto &cache_one, auto &cache_two, auto &temp) {
                                        // initialize private and local variables
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const std::size_t threadIdx_x = idx.get_local_id(group, 0);       // current thread in block x-dimension
-                                           const std::size_t threadIdx_y = idx.get_local_id(group, 1);       // current thread in block y-dimension
-                                           const std::size_t blockDim_x = group.get_logical_local_range(0);  // number of threads in block x-dimension
-                                           const std::size_t blockDim_y = group.get_logical_local_range(1);  // number of threads in block y-dimension
-                                           const std::size_t blockIdx_x = group[0] + grid_x_offset_;         // current block in grid x-dimension + offsets if the grid size would be too large
-                                           const std::size_t blockIdx_y = group[1] + grid_y_offset_;         // current block in grid y-dimension + offsets if the grid size would be too large
-
-                                           const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-                                           // indices
-                                           i(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-                                           i_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-                                           j(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-                                           j_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+                                           // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                           constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+
+                                           const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                           const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                           const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                           const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                           const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                           const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
+
+                                           // calculate the indices to access the global data
+                                           i_idx(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
+                                           j_idx(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
+                                           // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                           i_idx_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+                                           j_idx_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+
+                                           // initialize private temp matrix to zero
+                                           for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                               for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                   temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
+                                               }
+                                           }
                                        });
 
-                                       // exploit symmetry
+                                       // only calculate the upper triangular matrix -> can't use get_local_id() since all work-items in a work-group must progress further
                                        if (group[1] >= group[0]) {
-                                           // iterate over all features using blocking to be able to cache them for faster memory accesses
-                                           for (std::size_t dim = 0; dim < num_features_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
-                                               // load data into local memory
-                                               ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                                   const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
-                                                   const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
-
-                                                   const std::size_t threadIdx_x = idx.get_local_id(group, 0);
-
-                                                   const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                                   const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-                                                   for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                       const auto global_i = row_offset_ + i_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                                                       const auto global_j = row_offset_ + j_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                                                       // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                                                       data_cache_i[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                                                       data_cache_i[(local_id_0 + THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                                                       data_cache_j[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
-                                                       data_cache_j[(local_id_0 + THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
-                                                   }
-                                               });
-
-                                               // perform the feature reduction calculation
-                                               ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                                   const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
-                                                   const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
-
-                                                   for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                                                       for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                                                           for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                               temp(idx)[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i[block_dim * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
-                                                                                                                                            data_cache_j[block_dim * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                           //*************************************************************************//
+                                           //                   inplace kernel matrix construction                    //
+                                           //*************************************************************************//
+                                           {
+                                               // rename cached arrays
+                                               auto &data_i_cache = cache_one;  // [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+                                               auto &data_j_cache = cache_two;  // [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+
+                                               // iterate over all features using blocking to be able to cache them for faster memory accesses
+                                               for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
+                                                   // load data into local memory
+                                                   ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                       // cast values to 32-bit unsigned int values to prevent implicit conversions
+                                                       const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
+                                                       const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
+
+                                                       // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                                       constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                                                       constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                                                       const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));  // current work-item in work-group x-dimension
+
+                                                       for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                                                           // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                                           const auto global_i_idx_linear = device_row_offset_ + i_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                           const auto global_j_idx_linear = device_row_offset_ + j_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                                                           // store the values in the local memory
+                                                           data_i_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                                                           data_j_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
+                                                       }
+                                                   });
+
+                                                   // perform the feature reduction calculation
+                                                   ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                       // cast values to 32-bit unsigned int values to prevent implicit conversions
+                                                       const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
+                                                       const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
+
+                                                       if constexpr (target == target_platform::cpu) {
+                                                           // perform the feature reduction calculation, the feature is the fastest moving index
+                                                           for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                                               for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                                   real_type sum{ 0.0 };
+                                                                   for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                                                       sum += detail::feature_reduce<kernel_function>(data_i_cache[feature * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                                      data_j_cache[feature * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                                                   }
+                                                                   temp(idx)[internal_i][internal_j] += sum;
+                                                               }
+                                                           }
+                                                       } else {
+                                                           // perform the feature reduction calculation, the feature is the slowest moving index
+                                                           for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                                               for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                                                   for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                                       temp(idx)[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache[feature * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                                                                    data_j_cache[feature * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                                                   }
+                                                               }
                                                            }
                                                        }
-                                                   }
-                                               });
+                                                   });
+                                               }
                                            }
 
                                            // apply the remaining part of the kernel function and store the value in the output kernel matrix
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
                                                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                       const auto global_i = row_offset_ + i(idx) + static_cast<std::size_t>(internal_i);
-                                                       const auto device_global_i = i(idx) + static_cast<std::size_t>(internal_i);
-                                                       const auto global_j = row_offset_ + j(idx) + static_cast<std::size_t>(internal_j);
-                                                       const auto device_global_j = j(idx) + static_cast<std::size_t>(internal_j);
-
-                                                       // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                                                       if (device_global_i < (num_rows_ - row_offset_) && device_global_j < device_num_rows_ && global_i >= global_j) {
-                                                           temp(idx)[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp(idx)[internal_i][internal_j], kernel_function_parameter_) + QA_cost_ - q_[global_i] - q_[global_j];
+                                                       // calculate the indices to access the global data and the data with respect to the current device
+                                                       const auto device_global_i_idx = i_idx(idx) + static_cast<std::size_t>(internal_i);
+                                                       const auto global_i_idx = device_row_offset_ + device_global_i_idx;
+                                                       const auto device_global_j_idx = j_idx(idx) + static_cast<std::size_t>(internal_j);
+                                                       const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                                                       // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                                                       if (device_global_i_idx < (num_rows_ - device_row_offset_) && device_global_j_idx < device_num_rows_ && global_i_idx >= global_j_idx) {
+                                                           // apply the final kernel function
+                                                           temp(idx)[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp(idx)[internal_i][internal_j], kernel_function_parameter_) + QA_cost_ - q_[global_i_idx] - q_[global_j_idx];
                                                            // apply the cost on the diagonal
-                                                           if (global_i == global_j) {
+                                                           if (global_i_idx == global_j_idx) {
                                                                temp(idx)[internal_i][internal_j] += cost_;
                                                            }
                                                        } else {
@@ -169,64 +219,70 @@ class device_kernel_assembly_symm {
                                                }
                                            });
 
-                                           // calculate C += alpha * temp * B for the UPPER triangular matrix
+                                           //*************************************************************************//
+                                           //     calculate C += alpha * temp * B for the UPPER triangular matrix     //
+                                           //*************************************************************************//
                                            {
                                                // rename cached arrays
-                                               auto &B_cache = data_cache_i;      // [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][FEATURE_BLOCK_SIZE]
-                                               auto &C_out_cache = data_cache_j;  // [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][FEATURE_BLOCK_SIZE]
+                                               auto &B_cache = cache_one;      // [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][THREAD_BLOCK_SIZE]
+                                               auto &C_out_cache = cache_two;  // [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][THREAD_BLOCK_SIZE]
 
                                                // iterate over all classes using blocking to be able to cache them for faster memory accesses
-                                               for (std::size_t dim = 0; dim < num_classes_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+                                               for (std::size_t class_block = 0; class_block < num_classes_; class_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
                                                    // load data into local memory
                                                    ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                       // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                        const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                        const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                                       const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                                       // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                                       constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                                                       constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                                                       const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                                       const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                                       const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));  // current work-item in work-group x-dimension
 
                                                        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                           const std::size_t global_i = row_offset_ + i_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                           // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                                           const auto global_i_idx_linear = device_row_offset_ + i_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                                                           // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                                                           B_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * FEATURE_BLOCK_SIZE + local_id_0] = alpha_ * B_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x];
-                                                           B_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * FEATURE_BLOCK_SIZE + local_id_0 + THREAD_BLOCK_SIZE] = alpha_ * B_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz];
-                                                           C_out_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * FEATURE_BLOCK_SIZE + local_id_0] = real_type{ 0.0 };
-                                                           C_out_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * FEATURE_BLOCK_SIZE + local_id_0 + THREAD_BLOCK_SIZE] = real_type{ 0.0 };
+                                                           // store the values in the local memory
+                                                           B_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * THREAD_BLOCK_SIZE + local_id_0] = alpha_ * B_[global_i_idx_linear * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x];  // SoA
+                                                           C_out_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * THREAD_BLOCK_SIZE + local_id_0] = real_type{ 0.0 };                                                                             // SoA
                                                        }
                                                    });
 
-                                                   // calculate intermediate results and store them in shared memory
-                                                   for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                                                   // calculate intermediate results and store them in local memory
+                                                   for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                           // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                            const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                            const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
                                                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                                   C_out_cache[(local_id_0 * INTERNAL_BLOCK_SIZE + internal_j) * FEATURE_BLOCK_SIZE + (class_idx + local_id_1) % FEATURE_BLOCK_SIZE] +=
-                                                                       temp(idx)[internal_i][internal_j] * B_cache[(local_id_1 * INTERNAL_BLOCK_SIZE + internal_i) * FEATURE_BLOCK_SIZE + (class_idx + local_id_1) % FEATURE_BLOCK_SIZE];
+                                                                   C_out_cache[(local_id_0 * INTERNAL_BLOCK_SIZE + internal_j) * THREAD_BLOCK_SIZE + (class_idx + local_id_1) % THREAD_BLOCK_SIZE] +=
+                                                                       temp(idx)[internal_i][internal_j] * B_cache[(local_id_1 * INTERNAL_BLOCK_SIZE + internal_i) * THREAD_BLOCK_SIZE + (class_idx + local_id_1) % THREAD_BLOCK_SIZE];
                                                                }
                                                            }
                                                        });
                                                    }
 
-                                                   // add intermediate cached results to C
+                                                   // atomically add the intermediate cached results to the C matrix
                                                    ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                       // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                        const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                        const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                                       const std::size_t threadIdx_y = idx.get_local_id(group, 1);
+                                                       // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                                       constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                                                       const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                                       const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                                       const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));  // current work-item in work-group y-dimension
 
                                                        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                           const auto global_j = row_offset_ + j(idx) + static_cast<std::size_t>(internal);
-                                                           detail::atomic_op<real_type>{ C_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_y] } += C_out_cache[(local_id_0 * INTERNAL_BLOCK_SIZE + internal) * FEATURE_BLOCK_SIZE + local_id_1];
-                                                           detail::atomic_op<real_type>{ C_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_y + THREAD_BLOCK_SIZE_uz] } += C_out_cache[(local_id_0 * INTERNAL_BLOCK_SIZE + internal) * FEATURE_BLOCK_SIZE + local_id_1 + THREAD_BLOCK_SIZE];
+                                                           // calculate the indices to access the global data
+                                                           const auto global_j_idx = device_row_offset_ + j_idx(idx) + static_cast<std::size_t>(internal);
+
+                                                           detail::atomic_op<real_type>{ C_[global_j_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_y] } += C_out_cache[(local_id_0 * INTERNAL_BLOCK_SIZE + internal) * THREAD_BLOCK_SIZE + local_id_1];  // SoA
                                                        }
                                                    });
                                                }
@@ -236,82 +292,83 @@ class device_kernel_assembly_symm {
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
                                                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                       const auto global_i = row_offset_ + i(idx) + static_cast<std::size_t>(internal_i);
-                                                       const auto global_j = row_offset_ + j(idx) + static_cast<std::size_t>(internal_j);
+                                                       // calculate the indices to access the global data
+                                                       const auto global_i_idx = device_row_offset_ + i_idx(idx) + static_cast<std::size_t>(internal_i);
+                                                       const auto global_j_idx = device_row_offset_ + j_idx(idx) + static_cast<std::size_t>(internal_j);
 
-                                                       if (global_i == global_j) {
+                                                       if (global_i_idx == global_j_idx) {
                                                            temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
                                                        }
                                                    }
                                                }
                                            });
 
-                                           // calculate C += alpha * temp * B for the LOWER triangular matrix
+                                           //*************************************************************************//
+                                           //     calculate C += alpha * temp * B for the LOWER triangular matrix     //
+                                           //*************************************************************************//
                                            {
-                                               // allocate shared memory
-                                               auto &B_cache = data_cache_i;      // [FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
-                                               auto &C_out_cache = data_cache_j;  // [FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+                                               // rename local memory
+                                               auto &B_cache = cache_one;      // [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+                                               auto &C_out_cache = cache_two;  // [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
 
                                                // iterate over all classes using blocking to be able to cache them for faster memory accesses
-                                               for (std::size_t dim = 0; dim < num_classes_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+                                               for (std::size_t class_block = 0; class_block < num_classes_; class_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
                                                    ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                       // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                        const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                        const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                                       const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                                       // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                                       constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                                                       constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                                                       const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                                       const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                                       const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));  // current work-item in work-group x-dimension
 
                                                        // load data into local memory
                                                        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                           const auto global_j = row_offset_ + j_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                           // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                                           const auto global_j_idx_linear = device_row_offset_ + j_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                                                           // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                                                           B_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_ * B_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x];
-                                                           B_cache[(local_id_0 + THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_ * B_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz];
+                                                           // store the values in the local memory
+                                                           B_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_ * B_[global_j_idx_linear * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x];  // SoA
                                                            C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
-                                                           C_out_cache[(local_id_0 + THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
                                                        }
                                                    });
 
-                                                   // implicit group barrier
-
-                                                   // calculate intermediate results and store them in shared memory
-                                                   for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                                                   // calculate intermediate results and store them in local memory
+                                                   for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                           // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                            const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                            const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
                                                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                                                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                                                   C_out_cache[((class_idx + local_id_0) % FEATURE_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal_i * THREAD_BLOCK_SIZE + local_id_1] +=
-                                                                       temp(idx)[internal_i][internal_j] * B_cache[((class_idx + local_id_0) % FEATURE_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_0 * INTERNAL_BLOCK_SIZE + internal_j];
+                                                                   C_out_cache[((class_idx + local_id_0) % THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal_i * THREAD_BLOCK_SIZE + local_id_1] +=
+                                                                       temp(idx)[internal_i][internal_j] * B_cache[((class_idx + local_id_0) % THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_0 * INTERNAL_BLOCK_SIZE + internal_j];
                                                                }
                                                            }
                                                        });
-
-                                                       // implicit group barrier
                                                    }
 
-                                                   // add intermediate cached results to C
+                                                   // atomically add the intermediate cached results to the C matrix
                                                    ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                       // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                        const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                        const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                                       const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                                       // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                                       constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                                                       const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                                       const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                                       const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));  // current work-item in work-group x-dimension
 
                                                        for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                           const auto global_i = row_offset_ + i(idx) + static_cast<std::size_t>(internal);
-                                                           detail::atomic_op<real_type>{ C_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x] } += C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1];
-                                                           detail::atomic_op<real_type>{ C_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz] } += C_out_cache[(local_id_0 + THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1];
+                                                           // calculate the indices to access the global data
+                                                           const auto global_i_idx = device_row_offset_ + i_idx(idx) + static_cast<std::size_t>(internal);
+
+                                                           detail::atomic_op<real_type>{ C_[global_i_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x] } += C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1];  // SoA
                                                        }
                                                    });
-
-                                                   // implicit group barrier
                                                }
                                            }
                                        }
@@ -322,10 +379,10 @@ class device_kernel_assembly_symm {
     /// @cond Doxygen_suppress
     const real_type alpha_;
     const real_type *q_;
-    const real_type *data_d_;
+    const real_type *data_;
     const std::size_t num_rows_;
     const std::size_t device_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_row_offset_;
     const std::size_t num_features_;
     const real_type QA_cost_;
     const real_type cost_;
@@ -340,4 +397,4 @@ class device_kernel_assembly_symm {
 
 }  // namespace plssvm::sycl::detail::scoped
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_SCOPED_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/cg_implicit/work_group/kernel_matrix_assembly_blas.hpp b/include/plssvm/backends/SYCL/kernel/cg_implicit/work_group/kernel_matrix_assembly_blas.hpp
index 34b55fff4..27e12344c 100644
--- a/include/plssvm/backends/SYCL/kernel/cg_implicit/work_group/kernel_matrix_assembly_blas.hpp
+++ b/include/plssvm/backends/SYCL/kernel/cg_implicit/work_group/kernel_matrix_assembly_blas.hpp
@@ -9,17 +9,20 @@
  * @brief Functions for implicitly assembling the kernel matrix using the SYCL backend and the work-group data parallel kernels.
  */
 
-#ifndef PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
-#define PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/detail/atomics.hpp"           // plssvm::sycl::detail::atomic_op
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::handler, sycl::range, sycl::nd_item, sycl::local_accessor
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
@@ -28,21 +31,25 @@ namespace plssvm::sycl::detail::work_group {
 /**
  * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel_function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
  * @details Uses SYCL's work-group data parallel kernels.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_assembly_symm {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::work_group;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] cgh the SYCL handler used to allocate the local memory
      * @param[in] alpha the scalar alpha value
      * @param[in] q the vector used in the dimensional reduction
-     * @param[in] data_d the data points to calculate the implicit kernel matrix from
+     * @param[in] data the data points to calculate the implicit kernel matrix from
      * @param[in] num_rows the total number of data points (= total number of rows)
      * @param[in] device_num_rows the number of rows the current device is responsible for
-     * @param[in] row_offset the first row in @p data_d the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data the current device is responsible for
      * @param[in] num_features the number of features per data point
      * @param[in] QA_cost the scalar used in the dimensional reduction
      * @param[in] cost the cost factor the diagonal is scaled with
@@ -53,15 +60,15 @@ class device_kernel_assembly_symm {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_assembly_symm(::sycl::handler &cgh, const real_type alpha, const real_type *q, const real_type *data_d, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
-        data_cache_i_{ ::sycl::range<1>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE) * static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },  // [FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
-        data_cache_j_{ ::sycl::range<1>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE) * static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },  // [FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+    device_kernel_assembly_symm(::sycl::handler &cgh, const real_type alpha, const real_type *q, const real_type *data, const std::size_t num_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::size_t num_features, const real_type QA_cost, const real_type cost, const real_type *B, real_type *C, const std::size_t num_classes, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+        cache_one_{ ::sycl::range<1>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE) * static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },  // [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+        cache_two_{ ::sycl::range<1>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE) * static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },  // [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
         alpha_{ alpha },
         q_{ q },
-        data_d_{ data_d },
+        data_{ data },
         num_rows_{ num_rows },
         device_num_rows_{ device_num_rows },
-        row_offset_{ row_offset },
+        device_row_offset_{ device_row_offset },
         num_features_{ num_features },
         QA_cost_{ QA_cost },
         cost_{ cost },
@@ -70,7 +77,7 @@ class device_kernel_assembly_symm {
         num_classes_{ num_classes },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } { }
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } { }
 
     /**
      * @brief Function call operator overload performing the actual calculation.
@@ -82,50 +89,72 @@ class device_kernel_assembly_symm {
         const auto local_id_1 = static_cast<unsigned>(nd_idx.get_local_id(1));
 
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const std::size_t threadIdx_x = nd_idx.get_local_id(0);               // current thread in block x-dimension
-        const std::size_t threadIdx_y = nd_idx.get_local_id(1);               // current thread in block y-dimension
-        const std::size_t blockDim_x = nd_idx.get_local_range(0);             // number of threads in block x-dimension
-        const std::size_t blockDim_y = nd_idx.get_local_range(1);             // number of threads in block y-dimension
-        const std::size_t blockIdx_x = nd_idx.get_group(0) + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const std::size_t blockIdx_y = nd_idx.get_group(1) + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_uz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        const auto threadIdx_x = static_cast<std::size_t>(nd_idx.get_local_id(0));               // current work-item in work-group x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(nd_idx.get_local_id(1));               // current work-item in work-group y-dimension
+        const auto blockDim_x = static_cast<std::size_t>(nd_idx.get_local_range(0));             // number of work-items in work-group x-dimension
+        const auto blockDim_y = static_cast<std::size_t>(nd_idx.get_local_range(1));             // number of work-items in work-group y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(nd_idx.get_group(0)) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+        const auto blockIdx_y = static_cast<std::size_t>(nd_idx.get_group(1)) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
         // calculate the indices used in the current work-item
-        const auto i = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-        const auto i_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-        const auto j = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-        const auto j_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+        const auto i_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+        const auto j_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
+        // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+        const auto i_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_rows - device_row_offset
+        const auto j_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // device_num_rows
 
         // only calculate the upper triangular matrix -> can't use get_local_id() since all work-items in a work-group must progress further
         if (blockIdx_y >= blockIdx_x) {
             // create a work-item private array used for internal caching
-            real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
 
+            //*************************************************************************//
+            //                   inplace kernel matrix construction                    //
+            //*************************************************************************//
             {
+                // rename cached arrays
+                const auto &data_i_cache = cache_one_;  // [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+                const auto &data_j_cache = cache_two_;  // [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+
                 // iterate over all features using blocking to be able to cache them for faster memory accesses
-                for (std::size_t dim = 0; dim < num_features_; dim += FEATURE_BLOCK_SIZE_uz) {
+                for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
                     // load data into local memory
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_i = row_offset_ + i_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                        const auto global_j = row_offset_ + j_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                        // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                        data_cache_i_[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                        data_cache_i_[(local_id_0 + THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i];
-                        data_cache_j_[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
-                        data_cache_j_[(local_id_0 + THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j];
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_i_idx_linear = device_row_offset_ + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                        const auto global_j_idx_linear = device_row_offset_ + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                        // store the values in the local memory
+                        data_i_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx_linear];  // SoA
+                        data_j_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = data_[(feature_block + threadIdx_x) * (num_rows_ + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx_linear];  // SoA
                     }
                     nd_idx.barrier();  // wait until all work-items loaded their part of the data
 
-                    // perform the feature reduction calculation
-                    for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
+                    if constexpr (target == target_platform::cpu) {
+                        // perform the feature reduction calculation, the feature is the fastest moving index
                         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_cache_i_[block_dim * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
-                                                                                                        data_cache_j_[block_dim * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                real_type sum{ 0.0 };
+                                for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                    sum += detail::feature_reduce<kernel_function>(data_i_cache[feature * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                   data_j_cache[feature * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                }
+                                temp[internal_i][internal_j] += sum;
+                            }
+                        }
+                    } else {
+                        // perform the feature reduction calculation, the feature is the slowest moving index
+                        for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                    temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_i_cache[feature * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_1 * INTERNAL_BLOCK_SIZE + internal_i],
+                                                                                                            data_j_cache[feature * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_0 * INTERNAL_BLOCK_SIZE + internal_j]);
+                                }
                             }
                         }
                     }
@@ -136,16 +165,18 @@ class device_kernel_assembly_symm {
             // apply the remaining part of the kernel function and store the value in the output kernel matrix
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal_i);
-                    const auto device_global_i = i + static_cast<std::size_t>(internal_i);
-                    const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
-                    const auto device_global_j = j + static_cast<std::size_t>(internal_j);
-
-                    // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                    if (device_global_i < (num_rows_ - row_offset_) && device_global_j < device_num_rows_ && global_i >= global_j) {
-                        temp[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp[internal_i][internal_j], kernel_function_parameter_) + QA_cost_ - q_[global_i] - q_[global_j];
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_i_idx = device_row_offset_ + device_global_i_idx;
+                    const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset_ + device_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                    if (device_global_i_idx < (num_rows_ - device_row_offset_) && device_global_j_idx < device_num_rows_ && global_i_idx >= global_j_idx) {
+                        // apply the final kernel function
+                        temp[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp[internal_i][internal_j], kernel_function_parameter_) + QA_cost_ - q_[global_i_idx] - q_[global_j_idx];
                         // apply the cost on the diagonal
-                        if (global_i == global_j) {
+                        if (global_i_idx == global_j_idx) {
                             temp[internal_i][internal_j] += cost_;
                         }
                     } else {
@@ -155,42 +186,44 @@ class device_kernel_assembly_symm {
                 }
             }
 
-            // calculate C += alpha * temp * B for the UPPER triangular matrix
+            //*************************************************************************//
+            //     calculate C += alpha * temp * B for the UPPER triangular matrix     //
+            //*************************************************************************//
             {
                 // rename cached arrays
-                auto &B_cache = data_cache_i_;      // [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][FEATURE_BLOCK_SIZE]
-                auto &C_out_cache = data_cache_j_;  // [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][FEATURE_BLOCK_SIZE]
+                const auto &B_cache = cache_one_;      // [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][THREAD_BLOCK_SIZE]
+                const auto &C_out_cache = cache_two_;  // [INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE][THREAD_BLOCK_SIZE]
 
                 // iterate over all classes using blocking to be able to cache them for faster memory accesses
-                for (std::size_t dim = 0; dim < num_classes_; dim += FEATURE_BLOCK_SIZE_uz) {
+                for (std::size_t class_block = 0; class_block < num_classes_; class_block += THREAD_BLOCK_SIZE_uz) {
                     // load data into local memory
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const std::size_t global_i = row_offset_ + i_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_i_idx_linear = device_row_offset_ + i_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                        // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                        B_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * FEATURE_BLOCK_SIZE + local_id_0] = alpha_ * B_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x];
-                        B_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * FEATURE_BLOCK_SIZE + local_id_0 + THREAD_BLOCK_SIZE] = alpha_ * B_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz];
-                        C_out_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * FEATURE_BLOCK_SIZE + local_id_0] = real_type{ 0.0 };
-                        C_out_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * FEATURE_BLOCK_SIZE + local_id_0 + THREAD_BLOCK_SIZE] = real_type{ 0.0 };
+                        // store the values in the local memory
+                        B_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * THREAD_BLOCK_SIZE + local_id_0] = alpha_ * B_[global_i_idx_linear * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x];  // SoA
+                        C_out_cache[(internal * THREAD_BLOCK_SIZE + local_id_1) * THREAD_BLOCK_SIZE + local_id_0] = real_type{ 0.0 };                                                                             // SoA
                     }
                     nd_idx.barrier();  // wait until all work-items loaded their part of the data
 
-                    // calculate intermediate results and store them in shared memory
-                    for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                    // calculate intermediate results and store them in local memory
+                    for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                C_out_cache[(local_id_0 * INTERNAL_BLOCK_SIZE + internal_j) * FEATURE_BLOCK_SIZE + (class_idx + local_id_1) % FEATURE_BLOCK_SIZE] +=
-                                    temp[internal_i][internal_j] * B_cache[(local_id_1 * INTERNAL_BLOCK_SIZE + internal_i) * FEATURE_BLOCK_SIZE + (class_idx + local_id_1) % FEATURE_BLOCK_SIZE];
+                                C_out_cache[(local_id_0 * INTERNAL_BLOCK_SIZE + internal_j) * THREAD_BLOCK_SIZE + (class_idx + local_id_1) % THREAD_BLOCK_SIZE] +=
+                                    temp[internal_i][internal_j] * B_cache[(local_id_1 * INTERNAL_BLOCK_SIZE + internal_i) * THREAD_BLOCK_SIZE + (class_idx + local_id_1) % THREAD_BLOCK_SIZE];
                             }
                         }
                         nd_idx.barrier();  // wait until all work-items performed their part of the calculations
                     }
 
-                    // add intermediate cached results to C
+                    // atomically add the intermediate cached results to the C matrix
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal);
-                        detail::atomic_op<real_type>{ C_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_y] } += C_out_cache[(local_id_0 * INTERNAL_BLOCK_SIZE + internal) * FEATURE_BLOCK_SIZE + local_id_1];
-                        detail::atomic_op<real_type>{ C_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_y + THREAD_BLOCK_SIZE_uz] } += C_out_cache[(local_id_0 * INTERNAL_BLOCK_SIZE + internal) * FEATURE_BLOCK_SIZE + local_id_1 + THREAD_BLOCK_SIZE];
+                        // calculate the indices to access the global data
+                        const auto global_j_idx = device_row_offset_ + j_idx + static_cast<std::size_t>(internal);
+
+                        detail::atomic_op<real_type>{ C_[global_j_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_y] } += C_out_cache[(local_id_0 * INTERNAL_BLOCK_SIZE + internal) * THREAD_BLOCK_SIZE + local_id_1];  // SoA
                     }
                     nd_idx.barrier();  // wai until all work-items updated C with their values
                 }
@@ -199,51 +232,55 @@ class device_kernel_assembly_symm {
             // set potential diagonal entries in temp to 0.0 such that we don't apply the main diagonal twice to C
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal_i);
-                    const auto global_j = row_offset_ + j + static_cast<std::size_t>(internal_j);
+                    // calculate the indices to access the global data
+                    const auto global_i_idx = device_row_offset_ + i_idx + static_cast<std::size_t>(internal_i);
+                    const auto global_j_idx = device_row_offset_ + j_idx + static_cast<std::size_t>(internal_j);
 
-                    if (global_i == global_j) {
+                    // update the diagonal
+                    if (global_i_idx == global_j_idx) {
                         temp[internal_i][internal_j] = real_type{ 0.0 };
                     }
                 }
             }
 
-            // calculate C += alpha * temp * B for the LOWER triangular matrix
+            //*************************************************************************//
+            //     calculate C += alpha * temp * B for the LOWER triangular matrix     //
+            //*************************************************************************//
             {
                 // rename cached arrays
-                auto &B_cache = data_cache_i_;      // [FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
-                auto &C_out_cache = data_cache_j_;  // [FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+                const auto &B_cache = cache_one_;      // [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
+                const auto &C_out_cache = cache_two_;  // [THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]
 
                 // iterate over all classes using blocking to be able to cache them for faster memory accesses
-                for (std::size_t dim = 0; dim < num_classes_; dim += FEATURE_BLOCK_SIZE_uz) {
+                for (std::size_t class_block = 0; class_block < num_classes_; class_block += THREAD_BLOCK_SIZE_uz) {
                     // load data into local memory
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_j = row_offset_ + j_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_j_idx_linear = device_row_offset_ + j_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                        // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                        B_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_ * B_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x];
-                        B_cache[(local_id_0 + THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_ * B_[global_j * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz];
+                        // store the values in the local memory
+                        B_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_ * B_[global_j_idx_linear * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x];  // SoA
                         C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
-                        C_out_cache[(local_id_0 + THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
                     }
                     nd_idx.barrier();  // wait until all work-items loaded their part of the data
 
-                    // calculate intermediate results and store them in shared memory
-                    for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                    // calculate intermediate results and store them in local memory
+                    for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                         for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                             for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                                C_out_cache[((class_idx + local_id_0) % FEATURE_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal_i * THREAD_BLOCK_SIZE + local_id_1] +=
-                                    temp[internal_i][internal_j] * B_cache[((class_idx + local_id_0) % FEATURE_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_0 * INTERNAL_BLOCK_SIZE + internal_j];
+                                C_out_cache[((class_idx + local_id_0) % THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal_i * THREAD_BLOCK_SIZE + local_id_1] +=
+                                    temp[internal_i][internal_j] * B_cache[((class_idx + local_id_0) % THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + local_id_0 * INTERNAL_BLOCK_SIZE + internal_j];
                             }
                         }
                         nd_idx.barrier();  // wait until all work-items performed their part of the calculations
                     }
 
-                    // add intermediate cached results to C
+                    // atomically add the intermediate cached results to the C matrix
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_i = row_offset_ + i + static_cast<std::size_t>(internal);
-                        detail::atomic_op<real_type>{ C_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x] } += C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1];
-                        detail::atomic_op<real_type>{ C_[global_i * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz] } += C_out_cache[(local_id_0 + THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1];
+                        // calculate the indices to access the global data
+                        const auto global_i_idx = device_row_offset_ + i_idx + static_cast<std::size_t>(internal);
+
+                        detail::atomic_op<real_type>{ C_[global_i_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x] } += C_out_cache[local_id_0 * INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE + internal * THREAD_BLOCK_SIZE + local_id_1];  // SoA
                     }
                     nd_idx.barrier();  // wait until all threads updated C with their values
                 }
@@ -253,17 +290,17 @@ class device_kernel_assembly_symm {
 
   private:
     /// Local memory used for internal memory access optimizations.
-    ::sycl::local_accessor<real_type, 1> data_cache_i_;
+    ::sycl::local_accessor<real_type, 1> cache_one_;
     /// Local memory used for internal memory access optimizations.
-    ::sycl::local_accessor<real_type, 1> data_cache_j_;
+    ::sycl::local_accessor<real_type, 1> cache_two_;
 
     /// @cond Doxygen_suppress
     const real_type alpha_;
     const real_type *q_;
-    const real_type *data_d_;
+    const real_type *data_;
     const std::size_t num_rows_;
     const std::size_t device_num_rows_;
-    const std::size_t row_offset_;
+    const std::size_t device_row_offset_;
     const std::size_t num_features_;
     const real_type QA_cost_;
     const real_type cost_;
@@ -278,4 +315,4 @@ class device_kernel_assembly_symm {
 
 }  // namespace plssvm::sycl::detail::work_group
 
-#endif  // PLSSVM_BACKENDS_SYCL_CG_IMPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_CG_IMPLICIT_WORK_GROUP_KERNEL_MATRIX_ASSEMBLY_BLAS_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/detail/reinterpret_array.hpp b/include/plssvm/backends/SYCL/kernel/detail/reinterpret_array.hpp
new file mode 100644
index 000000000..1e0fa6038
--- /dev/null
+++ b/include/plssvm/backends/SYCL/kernel/detail/reinterpret_array.hpp
@@ -0,0 +1,50 @@
+/**
+ * @file
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Defines a utility function to reinterpret a 2D array inside a CUDA kernel.
+ */
+
+#ifndef PLSSVM_BACKENDS_SYCL_KERNEL_DETAIL_REINTERPRET_ARRAY_HPP_
+#define PLSSVM_BACKENDS_SYCL_KERNEL_DETAIL_REINTERPRET_ARRAY_HPP_
+#pragma once
+
+#include <array>    // std::array
+#include <cstddef>  // std::size_t
+
+namespace plssvm::sycl::detail {
+
+/**
+ * @brief Given the input array of dimensions [N][M], reinterpret it to be of dimensions [...][SIZE].
+ * @tparam SIZE the new y-dimension size of the array
+ * @tparam T the type of the values in the array
+ * @tparam N the x-dimension of the array
+ * @tparam M the y-dimension of the array
+ * @param[in] input the array to reinterpret
+ * @return the array of the newly specified dimensions (`[[nodiscard]]`)
+ */
+template <std::size_t SIZE, typename T, std::size_t N, std::size_t M>
+[[nodiscard]] inline auto *reinterpret_array(std::array<std::array<T, M>, N> &input) noexcept {
+    return reinterpret_cast<T(*)[SIZE]>(input[0].data());  // NOLINT: reinterpret_cast + C-style array necessary
+}
+
+/**
+ * @brief Given the input array of dimensions [N], reinterpret it to be of dimensions [...][SIZE].
+ * @tparam SIZE the new y-dimension size of the array
+ * @tparam T the type of the values in the array
+ * @tparam N the dimension of the array
+ * @param[in] input the array to reinterpret
+ * @return the array of the newly specified dimensions (`[[nodiscard]]`)
+ */
+template <std::size_t SIZE, typename T, std::size_t N>
+[[nodiscard]] inline auto *reinterpret_array(std::array<T, N> &input) noexcept {
+    return reinterpret_cast<T(*)[SIZE]>(input.data());  // NOLINT: reinterpret_cast + C-style array necessary
+}
+
+}  // namespace plssvm::sycl::detail
+
+#endif  // PLSSVM_BACKENDS_SYCL_KERNEL_DETAIL_REINTERPRET_ARRAY_HPP_
diff --git a/include/plssvm/backends/SYCL/kernel/kernel_functions.hpp b/include/plssvm/backends/SYCL/kernel/kernel_functions.hpp
index 97c5c6248..6cfa159bc 100644
--- a/include/plssvm/backends/SYCL/kernel/kernel_functions.hpp
+++ b/include/plssvm/backends/SYCL/kernel/kernel_functions.hpp
@@ -30,42 +30,17 @@ namespace plssvm::sycl::detail {
 
 /**
  * @brief Fast integer power function. Computes base^exponent and takes advantage of the fact that degree may only be positive integer values.
- * @details Hardcodes the power function for degree <= 6, uses a simple for loop otherwise.
  * @param[in] base the base
  * @param[in] exponent the exponent
  * @return base^exponent (`[[nodiscard]]`)
  */
 [[nodiscard]] inline real_type powi(const real_type base, const int exponent) {
-    switch (exponent) {
-        case 0: return real_type{ 1.0 };
-        case 1: return base;
-        case 2: return base * base;
-        case 3: return base * base * base;
-        case 4:
-            {
-                const real_type temp = base * base;
-                return temp * temp;
-            }
-        case 5:
-            {
-                const real_type temp = base * base;
-                return temp * temp * base;
-            }
-        case 6:
-            {
-                const real_type temp = base * base * base;
-                return temp * temp;
-            }
-        default:
-            {
-                // generic integer power function
-                real_type result{ 1.0 };
-                for (int i = 0; i < exponent; ++i) {
-                    result *= base;
-                }
-                return result;
-            }
+    // generic integer power function
+    real_type result{ 1.0 };
+    for (int i = 0; i < exponent; ++i) {
+        result *= base;
     }
+    return result;
 }
 
 //***************************************************//
diff --git a/include/plssvm/backends/SYCL/kernel/predict/basic/predict_kernel.hpp b/include/plssvm/backends/SYCL/kernel/predict/basic/predict_kernel.hpp
index c16965cb1..16011242b 100644
--- a/include/plssvm/backends/SYCL/kernel/predict/basic/predict_kernel.hpp
+++ b/include/plssvm/backends/SYCL/kernel/predict/basic/predict_kernel.hpp
@@ -13,44 +13,52 @@
 #define PLSSVM_BACKENDS_SYCL_KERNEL_PREDICT_BASIC_PREDICT_KERNEL_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/detail/atomics.hpp"           // plssvm::sycl::detail::atomic_op
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
 namespace plssvm::sycl::detail::basic {
 
 /**
- * @brief Calculate the `q` vector used to speedup the prediction using the linear kernel function.
+ * @brief Calculate the `w` vector used to speedup the prediction using the linear kernel function.
  * @details Uses SYCL's basic data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_w_linear {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::basic;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[in,out] w_d the vector to speedup the linear prediction
-     * @param[in] alpha_d the previously learned weights
-     * @param[in] sv_d the support vectors
+     * @param[in,out] w the vector to speedup the linear prediction
+     * @param[in] alpha the previously learned weights
+     * @param[in] support_vectors the support vectors
      * @param[in] num_classes the number of classes
      * @param[in] num_sv the number of support vectors
-     * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
-     * @param[in] sv_offset the first support vector (row in @p alpha_d) the current device is responsible for
+     * @param[in] device_num_sv the number of support vectors the current device is responsible for
+     * @param[in] device_sv_offset the first support vector (row in @p alpha) the current device is responsible for
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_w_linear(real_type *w_d, const real_type *alpha_d, const real_type *sv_d, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_specific_num_sv, const std::size_t sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
-        w_d_{ w_d },
-        alpha_d_{ alpha_d },
-        sv_d_{ sv_d },
+    device_kernel_w_linear(real_type *w, const real_type *alpha, const real_type *support_vectors, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_num_sv, const std::size_t device_sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+        w_{ w },
+        alpha_{ alpha },
+        support_vectors_{ support_vectors },
         num_classes_{ num_classes },
         num_sv_{ num_sv },
-        device_specific_num_sv_{ device_specific_num_sv },
-        sv_offset_{ sv_offset },
+        device_num_sv_{ device_num_sv },
+        device_sv_offset_{ device_sv_offset },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset } { }
 
@@ -60,77 +68,106 @@ class device_kernel_w_linear {
      */
     void operator()(::sycl::item<2> idx) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
         // calculate the indices used in the current work-item
-        const std::size_t feature_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t class_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
+        const auto feature_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+        const auto class_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;    // num_classes
 
         // create a work-item private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-        for (std::size_t sv = 0; sv < device_specific_num_sv_; ++sv) {
-            // perform the dot product calculation
-            for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
-                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
-                    const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
-
-                    temp[internal_feature][internal_class] += alpha_d_[global_class_idx * (num_sv_ + PADDING_SIZE_uz) + sv + sv_offset_] * sv_d_[global_feature_idx * (device_specific_num_sv_ + PADDING_SIZE_uz) + sv];
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+        // iterate over all support vectors using blocking
+        for (std::size_t sv_block = 0; sv_block < device_num_sv_; sv_block += THREAD_BLOCK_SIZE_uz) {
+            if constexpr (target == target_platform::cpu) {
+                // perform the dot product calculation, the sv is the fastest moving index
+                for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                    for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                        // calculate the indices to access the global data
+                        const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+                        const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+
+                        real_type sum{ 0.0 };
+                        for (std::size_t sv = 0; sv < THREAD_BLOCK_SIZE_uz; ++sv) {
+                            sum += alpha_[global_class_idx * (num_sv_ + PADDING_SIZE_uz) + sv_block + sv + device_sv_offset_] *  // AoS
+                                   support_vectors_[global_feature_idx * (device_num_sv_ + PADDING_SIZE_uz) + sv_block + sv];    // SoA
+                        }
+                        temp[internal_feature][internal_class] += sum;
+                    }
+                }
+            } else {
+                // perform the dot product calculation, the sv is the slowest moving index
+                for (std::size_t sv = 0; sv < THREAD_BLOCK_SIZE_uz; ++sv) {
+                    for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                            // calculate the indices to access the global data
+                            const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+                            const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+
+                            temp[internal_feature][internal_class] += alpha_[global_class_idx * (num_sv_ + PADDING_SIZE_uz) + sv_block + sv + device_sv_offset_] *  // AoS
+                                                                      support_vectors_[global_feature_idx * (device_num_sv_ + PADDING_SIZE_uz) + sv_block + sv];    // SoA
+                        }
+                    }
                 }
             }
         }
 
-        // update global array with local one
+        // update the global w-vector with the locally cached values
         for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
             for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+                // calculate the indices to access the global data
                 const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                w_d_[global_feature_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp[internal_feature][internal_class];
+                w_[global_feature_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp[internal_feature][internal_class];  // SoA
             }
         }
     }
 
   private:
     /// @cond Doxygen_suppress
-    real_type *w_d_;
-    const real_type *alpha_d_;
-    const real_type *sv_d_;
+    real_type *w_;
+    const real_type *alpha_;
+    const real_type *support_vectors_;
     const std::size_t num_classes_;
     const std::size_t num_sv_;
-    const std::size_t device_specific_num_sv_;
-    const std::size_t sv_offset_;
+    const std::size_t device_num_sv_;
+    const std::size_t device_sv_offset_;
     const std::size_t grid_x_offset_;
     const std::size_t grid_y_offset_;
     /// @endcond
 };
 
 /**
- * @brief Predict the @p predict_points_d using the linear kernel speeding up the calculation using the @p w_d vector.
+ * @brief Predict the @p predict_points using the linear kernel speeding up the calculation using the @p w vector.
  * @details Uses SYCL's basic data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_predict_linear {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::basic;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[out] prediction_d the predicted values
-     * @param[in] w_d the vector to speedup the calculations
-     * @param[in] rho_d the previously learned bias
-     * @param[in] predict_points_d the data points to predict
+     * @param[out] prediction the predicted values
+     * @param[in] w the vector to speedup the calculations
+     * @param[in] rho the previously learned bias
+     * @param[in] predict_points the data points to predict
      * @param[in] num_classes the number of classes
      * @param[in] num_predict_points the number of data points to predict
      * @param[in] num_features the number of features per data point
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_predict_linear(real_type *prediction_d, const real_type *w_d, const real_type *rho_d, const real_type *predict_points_d, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
-        prediction_d_{ prediction_d },
-        w_d_{ w_d },
-        rho_d_{ rho_d },
-        predict_points_d_{ predict_points_d },
+    device_kernel_predict_linear(real_type *prediction, const real_type *w, const real_type *rho, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+        prediction_{ prediction },
+        w_{ w },
+        rho_{ rho },
+        predict_points_{ predict_points },
         num_classes_{ num_classes },
         num_predict_points_{ num_predict_points },
         num_features_{ num_features },
@@ -143,46 +180,70 @@ class device_kernel_predict_linear {
      */
     void operator()(::sycl::item<2> idx) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
         // calculate the indices used in the current work-item
-        const std::size_t pp_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t class_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
+        const auto pp_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;     // num_predict_points
+        const auto class_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
 
         // create a work-item private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < num_features_; ++dim) {
-            // perform the dot product calculation
-            for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
-                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pd);
-                    const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
-
-                    temp[internal_pd][internal_class] += w_d_[dim * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] * predict_points_d_[dim * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+        // iterate over all features using blocking
+        for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
+            if constexpr (target == target_platform::cpu) {
+                // perform the dot product calculation, the feature is the fastest moving index
+                for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                    for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                        // calculate the indices to access the global data
+                        const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
+                        const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                        real_type sum{ 0.0 };
+                        for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                            sum += w_[(feature_block + feature) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] *                  // SoA
+                                   predict_points_[(feature_block + feature) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];  // SoA
+                        }
+                        temp[internal_pp][internal_class] += sum;
+                    }
+                }
+            } else {
+                // perform the dot product calculation, the feature is the slowest moving index
+                for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                            // calculate the indices to access the global data
+                            const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
+                            const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                            temp[internal_pp][internal_class] += w_[(feature_block + feature) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] *                  // SoA
+                                                                 predict_points_[(feature_block + feature) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];  // SoA
+                        }
+                    }
                 }
             }
         }
 
-        // update global array with local one
-        for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+        // update the global array with the local one
+        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
             for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                // calculate the indices to access the global data
+                const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
                 const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
-                const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pd);
 
-                prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp[internal_pd][internal_class] - rho_d_[global_class_idx];
+                prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp[internal_pp][internal_class] - rho_[global_class_idx];  // AoS
             }
         }
     }
 
   private:
     /// @cond Doxygen_suppress
-    real_type *prediction_d_;
-    const real_type *w_d_;
-    const real_type *rho_d_;
-    const real_type *predict_points_d_;
+    real_type *prediction_;
+    const real_type *w_;
+    const real_type *rho_;
+    const real_type *predict_points_;
     const std::size_t num_classes_;
     const std::size_t num_predict_points_;
     const std::size_t num_features_;
@@ -192,21 +253,25 @@ class device_kernel_predict_linear {
 };
 
 /**
- * @brief Predict the @p predict_points_d using the @p kernel_function.
+ * @brief Predict the @p predict_points using the @p kernel_function.
  * @details Uses SYCL's basic data parallel kernels.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function; stored in a `std::tuple`
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_predict {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::basic;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[in] prediction_d the predicted values
-     * @param[in] alpha_d the previously learned weights
-     * @param[in] rho_d the previously learned biases
-     * @param[in] sv_d the support vectors
-     * @param[in] predict_points_d the data points to predict
+     * @param[in] prediction the predicted values
+     * @param[in] alpha the previously learned weights
+     * @param[in] rho the previously learned biases
+     * @param[in] support_vectors the support vectors
+     * @param[in] predict_points the data points to predict
      * @param[in] num_classes the number of classes
      * @param[in] num_sv the number of support vectors
      * @param[in] num_predict_points the number of data points to predict
@@ -215,19 +280,19 @@ class device_kernel_predict {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_predict(real_type *prediction_d, const real_type *alpha_d, const real_type *rho_d, const real_type *sv_d, const real_type *predict_points_d, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
-        prediction_d_{ prediction_d },
-        alpha_d_{ alpha_d },
-        rho_d_{ rho_d },
-        sv_d_{ sv_d },
-        predict_points_d_{ predict_points_d },
+    device_kernel_predict(real_type *prediction, const real_type *alpha, const real_type *rho, const real_type *support_vectors, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+        prediction_{ prediction },
+        alpha_{ alpha },
+        rho_{ rho },
+        support_vectors_{ support_vectors },
+        predict_points_{ predict_points },
         num_classes_{ num_classes },
         num_sv_{ num_sv },
         num_predict_points_{ num_predict_points },
         num_features_{ num_features },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } { }
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } { }
 
     /**
      * @brief Function call operator overload performing the actual calculation.
@@ -235,54 +300,84 @@ class device_kernel_predict {
      */
     void operator()(::sycl::item<2> idx) const {
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
         // calculate the indices used in the current work-item
-        const std::size_t pp_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t sv_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE) * INTERNAL_BLOCK_SIZE_uz;
+        const auto pp_idx = (idx.get_id(1) + grid_x_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
+        const auto sv_idx = (idx.get_id(0) + grid_y_offset_ * THREAD_BLOCK_SIZE_uz) * INTERNAL_BLOCK_SIZE_uz;  // num_support_vectors
 
         // create a work-item private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < num_features_; ++dim) {
-            // perform the feature reduction calculation
-            for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
-                for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                    const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pd);
-                    const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
-
-                    temp[internal_pd][internal_sv] += detail::feature_reduce<kernel_function>(sv_d_[dim * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx],
-                                                                                              predict_points_d_[dim * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx]);
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+        // iterate over all features using blocking
+        for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
+            if constexpr (target == target_platform::cpu) {
+                // perform the feature reduction calculation, the feature is the fastest moving index
+                for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                    for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                        // calculate the indices to access the global data
+                        const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
+                        const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
+
+                        real_type sum{ 0.0 };
+                        for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                            sum += detail::feature_reduce<kernel_function>(support_vectors_[(feature_block + feature) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx],              // SoA
+                                                                           predict_points_[(feature_block + feature) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx]);  // SoA
+                        }
+                        temp[internal_pp][internal_sv] += sum;
+                    }
+                }
+            } else {
+                // perform the feature reduction calculation, the feature is the slowest moving index
+                for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                        for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                            // calculate the indices to access the global data
+                            const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
+                            const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
+
+                            temp[internal_pp][internal_sv] += detail::feature_reduce<kernel_function>(support_vectors_[(feature_block + feature) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx],              // SoA
+                                                                                                      predict_points_[(feature_block + feature) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx]);  // SoA
+                        }
+                    }
                 }
             }
         }
 
         // update temp using the respective kernel function
-        for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
             for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                temp[internal_pd][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pd][internal_sv], kernel_function_parameter_);
+                temp[internal_pp][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pp][internal_sv], kernel_function_parameter_);
             }
         }
 
-        // iterate over all features using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < num_classes_; ++dim) {
+        // iterate over all classes using blocking
+        for (std::size_t class_block = 0; class_block < num_classes_; class_block += THREAD_BLOCK_SIZE_uz) {
             if (sv_idx == 0) {
-                for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
-                    const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pd);
-                    detail::atomic_op<real_type>{ prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + dim] } += -rho_d_[dim];
+                for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                        // calculate the index to access the global data
+                        const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
+
+                        detail::atomic_op<real_type>{ prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + class_idx] } += -rho_[class_block + class_idx];
+                    }
                 }
             }
 
-            // calculate intermediate results and store them in local memory
-            for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+            // atomically add the results to the prediction
+            for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                 for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                    const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pd);
+                    // calculate the indices to access the global data
+                    const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
                     const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
 
-                    detail::atomic_op<real_type>{ prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + dim] } +=
-                        temp[internal_pd][internal_sv] * alpha_d_[dim * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
+                    for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
+                        detail::atomic_op<real_type>{ prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + class_idx] } +=
+                            alpha_[(class_block + class_idx) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx] *  // AoS
+                            temp[internal_pp][internal_sv];
+                    }
                 }
             }
         }
@@ -290,11 +385,11 @@ class device_kernel_predict {
 
   private:
     /// @cond Doxygen_suppress
-    real_type *prediction_d_;
-    const real_type *alpha_d_;
-    const real_type *rho_d_;
-    const real_type *sv_d_;
-    const real_type *predict_points_d_;
+    real_type *prediction_;
+    const real_type *alpha_;
+    const real_type *rho_;
+    const real_type *support_vectors_;
+    const real_type *predict_points_;
     const std::size_t num_classes_;
     const std::size_t num_sv_;
     const std::size_t num_predict_points_;
diff --git a/include/plssvm/backends/SYCL/kernel/predict/hierarchical/predict_kernel.hpp b/include/plssvm/backends/SYCL/kernel/predict/hierarchical/predict_kernel.hpp
index 4098c4914..512a80241 100644
--- a/include/plssvm/backends/SYCL/kernel/predict/hierarchical/predict_kernel.hpp
+++ b/include/plssvm/backends/SYCL/kernel/predict/hierarchical/predict_kernel.hpp
@@ -13,44 +13,52 @@
 #define PLSSVM_BACKENDS_SYCL_KERNEL_PREDICT_HIERARCHICAL_PREDICT_KERNEL_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/detail/atomics.hpp"           // plssvm::sycl::detail::atomic_op
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::group, sycl::private_memory, sycl::h_item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
 namespace plssvm::sycl::detail::hierarchical {
 
 /**
- * @brief Calculate the `q` vector used to speedup the prediction using the linear kernel function.
+ * @brief Calculate the `w` vector used to speedup the prediction using the linear kernel function.
  * @details Uses SYCL's hierarchical data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_w_linear {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::hierarchical;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[in,out] w_d the vector to speedup the linear prediction
-     * @param[in] alpha_d the previously learned weights
-     * @param[in] sv_d the support vectors
+     * @param[in,out] w the vector to speedup the linear prediction
+     * @param[in] alpha the previously learned weights
+     * @param[in] support_vectors the support vectors
      * @param[in] num_classes the number of classes
      * @param[in] num_sv the number of support vectors
-     * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
-     * @param[in] sv_offset the first support vector (row in @p alpha_d) the current device is responsible for
+     * @param[in] device_num_sv the number of support vectors the current device is responsible for
+     * @param[in] device_sv_offset the first support vector (row in @p alpha) the current device is responsible for
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_w_linear(real_type *w_d, const real_type *alpha_d, const real_type *sv_d, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_specific_num_sv, const std::size_t sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
-        w_d_{ w_d },
-        alpha_d_{ alpha_d },
-        sv_d_{ sv_d },
+    device_kernel_w_linear(real_type *w, const real_type *alpha, const real_type *support_vectors, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_num_sv, const std::size_t device_sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+        w_{ w },
+        alpha_{ alpha },
+        support_vectors_{ support_vectors },
         num_classes_{ num_classes },
         num_sv_{ num_sv },
-        device_specific_num_sv_{ device_specific_num_sv },
-        sv_offset_{ sv_offset },
+        device_num_sv_{ device_num_sv },
+        device_sv_offset_{ device_sv_offset },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset } { }
 
@@ -59,36 +67,15 @@ class device_kernel_w_linear {
      * @param[in] group indices representing the current point in the execution space
      */
     void operator()(::sycl::group<2> group) const {
-        // allocate shared memory
-        real_type data_cache_feature[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-        real_type data_cache_alpha[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-
-        // calculate the indices used in the current work-item
-        ::sycl::private_memory<std::size_t, 2> feature_idx{ group };
-        ::sycl::private_memory<std::size_t, 2> feature_idx_linear{ group };
-        ::sycl::private_memory<std::size_t, 2> class_idx{ group };
-        ::sycl::private_memory<std::size_t, 2> class_idx_linear{ group };
+        // create two local memory arrays used for caching
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> feature_cache{};
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> alpha_cache{};
 
-        ::sycl::private_memory<real_type[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE], 2> temp{ group };
+        // create a private memory array used for internal caching
+        ::sycl::private_memory<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, 2> temp{ group };
 
-        // initialize private and local variables
+        // initialize private temp matrix to zero
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            const std::size_t threadIdx_x = idx.get_local_id(0);       // current thread in block x-dimension
-            const std::size_t threadIdx_y = idx.get_local_id(1);       // current thread in block y-dimension
-            const std::size_t blockDim_x = idx.get_local_range(0);     // number of threads in block x-dimension
-            const std::size_t blockDim_y = idx.get_local_range(1);     // number of threads in block y-dimension
-            const std::size_t blockIdx_x = group[0] + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-            const std::size_t blockIdx_y = group[1] + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-            const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-            // indices
-            feature_idx(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-            feature_idx_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-            class_idx(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-            class_idx_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-
-            // initialize private temp matrix to zero
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
                     temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
@@ -99,23 +86,36 @@ class device_kernel_w_linear {
         // implicit group barrier
 
         // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-        for (std::size_t sv = 0; sv < device_specific_num_sv_; sv += THREAD_BLOCK_SIZE) {
+        for (std::size_t sv_block = 0; sv_block < device_num_sv_; sv_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
             // load data into local memory
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                // cast values to 32-bit unsigned int values to prevent implicit conversions
                 const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                 const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                const std::size_t threadIdx_x = idx.get_local_id(0);
+                // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+                const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+                const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+                const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+                const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+                const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+                // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+                const auto feature_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_features
+                const auto class_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;    // num_classes
 
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_class_idx = class_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                    const auto global_feature_idx = feature_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_feature_idx_linear = feature_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                    data_cache_feature[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = sv_d_[global_feature_idx * (device_specific_num_sv_ + PADDING_SIZE_uz) + sv + threadIdx_x];  // SoA
-                    data_cache_alpha[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_d_[global_class_idx * (num_sv_ + PADDING_SIZE_uz) + sv + sv_offset_ + threadIdx_x];      // AoS
+                    feature_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = support_vectors_[global_feature_idx_linear * (device_num_sv_ + PADDING_SIZE_uz) + sv_block + threadIdx_x];  // SoA
+                    alpha_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_[global_class_idx_linear * (num_sv_ + PADDING_SIZE_uz) + sv_block + device_sv_offset_ + threadIdx_x];   // AoS
                 }
             });
 
@@ -123,13 +123,28 @@ class device_kernel_w_linear {
 
             // perform the dot product calculation
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                // cast values to 32-bit unsigned int values to prevent implicit conversions
                 const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                 const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                for (unsigned block_dim = 0; block_dim < THREAD_BLOCK_SIZE; ++block_dim) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the sv is the fastest moving index
                     for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
                         for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                            temp(idx)[internal_feature][internal_class] += data_cache_alpha[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_feature[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_feature];
+                            real_type sum{ 0.0 };
+                            for (unsigned sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                                sum += alpha_cache[sv][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * feature_cache[sv][local_id_1 * INTERNAL_BLOCK_SIZE + internal_feature];
+                            }
+                            temp(idx)[internal_feature][internal_class] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the sv is the slowest moving index
+                    for (unsigned sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                        for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                temp(idx)[internal_feature][internal_class] += alpha_cache[sv][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * feature_cache[sv][local_id_1 * INTERNAL_BLOCK_SIZE + internal_feature];
+                            }
                         }
                     }
                 }
@@ -138,16 +153,30 @@ class device_kernel_w_linear {
             // implicit group barrier
         }
 
-        // update global array with local one
+        // update the global w-vector with the locally cached values
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+            // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+            constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+            constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+            const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+            const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+            const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+            const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+            const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+            const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+            // calculate the indices used in the current work-item
+            const auto feature_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+            const auto class_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;    // num_classes
 
             for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
                 for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    const auto global_class_idx = class_idx(idx) + static_cast<std::size_t>(internal_class);
-                    const auto global_feature_idx = feature_idx(idx) + static_cast<std::size_t>(internal_feature);
+                    // calculate the indices to access the global data
+                    const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                    const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                    w_d_[global_feature_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp(idx)[internal_feature][internal_class];
+                    w_[global_feature_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp(idx)[internal_feature][internal_class];  // SoA
                 }
             }
         });
@@ -155,41 +184,46 @@ class device_kernel_w_linear {
 
   private:
     /// @cond Doxygen_suppress
-    real_type *w_d_;
-    const real_type *alpha_d_;
-    const real_type *sv_d_;
+    real_type *w_;
+    const real_type *alpha_;
+    const real_type *support_vectors_;
     const std::size_t num_classes_;
     const std::size_t num_sv_;
-    const std::size_t device_specific_num_sv_;
-    const std::size_t sv_offset_;
+    const std::size_t device_num_sv_;
+    const std::size_t device_sv_offset_;
     const std::size_t grid_x_offset_;
     const std::size_t grid_y_offset_;
     /// @endcond
 };
 
 /**
- * @brief Predict the @p predict_points_d using the linear kernel speeding up the calculation using the @p w_d vector.
+ * @brief Predict the @p predict_points using the linear kernel speeding up the calculation using the @p w vector.
  * @details Uses SYCL's hierarchical data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_predict_linear {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::hierarchical;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[out] prediction_d the predicted values
-     * @param[in] w_d the vector to speedup the calculations
-     * @param[in] rho_d the previously learned bias
-     * @param[in] predict_points_d the data points to predict
+     * @param[out] prediction the predicted values
+     * @param[in] w the vector to speedup the calculations
+     * @param[in] rho the previously learned bias
+     * @param[in] predict_points the data points to predict
      * @param[in] num_classes the number of classes
      * @param[in] num_predict_points the number of data points to predict
      * @param[in] num_features the number of features per data point
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_predict_linear(real_type *prediction_d, const real_type *w_d, const real_type *rho_d, const real_type *predict_points_d, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
-        prediction_d_{ prediction_d },
-        w_d_{ w_d },
-        rho_d_{ rho_d },
-        predict_points_d_{ predict_points_d },
+    device_kernel_predict_linear(real_type *prediction, const real_type *w, const real_type *rho, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+        prediction_{ prediction },
+        w_{ w },
+        rho_{ rho },
+        predict_points_{ predict_points },
         num_classes_{ num_classes },
         num_predict_points_{ num_predict_points },
         num_features_{ num_features },
@@ -201,35 +235,15 @@ class device_kernel_predict_linear {
      * @param[in] group indices representing the current point in the execution space
      */
     void operator()(::sycl::group<2> group) const {
-        // allocate shared memory
-        real_type data_cache_pp[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-        real_type data_cache_w[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
+        // create two local memory arrays used for caching
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> pp_cache{};
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> w_cache{};
 
-        // calculate the indices used in the current work-item
-        ::sycl::private_memory<std::size_t, 2> pp_idx{ group };
-        ::sycl::private_memory<std::size_t, 2> pp_idx_linear{ group };
-        ::sycl::private_memory<std::size_t, 2> class_idx{ group };
-        ::sycl::private_memory<std::size_t, 2> class_idx_linear{ group };
+        // create a private memory array used for internal caching
+        ::sycl::private_memory<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, 2> temp{ group };
 
-        ::sycl::private_memory<real_type[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE], 2> temp{ group };
-
-        // initialize private and local variables
+        // initialize private variable
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            const std::size_t threadIdx_x = idx.get_local_id(0);       // current thread in block x-dimension
-            const std::size_t threadIdx_y = idx.get_local_id(1);       // current thread in block y-dimension
-            const std::size_t blockDim_x = idx.get_local_range(0);     // number of threads in block x-dimension
-            const std::size_t blockDim_y = idx.get_local_range(1);     // number of threads in block y-dimension
-            const std::size_t blockIdx_x = group[0] + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-            const std::size_t blockIdx_y = group[1] + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-            const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-            // indices
-            pp_idx(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-            pp_idx_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-            class_idx(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-            class_idx_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-
             // initialize private temp matrix to zero
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
@@ -240,27 +254,38 @@ class device_kernel_predict_linear {
 
         // implicit group barrier
 
-        // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < num_features_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+        // iterate over all features using blocking to be able to cache them for faster memory accesses
+        for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                // cast values to 32-bit unsigned int values to prevent implicit conversions
                 const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                 const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                const std::size_t threadIdx_x = idx.get_local_id(0);
+                // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+                const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+                const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+                const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+                const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+                const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
-                // load data into shared memory
+                // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+                const auto pp_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;     // num_predict_points
+                const auto class_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_classes
+
+                // load data into local memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_pp_idx = pp_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                    const auto global_class_idx = class_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                    data_cache_pp[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                    data_cache_pp[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                    data_cache_w[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = w_d_[(dim + threadIdx_x) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx];
-                    data_cache_w[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = w_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx];
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the local memory
+                    pp_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_[(feature_block + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                    w_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = w_[(feature_block + threadIdx_x) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx_linear];                    // SoA
                 }
             });
 
@@ -268,13 +293,28 @@ class device_kernel_predict_linear {
 
             // perform the dot product calculation
             group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                // cast values to 32-bit unsigned int values to prevent implicit conversions
                 const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                 const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                    for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the feature is the fastest moving index
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                         for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                            temp(idx)[internal_pd][internal_class] += data_cache_w[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_pp[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pd];
+                            real_type sum{ 0.0 };
+                            for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                sum += w_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * pp_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp];
+                            }
+                            temp(idx)[internal_pp][internal_class] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the feature is the slowest moving index
+                    for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                temp(idx)[internal_pp][internal_class] += w_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * pp_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp];
+                            }
                         }
                     }
                 }
@@ -283,16 +323,30 @@ class device_kernel_predict_linear {
             // implicit group barrier
         }
 
-        // update global array with local one
+        // update the global array with the local one
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-            for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+            // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+            constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+            constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+            const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+            const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+            const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+            const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+            const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+            const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
+
+            // calculate the indices used in the current work-item
+            const auto pp_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;     // num_predict_points
+            const auto class_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
+
+            for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                 for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    const auto global_class_idx = class_idx(idx) + static_cast<std::size_t>(internal_class);
-                    const auto global_pp_idx = pp_idx(idx) + static_cast<std::size_t>(internal_pd);
+                    // calculate the indices to access the global data
+                    const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
+                    const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                    prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp(idx)[internal_pd][internal_class] - rho_d_[global_class_idx];
+                    prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp(idx)[internal_pp][internal_class] - rho_[global_class_idx];  // AoS
                 }
             }
         });
@@ -300,10 +354,10 @@ class device_kernel_predict_linear {
 
   private:
     /// @cond Doxygen_suppress
-    real_type *prediction_d_;
-    const real_type *w_d_;
-    const real_type *rho_d_;
-    const real_type *predict_points_d_;
+    real_type *prediction_;
+    const real_type *w_;
+    const real_type *rho_;
+    const real_type *predict_points_;
     const std::size_t num_classes_;
     const std::size_t num_predict_points_;
     const std::size_t num_features_;
@@ -313,21 +367,25 @@ class device_kernel_predict_linear {
 };
 
 /**
- * @brief Predict the @p predict_points_d using the @p kernel_function.
+ * @brief Predict the @p predict_points using the @p kernel_function.
  * @details Uses SYCL's hierarchical data parallel kernels.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function; stored in a `std::tuple`
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_predict {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::hierarchical;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[in] prediction_d the predicted values
-     * @param[in] alpha_d the previously learned weights
-     * @param[in] rho_d the previously learned biases
-     * @param[in] sv_d the support vectors
-     * @param[in] predict_points_d the data points to predict
+     * @param[in] prediction the predicted values
+     * @param[in] alpha the previously learned weights
+     * @param[in] rho the previously learned biases
+     * @param[in] support_vectors the support vectors
+     * @param[in] predict_points the data points to predict
      * @param[in] num_classes the number of classes
      * @param[in] num_sv the number of support vectors
      * @param[in] num_predict_points the number of data points to predict
@@ -336,51 +394,34 @@ class device_kernel_predict {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_predict(real_type *prediction_d, const real_type *alpha_d, const real_type *rho_d, const real_type *sv_d, const real_type *predict_points_d, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
-        prediction_d_{ prediction_d },
-        alpha_d_{ alpha_d },
-        rho_d_{ rho_d },
-        sv_d_{ sv_d },
-        predict_points_d_{ predict_points_d },
+    device_kernel_predict(real_type *prediction, const real_type *alpha, const real_type *rho, const real_type *support_vectors, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+        prediction_{ prediction },
+        alpha_{ alpha },
+        rho_{ rho },
+        support_vectors_{ support_vectors },
+        predict_points_{ predict_points },
         num_classes_{ num_classes },
         num_sv_{ num_sv },
         num_predict_points_{ num_predict_points },
         num_features_{ num_features },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } { }
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } { }
 
     /**
      * @brief Function call operator overload performing the actual calculation.
      * @param[in] group indices representing the current point in the execution space
      */
     void operator()(::sycl::group<2> group) const {
-        // allocate shared memory
-        real_type data_cache_pp[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-        real_type data_cache_sv[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE];
-
-        // calculate the indices used in the current work-item
-        ::sycl::private_memory<std::size_t, 2> pp_idx{ group };
-        ::sycl::private_memory<std::size_t, 2> pp_idx_linear{ group };
-        ::sycl::private_memory<std::size_t, 2> sv_idx_linear{ group };
+        // create two local memory arrays used for caching
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> cache_one{};
+        std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)> cache_two{};
 
-        ::sycl::private_memory<real_type[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE], 2> temp{ group };
+        // create a private memory array used for internal caching
+        ::sycl::private_memory<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, 2> temp{ group };
 
-        // initialize private and local variables
+        // initialize private variable
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            const std::size_t threadIdx_y = idx.get_local_id(1);       // current thread in block y-dimension
-            const std::size_t blockDim_x = idx.get_local_range(0);     // number of threads in block x-dimension
-            const std::size_t blockDim_y = idx.get_local_range(1);     // number of threads in block y-dimension
-            const std::size_t blockIdx_x = group[0] + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-            const std::size_t blockIdx_y = group[1] + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-
-            const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-            // indices
-            pp_idx(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-            pp_idx_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-            sv_idx_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-
             // initialize private temp matrix to zero
             for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
                 for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
@@ -392,27 +433,42 @@ class device_kernel_predict {
         // implicit group barrier
 
         {
+            // rename cached arrays -> not possible due to an AdaptiveCpp runtime exception
+            // auto &pp_cache = cache_one;
+            // auto &sv_cache = cache_two;
+
             // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (std::size_t dim = 0; dim < num_features_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+            for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
                 group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                    // cast values to 32-bit unsigned int values to prevent implicit conversions
                     const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                     const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                    const std::size_t threadIdx_x = idx.get_local_id(0);
+                    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                    const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+                    const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+                    const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+                    const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+                    const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+                    const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
-                    const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                    // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+                    const auto pp_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_predict_points
+                    const auto sv_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_support_vectors
 
                     // load data into local memory
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_pp_idx = pp_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                        const auto global_sv_idx = sv_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                        // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                        data_cache_pp[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                        data_cache_pp[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                        data_cache_sv[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = sv_d_[(dim + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
-                        data_cache_sv[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = sv_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                        const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                        // store the values in the local memory
+                        cache_one[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_[(feature_block + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx_linear];
+                        cache_two[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = support_vectors_[(feature_block + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx_linear];
                     }
                 });
 
@@ -420,14 +476,30 @@ class device_kernel_predict {
 
                 // perform the feature reduction calculation
                 group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                    // cast values to 32-bit unsigned int values to prevent implicit conversions
                     const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                     const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                    for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                        for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                    if constexpr (target == target_platform::cpu) {
+                        // perform the feature reduction calculation, the feature is the fastest moving index
+                        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                             for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                                temp(idx)[internal_pd][internal_sv] += detail::feature_reduce<kernel_function>(data_cache_sv[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv],
-                                                                                                               data_cache_pp[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pd]);
+                                real_type sum{ 0.0 };
+                                for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                    sum += detail::feature_reduce<kernel_function>(cache_two[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv],
+                                                                                   cache_one[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp]);
+                                }
+                                temp(idx)[internal_pp][internal_sv] += sum;
+                            }
+                        }
+                    } else {
+                        // perform the feature reduction calculation, the feature is the slowest moving index
+                        for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                            for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                                for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                                    temp(idx)[internal_pp][internal_sv] += detail::feature_reduce<kernel_function>(cache_two[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv],
+                                                                                                                   cache_one[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp]);
+                                }
                             }
                         }
                     }
@@ -439,9 +511,9 @@ class device_kernel_predict {
 
         // update temp using the respective kernel function
         group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
-            for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+            for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                 for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                    temp(idx)[internal_pd][internal_sv] = detail::apply_kernel_function<kernel_function>(temp(idx)[internal_pd][internal_sv], kernel_function_parameter_);
+                    temp(idx)[internal_pp][internal_sv] = detail::apply_kernel_function<kernel_function>(temp(idx)[internal_pp][internal_sv], kernel_function_parameter_);
                 }
             }
         });
@@ -449,36 +521,42 @@ class device_kernel_predict {
         // implicit group barrier
 
         {
-            // rename cached arrays -> can't rename the arrays due to AdaptiveCpp runtime exception
-            // auto &alpha_cache = data_cache_pp;
-            // auto &out_cache = data_cache_sv;
+            // rename cached arrays -> not possible due to an AdaptiveCpp runtime exception
+            // auto &alpha_cache = cache_one;
+            // auto &out_cache = cache_two;
 
-            // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (std::size_t dim = 0; dim < num_classes_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+            // iterate over all classes using blocking to be able to cache them for faster memory accesses
+            for (std::size_t class_block = 0; class_block < num_classes_; class_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
                 // load data into local memory
                 group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                    // cast values to 32-bit unsigned int values to prevent implicit conversions
                     const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                     const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                    const std::size_t blockIdx_x = group[0] + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-                    const std::size_t threadIdx_x = idx.get_local_id(0);
+                    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                    constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                    const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                    const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+                    const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+                    const auto blockDim_x = static_cast<std::size_t>(idx.get_local_range(0));     // number of work-items in work-group x-dimension
+                    const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
 
-                    for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const std::size_t global_sv_idx = sv_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+                    const auto sv_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_support_vectors
 
-                        data_cache_pp[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_d_[(dim + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
-                        data_cache_pp[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
+                    for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                        // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                        const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
+                        // store the values in the local memory
+                        cache_one[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_[(class_block + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx_linear];  // AoS
                         // the bias (rho) must only be applied once for all support vectors
                         if (blockIdx_x == std::size_t{ 0 }) {
-                            data_cache_sv[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = -rho_d_[dim + threadIdx_x];
-                            data_cache_sv[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = -rho_d_[dim + threadIdx_x + THREAD_BLOCK_SIZE_uz];
+                            cache_two[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = -rho_[class_block + threadIdx_x];
                         } else {
-                            data_cache_sv[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
-                            data_cache_sv[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
+                            cache_two[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
                         }
                     }
                 });
@@ -486,15 +564,16 @@ class device_kernel_predict {
                 // implicit group barrier
 
                 // calculate intermediate results and store them in local memory
-                for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                     group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                        // cast values to 32-bit unsigned int values to prevent implicit conversions
                         const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                         const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                        for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                             for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                                data_cache_sv[(class_idx + local_id_0) % FEATURE_BLOCK_SIZE][internal_pd * THREAD_BLOCK_SIZE + local_id_1] +=
-                                    temp(idx)[internal_pd][internal_sv] * data_cache_pp[(class_idx + local_id_0) % FEATURE_BLOCK_SIZE][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv];
+                                cache_two[(class_idx + local_id_0) % THREAD_BLOCK_SIZE][internal_pp * THREAD_BLOCK_SIZE + local_id_1] +=
+                                    temp(idx)[internal_pp][internal_sv] * cache_one[(class_idx + local_id_0) % THREAD_BLOCK_SIZE][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv];
                             }
                         }
                     });
@@ -502,21 +581,29 @@ class device_kernel_predict {
                     // implicit group barrier
                 }
 
-                // add intermediate cached results to prediction_d
+                // atomically add the intermediate cached results to the prediction
                 group.parallel_for_work_item([&](::sycl::h_item<2> idx) {
+                    // cast values to 32-bit unsigned int values to prevent implicit conversions
                     const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(0));
                     const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(1));
 
-                    const std::size_t threadIdx_x = idx.get_local_id(0);
+                    // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                    constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                    constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                    const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(0));       // current work-item in work-group x-dimension
+                    const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(1));       // current work-item in work-group y-dimension
+                    const auto blockDim_y = static_cast<std::size_t>(idx.get_local_range(1));     // number of work-items in work-group y-dimension
+                    const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
-                    const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                    // calculate the indices used in the current thread
+                    const auto pp_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
 
                     for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                        const auto global_pp_idx = pp_idx(idx) + static_cast<std::size_t>(internal);
+                        // calculate the indices to access the global data
+                        const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal);
 
-                        detail::atomic_op<real_type>{ prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x] } += data_cache_sv[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1];
-                        detail::atomic_op<real_type>{ prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz] } += data_cache_sv[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1];
+                        detail::atomic_op<real_type>{ prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x] } += cache_two[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1];
                     }
                 });
 
@@ -527,11 +614,11 @@ class device_kernel_predict {
 
   private:
     /// @cond Doxygen_suppress
-    real_type *prediction_d_;
-    const real_type *alpha_d_;
-    const real_type *rho_d_;
-    const real_type *sv_d_;
-    const real_type *predict_points_d_;
+    real_type *prediction_;
+    const real_type *alpha_;
+    const real_type *rho_;
+    const real_type *support_vectors_;
+    const real_type *predict_points_;
     const std::size_t num_classes_;
     const std::size_t num_sv_;
     const std::size_t num_predict_points_;
diff --git a/include/plssvm/backends/SYCL/kernel/predict/scoped/predict_kernel.hpp b/include/plssvm/backends/SYCL/kernel/predict/scoped/predict_kernel.hpp
index 1a42161f5..7a7e3a711 100644
--- a/include/plssvm/backends/SYCL/kernel/predict/scoped/predict_kernel.hpp
+++ b/include/plssvm/backends/SYCL/kernel/predict/scoped/predict_kernel.hpp
@@ -13,44 +13,52 @@
 #define PLSSVM_BACKENDS_SYCL_KERNEL_PREDICT_SCOPED_PREDICT_KERNEL_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/detail/atomics.hpp"           // plssvm::sycl::detail::atomic_op
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::memory_environment, sycl::require_local_mem, sycl::require_private_mem, sycl::distribute_items_and_wait, sycl::s_item
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
 namespace plssvm::sycl::detail::scoped {
 
 /**
- * @brief Calculate the `q` vector used to speedup the prediction using the linear kernel function.
+ * @brief Calculate the `w` vector used to speedup the prediction using the linear kernel function.
  * @details Uses AdaptiveCpp's scoped parallelism.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_w_linear {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::scoped;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[in,out] w_d the vector to speedup the linear prediction
-     * @param[in] alpha_d the previously learned weights
-     * @param[in] sv_d the support vectors
+     * @param[in,out] w the vector to speedup the linear prediction
+     * @param[in] alpha the previously learned weights
+     * @param[in] support_vectors the support vectors
      * @param[in] num_classes the number of classes
      * @param[in] num_sv the number of support vectors
-     * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
-     * @param[in] sv_offset the first support vector (row in @p alpha_d) the current device is responsible for
+     * @param[in] device_num_sv the number of support vectors the current device is responsible for
+     * @param[in] device_sv_offset the first support vector (row in @p alpha) the current device is responsible for
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_w_linear(real_type *w_d, const real_type *alpha_d, const real_type *sv_d, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_specific_num_sv, const std::size_t sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
-        w_d_{ w_d },
-        alpha_d_{ alpha_d },
-        sv_d_{ sv_d },
+    device_kernel_w_linear(real_type *w, const real_type *alpha, const real_type *support_vectors, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_num_sv, const std::size_t device_sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+        w_{ w },
+        alpha_{ alpha },
+        support_vectors_{ support_vectors },
         num_classes_{ num_classes },
         num_sv_{ num_sv },
-        device_specific_num_sv_{ device_specific_num_sv },
-        sv_offset_{ sv_offset },
+        device_num_sv_{ device_num_sv },
+        device_sv_offset_{ device_sv_offset },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset } { }
 
@@ -62,78 +70,110 @@ class device_kernel_w_linear {
     template <typename T>
     void operator()(T group) const {
         ::sycl::memory_environment(group,
-                                   ::sycl::require_local_mem<real_type[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_local_mem<real_type[THREAD_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE>>({}),
-                                   [&](auto &data_cache_feature, auto &data_cache_alpha, auto &feature_idx, auto &feature_idx_linear, auto &class_idx, auto &class_idx_linear, auto &temp) {
-                                       // initialize private and local variables
+                                   // create two local memory arrays used for caching
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // feature_cache
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // alpha_cache
+
+                                   // create a private memory array used for internal caching
+                                   ::sycl::require_private_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>>(),
+                                   [&](auto &feature_cache, auto &alpha_cache, auto &temp) {
+                                       // initialize private temp matrix to zero
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const std::size_t threadIdx_x = idx.get_local_id(group, 0);       // current thread in block x-dimension
-                                           const std::size_t threadIdx_y = idx.get_local_id(group, 1);       // current thread in block y-dimension
-                                           const std::size_t blockDim_x = group.get_logical_local_range(0);  // number of threads in block x-dimension
-                                           const std::size_t blockDim_y = group.get_logical_local_range(1);  // number of threads in block y-dimension
-                                           const std::size_t blockIdx_x = group[0] + grid_x_offset_;         // current block in grid x-dimension + offsets if the grid size would be too large
-                                           const std::size_t blockIdx_y = group[1] + grid_y_offset_;         // current block in grid y-dimension + offsets if the grid size would be too large
-
-                                           const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-                                           // indices
-                                           feature_idx(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-                                           feature_idx_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-                                           class_idx(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-                                           class_idx_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+                                           for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                               for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                   temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
+                                               }
+                                           }
                                        });
 
                                        // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-                                       for (std::size_t sv = 0; sv < device_specific_num_sv_; sv += THREAD_BLOCK_SIZE) {
+                                       for (std::size_t sv_block = 0; sv_block < device_num_sv_; sv_block += THREAD_BLOCK_SIZE) {
                                            // load data into local memory
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                               // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                               const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                               // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                               constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                               constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                                               constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                                               const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                               const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                               const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                               const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                               const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                               const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                               const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                               const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
+
+                                               // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+                                               const auto feature_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_features
+                                               const auto class_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;    // num_classes
 
                                                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                   const auto global_class_idx = class_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                                                   const auto global_feature_idx = feature_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                   // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                                   const auto global_feature_idx_linear = feature_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                   const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-                                                   data_cache_feature[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = sv_d_[global_feature_idx * (device_specific_num_sv_ + PADDING_SIZE_uz) + sv + threadIdx_x];  // SoA
-                                                   data_cache_alpha[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_d_[global_class_idx * (num_sv_ + PADDING_SIZE_uz) + sv + sv_offset_ + threadIdx_x];      // AoS
+                                                   feature_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = support_vectors_[global_feature_idx_linear * (device_num_sv_ + PADDING_SIZE_uz) + sv_block + threadIdx_x];  // SoA
+                                                   alpha_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_[global_class_idx_linear * (num_sv_ + PADDING_SIZE_uz) + sv_block + device_sv_offset_ + threadIdx_x];   // AoS
                                                }
                                            });
 
                                            // perform the dot product calculation
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                               // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                               for (unsigned block_dim = 0; block_dim < THREAD_BLOCK_SIZE; ++block_dim) {
+                                               if constexpr (target == target_platform::cpu) {
+                                                   // perform the dot product calculation, the sv is the fastest moving index
                                                    for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
                                                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                                                           temp(idx)[internal_feature][internal_class] += data_cache_alpha[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_feature[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_feature];
+                                                           real_type sum{ 0.0 };
+                                                           for (unsigned sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                                                               sum += alpha_cache[sv][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * feature_cache[sv][local_id_1 * INTERNAL_BLOCK_SIZE + internal_feature];
+                                                           }
+                                                           temp(idx)[internal_feature][internal_class] += sum;
+                                                       }
+                                                   }
+                                               } else {
+                                                   // perform the dot product calculation, the sv is the fastest moving index
+                                                   for (unsigned sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                                                       for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                                                           for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                                               temp(idx)[internal_feature][internal_class] += alpha_cache[sv][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * feature_cache[sv][local_id_1 * INTERNAL_BLOCK_SIZE + internal_feature];
+                                                           }
                                                        }
                                                    }
                                                }
                                            });
                                        }
 
-                                       // update global array with local one
+                                       // update the global w-vector with the locally cached values
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                           // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                           constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                           constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                                           const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                           const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                           const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                           const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                           const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                           const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
+
+                                           // calculate the indices used in the current thread
+                                           const auto feature_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+                                           const auto class_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;    // num_classes
 
                                            for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
                                                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                                                   const auto global_class_idx = class_idx(idx) + static_cast<std::size_t>(internal_class);
-                                                   const auto global_feature_idx = feature_idx(idx) + static_cast<std::size_t>(internal_feature);
+                                                   // calculate the indices to access the global data
+                                                   const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                                                   const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                                                   w_d_[global_feature_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp(idx)[internal_feature][internal_class];
+                                                   w_[global_feature_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp(idx)[internal_feature][internal_class];  // SoA
                                                }
                                            }
                                        });
@@ -142,41 +182,46 @@ class device_kernel_w_linear {
 
   private:
     /// @cond Doxygen_suppress
-    real_type *w_d_;
-    const real_type *alpha_d_;
-    const real_type *sv_d_;
+    real_type *w_;
+    const real_type *alpha_;
+    const real_type *support_vectors_;
     const std::size_t num_classes_;
     const std::size_t num_sv_;
-    const std::size_t device_specific_num_sv_;
-    const std::size_t sv_offset_;
+    const std::size_t device_num_sv_;
+    const std::size_t device_sv_offset_;
     const std::size_t grid_x_offset_;
     const std::size_t grid_y_offset_;
     /// @endcond
 };
 
 /**
- * @brief Predict the @p predict_points_d using the linear kernel speeding up the calculation using the @p w_d vector.
+ * @brief Predict the @p predict_points using the linear kernel speeding up the calculation using the @p w vector.
  * @details Uses AdaptiveCpp's scoped parallelism.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_predict_linear {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::scoped;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[out] prediction_d the predicted values
-     * @param[in] w_d the vector to speedup the calculations
-     * @param[in] rho_d the previously learned bias
-     * @param[in] predict_points_d the data points to predict
+     * @param[out] prediction the predicted values
+     * @param[in] w the vector to speedup the calculations
+     * @param[in] rho the previously learned bias
+     * @param[in] predict_points the data points to predict
      * @param[in] num_classes the number of classes
      * @param[in] num_predict_points the number of data points to predict
      * @param[in] num_features the number of features per data point
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_predict_linear(real_type *prediction_d, const real_type *w_d, const real_type *rho_d, const real_type *predict_points_d, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
-        prediction_d_{ prediction_d },
-        w_d_{ w_d },
-        rho_d_{ rho_d },
-        predict_points_d_{ predict_points_d },
+    device_kernel_predict_linear(real_type *prediction, const real_type *w, const real_type *rho, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+        prediction_{ prediction },
+        w_{ w },
+        rho_{ rho },
+        predict_points_{ predict_points },
         num_classes_{ num_classes },
         num_predict_points_{ num_predict_points },
         num_features_{ num_features },
@@ -191,81 +236,110 @@ class device_kernel_predict_linear {
     template <typename T>
     void operator()(T group) const {
         ::sycl::memory_environment(group,
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE>>({}),
-                                   [&](auto &data_cache_pp, auto &data_cache_w, auto &pp_idx, auto &pp_idx_linear, auto &class_idx, auto &class_idx_linear, auto &temp) {
-                                       // initialize private and local variables
+                                   // create two local memory arrays used for caching
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // pp_cache
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // w_cache
+
+                                   // create a private memory array used for internal caching
+                                   ::sycl::require_private_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>>(),
+                                   [&](auto &pp_cache, auto &w_cache, auto &temp) {
+                                       // initialize private temp matrix to zero
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const std::size_t threadIdx_x = idx.get_local_id(group, 0);       // current thread in block x-dimension
-                                           const std::size_t threadIdx_y = idx.get_local_id(group, 1);       // current thread in block y-dimension
-                                           const std::size_t blockDim_x = group.get_logical_local_range(0);  // number of threads in block x-dimension
-                                           const std::size_t blockDim_y = group.get_logical_local_range(1);  // number of threads in block y-dimension
-                                           const std::size_t blockIdx_x = group[0] + grid_x_offset_;         // current block in grid x-dimension + offsets if the grid size would be too large
-                                           const std::size_t blockIdx_y = group[1] + grid_y_offset_;         // current block in grid y-dimension + offsets if the grid size would be too large
-
-                                           const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-                                           // indices
-                                           pp_idx(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-                                           pp_idx_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-                                           class_idx(idx) = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-                                           class_idx_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+                                           for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                               for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                   temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
+                                               }
+                                           }
                                        });
-
-                                       // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-                                       for (std::size_t dim = 0; dim < num_features_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+                                       // iterate over all features using blocking to be able to cache them for faster memory accesses
+                                       for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                               // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                               const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                               // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                               constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                               constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                                               constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                                               const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                               const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                               const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                               const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                               const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                               const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
 
-                                               const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                               const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                               // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+                                               const auto pp_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;     // num_predict_points
+                                               const auto class_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_classes
 
-                                               // load data into shared memory
+                                               // load data into local memory
                                                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                   const auto global_pp_idx = pp_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                                                   const auto global_class_idx = class_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                                                   // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                                                   data_cache_pp[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                                                   data_cache_pp[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                                                   data_cache_w[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = w_d_[(dim + threadIdx_x) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx];
-                                                   data_cache_w[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = w_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx];
+                                                   // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                                   const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                   const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                                                   // store the values in the local memory
+                                                   pp_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_[(feature_block + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                                                   w_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = w_[(feature_block + threadIdx_x) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx_linear];                    // SoA
                                                }
                                            });
 
                                            // perform the dot product calculation
                                            ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                               // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                               for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                                                   for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                                               if constexpr (target == target_platform::cpu) {
+                                                   // perform the dot product calculation, the feature is the fastest moving index
+                                                   for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                                                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                                                           temp(idx)[internal_pd][internal_class] += data_cache_w[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_pp[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pd];
+                                                           real_type sum{ 0.0 };
+                                                           for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                                               sum += w_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * pp_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp];
+                                                           }
+                                                           temp(idx)[internal_pp][internal_class] += sum;
+                                                       }
+                                                   }
+                                               } else {
+                                                   // perform the dot product calculation, the feature is the slowest moving index
+                                                   for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                                       for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                                                           for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                                               temp(idx)[internal_pp][internal_class] += w_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * pp_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp];
+                                                           }
                                                        }
                                                    }
                                                }
                                            });
                                        }
 
-                                       // update global array with local one
+                                       // update the global array with the local one
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-                                           for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                                           // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                           constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                           constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                                           const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                           const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                           const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                           const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                           const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                           const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
+
+                                           // calculate the indices used in the current work-item
+                                           const auto pp_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;     // num_predict_points
+                                           const auto class_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
+
+                                           for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                                                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                                                   const auto global_class_idx = class_idx(idx) + static_cast<std::size_t>(internal_class);
-                                                   const auto global_pp_idx = pp_idx(idx) + static_cast<std::size_t>(internal_pd);
+                                                   // calculate the indices to access the global data
+                                                   const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
+                                                   const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                                                   prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp(idx)[internal_pd][internal_class] - rho_d_[global_class_idx];
+                                                   prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp(idx)[internal_pp][internal_class] - rho_[global_class_idx];  // AoS
                                                }
                                            }
                                        });
@@ -274,10 +348,10 @@ class device_kernel_predict_linear {
 
   private:
     /// @cond Doxygen_suppress
-    real_type *prediction_d_;
-    const real_type *w_d_;
-    const real_type *rho_d_;
-    const real_type *predict_points_d_;
+    real_type *prediction_;
+    const real_type *w_;
+    const real_type *rho_;
+    const real_type *predict_points_;
     const std::size_t num_classes_;
     const std::size_t num_predict_points_;
     const std::size_t num_features_;
@@ -287,21 +361,25 @@ class device_kernel_predict_linear {
 };
 
 /**
- * @brief Predict the @p predict_points_d using the @p kernel_function.
+ * @brief Predict the @p predict_points using the @p kernel_function.
  * @details Uses AdaptiveCpp's scoped parallelism.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function; stored in a `std::tuple`
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_predict {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::scoped;
+
     /**
      * @brief Initialize the SYCL kernel function object.
-     * @param[in] prediction_d the predicted values
-     * @param[in] alpha_d the previously learned weights
-     * @param[in] rho_d the previously learned biases
-     * @param[in] sv_d the support vectors
-     * @param[in] predict_points_d the data points to predict
+     * @param[in] prediction the predicted values
+     * @param[in] alpha the previously learned weights
+     * @param[in] rho the previously learned biases
+     * @param[in] support_vectors the support vectors
+     * @param[in] predict_points the data points to predict
      * @param[in] num_classes the number of classes
      * @param[in] num_sv the number of support vectors
      * @param[in] num_predict_points the number of data points to predict
@@ -310,19 +388,19 @@ class device_kernel_predict {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_predict(real_type *prediction_d, const real_type *alpha_d, const real_type *rho_d, const real_type *sv_d, const real_type *predict_points_d, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
-        prediction_d_{ prediction_d },
-        alpha_d_{ alpha_d },
-        rho_d_{ rho_d },
-        sv_d_{ sv_d },
-        predict_points_d_{ predict_points_d },
+    device_kernel_predict(real_type *prediction, const real_type *alpha, const real_type *rho, const real_type *support_vectors, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+        prediction_{ prediction },
+        alpha_{ alpha },
+        rho_{ rho },
+        support_vectors_{ support_vectors },
+        predict_points_{ predict_points },
         num_classes_{ num_classes },
         num_sv_{ num_sv },
         num_predict_points_{ num_predict_points },
         num_features_{ num_features },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } { }
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } { }
 
     /**
      * @brief Function call operator overload performing the actual calculation.
@@ -332,143 +410,184 @@ class device_kernel_predict {
     template <typename T>
     void operator()(T group) const {
         ::sycl::memory_environment(group,
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_local_mem<real_type[FEATURE_BLOCK_SIZE][INTERNAL_BLOCK_SIZE * THREAD_BLOCK_SIZE]>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::size_t>(),
-                                   ::sycl::require_private_mem<std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE>>({}),
-                                   [&](auto &data_cache_pp, auto &data_cache_sv, auto &pp_idx, auto &pp_idx_linear, auto &sv_idx_linear, auto &temp) {
-                                       // initialize private and local variables
+                                   // create two local memory arrays used for caching
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // cache_one
+                                   ::sycl::require_local_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE)>, static_cast<std::size_t>(THREAD_BLOCK_SIZE)>>(),  // cache_two
+
+                                   // create a private memory array used for internal caching
+                                   ::sycl::require_private_mem<std::array<std::array<real_type, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>, static_cast<std::size_t>(INTERNAL_BLOCK_SIZE)>>(),
+                                   [&](auto &cache_one, auto &cache_two, auto &temp) {
+                                       // initialize private temp matrix to zero
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           const std::size_t threadIdx_y = idx.get_local_id(group, 1);       // current thread in block y-dimension
-                                           const std::size_t blockDim_x = group.get_logical_local_range(0);  // number of threads in block x-dimension
-                                           const std::size_t blockDim_y = group.get_logical_local_range(1);  // number of threads in block y-dimension
-                                           const std::size_t blockIdx_x = group[0] + grid_x_offset_;         // current block in grid x-dimension + offsets if the grid size would be too large
-                                           const std::size_t blockIdx_y = group[1] + grid_y_offset_;         // current block in grid y-dimension + offsets if the grid size would be too large
-
-                                           const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-
-                                           // indices
-                                           pp_idx(idx) = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-                                           pp_idx_linear(idx) = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-                                           sv_idx_linear(idx) = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+                                           for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                               for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                                   temp(idx)[internal_i][internal_j] = real_type{ 0.0 };
+                                               }
+                                           }
                                        });
 
-                                       // iterate over all features using blocking to be able to cache them for faster memory accesses
-                                       for (std::size_t dim = 0; dim < num_features_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
-                                           ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                               const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
-                                               const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
+                                       {
+                                           // rename cached arrays
+                                           auto &pp_cache = cache_one;
+                                           auto &sv_cache = cache_two;
 
-                                               const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                           // iterate over all features using blocking to be able to cache them for faster memory accesses
+                                           for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
+                                               ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                   // cast values to 32-bit unsigned int values to prevent implicit conversions
+                                                   const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
+                                                   const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                               const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                               const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                                   // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                                   constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                                   constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                                                   constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                                               // load data into local memory
-                                               for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                   const auto global_pp_idx = pp_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                                                   const auto global_sv_idx = sv_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                                                   // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                                                   data_cache_pp[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                                                   data_cache_pp[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                                                   data_cache_sv[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = sv_d_[(dim + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
-                                                   data_cache_sv[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = sv_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
-                                               }
-                                           });
+                                                   const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                                   const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                                   const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                                   const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                                   const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
+                                                   const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
 
-                                           // perform the feature reduction calculation
-                                           ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                               const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
-                                               const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
+                                                   // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+                                                   const auto pp_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_predict_points
+                                                   const auto sv_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_support_vectors
+
+                                                   // load data into local memory
+                                                   for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                                                       // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                                       const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                       const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                                                       // store the values in the local memory
+                                                       pp_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_[(feature_block + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx_linear];
+                                                       sv_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = support_vectors_[(feature_block + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx_linear];
+                                                   }
+                                               });
 
-                                               for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                                                   for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
-                                                       for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                                                           temp(idx)[internal_pd][internal_sv] += detail::feature_reduce<kernel_function>(data_cache_sv[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv],
-                                                                                                                                          data_cache_pp[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pd]);
+                                               // perform the feature reduction calculation
+                                               ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                   // cast values to 32-bit unsigned int values to prevent implicit conversions
+                                                   const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
+                                                   const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
+
+                                                   if constexpr (target == target_platform::cpu) {
+                                                       // perform the feature reduction calculation, the feature is the fastest moving index
+                                                       for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                                                           for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                                                               real_type sum{ 0.0 };
+                                                               for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                                                   sum += detail::feature_reduce<kernel_function>(sv_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv],
+                                                                                                                  pp_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp]);
+                                                               }
+                                                               temp(idx)[internal_pp][internal_sv] += sum;
+                                                           }
+                                                       }
+                                                   } else {
+                                                       // perform the feature reduction calculation, the feature is the slowest moving index
+                                                       for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                                           for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                                                               for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                                                                   temp(idx)[internal_pp][internal_sv] += detail::feature_reduce<kernel_function>(sv_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv],
+                                                                                                                                                  pp_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp]);
+                                                               }
+                                                           }
                                                        }
                                                    }
-                                               }
-                                           });
+                                               });
+                                           }
                                        }
 
                                        // update temp using the respective kernel function
                                        ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
-                                           for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                                           for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                                                for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                                                   temp(idx)[internal_pd][internal_sv] = detail::apply_kernel_function<kernel_function>(temp(idx)[internal_pd][internal_sv], kernel_function_parameter_);
+                                                   temp(idx)[internal_pp][internal_sv] = detail::apply_kernel_function<kernel_function>(temp(idx)[internal_pp][internal_sv], kernel_function_parameter_);
                                                }
                                            }
                                        });
 
                                        {
                                            // rename cached arrays
-                                           auto &alpha_cache = data_cache_pp;
-                                           auto &out_cache = data_cache_sv;
+                                           auto &alpha_cache = cache_one;
+                                           auto &out_cache = cache_two;
 
-                                           // iterate over all features using blocking to be able to cache them for faster memory accesses
-                                           for (std::size_t dim = 0; dim < num_classes_; dim += static_cast<std::size_t>(FEATURE_BLOCK_SIZE)) {
+                                           // iterate over all classes using blocking to be able to cache them for faster memory accesses
+                                           for (std::size_t class_block = 0; class_block < num_classes_; class_block += static_cast<std::size_t>(THREAD_BLOCK_SIZE)) {
                                                // load data into local memory
                                                ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                   // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                    const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                    const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                                   const std::size_t blockIdx_x = group[0] + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-                                                   const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                                   // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                                   constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                                   constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+                                                   constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-                                                   const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                                   const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                                   const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                                   const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                                   const auto blockDim_x = static_cast<std::size_t>(group.get_logical_local_range(0));  // number of work-items in work-group x-dimension
+                                                   const auto blockIdx_x = static_cast<std::size_t>(group[0]) + grid_x_offset_;         // current work-group in global range x-dimension + offsets if the global range is too large
 
-                                                   for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                       const std::size_t global_sv_idx = sv_idx_linear(idx) + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                                                   // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+                                                   const auto sv_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_support_vectors
 
-                                                       alpha_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_d_[(dim + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
-                                                       alpha_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
+                                                   for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                                                       // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                                                       const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
+                                                       // store the values in the local memory
+                                                       alpha_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_[(class_block + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx_linear];  // AoS
                                                        // the bias (rho) must only be applied once for all support vectors
                                                        if (blockIdx_x == std::size_t{ 0 }) {
-                                                           out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = -rho_d_[dim + threadIdx_x];
-                                                           out_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = -rho_d_[dim + threadIdx_x + THREAD_BLOCK_SIZE_uz];
+                                                           out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = -rho_[class_block + threadIdx_x];
                                                        } else {
                                                            out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
-                                                           out_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
                                                        }
                                                    }
                                                });
 
                                                // calculate intermediate results and store them in local memory
-                                               for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
+                                               for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
                                                    ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                       // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                        const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                        const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                                       for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                                                       for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                                                            for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                                                               out_cache[(class_idx + local_id_0) % FEATURE_BLOCK_SIZE][internal_pd * THREAD_BLOCK_SIZE + local_id_1] +=
-                                                                   temp(idx)[internal_pd][internal_sv] * alpha_cache[(class_idx + local_id_0) % FEATURE_BLOCK_SIZE][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv];
+                                                               out_cache[(class_idx + local_id_0) % THREAD_BLOCK_SIZE][internal_pp * THREAD_BLOCK_SIZE + local_id_1] +=
+                                                                   temp(idx)[internal_pp][internal_sv] * alpha_cache[(class_idx + local_id_0) % THREAD_BLOCK_SIZE][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv];
                                                            }
                                                        }
                                                    });
                                                }
 
-                                               // add intermediate cached results to prediction_d
+                                               // atomically add the intermediate cached results to the prediction
                                                ::sycl::distribute_items_and_wait(group, [&](::sycl::s_item<2> idx) {
+                                                   // cast values to 32-bit unsigned int values to prevent implicit conversions
                                                    const auto local_id_0 = static_cast<unsigned>(idx.get_local_id(group, 0));
                                                    const auto local_id_1 = static_cast<unsigned>(idx.get_local_id(group, 1));
 
-                                                   const std::size_t threadIdx_x = idx.get_local_id(group, 0);
+                                                   // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
+                                                   constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+                                                   constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+                                                   const auto threadIdx_x = static_cast<std::size_t>(idx.get_local_id(group, 0));       // current work-item in work-group x-dimension
+                                                   const auto threadIdx_y = static_cast<std::size_t>(idx.get_local_id(group, 1));       // current work-item in work-group y-dimension
+                                                   const auto blockDim_y = static_cast<std::size_t>(group.get_logical_local_range(1));  // number of work-items in work-group y-dimension
+                                                   const auto blockIdx_y = static_cast<std::size_t>(group[1]) + grid_y_offset_;         // current work-group in global range y-dimension + offsets if the global range is too large
 
-                                                   const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-                                                   const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+                                                   // calculate the indices used in the current thread
+                                                   const auto pp_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
 
                                                    for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                                                       const auto global_pp_idx = pp_idx(idx) + static_cast<std::size_t>(internal);
+                                                       // calculate the indices to access the global data
+                                                       const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal);
 
-                                                       detail::atomic_op<real_type>{ prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x] } += out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1];
-                                                       detail::atomic_op<real_type>{ prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz] } += out_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1];
+                                                       detail::atomic_op<real_type>{ prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x] } += out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1];
                                                    }
                                                });
                                            }
@@ -478,11 +597,11 @@ class device_kernel_predict {
 
   private:
     /// @cond Doxygen_suppress
-    real_type *prediction_d_;
-    const real_type *alpha_d_;
-    const real_type *rho_d_;
-    const real_type *sv_d_;
-    const real_type *predict_points_d_;
+    real_type *prediction_;
+    const real_type *alpha_;
+    const real_type *rho_;
+    const real_type *support_vectors_;
+    const real_type *predict_points_;
     const std::size_t num_classes_;
     const std::size_t num_sv_;
     const std::size_t num_predict_points_;
diff --git a/include/plssvm/backends/SYCL/kernel/predict/work_group/predict_kernel.hpp b/include/plssvm/backends/SYCL/kernel/predict/work_group/predict_kernel.hpp
index d451ac7d5..216bf4afb 100644
--- a/include/plssvm/backends/SYCL/kernel/predict/work_group/predict_kernel.hpp
+++ b/include/plssvm/backends/SYCL/kernel/predict/work_group/predict_kernel.hpp
@@ -13,47 +13,55 @@
 #define PLSSVM_BACKENDS_SYCL_KERNEL_PREDICT_WORK_GROUP_PREDICT_KERNEL_HPP_
 #pragma once
 
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"    // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/detail/atomics.hpp"           // plssvm::sycl::detail::atomic_op
 #include "plssvm/backends/SYCL/kernel/kernel_functions.hpp"  // plssvm::sycl::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                              // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::handler, sycl::range, sycl::nd_item, sycl::local_accessor
 
+#include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::make_tuple
 
 namespace plssvm::sycl::detail::work_group {
 
 /**
- * @brief Calculate the `q` vector used to speedup the prediction using the linear kernel function.
+ * @brief Calculate the `w` vector used to speedup the prediction using the linear kernel function.
  * @details Uses SYCL's work-group data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_w_linear {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::work_group;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] cgh the SYCL handler used to allocate the local memory
-     * @param[in,out] w_d the vector to speedup the linear prediction
-     * @param[in] alpha_d the previously learned weights
-     * @param[in] sv_d the support vectors
+     * @param[in,out] w the vector to speedup the linear prediction
+     * @param[in] alpha the previously learned weights
+     * @param[in] support_vectors the support vectors
      * @param[in] num_classes the number of classes
      * @param[in] num_sv the number of support vectors
-     * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
-     * @param[in] sv_offset the first support vector (row in @p alpha_d) the current device is responsible for
+     * @param[in] device_num_sv the number of support vectors the current device is responsible for
+     * @param[in] device_sv_offset the first support vector (row in @p alpha) the current device is responsible for
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_w_linear(::sycl::handler &cgh, real_type *w_d, const real_type *alpha_d, const real_type *sv_d, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_specific_num_sv, const std::size_t sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
-        data_cache_feature_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
-        data_cache_alpha_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
-        w_d_{ w_d },
-        alpha_d_{ alpha_d },
-        sv_d_{ sv_d },
+    device_kernel_w_linear(::sycl::handler &cgh, real_type *w, const real_type *alpha, const real_type *support_vectors, const std::size_t num_classes, const std::size_t num_sv, const std::size_t device_num_sv, const std::size_t device_sv_offset, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+        feature_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+        alpha_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+        w_{ w },
+        alpha_{ alpha },
+        support_vectors_{ support_vectors },
         num_classes_{ num_classes },
         num_sv_{ num_sv },
-        device_specific_num_sv_{ device_specific_num_sv },
-        sv_offset_{ sv_offset },
+        device_num_sv_{ device_num_sv },
+        device_sv_offset_{ device_sv_offset },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset } { }
 
@@ -67,104 +75,130 @@ class device_kernel_w_linear {
         const auto local_id_1 = static_cast<unsigned>(nd_idx.get_local_id(1));
 
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const std::size_t threadIdx_x = nd_idx.get_local_id(0);               // current thread in block x-dimension
-        const std::size_t threadIdx_y = nd_idx.get_local_id(1);               // current thread in block y-dimension
-        const std::size_t blockDim_x = nd_idx.get_local_range(0);             // number of threads in block x-dimension
-        const std::size_t blockDim_y = nd_idx.get_local_range(1);             // number of threads in block y-dimension
-        const std::size_t blockIdx_x = nd_idx.get_group(0) + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const std::size_t blockIdx_y = nd_idx.get_group(1) + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-        // calculate the indices used in the current work-item
-        const auto feature_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-        const auto feature_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-        const auto class_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-        const auto class_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+        const auto threadIdx_x = static_cast<std::size_t>(nd_idx.get_local_id(0));               // current work-item in work-group x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(nd_idx.get_local_id(1));               // current work-item in work-group y-dimension
+        const auto blockDim_x = static_cast<std::size_t>(nd_idx.get_local_range(0));             // number of work-items in work-group x-dimension
+        const auto blockDim_y = static_cast<std::size_t>(nd_idx.get_local_range(1));             // number of work-items in work-group y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(nd_idx.get_group(0)) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+        const auto blockIdx_y = static_cast<std::size_t>(nd_idx.get_group(1)) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
         // create a work-item private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
 
-        // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-        for (std::size_t sv = 0; sv < device_specific_num_sv_; sv += THREAD_BLOCK_SIZE) {
-            // load data into local memory
-            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_class_idx = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                const auto global_feature_idx = feature_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+        {
+            // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+            const auto feature_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_features
+            const auto class_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;    // num_classes
 
-                data_cache_feature_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = sv_d_[global_feature_idx * (device_specific_num_sv_ + PADDING_SIZE_uz) + sv + threadIdx_x];  // SoA
-                data_cache_alpha_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_d_[global_class_idx * (num_sv_ + PADDING_SIZE_uz) + sv + sv_offset_ + threadIdx_x];      // AoS
-            }
-            nd_idx.barrier();  // wait until all work-items loaded their part of the data
+            // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
+            for (std::size_t sv_block = 0; sv_block < device_num_sv_; sv_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into local memory
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_feature_idx_linear = feature_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
-            // perform the dot product calculation
-            for (unsigned block_dim = 0; block_dim < THREAD_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
-                    for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                        temp[internal_feature][internal_class] += data_cache_alpha_[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_feature_[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_feature];
+                    // store the values in the local memory
+                    feature_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = support_vectors_[global_feature_idx_linear * (device_num_sv_ + PADDING_SIZE_uz) + sv_block + threadIdx_x];  // SoA
+                    alpha_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_[global_class_idx_linear * (num_sv_ + PADDING_SIZE_uz) + sv_block + device_sv_offset_ + threadIdx_x];   // AoS
+                }
+                nd_idx.barrier();  // wait until all work-items loaded their part of the data
+
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the sv is the fastest moving index
+                    for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                            real_type sum{ 0.0 };
+                            for (unsigned sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                                sum += alpha_cache_[sv][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * feature_cache_[sv][local_id_1 * INTERNAL_BLOCK_SIZE + internal_feature];
+                            }
+                            temp[internal_feature][internal_class] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the sv is the slowest moving index
+                    for (unsigned sv = 0; sv < THREAD_BLOCK_SIZE; ++sv) {
+                        for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                temp[internal_feature][internal_class] += alpha_cache_[sv][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * feature_cache_[sv][local_id_1 * INTERNAL_BLOCK_SIZE + internal_feature];
+                            }
+                        }
                     }
                 }
+                nd_idx.barrier();  // wait until all work-items performed their part of the calculations
             }
-            nd_idx.barrier();  // wait until all work-items performed their part of the calculations
         }
 
-        // update global array with local one
+        // calculate the indices used in the current work-item
+        const auto feature_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+        const auto class_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;    // num_classes
+
+        // update the global w-vector with the locally cached values
         for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
             for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+                // calculate the indices to access the global data
                 const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                w_d_[global_feature_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp[internal_feature][internal_class];
+                w_[global_feature_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp[internal_feature][internal_class];  // SoA
             }
         }
     }
 
   private:
     /// Local memory used for internal memory access optimizations.
-    ::sycl::local_accessor<real_type, 2> data_cache_feature_;
+    ::sycl::local_accessor<real_type, 2> feature_cache_;
     /// Local memory used for internal memory access optimizations.
-    ::sycl::local_accessor<real_type, 2> data_cache_alpha_;
+    ::sycl::local_accessor<real_type, 2> alpha_cache_;
 
     /// @cond Doxygen_suppress
-    real_type *w_d_;
-    const real_type *alpha_d_;
-    const real_type *sv_d_;
+    real_type *w_;
+    const real_type *alpha_;
+    const real_type *support_vectors_;
     const std::size_t num_classes_;
     const std::size_t num_sv_;
-    const std::size_t device_specific_num_sv_;
-    const std::size_t sv_offset_;
+    const std::size_t device_num_sv_;
+    const std::size_t device_sv_offset_;
     const std::size_t grid_x_offset_;
     const std::size_t grid_y_offset_;
     /// @endcond
 };
 
 /**
- * @brief Predict the @p predict_points_d using the linear kernel speeding up the calculation using the @p w_d vector.
+ * @brief Predict the @p predict_points using the linear kernel speeding up the calculation using the @p w vector.
  * @details Uses SYCL's work-group data parallel kernels.
+ * @tparam target the target platform
  */
+template <target_platform target>
 class device_kernel_predict_linear {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::work_group;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] cgh the SYCL handler used to allocate the local memory
-     * @param[out] prediction_d the predicted values
-     * @param[in] w_d the vector to speedup the calculations
-     * @param[in] rho_d the previously learned bias
-     * @param[in] predict_points_d the data points to predict
+     * @param[out] prediction the predicted values
+     * @param[in] w the vector to speedup the calculations
+     * @param[in] rho the previously learned bias
+     * @param[in] predict_points the data points to predict
      * @param[in] num_classes the number of classes
      * @param[in] num_predict_points the number of data points to predict
      * @param[in] num_features the number of features per data point
      * @param[in] grid_x_offset the offset in x-dimension into the data points if more than one execution grid has to be used
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      */
-    device_kernel_predict_linear(::sycl::handler &cgh, real_type *prediction_d, const real_type *w_d, const real_type *rho_d, const real_type *predict_points_d, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
-        data_cache_pp_{ ::sycl::range<2>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
-        data_cache_w_{ ::sycl::range<2>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
-        prediction_d_{ prediction_d },
-        w_d_{ w_d },
-        rho_d_{ rho_d },
-        predict_points_d_{ predict_points_d },
+    device_kernel_predict_linear(::sycl::handler &cgh, real_type *prediction, const real_type *w, const real_type *rho, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset) :
+        pp_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+        w_cache_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+        prediction_{ prediction },
+        w_{ w },
+        rho_{ rho },
+        predict_points_{ predict_points },
         num_classes_{ num_classes },
         num_predict_points_{ num_predict_points },
         num_features_{ num_features },
@@ -181,74 +215,91 @@ class device_kernel_predict_linear {
         const auto local_id_1 = static_cast<unsigned>(nd_idx.get_local_id(1));
 
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const std::size_t threadIdx_x = nd_idx.get_local_id(0);               // current thread in block x-dimension
-        const std::size_t threadIdx_y = nd_idx.get_local_id(1);               // current thread in block y-dimension
-        const std::size_t blockDim_x = nd_idx.get_local_range(0);             // number of threads in block x-dimension
-        const std::size_t blockDim_y = nd_idx.get_local_range(1);             // number of threads in block y-dimension
-        const std::size_t blockIdx_x = nd_idx.get_group(0) + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const std::size_t blockIdx_y = nd_idx.get_group(1) + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_uz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-        // calculate the indices used in the current work-item
-        const auto pp_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-        const auto pp_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-        const auto class_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;
-        const auto class_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+        const auto threadIdx_x = static_cast<std::size_t>(nd_idx.get_local_id(0));               // current work-item in work-group x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(nd_idx.get_local_id(1));               // current work-item in work-group y-dimension
+        const auto blockDim_x = static_cast<std::size_t>(nd_idx.get_local_range(0));             // number of work-items in work-group x-dimension
+        const auto blockDim_y = static_cast<std::size_t>(nd_idx.get_local_range(1));             // number of work-items in work-group y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(nd_idx.get_group(0)) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+        const auto blockIdx_y = static_cast<std::size_t>(nd_idx.get_group(1)) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
         // create a work-item private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
-
-        // iterate over all support vectors using blocking to be able to cache them for faster memory accesses
-        for (std::size_t dim = 0; dim < num_features_; dim += FEATURE_BLOCK_SIZE_uz) {
-            // load data into shared memory
-            for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                const auto global_pp_idx = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                const auto global_class_idx = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the local memory
-                data_cache_pp_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                data_cache_pp_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                data_cache_w_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = w_d_[(dim + threadIdx_x) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx];
-                data_cache_w_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = w_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx];
-            }
-            nd_idx.barrier();  // wait until all work-items loaded their part of the data
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
+
+        {
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto pp_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;     // num_predict_points
+            const auto class_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_classes
+
+            // iterate over all features using blocking to be able to cache them for faster memory accesses
+            for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
+                // load data into local memory
+                for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_class_idx_linear = class_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the local memory
+                    pp_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_[(feature_block + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                    w_cache_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = w_[(feature_block + threadIdx_x) * (num_classes_ + PADDING_SIZE_uz) + global_class_idx_linear];                    // SoA
+                }
+                nd_idx.barrier();  // wait until all work-items loaded their part of the data
 
-            // perform the dot product calculation
-            for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
-                    for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                        temp[internal_pd][internal_class] += data_cache_w_[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * data_cache_pp_[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pd];
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the feature is the fastest moving index
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                            real_type sum{ 0.0 };
+                            for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                sum += w_cache_[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * pp_cache_[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp];
+                            }
+                            temp[internal_pp][internal_class] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the feature is the slowest moving index
+                    for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                temp[internal_pp][internal_class] += w_cache_[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_class] * pp_cache_[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp];
+                            }
+                        }
                     }
                 }
+                nd_idx.barrier();  // wait until all work-items performed their part of the calculations
             }
-            nd_idx.barrier();  // wait until all work-items performed their part of the calculations
         }
 
-        // update global array with local one
-        for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+        // calculate the indices used in the current work-item
+        const auto pp_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;     // num_predict_points
+        const auto class_idx = (blockIdx_x * blockDim_x + threadIdx_x) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
+
+        // update the global array with the local one
+        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
             for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                // calculate the indices to access the global data
+                const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
                 const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
-                const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pd);
 
-                prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp[internal_pd][internal_class] - rho_d_[global_class_idx];
+                prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + global_class_idx] = temp[internal_pp][internal_class] - rho_[global_class_idx];  // AoS
             }
         }
     }
 
   private:
     /// Local memory used for internal memory access optimizations.
-    ::sycl::local_accessor<real_type, 2> data_cache_pp_;
+    ::sycl::local_accessor<real_type, 2> pp_cache_;
     /// Local memory used for internal memory access optimizations.
-    ::sycl::local_accessor<real_type, 2> data_cache_w_;
+    ::sycl::local_accessor<real_type, 2> w_cache_;
 
     /// @cond Doxygen_suppress
-    real_type *prediction_d_;
-    const real_type *w_d_;
-    const real_type *rho_d_;
-    const real_type *predict_points_d_;
+    real_type *prediction_;
+    const real_type *w_;
+    const real_type *rho_;
+    const real_type *predict_points_;
     const std::size_t num_classes_;
     const std::size_t num_predict_points_;
     const std::size_t num_features_;
@@ -258,22 +309,26 @@ class device_kernel_predict_linear {
 };
 
 /**
- * @brief Predict the @p predict_points_d using the @p kernel_function.
+ * @brief Predict the @p predict_points using the @p kernel_function.
  * @details Uses SYCL's work-group data parallel kernels.
+ * @tparam target the target platform
  * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function; stored in a `std::tuple`
  */
-template <kernel_function_type kernel_function, typename... Args>
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
 class device_kernel_predict {
   public:
+    /// The used SYCL data parallel kernel.
+    constexpr static sycl::data_parallel_kernel data_parallel_kernel_type = sycl::data_parallel_kernel::work_group;
+
     /**
      * @brief Initialize the SYCL kernel function object.
      * @param[in] cgh the SYCL handler used to allocate the local memory
-     * @param[in] prediction_d the predicted values
-     * @param[in] alpha_d the previously learned weights
-     * @param[in] rho_d the previously learned biases
-     * @param[in] sv_d the support vectors
-     * @param[in] predict_points_d the data points to predict
+     * @param[in] prediction the predicted values
+     * @param[in] alpha the previously learned weights
+     * @param[in] rho the previously learned biases
+     * @param[in] support_vectors the support vectors
+     * @param[in] predict_points the data points to predict
      * @param[in] num_classes the number of classes
      * @param[in] num_sv the number of support vectors
      * @param[in] num_predict_points the number of data points to predict
@@ -282,21 +337,21 @@ class device_kernel_predict {
      * @param[in] grid_y_offset the offset in y-dimension into the data points if more than one execution grid has to be used
      * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
      */
-    device_kernel_predict(::sycl::handler &cgh, real_type *prediction_d, const real_type *alpha_d, const real_type *rho_d, const real_type *sv_d, const real_type *predict_points_d, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
-        data_cache_pp_{ ::sycl::range<2>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
-        data_cache_sv_{ ::sycl::range<2>{ static_cast<std::size_t>(FEATURE_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
-        prediction_d_{ prediction_d },
-        alpha_d_{ alpha_d },
-        rho_d_{ rho_d },
-        sv_d_{ sv_d },
-        predict_points_d_{ predict_points_d },
+    device_kernel_predict(::sycl::handler &cgh, real_type *prediction, const real_type *alpha, const real_type *rho, const real_type *support_vectors, const real_type *predict_points, const std::size_t num_classes, const std::size_t num_sv, const std::size_t num_predict_points, const std::size_t num_features, const std::size_t grid_x_offset, const std::size_t grid_y_offset, Args... kernel_function_parameter) :
+        cache_one_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+        cache_two_{ ::sycl::range<2>{ static_cast<std::size_t>(THREAD_BLOCK_SIZE), static_cast<std::size_t>(INTERNAL_BLOCK_SIZE) * static_cast<std::size_t>(THREAD_BLOCK_SIZE) }, cgh },
+        prediction_{ prediction },
+        alpha_{ alpha },
+        rho_{ rho },
+        support_vectors_{ support_vectors },
+        predict_points_{ predict_points },
         num_classes_{ num_classes },
         num_sv_{ num_sv },
         num_predict_points_{ num_predict_points },
         num_features_{ num_features },
         grid_x_offset_{ grid_x_offset },
         grid_y_offset_{ grid_y_offset },
-        kernel_function_parameter_{ std::make_tuple(std::forward<Args>(kernel_function_parameter)...) } { }
+        kernel_function_parameter_{ std::make_tuple(kernel_function_parameter...) } { }
 
     /**
      * @brief Function call operator overload performing the actual calculation.
@@ -308,47 +363,63 @@ class device_kernel_predict {
         const auto local_id_1 = static_cast<unsigned>(nd_idx.get_local_id(1));
 
         // cast all values to 64-bit std::size_t to prevent potential 32-bit overflows
-        const std::size_t threadIdx_x = nd_idx.get_local_id(0);               // current thread in block x-dimension
-        const std::size_t threadIdx_y = nd_idx.get_local_id(1);               // current thread in block y-dimension
-        const std::size_t blockDim_x = nd_idx.get_local_range(0);             // number of threads in block x-dimension
-        const std::size_t blockDim_y = nd_idx.get_local_range(1);             // number of threads in block y-dimension
-        const std::size_t blockIdx_x = nd_idx.get_group(0) + grid_x_offset_;  // current block in grid x-dimension + offsets if the grid size would be too large
-        const std::size_t blockIdx_y = nd_idx.get_group(1) + grid_y_offset_;  // current block in grid y-dimension + offsets if the grid size would be too large
-        const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-        const auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
-        const auto FEATURE_BLOCK_SIZE_uz = static_cast<std::size_t>(FEATURE_BLOCK_SIZE);
-        const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
 
-        // calculate the indices used in the current work-item
-        const auto pp_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;
-        const auto pp_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
-        const auto sv_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;
+        const auto threadIdx_x = static_cast<std::size_t>(nd_idx.get_local_id(0));               // current work-item in work-group x-dimension
+        const auto threadIdx_y = static_cast<std::size_t>(nd_idx.get_local_id(1));               // current work-item in work-group y-dimension
+        const auto blockDim_x = static_cast<std::size_t>(nd_idx.get_local_range(0));             // number of work-items in work-group x-dimension
+        const auto blockDim_y = static_cast<std::size_t>(nd_idx.get_local_range(1));             // number of work-items in work-group y-dimension
+        const auto blockIdx_x = static_cast<std::size_t>(nd_idx.get_group(0)) + grid_x_offset_;  // current work-group in global range x-dimension + offsets if the global range is too large
+        const auto blockIdx_y = static_cast<std::size_t>(nd_idx.get_group(1)) + grid_y_offset_;  // current work-group in global range y-dimension + offsets if the global range is too large
 
         // create a work-item private array used for internal caching
-        real_type temp[INTERNAL_BLOCK_SIZE][INTERNAL_BLOCK_SIZE]{};
+        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE_uz>, INTERNAL_BLOCK_SIZE_uz> temp{};
 
         {
+            // rename cached arrays
+            const auto &pp_cache = cache_one_;
+            const auto &sv_cache = cache_two_;
+
+            // calculate the indices used in the current thread, pays attention to coalesced memory accesses
+            const auto pp_idx_linear = blockIdx_y * blockDim_y * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_predict_points
+            const auto sv_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_support_vectors
+
             // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (std::size_t dim = 0; dim < num_features_; dim += FEATURE_BLOCK_SIZE_uz) {
+            for (std::size_t feature_block = 0; feature_block < num_features_; feature_block += THREAD_BLOCK_SIZE_uz) {
                 // load data into local memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const auto global_pp_idx = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-                    const auto global_sv_idx = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                    // FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE -> store twice as many values in the shared memory
-                    data_cache_pp_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                    data_cache_pp_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx];
-                    data_cache_sv_[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = sv_d_[(dim + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
-                    data_cache_sv_[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = sv_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_pp_idx_linear = pp_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+                    const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
+
+                    // store the values in the local memory
+                    pp_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = predict_points_[(feature_block + threadIdx_x) * (num_predict_points_ + PADDING_SIZE_uz) + global_pp_idx_linear];  // SoA
+                    sv_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = support_vectors_[(feature_block + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx_linear];             // SoA
                 }
                 nd_idx.barrier();  // wait until all work-items loaded their part of the data
 
-                // perform the feature reduction calculation
-                for (unsigned block_dim = 0; block_dim < FEATURE_BLOCK_SIZE; ++block_dim) {
-                    for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the feature reduction calculation, the feature is the fastest moving index
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                         for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                            temp[internal_pd][internal_sv] += detail::feature_reduce<kernel_function>(data_cache_sv_[block_dim][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv],
-                                                                                                      data_cache_pp_[block_dim][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pd]);
+                            real_type sum{ 0.0 };
+                            for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                                sum += detail::feature_reduce<kernel_function>(sv_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv],
+                                                                               pp_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp]);
+                            }
+                            temp[internal_pp][internal_sv] += sum;
+                        }
+                    }
+                } else {
+                    // perform the feature reduction calculation, the feature is the slowest moving index
+                    for (unsigned feature = 0; feature < THREAD_BLOCK_SIZE; ++feature) {
+                        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                            for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                                temp[internal_pp][internal_sv] += detail::feature_reduce<kernel_function>(sv_cache[feature][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv],
+                                                                                                          pp_cache[feature][local_id_1 * INTERNAL_BLOCK_SIZE + internal_pp]);
+                            }
                         }
                     }
                 }
@@ -357,54 +428,57 @@ class device_kernel_predict {
         }
 
         // update temp using the respective kernel function
-        for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
             for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                temp[internal_pd][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pd][internal_sv], kernel_function_parameter_);
+                temp[internal_pp][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pp][internal_sv], kernel_function_parameter_);
             }
         }
 
         {
             // rename cached arrays
-            auto &alpha_cache = data_cache_pp_;
-            auto &out_cache = data_cache_sv_;
+            const auto &alpha_cache = cache_one_;
+            const auto &out_cache = cache_two_;
 
-            // iterate over all features using blocking to be able to cache them for faster memory accesses
-            for (std::size_t dim = 0; dim < num_classes_; dim += FEATURE_BLOCK_SIZE_uz) {
+            // calculate the indices used in the current work-item
+            const auto pp_idx = (blockIdx_y * blockDim_y + threadIdx_y) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
+            // calculate the indices used in the current work-item, pays attention to coalesced memory accesses
+            const auto sv_idx_linear = blockIdx_x * blockDim_x * INTERNAL_BLOCK_SIZE_uz + threadIdx_y;  // num_support_vectors
+
+            // iterate over all classes using blocking to be able to cache them for faster memory accesses
+            for (std::size_t class_block = 0; class_block < num_classes_; class_block += THREAD_BLOCK_SIZE_uz) {
                 // load data into local memory
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
-                    const std::size_t global_sv_idx = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
-
-                    alpha_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_d_[(dim + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
-                    alpha_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_d_[(dim + threadIdx_x + THREAD_BLOCK_SIZE_uz) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx];
+                    // calculate the indices to access the global data, pays attention to coalesced memory accesses
+                    const auto global_sv_idx_linear = sv_idx_linear + static_cast<std::size_t>(internal) * THREAD_BLOCK_SIZE_uz;
 
+                    // store the values in the local memory
+                    alpha_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = alpha_[(class_block + threadIdx_x) * (num_sv_ + PADDING_SIZE_uz) + global_sv_idx_linear];  // AoS
                     // the bias (rho) must only be applied once for all support vectors
                     if (blockIdx_x == std::size_t{ 0 }) {
-                        out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = -rho_d_[dim + threadIdx_x];
-                        out_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = -rho_d_[dim + threadIdx_x + THREAD_BLOCK_SIZE_uz];
+                        out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = -rho_[class_block + threadIdx_x];
                     } else {
                         out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
-                        out_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1] = real_type{ 0.0 };
                     }
                 }
                 nd_idx.barrier();  // wait until all work-items loaded their part of the data
 
                 // calculate intermediate results and store them in local memory
-                for (unsigned class_idx = 0; class_idx < FEATURE_BLOCK_SIZE; ++class_idx) {
-                    for (unsigned internal_pd = 0; internal_pd < INTERNAL_BLOCK_SIZE; ++internal_pd) {
+                for (unsigned class_idx = 0; class_idx < THREAD_BLOCK_SIZE; ++class_idx) {
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                         for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                            out_cache[(class_idx + local_id_0) % FEATURE_BLOCK_SIZE][internal_pd * THREAD_BLOCK_SIZE + local_id_1] +=
-                                temp[internal_pd][internal_sv] * alpha_cache[(class_idx + local_id_0) % FEATURE_BLOCK_SIZE][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv];
+                            out_cache[(class_idx + local_id_0) % THREAD_BLOCK_SIZE][internal_pp * THREAD_BLOCK_SIZE + local_id_1] +=
+                                temp[internal_pp][internal_sv] * alpha_cache[(class_idx + local_id_0) % THREAD_BLOCK_SIZE][local_id_0 * INTERNAL_BLOCK_SIZE + internal_sv];
                         }
                     }
                     nd_idx.barrier();  // wait until all work-items performed their part of the calculations
                 }
 
-                // add intermediate cached results to prediction_d
+                // atomically add the intermediate cached results to the prediction
                 for (unsigned internal = 0; internal < INTERNAL_BLOCK_SIZE; ++internal) {
+                    // calculate the indices to access the global data
                     const auto global_pp_idx = pp_idx + static_cast<std::size_t>(internal);
 
-                    detail::atomic_op<real_type>{ prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x] } += out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1];
-                    detail::atomic_op<real_type>{ prediction_d_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + dim + threadIdx_x + THREAD_BLOCK_SIZE_uz] } += out_cache[local_id_0 + THREAD_BLOCK_SIZE][internal * THREAD_BLOCK_SIZE + local_id_1];
+                    detail::atomic_op<real_type>{ prediction_[global_pp_idx * (num_classes_ + PADDING_SIZE_uz) + class_block + threadIdx_x] } += out_cache[local_id_0][internal * THREAD_BLOCK_SIZE + local_id_1];
                 }
                 nd_idx.barrier();  // wait until all work-items updated their part of the prediction
             }
@@ -413,16 +487,16 @@ class device_kernel_predict {
 
   private:
     /// Local memory used for internal memory access optimizations.
-    ::sycl::local_accessor<real_type, 2> data_cache_pp_;
+    ::sycl::local_accessor<real_type, 2> cache_one_;
     /// Local memory used for internal memory access optimizations.
-    ::sycl::local_accessor<real_type, 2> data_cache_sv_;
+    ::sycl::local_accessor<real_type, 2> cache_two_;
 
     /// @cond Doxygen_suppress
-    real_type *prediction_d_;
-    const real_type *alpha_d_;
-    const real_type *rho_d_;
-    const real_type *sv_d_;
-    const real_type *predict_points_d_;
+    real_type *prediction_;
+    const real_type *alpha_;
+    const real_type *rho_;
+    const real_type *support_vectors_;
+    const real_type *predict_points_;
     const std::size_t num_classes_;
     const std::size_t num_sv_;
     const std::size_t num_predict_points_;
diff --git a/include/plssvm/backends/execution_range.hpp b/include/plssvm/backends/execution_range.hpp
index fdd7cd228..91c76a259 100644
--- a/include/plssvm/backends/execution_range.hpp
+++ b/include/plssvm/backends/execution_range.hpp
@@ -11,6 +11,7 @@
 
 #ifndef PLSSVM_BACKENDS_EXECUTION_RANGE_HPP_
 #define PLSSVM_BACKENDS_EXECUTION_RANGE_HPP_
+#pragma once
 
 #include "plssvm/backend_types.hpp"  // plssvm::backend_type
 
@@ -159,7 +160,7 @@ struct execution_range {
     [[nodiscard]] unsigned long long num_threads_in_block() const noexcept;
 
     /// The up-to three dimensional block (work-group) size.
-    dim_type block{};
+    dim_type block;
     /// 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;
diff --git a/include/plssvm/backends/gpu_csvm.hpp b/include/plssvm/backends/gpu_csvm.hpp
index 520f665ea..db841ac13 100644
--- a/include/plssvm/backends/gpu_csvm.hpp
+++ b/include/plssvm/backends/gpu_csvm.hpp
@@ -80,8 +80,8 @@ class gpu_csvm : virtual public ::plssvm::csvm {
      */
     gpu_csvm &operator=(gpu_csvm &&other) noexcept {
         if (this != std::addressof(other)) {
+            devices_ = std::exchange(other.devices_, {});
             ::plssvm::csvm::operator=(std::move(other));
-            devices_ = std::move(other.devices_);
         }
         return *this;
     }
diff --git a/include/plssvm/backends/gpu_device_ptr.hpp b/include/plssvm/backends/gpu_device_ptr.hpp
index 78729691f..35964be41 100644
--- a/include/plssvm/backends/gpu_device_ptr.hpp
+++ b/include/plssvm/backends/gpu_device_ptr.hpp
@@ -19,8 +19,12 @@
 #include "plssvm/matrix.hpp"                 // plssvm::layout_type, plssvm::matrix
 #include "plssvm/shape.hpp"                  // plssvm::shape
 
-#include <cstddef>  // std::size_t
-#include <vector>   // std::vector
+#include "fmt/format.h"  // fmt::format
+
+#include <algorithm>  // std::min
+#include <cstddef>    // std::size_t
+#include <utility>    // std::swap, std::exchange
+#include <vector>     // std::vector
 
 namespace plssvm::detail {
 
@@ -34,6 +38,9 @@ class gpu_device_ptr {
     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.");
 
+    /// Befriend device_ptr base class so we can make the gpu_device_ptr constructor private.
+    friend derived_gpu_device_ptr;
+
   public:
     /// The type of the values used in the device_ptr.
     using value_type = T;
@@ -48,6 +55,7 @@ class gpu_device_ptr {
     /// The type of the device pointer.
     using device_pointer_type = device_pointer_t;
 
+  private:
     /**
      * @brief Default construct a gpu_device_ptr with a size of 0.
      */
@@ -57,14 +65,14 @@ class gpu_device_ptr {
      * @param[in] size the size of the managed memory
      * @param[in] queue the queue (or similar) to manage the device_ptr
      */
-    gpu_device_ptr(size_type size, const queue_type queue);
+    gpu_device_ptr(size_type size, const queue_type queue);  // NOLINT: queue_type can be a pointer type where const qualification makes a difference
     /**
      * @brief Construct a device_ptr for the device managed by @p queue with the provided @p shape.
      * @details The managed memory size is: extents[0] * extents[1].
      * @param[in] shape the 2D size of the managed memory; size = shape.x * shape.y
      * @param[in] queue the queue (or similar) to manage the device_ptr
      */
-    gpu_device_ptr(plssvm::shape shape, const queue_type queue);
+    gpu_device_ptr(plssvm::shape shape, const queue_type queue);  // NOLINT: queue_type can be a pointer type where const qualification makes a difference
     /**
      * @brief Construct a device_ptr for the device managed by @p queue with the provided @p shape including @p padding.
      * @details The managed memory size is: (shape.x + padding.x) * (shape.y + padding.y).
@@ -72,18 +80,20 @@ class gpu_device_ptr {
      * @param[in] padding the padding applied to the extents
      * @param[in] queue the queue (or similar) to manage the device_ptr
      */
-    gpu_device_ptr(plssvm::shape shape, plssvm::shape padding, const queue_type queue);
+    gpu_device_ptr(plssvm::shape shape, plssvm::shape padding, const queue_type queue);  // NOLINT: queue_type can be a pointer type where const qualification makes a difference
 
-    /**
-     * @brief Delete copy-constructor to make device_ptr a move only type.
-     */
-    gpu_device_ptr(const gpu_device_ptr &) = delete;
     /**
      * @brief Move-constructor as device_ptr is a move-only type.
      * @param[in,out] other the device_ptr to move-construct from
      */
     gpu_device_ptr(gpu_device_ptr &&other) noexcept;
 
+  public:
+    /**
+     * @brief Delete copy-constructor to make device_ptr a move only type.
+     */
+    gpu_device_ptr(const gpu_device_ptr &) = delete;  // NOLINT(bugprone-crtp-constructor-accessibility): deleted constructor should be public
+
     /**
      * @brief Delete copy-assignment-operator to make device_ptr a move only type.
      */
@@ -115,7 +125,7 @@ class gpu_device_ptr {
 
     /**
      * @brief Checks whether `*this` currently wraps a device pointer.
-     * @details Same as `device_ptr::get() != nullptr`.
+     * @details Same as `device_ptr::get() != device_ptr::device_ptr()`.
      * @return `true` if `*this` wraps a device pointer, `false` otherwise (`[[nodiscard]]`)
      */
     [[nodiscard]] explicit operator bool() const noexcept {
@@ -192,7 +202,7 @@ class gpu_device_ptr {
      * @return `true` if the wrapped device_ptr is padded, `false` otherwise (`[[nodiscard]]`)
      */
     [[nodiscard]] bool is_padded() const noexcept {
-        return !(padding_.x == 0 && padding_.y == 0);
+        return padding_.x != 0 || padding_.y != 0;
     }
 
     /**
@@ -363,9 +373,9 @@ class gpu_device_ptr {
     /// The device queue used to manage the device memory associated with this device pointer.
     queue_type queue_{};
     /// The size of the managed memory.
-    plssvm::shape shape_{};
+    plssvm::shape shape_;
     /// The padding size of the managed memory.
-    plssvm::shape padding_{};
+    plssvm::shape padding_;
     /// The device pointer pointing to the managed memory.
     device_pointer_type data_{};
 };
@@ -394,7 +404,7 @@ gpu_device_ptr<T, queue_t, device_pointer_t, derived_gpu_device_ptr>::gpu_device
     data_{ std::exchange(other.data_, device_pointer_type{}) } { }
 
 template <typename T, typename queue_t, typename device_pointer_t, typename derived_gpu_device_ptr>
-auto gpu_device_ptr<T, queue_t, device_pointer_t, derived_gpu_device_ptr>::operator=(gpu_device_ptr &&other) noexcept -> gpu_device_ptr & {
+gpu_device_ptr<T, queue_t, device_pointer_t, derived_gpu_device_ptr> &gpu_device_ptr<T, queue_t, device_pointer_t, derived_gpu_device_ptr>::operator=(gpu_device_ptr &&other) noexcept {
     // guard against self-assignment
     if (this != std::addressof(other)) {
         queue_ = std::exchange(other.queue_, queue_type{});
diff --git a/include/plssvm/backends/host_pinned_memory.hpp b/include/plssvm/backends/host_pinned_memory.hpp
index 63ee1193b..63bc8bf84 100644
--- a/include/plssvm/backends/host_pinned_memory.hpp
+++ b/include/plssvm/backends/host_pinned_memory.hpp
@@ -98,7 +98,7 @@ template <typename T>
 host_pinned_memory<T>::~host_pinned_memory() = default;
 
 template <typename T>
-void host_pinned_memory<T>::pin_memory(const std::size_t) {
+void host_pinned_memory<T>::pin_memory([[maybe_unused]] const std::size_t num_bytes) {
     // explicitly set flag
     is_pinned_ = false;
 }
diff --git a/include/plssvm/backends/stdpar/csvm.hpp b/include/plssvm/backends/stdpar/csvm.hpp
index 109a436e8..6d3b0aef9 100644
--- a/include/plssvm/backends/stdpar/csvm.hpp
+++ b/include/plssvm/backends/stdpar/csvm.hpp
@@ -29,6 +29,7 @@
 
 #include <cstddef>      // std::size_t
 #include <memory>       // std::addressof
+#include <optional>     // std::optional
 #include <type_traits>  // std::true_type
 #include <utility>      // std::forward, std::pair
 #include <vector>       // std::vector
@@ -105,6 +106,10 @@ class csvm : virtual public ::plssvm::csvm {
      * @copydoc plssvm::csvm::get_max_mem_alloc_size
      */
     [[nodiscard]] std::vector<::plssvm::detail::memory_size> get_max_mem_alloc_size() const final;
+    /**
+     * @copydoc plssvm::csvm::get_local_memory
+     */
+    [[nodiscard]] std::vector<std::optional<::plssvm::detail::memory_size>> get_local_memory() const final;
 
     //***************************************************//
     //                        fit                        //
@@ -140,8 +145,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvc(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::stdpar::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVC using the stdpar backend with the parameters given through @p params.
@@ -150,8 +154,7 @@ class csvc : public ::plssvm::csvc,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     csvc(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::stdpar::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVC using the stdpar backend on the @p target platform with the parameters given through @p params.
@@ -232,8 +235,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     explicit csvr(const parameter params) :
-        ::plssvm::csvm{ mpi::communicator{}, params },
-        ::plssvm::stdpar::csvm{} { }
+        ::plssvm::csvm{ mpi::communicator{}, params } { }
 
     /**
      * @brief Construct a new C-SVR using the stdpar backend with the parameters given through @p params.
@@ -242,8 +244,7 @@ class csvr : public ::plssvm::csvr,
      * @throws plssvm::exception all exceptions thrown in the base class constructors
      */
     csvr(mpi::communicator comm, const parameter params) :
-        ::plssvm::csvm{ std::move(comm), params },
-        ::plssvm::stdpar::csvm{} { }
+        ::plssvm::csvm{ std::move(comm), params } { }
 
     /**
      * @brief Construct a new C-SVR using the stdpar backend on the @p target platform with the parameters given through @p params.
diff --git a/include/plssvm/backends/stdpar/detail/utility.hpp b/include/plssvm/backends/stdpar/detail/utility.hpp
index c4e8ff188..6595931ca 100644
--- a/include/plssvm/backends/stdpar/detail/utility.hpp
+++ b/include/plssvm/backends/stdpar/detail/utility.hpp
@@ -20,6 +20,8 @@
 
     #include "sycl/sycl.hpp"  // ::sycl::device
 #elif defined(PLSSVM_STDPAR_BACKEND_HAS_NVHPC)
+    #include "cuda_runtime_api.h"
+
     #include <cuda/atomic>  // cuda::atomic_ref, cuda::thread_scope_device
 #elif defined(PLSSVM_STDPAR_BACKEND_HAS_HIPSTDPAR)
 
@@ -40,7 +42,7 @@ using atomic_ref = ::cuda::atomic_ref<T, ::cuda::thread_scope_device>;
 #elif defined(PLSSVM_STDPAR_BACKEND_HAS_HIPSTDPAR)
 template <typename T>
 struct atomic_ref {
-    T &value_;
+    T &value_;  // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members): must by a reference
 
     __device__ T operator+=(const T other) noexcept {
         atomicAdd(&value_, other);
diff --git a/include/plssvm/backends/stdpar/implementation_types.hpp b/include/plssvm/backends/stdpar/implementation_types.hpp
index 5b4b67336..7c4923403 100644
--- a/include/plssvm/backends/stdpar/implementation_types.hpp
+++ b/include/plssvm/backends/stdpar/implementation_types.hpp
@@ -9,8 +9,8 @@
  * @brief Defines an enumeration holding all supported stdpar implementations.
  */
 
-#ifndef PLSSVM_BACKENDS_STDPAR_IMPLEMENTATION_TYPE_HPP_
-#define PLSSVM_BACKENDS_STDPAR_IMPLEMENTATION_TYPE_HPP_
+#ifndef PLSSVM_BACKENDS_STDPAR_IMPLEMENTATION_TYPES_HPP_
+#define PLSSVM_BACKENDS_STDPAR_IMPLEMENTATION_TYPES_HPP_
 #pragma once
 
 #include "fmt/base.h"     // fmt::formatter
@@ -69,4 +69,4 @@ struct fmt::formatter<plssvm::stdpar::implementation_type> : fmt::ostream_format
 
 /// @endcond
 
-#endif  // PLSSVM_BACKENDS_STDPAR_IMPLEMENTATION_TYPE_HPP_
+#endif  // PLSSVM_BACKENDS_STDPAR_IMPLEMENTATION_TYPES_HPP_
diff --git a/include/plssvm/backends/stdpar/kernel/cg_explicit/blas.hpp b/include/plssvm/backends/stdpar/kernel/cg_explicit/blas.hpp
index 63e9f9831..0ed74facd 100644
--- a/include/plssvm/backends/stdpar/kernel/cg_explicit/blas.hpp
+++ b/include/plssvm/backends/stdpar/kernel/cg_explicit/blas.hpp
@@ -13,10 +13,11 @@
 #define PLSSVM_BACKENDS_STDPAR_KERNEL_CG_EXPLICIT_BLAS_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"      // plssvm::{real_type, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
-#include "plssvm/detail/assert.hpp"  // PLSSVM_ASSERT
-#include "plssvm/matrix.hpp"         // plssvm::soa_matrix
-#include "plssvm/shape.hpp"          // plssvm::shape
+#include "plssvm/constants.hpp"         // plssvm::{real_type, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/detail/assert.hpp"     // PLSSVM_ASSERT
+#include "plssvm/matrix.hpp"            // plssvm::soa_matrix
+#include "plssvm/shape.hpp"             // plssvm::shape
+#include "plssvm/target_platforms.hpp"  // plssvm::target_platform
 
 #include <algorithm>  // std::for_each
 #include <array>      // std::array
@@ -29,157 +30,218 @@
 namespace plssvm::stdpar::detail {
 
 /**
- * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a symmetric matrix (memory optimized), @p B and @p C are matrices, and @p alpha and @p beta are scalars.
- * @param[in] num_rows the number of rows in @p A and @p C
- * @param[in] num_rhs the number of columns in @p B and @p C
- * @param[in] device_specific_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data the current device is responsible for
- * @param[in] alpha the scalar alpha value
- * @param[in] A the matrix @p A
- * @param[in] B the matrix @p B
- * @param[in] beta the scalar beta value
- * @param[in,out] C the matrix @p C, also used as result matrix
+ * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
+ * @tparam target the target platform
  */
-inline void device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const std::vector<real_type> &A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
-    PLSSVM_ASSERT(!A.empty(), "A matrix may not be empty!");
-    PLSSVM_ASSERT(B.shape() == (plssvm::shape{ num_rhs, num_rows }), "B matrix sizes mismatch!: {} != [{}, {}]", B.shape(), num_rhs, num_rows);
-    PLSSVM_ASSERT(C.shape() == (plssvm::shape{ num_rhs, num_rows }), "C matrix sizes mismatch!: {} != [{}, {}]", C.shape(), num_rhs, num_rows);
-    PLSSVM_ASSERT(num_rows >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, num_rows);
-    PLSSVM_ASSERT(num_rows >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, num_rows);
-
-    // calculate constants
-    const auto blocked_num_rhs = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rhs) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_rows) / INTERNAL_BLOCK_SIZE));
-
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-    // define range over which should be iterated
-    std::vector<std::size_t> range(blocked_num_rhs * blocked_device_specific_num_rows);
-    std::iota(range.begin(), range.end(), 0);
-
-    std::for_each(std::execution::par_unseq, range.begin(), range.end(), [=, A_ptr = A.data(), B_ptr = B.data(), C_ptr = C.data()](const std::size_t idx) {
-        // calculate the indices used in the current thread
-        const std::size_t rhs = idx / blocked_device_specific_num_rows;
-        const std::size_t row = idx % blocked_device_specific_num_rows;
-
-        const std::size_t rhs_idx = rhs * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t row_idx = row * INTERNAL_BLOCK_SIZE_uz;
-
-        // create a thread private array used for internal caching
-        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
-
-        // iterate over all features
-        for (std::size_t dim = 0; dim < (num_rows - row_offset); ++dim) {
-            // perform the dot product calculation
-            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                    const std::size_t global_row = row_idx + static_cast<std::size_t>(internal_j);
-
-                    real_type A_val = 0.0;
-                    // determine on which side of the diagonal we are located
-                    if (dim < global_row) {
-                        A_val = A_ptr[dim * (num_rows - row_offset + PADDING_SIZE_uz) + global_row - dim * (dim + std::size_t{ 1 }) / std::size_t{ 2 }];
-                    } else {
-                        A_val = A_ptr[global_row * (num_rows - row_offset + PADDING_SIZE_uz) + dim - global_row * (global_row + std::size_t{ 1 }) / std::size_t{ 2 }];
+template <target_platform target>
+struct device_kernel_symm {
+    /**
+     * @brief Perform an explicit BLAS SYMM operation.
+     * @param[in] num_rows the number of rows in @p A and @p C
+     * @param[in] num_rhs the number of columns in @p B and @p C
+     * @param[in] device_num_rows the number of rows the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data the current device is responsible for
+     * @param[in] alpha the scalar alpha value
+     * @param[in] A the matrix @p A
+     * @param[in] B the matrix @p B
+     * @param[in] beta the scalar beta value
+     * @param[in,out] C the matrix @p C, also used as result matrix
+     */
+    void operator()(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
+        PLSSVM_ASSERT(A != nullptr, "The A matrix result pointer must be valid!");
+        PLSSVM_ASSERT(B.shape() == (plssvm::shape{ num_rhs, num_rows }), "B matrix sizes mismatch!: {} != [{}, {}]", B.shape(), num_rhs, num_rows);
+        PLSSVM_ASSERT(C.shape() == (plssvm::shape{ num_rhs, num_rows }), "C matrix sizes mismatch!: {} != [{}, {}]", C.shape(), num_rhs, num_rows);
+        PLSSVM_ASSERT(num_rows >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, num_rows);
+        PLSSVM_ASSERT(num_rows >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, num_rows);
+
+        // calculate constants
+        const auto blocked_num_rhs = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rhs) / INTERNAL_BLOCK_SIZE));
+        const auto blocked_device_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_rows) / INTERNAL_BLOCK_SIZE));
+
+        // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        // define the range over which should be iterated
+        std::vector<std::size_t> range(blocked_num_rhs * blocked_device_num_rows);
+        std::iota(range.begin(), range.end(), 0);
+
+        std::for_each(std::execution::par_unseq, range.begin(), range.end(), [=, A_ptr = A, B_ptr = B.data(), C_ptr = C.data()](const std::size_t idx) {
+            // calculate the indices used in the current thread
+            const std::size_t i_idx = (idx / blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+            const std::size_t j_idx = (idx % blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
+            // create a thread private array used for internal caching
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+            // iterate over all values
+            for (std::size_t dim_block = 0; dim_block < (num_rows - device_row_offset); dim_block += THREAD_BLOCK_SIZE_uz) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the dim is the fastest moving index
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            // calculate the indices to access the global data
+                            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                            const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                            real_type sum{ 0.0 };
+                            for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE_uz; ++dim) {
+                                real_type A_cache = 0.0;
+                                // determine on which side of the diagonal we are located
+                                if (dim_block + dim < global_j_idx) {
+                                    A_cache = A_ptr[(dim_block + dim) * (num_rows - device_row_offset + PADDING_SIZE_uz) + global_j_idx - (dim_block + dim) * (dim_block + dim + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                                } else {
+                                    A_cache = A_ptr[global_j_idx * (num_rows - device_row_offset + PADDING_SIZE_uz) + dim_block + dim - global_j_idx * (global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                                }
+                                sum += A_cache * B_ptr[(dim_block + dim + device_row_offset) * (num_rhs + PADDING_SIZE_uz) + global_i_idx];
+                            }
+                            temp[internal_i][internal_j] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the dim is the slowest moving index
+                    for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE_uz; ++dim) {
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                // calculate the indices to access the global data
+                                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                                const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                                real_type A_cache = 0.0;
+                                // determine on which side of the diagonal we are located
+                                if (dim_block + dim < global_j_idx) {
+                                    A_cache = A_ptr[(dim_block + dim) * (num_rows - device_row_offset + PADDING_SIZE_uz) + global_j_idx - (dim_block + dim) * (dim_block + dim + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                                } else {
+                                    A_cache = A_ptr[global_j_idx * (num_rows - device_row_offset + PADDING_SIZE_uz) + dim_block + dim - global_j_idx * (global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 }];  // SoA, upper triangular matrix only
+                                }
+                                temp[internal_i][internal_j] += A_cache * B_ptr[(dim_block + dim + device_row_offset) * (num_rhs + PADDING_SIZE_uz) + global_i_idx];
+                            }
+                        }
                     }
-                    temp[internal_i][internal_j] += A_val * B_ptr[(dim + row_offset) * (num_rhs + PADDING_SIZE_uz) + global_rhs];
                 }
             }
-        }
-
-        // apply the (partial) BLAS operation and update C
-        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                const std::size_t device_global_row = row_idx + static_cast<std::size_t>(internal_j);
-                const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_j);
-
-                // be sure to not perform out of bounds accesses
-                if (global_rhs < num_rhs && device_global_row < device_specific_num_rows) {
-                    C_ptr[global_row * (num_rhs + PADDING_SIZE_uz) + global_rhs] = alpha * temp[internal_i][internal_j] + beta * C_ptr[global_row * (num_rhs + PADDING_SIZE_uz) + global_rhs];
+
+            // apply the (partial) BLAS operation and update C
+            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses
+                    if (global_i_idx < num_rhs && device_global_j_idx < device_num_rows) {
+                        C_ptr[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx] = alpha * temp[internal_i][internal_j] + beta * C_ptr[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx];  // SoA
+                    }
                 }
             }
-        }
-    });
-}
+        });
+    }
+};
 
 /**
  * @brief Perform an explicit BLAS SYMM operation: `C = alpha * A * B + beta * C` where @p A is a `m x k` symmetric matrix (memory optimized), @p B is a `k x n` matrix, @p C is a `m x n` matrix, and @p alpha and @p beta are scalars.
- * @param[in] num_rows the number of rows in @p A and @p C
- * @param[in] num_rhs the number of columns in @p B and @p C
- * @param[in] num_mirror_rows the number of rows to mirror down
- * @param[in] device_specific_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
- * @param[in] row_offset the first row this device is responsible for
- * @param[in] alpha the scalar alpha value
- * @param[in] A the matrix @p A
- * @param[in] B the matrix @p B
- * @param[in] beta the scalar beta value
- * @param[in,out] C the matrix @p C, also used as result matrix
+ * @details In a multi-GPU setting, this function is responsible for mirroring down the columns this device is responsible for!
+ * @tparam target the target platform
  */
-inline void device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type alpha, const std::vector<real_type> &A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
-    // compute: C = alpha * A * B + beta * C with A in m x k, B in n x k, and C in n x m, alpha, beta as scalar
-    PLSSVM_ASSERT(!A.empty(), "A matrix may not be empty!");
-    PLSSVM_ASSERT(B.shape() == (plssvm::shape{ num_rhs, num_rows }), "B matrix sizes mismatch!: {} != [{}, {}]", B.shape(), num_rhs, num_rows);
-    PLSSVM_ASSERT(C.shape() == (plssvm::shape{ num_rhs, num_rows }), "C matrix sizes mismatch!: {} != [{}, {}]", C.shape(), num_rhs, num_rows);
-    PLSSVM_ASSERT(num_rows >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, num_rows);
-    PLSSVM_ASSERT(num_rows >= num_mirror_rows, "The number of mirror rows ({}) cannot be greater the the total number of rows ({})!", num_mirror_rows, num_rows);
-    PLSSVM_ASSERT(num_rows >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, num_rows);
-
-    // calculate constants
-    const auto blocked_num_rhs = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rhs) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_num_mirror_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_mirror_rows) / INTERNAL_BLOCK_SIZE));
-
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-    // define range over which should be iterated
-    std::vector<std::size_t> range(blocked_num_rhs * blocked_num_mirror_rows);  // define range over which should be iterated
-    std::iota(range.begin(), range.end(), 0);
-
-    std::for_each(std::execution::par_unseq, range.begin(), range.end(), [=, A_ptr = A.data(), B_ptr = B.data(), C_ptr = C.data()](const std::size_t idx) {
-        // calculate the indices used in the current thread
-        const std::size_t rhs = idx / blocked_num_mirror_rows;
-        const std::size_t row = idx % blocked_num_mirror_rows;
-
-        const std::size_t rhs_idx = rhs * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t row_idx = row * INTERNAL_BLOCK_SIZE_uz;
-
-        // create a thread private array used for internal caching
-        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
-
-        // iterate over all features
-        for (std::size_t dim = 0; dim < device_specific_num_rows; ++dim) {
-            // perform the dot product calculation
-            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                    const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                    const std::size_t global_row = row_idx + static_cast<std::size_t>(internal_j);
-
-                    const real_type A_val = A_ptr[dim * (num_rows - row_offset + PADDING_SIZE_uz) - (dim - std::size_t{ 1 }) * dim / std::size_t{ 2 } + device_specific_num_rows - dim + global_row];
-                    temp[internal_i][internal_j] += A_val * B_ptr[(dim + row_offset) * (num_rhs + PADDING_SIZE_uz) + global_rhs];
+template <target_platform target>
+struct device_kernel_symm_mirror {
+    /**
+     * @brief Perform an explicit BLAS SYMM operation.
+     * @param[in] num_rows the number of rows in @p A and @p C
+     * @param[in] num_rhs the number of columns in @p B and @p C
+     * @param[in] num_mirror_rows the number of rows to mirror down
+     * @param[in] device_num_rows the number of rows in @p A and number of rows in @p B; thr rows in @p A are potentially distributed across multiple devices
+     * @param[in] device_row_offset the first row this device is responsible for
+     * @param[in] alpha the scalar alpha value
+     * @param[in] A the matrix @p A
+     * @param[in] B the matrix @p B
+     * @param[in] beta the scalar beta value
+     * @param[in,out] C the matrix @p C, also used as result matrix
+     */
+    void operator()(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type alpha, const real_type *A, const soa_matrix<real_type> &B, const real_type beta, soa_matrix<real_type> &C) {
+        // compute: C = alpha * A * B + beta * C with A in m x k, B in n x k, and C in n x m, alpha, beta as scalar
+        PLSSVM_ASSERT(A != nullptr, "The A matrix result pointer must be valid!");
+        PLSSVM_ASSERT(B.shape() == (plssvm::shape{ num_rhs, num_rows }), "B matrix sizes mismatch!: {} != [{}, {}]", B.shape(), num_rhs, num_rows);
+        PLSSVM_ASSERT(C.shape() == (plssvm::shape{ num_rhs, num_rows }), "C matrix sizes mismatch!: {} != [{}, {}]", C.shape(), num_rhs, num_rows);
+        PLSSVM_ASSERT(num_rows >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, num_rows);
+        PLSSVM_ASSERT(num_rows >= num_mirror_rows, "The number of mirror rows ({}) cannot be greater the the total number of rows ({})!", num_mirror_rows, num_rows);
+        PLSSVM_ASSERT(num_rows >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, num_rows);
+
+        // calculate constants
+        const auto blocked_num_rhs = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rhs) / INTERNAL_BLOCK_SIZE));
+        const auto blocked_num_mirror_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_mirror_rows) / INTERNAL_BLOCK_SIZE));
+
+        // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        // define the range over which should be iterated
+        std::vector<std::size_t> range(blocked_num_rhs * blocked_num_mirror_rows);
+        std::iota(range.begin(), range.end(), 0);
+
+        std::for_each(std::execution::par_unseq, range.begin(), range.end(), [=, A_ptr = A, B_ptr = B.data(), C_ptr = C.data()](const std::size_t idx) {
+            // calculate the indices used in the current thread
+            const std::size_t i_idx = (idx / blocked_num_mirror_rows) * INTERNAL_BLOCK_SIZE_uz;  // num_rhs
+            const std::size_t j_idx = (idx % blocked_num_mirror_rows) * INTERNAL_BLOCK_SIZE_uz;  // num_mirror_rows
+
+            // create a thread private array used for internal caching
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+            // iterate over the remaining values
+            for (std::size_t dim_block = 0; dim_block < device_num_rows; dim_block += THREAD_BLOCK_SIZE_uz) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the dim is the fastest moving index
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            // calculate the indices to access the global data
+                            const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                            const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                            real_type sum{ 0.0 };
+                            for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE_uz; ++dim) {
+                                sum += A_ptr[(dim_block + dim) * (num_rows - device_row_offset + PADDING_SIZE_uz) - (dim_block + dim - std::size_t{ 1 }) * (dim_block + dim) / std::size_t{ 2 } + device_num_rows - (dim_block + dim) + global_j_idx] *  // SoA, upper triangular matrix only
+                                       B_ptr[(dim_block + dim + device_row_offset) * (num_rhs + PADDING_SIZE_uz) + global_i_idx];                                                                                                                        // SoA
+                            }
+                            temp[internal_i][internal_j] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the dim is the slowest moving index
+                    for (std::size_t dim = 0; dim < THREAD_BLOCK_SIZE_uz; ++dim) {
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                // calculate the indices to access the global data
+                                const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                                const auto global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+
+                                temp[internal_i][internal_j] += A_ptr[(dim_block + dim) * (num_rows - device_row_offset + PADDING_SIZE_uz) - (dim_block + dim - std::size_t{ 1 }) * (dim_block + dim) / std::size_t{ 2 } + device_num_rows - (dim_block + dim) + global_j_idx] *  // SoA, upper triangular matrix only
+                                                                B_ptr[(dim_block + dim + device_row_offset) * (num_rhs + PADDING_SIZE_uz) + global_i_idx];                                                                                                                        // SoA
+                            }
+                        }
+                    }
                 }
             }
-        }
-
-        // apply the (partial) BLAS operation and update C
-        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
-            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
-                const std::size_t global_rhs = rhs_idx + static_cast<std::size_t>(internal_i);
-                const std::size_t partial_global_row = row_idx + static_cast<std::size_t>(internal_j);
-                const std::size_t global_row = row_offset + device_specific_num_rows + row_idx + static_cast<std::size_t>(internal_j);
-
-                // be sure to not perform out of bounds accesses
-                if (global_rhs < num_rhs && partial_global_row < num_mirror_rows) {
-                    C_ptr[global_row * (num_rhs + PADDING_SIZE_uz) + global_rhs] = alpha * temp[internal_i][internal_j] + beta * C_ptr[global_row * (num_rhs + PADDING_SIZE_uz) + global_rhs];
+
+            // apply the (remaining) BLAS operation and update C
+            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                    const auto partial_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                    const auto global_j_idx = device_row_offset + device_num_rows + partial_global_j_idx;
+
+                    // be sure to not perform out-of-bounds accesses
+                    if (global_i_idx < num_rhs && partial_global_j_idx < num_mirror_rows) {
+                        C_ptr[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx] = alpha * temp[internal_i][internal_j] + beta * C_ptr[global_j_idx * (num_rhs + PADDING_SIZE_uz) + global_i_idx];  // SoA
+                    }
                 }
             }
-        }
-    });
-}
+        });
+    }
+};
 
 }  // namespace plssvm::stdpar::detail
 
diff --git a/include/plssvm/backends/stdpar/kernel/cg_explicit/kernel_matrix_assembly.hpp b/include/plssvm/backends/stdpar/kernel/cg_explicit/kernel_matrix_assembly.hpp
index 93772aab3..ab500396e 100644
--- a/include/plssvm/backends/stdpar/kernel/cg_explicit/kernel_matrix_assembly.hpp
+++ b/include/plssvm/backends/stdpar/kernel/cg_explicit/kernel_matrix_assembly.hpp
@@ -14,14 +14,15 @@
 #pragma once
 
 #include "plssvm/backends/stdpar/kernel/kernel_functions.hpp"  // plssvm::stdpar::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                                // plssvm::{real_type, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                                // plssvm::{real_type, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/detail/assert.hpp"                            // PLSSVM_ASSERT
 #include "plssvm/kernel_function_types.hpp"                    // plssvm::kernel_function_type
-#include "plssvm/matrix.hpp"                                   // plssvm::aos_matrix
+#include "plssvm/matrix.hpp"                                   // plssvm::soa_matrix
+#include "plssvm/target_platforms.hpp"                         // plssvm::target_platform
 
 #include <algorithm>  // std::for_each
 #include <array>      // std::array
-#include <cmath>      // std::ceil, std::sqrt
+#include <cmath>      // std::ceil
 #include <cstddef>    // std::size_t
 #include <execution>  // std::execution::par_unseq
 #include <numeric>    // std::iota
@@ -30,88 +31,118 @@
 namespace plssvm::stdpar::detail {
 
 /**
- * @brief Assemble the kernel matrix using the @p kernel function.
- * @tparam kernel the compile-time kernel function to use
- * @tparam Args the types of the potential additional arguments for the @p kernel function
- * @param[out] kernel_matrix the resulting kernel matrix
- * @param[in] data the data matrix
- * @param[in] device_specific_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data the current device is responsible for
- * @param[in] q the `q` vector
- * @param[in] QA_cost he bottom right matrix entry multiplied by cost
- * @param[in] cost 1 / the cost parameter in the C-SVM
- * @param[in] kernel_function_parameter the potential additional arguments for the @p kernel function
+ * @brief Create the explicit kernel matrix using the @p kernel_function.
+ * @tparam target the target platform
+ * @tparam kernel_function the type of the used kernel function
+ * @tparam Args the types of the parameters necessary for the specific kernel function
  */
-template <kernel_function_type kernel, typename... Args>
-void device_kernel_assembly(std::vector<real_type> &kernel_matrix, const soa_matrix<real_type> &data, const std::size_t device_specific_num_rows, const std::size_t row_offset, const std::vector<real_type> &q, const real_type QA_cost, const real_type cost, Args... kernel_function_parameter) {
-    PLSSVM_ASSERT(q.size() == data.num_rows() - 1, "Sizes mismatch!: {} != {}", q.size(), data.num_rows() - 1);
-    PLSSVM_ASSERT(!kernel_matrix.empty(), "A matrix may not be empty!");
-    PLSSVM_ASSERT(q.size() >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, q.size());
-    PLSSVM_ASSERT(q.size() >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, q.size());
-    PLSSVM_ASSERT(cost != real_type{ 0.0 }, "cost must not be 0.0 since it is 1 / plssvm::cost!");
-
-    // calculate constants
-    const std::size_t num_rows = data.num_rows() - 1;
-    const std::size_t num_features = data.num_cols();
-    const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - row_offset) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_rows) / INTERNAL_BLOCK_SIZE));
-
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-    // count the number of entries in the final index list
-    std::vector<std::size_t> indices(blocked_row_range * blocked_device_specific_num_rows);  // define range over which should be iterated
-    std::iota(indices.begin(), indices.end(), 0);
-
-    std::for_each(std::execution::par_unseq, indices.begin(), indices.end(), [=, q_ptr = q.data(), data_ptr = data.data(), kernel_matrix_ptr = kernel_matrix.data()](const std::size_t idx) {
-        // calculate the indices used in the current thread
-        const std::size_t row_idx = (idx / blocked_device_specific_num_rows) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t col_idx = (idx % blocked_device_specific_num_rows) * INTERNAL_BLOCK_SIZE_uz;
-
-        // only calculate the upper triangular matrix
-        if (row_idx >= col_idx) {
-            // only calculate the upper triangular matrix -> done be only iterating over valid row <-> col pairs
-            // create a thread private array used for internal caching
-            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
-
-            // iterate over all features
-            for (std::size_t dim = 0; dim < num_features; ++dim) {
-                // perform the feature reduction calculation
-                for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                    for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                        const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                        const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
-
-                        temp[internal_row][internal_col] += detail::feature_reduce<kernel>(data_ptr[dim * (num_rows + 1 + PADDING_SIZE_uz) + global_row], data_ptr[dim * (num_rows + 1 + PADDING_SIZE_uz) + global_col]);
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
+struct device_kernel_assembly {
+    /**
+     * @brief Assemble the kernel matrix using the specified kernel function.
+     * @param[out] kernel_matrix the resulting kernel matrix
+     * @param[in] data the data matrix
+     * @param[in] device_num_rows the number of rows the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data the current device is responsible for
+     * @param[in] q the `q` vector
+     * @param[in] QA_cost he bottom right matrix entry multiplied by cost
+     * @param[in] cost 1 / the cost parameter in the C-SVM
+     * @param[in] kernel_function_parameter the potential additional arguments for the kernel function
+     */
+    void operator()(real_type *kernel_matrix, const soa_matrix<real_type> &data, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::vector<real_type> &q, const real_type QA_cost, const real_type cost, Args... kernel_function_parameter) {
+        PLSSVM_ASSERT(kernel_matrix != nullptr, "The kernel matrix result pointer must be valid!");
+        PLSSVM_ASSERT(q.size() == data.num_rows() - 1, "Sizes mismatch!: {} != {}", q.size(), data.num_rows() - 1);
+        PLSSVM_ASSERT(q.size() >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, q.size());
+        PLSSVM_ASSERT(q.size() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, q.size());
+        PLSSVM_ASSERT(cost != real_type{ 0.0 }, "cost must not be 0.0 since it is 1 / plssvm::cost!");
+
+        // calculate constants
+        const std::size_t num_rows = data.num_rows() - 1;
+        const std::size_t num_features = data.num_cols();
+        const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - device_row_offset) / INTERNAL_BLOCK_SIZE));
+        const auto blocked_device_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_rows) / INTERNAL_BLOCK_SIZE));
+
+        // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        // define the range over which should be iterated
+        std::vector<std::size_t> indices(blocked_row_range * blocked_device_num_rows);
+        std::iota(indices.begin(), indices.end(), 0);
+
+        std::for_each(std::execution::par_unseq, indices.begin(), indices.end(), [=, q_ptr = q.data(), data_ptr = data.data(), kernel_matrix_ptr = kernel_matrix](const std::size_t idx) {
+            // calculate the indices used in the current thread
+            const std::size_t i_idx = (idx % blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+            const std::size_t j_idx = (idx / blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
+            // only calculate the upper triangular matrix
+            if (i_idx >= j_idx) {
+                // create a thread private array used for internal caching
+                std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+                // iterate over all features
+                for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                    if constexpr (target == target_platform::cpu) {
+                        // perform the feature reduction calculation, the feature is the fastest moving index
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                // calculate the indices to access the global data
+                                const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                                const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
+
+                                real_type sum{ 0.0 };
+                                for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                                    sum += detail::feature_reduce<kernel_function>(data_ptr[(feature_block + feature) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx],   // SoA
+                                                                                   data_ptr[(feature_block + feature) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx]);  // SoA
+                                }
+                                temp[internal_i][internal_j] += sum;
+                            }
+                        }
+                    } else {
+                        // perform the feature reduction calculation, the feature is the slowest moving index
+                        for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                    // calculate the indices to access the global data
+                                    const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                                    const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
+
+                                    temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_ptr[(feature_block + feature) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx],   // SoA
+                                                                                                            data_ptr[(feature_block + feature) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx]);  // SoA
+                                }
+                            }
+                        }
                     }
                 }
-            }
 
-            // apply the remaining part of the kernel function and store the value in the output kernel matrix
-            for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                    // calculate the indices to access the kernel matrix (the part stored on the current device)
-                    const std::size_t device_global_row = row_idx + static_cast<std::size_t>(internal_row);
-                    const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                    const std::size_t device_global_col = col_idx + static_cast<std::size_t>(internal_col);
-                    const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
-
-                    // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                    if (device_global_row < (num_rows - row_offset) && device_global_col < device_specific_num_rows && global_row >= global_col) {
-                        real_type temp_ij = temp[internal_row][internal_col];
-                        temp_ij = detail::apply_kernel_function<kernel>(temp_ij, kernel_function_parameter...) + QA_cost - q_ptr[global_row] - q_ptr[global_col];
-                        // apply the cost on the diagonal
-                        if (global_row == global_col) {
-                            temp_ij += cost;
+                // apply the remaining part of the kernel function and store the value in the output kernel matrix
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        // calculate the indices to access the global data and the data with respect to the current device
+                        const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                        const auto global_i_idx = device_row_offset + device_global_i_idx;
+                        const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                        const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                        // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                        if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
+                            real_type temp_ij = temp[internal_i][internal_j];
+                            // apply the final kernel function
+                            temp_ij = detail::apply_kernel_function<kernel_function>(temp_ij, kernel_function_parameter...) + QA_cost - q_ptr[global_i_idx] - q_ptr[global_j_idx];
+                            // apply the cost on the diagonal
+                            if (global_i_idx == global_j_idx) {
+                                temp_ij += cost;
+                            }
+                            // update the upper triangular kernel matrix
+                            kernel_matrix_ptr[device_global_j_idx * (num_rows - device_row_offset + PADDING_SIZE_uz) - device_global_j_idx * (device_global_j_idx + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_i_idx] = temp_ij;
                         }
-                        kernel_matrix_ptr[device_global_col * (num_rows - row_offset + PADDING_SIZE_uz) - device_global_col * (device_global_col + std::size_t{ 1 }) / std::size_t{ 2 } + device_global_row] = temp_ij;
                     }
                 }
             }
-        }
-    });
-}
+        });
+    }
+};
 
 }  // namespace plssvm::stdpar::detail
 
diff --git a/include/plssvm/backends/stdpar/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp b/include/plssvm/backends/stdpar/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
index fdebd9cb5..ab3690eb5 100644
--- a/include/plssvm/backends/stdpar/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
+++ b/include/plssvm/backends/stdpar/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp
@@ -18,8 +18,8 @@
 #include "plssvm/constants.hpp"                                // plssvm::real_type
 #include "plssvm/detail/assert.hpp"                            // PLSSVM_ASSERT
 #include "plssvm/kernel_function_types.hpp"                    // plssvm::kernel_function_type
-#include "plssvm/kernel_functions.hpp"                         // plssvm::kernel_function
-#include "plssvm/matrix.hpp"                                   // aos_matrix
+#include "plssvm/matrix.hpp"                                   // plssvm::soa_matrix
+#include "plssvm/target_platforms.hpp"                         // plssvm::target_platform
 
 #include <algorithm>  // std::for_each
 #include <array>      // std::array
@@ -32,100 +32,152 @@
 namespace plssvm::stdpar::detail {
 
 /**
- * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
- * @tparam kernel the compile-time kernel function to use
- * @tparam Args the types of the potential additional arguments for the @p kernel function
- * @param[in] alpha the scalar alpha value
- * @param[in] q the `q` vector
- * @param[in] data the data matrix
- * @param[in] device_specific_num_rows the number of rows the current device is responsible for
- * @param[in] row_offset the first row in @p data the current device is responsible for
- * @param[in] QA_cost he bottom right matrix entry multiplied by cost
- * @param[in] cost 1 / the cost parameter in the C-SVM
- * @param[in] B the matrix @p B
- * @param[in,out] C the matrix @p C
- * @param[in] kernel_function_parameter the potential additional arguments for the @p kernel function
+ * @brief Perform an implicit BLAS SYMM-like operation: `C = alpha * A * B + C` where `A` is the implicitly calculated kernel matrix using the @p kernel_function (never actually stored, reducing the amount of needed global memory), @p B and @p C are matrices, and @p alpha is a scalar.
+ * @tparam target the target platform
+ * @tparam kernel_function the type of the used kernel function
+ * @tparam Args the types of the parameters necessary for the specific kernel function
  */
-template <kernel_function_type kernel, typename... Args>
-inline void device_kernel_assembly_symm(const real_type alpha, const std::vector<real_type> &q, const soa_matrix<real_type> &data, const std::size_t device_specific_num_rows, const std::size_t row_offset, const real_type QA_cost, const real_type cost, const soa_matrix<real_type> &B, soa_matrix<real_type> &C, Args... kernel_function_parameter) {
-    PLSSVM_ASSERT(q.size() == data.num_rows() - 1, "Sizes mismatch!: {} != {}", q.size(), data.num_rows() - 1);
-    PLSSVM_ASSERT(q.size() >= device_specific_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_specific_num_rows, q.size());
-    PLSSVM_ASSERT(q.size() >= row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", row_offset, q.size());
-    PLSSVM_ASSERT(cost != real_type{ 0.0 }, "cost must not be 0.0 since it is 1 / plssvm::cost!");
-    PLSSVM_ASSERT(B.shape() == C.shape(), "The matrices B and C must have the same shape!");
-    PLSSVM_ASSERT(B.num_cols() == q.size(), "The number of columns in B ({}) must be the same as the values in q ({})!", B.num_cols(), q.size());
-
-    // calculate constants
-    const std::size_t num_rows = data.num_rows() - 1;
-    const std::size_t num_features = data.num_cols();
-    const std::size_t num_classes = B.num_rows();
-    const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - row_offset) / INTERNAL_BLOCK_SIZE));
-    const auto blocked_device_specific_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_rows) / INTERNAL_BLOCK_SIZE));
-
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-    // count the number of entries in the final index list
-    std::vector<std::size_t> indices(blocked_row_range * blocked_device_specific_num_rows);  // define range over which should be iterated
-    std::iota(indices.begin(), indices.end(), 0);
-
-    std::for_each(std::execution::par_unseq, indices.begin(), indices.end(), [=, q_ptr = q.data(), data_ptr = data.data(), B_ptr = B.data(), C_ptr = C.data()](const std::size_t idx) {
-        // calculate the indices used in the current thread
-        const std::size_t row_idx = (idx / blocked_device_specific_num_rows) * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t col_idx = (idx % blocked_device_specific_num_rows) * INTERNAL_BLOCK_SIZE_uz;
-
-        // only calculate the upper triangular matrix
-        if (row_idx >= col_idx) {
-            // only calculate the upper triangular matrix -> done be only iterating over valid row <-> col pairs
-            // create a thread private array used for internal caching
-            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
-
-            // iterate over all features
-            for (std::size_t dim = 0; dim < num_features; ++dim) {
-                for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                    for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                        const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                        const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
-
-                        temp[internal_row][internal_col] += detail::feature_reduce<kernel>(data_ptr[dim * (num_rows + 1 + PADDING_SIZE_uz) + global_row], data_ptr[dim * (num_rows + 1 + PADDING_SIZE_uz) + global_col]);
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
+struct device_kernel_assembly_symm {
+    /**
+     * @brief Perform an implicit BLAS SYMM-like operation.
+     * @param[in] alpha the scalar alpha value
+     * @param[in] q the `q` vector
+     * @param[in] data the data matrix
+     * @param[in] device_num_rows the number of rows the current device is responsible for
+     * @param[in] device_row_offset the first row in @p data the current device is responsible for
+     * @param[in] QA_cost he bottom right matrix entry multiplied by cost
+     * @param[in] cost 1 / the cost parameter in the C-SVM
+     * @param[in] B the matrix @p B
+     * @param[in,out] C the matrix @p C
+     * @param[in] kernel_function_parameter the potential additional arguments for the kernel function
+     */
+    void operator()(const real_type alpha, const std::vector<real_type> &q, const soa_matrix<real_type> &data, const std::size_t device_num_rows, const std::size_t device_row_offset, const real_type QA_cost, const real_type cost, const soa_matrix<real_type> &B, soa_matrix<real_type> &C, Args... kernel_function_parameter) {
+        PLSSVM_ASSERT(q.size() == data.num_rows() - 1, "Sizes mismatch!: {} != {}", q.size(), data.num_rows() - 1);
+        PLSSVM_ASSERT(q.size() >= device_num_rows, "The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", device_num_rows, q.size());
+        PLSSVM_ASSERT(q.size() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of rows ({})!", device_row_offset, q.size());
+        PLSSVM_ASSERT(cost != real_type{ 0.0 }, "cost must not be 0.0 since it is 1 / plssvm::cost!");
+        PLSSVM_ASSERT(B.shape() == C.shape(), "The matrices B and C must have the same shape!");
+        PLSSVM_ASSERT(B.num_cols() == q.size(), "The number of columns in B ({}) must be the same as the values in q ({})!", B.num_cols(), q.size());
+
+        // calculate constants
+        const std::size_t num_rows = data.num_rows() - 1;
+        const std::size_t num_features = data.num_cols();
+        const std::size_t num_classes = B.num_rows();
+        const auto blocked_row_range = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_rows - device_row_offset) / INTERNAL_BLOCK_SIZE));
+        const auto blocked_device_num_rows = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_rows) / INTERNAL_BLOCK_SIZE));
+
+        // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        // define the range over which should be iterated
+        std::vector<std::size_t> indices(blocked_row_range * blocked_device_num_rows);
+        std::iota(indices.begin(), indices.end(), 0);
+
+        std::for_each(std::execution::par_unseq, indices.begin(), indices.end(), [=, q_ptr = q.data(), data_ptr = data.data(), B_ptr = B.data(), C_ptr = C.data()](const std::size_t idx) {
+            // calculate the indices used in the current thread
+            const std::size_t i_idx = (idx % blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // num_rows - device_row_offset
+            const std::size_t j_idx = (idx / blocked_device_num_rows) * INTERNAL_BLOCK_SIZE_uz;  // device_num_rows
+
+            // only calculate the upper triangular matrix
+            if (i_idx >= j_idx) {
+                // create a thread private array used for internal caching
+                std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+                //*************************************************************************//
+                //                   inplace kernel matrix construction                    //
+                //*************************************************************************//
+                // iterate over all features
+                for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                    if constexpr (target == target_platform::cpu) {
+                        // perform the feature reduction calculation, the feature is the fastest moving index
+                        for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                            for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                // calculate the indices to access the global data
+                                const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                                const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
+
+                                real_type sum{ 0.0 };
+                                for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                                    sum += detail::feature_reduce<kernel_function>(data_ptr[(feature_block + feature) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx],   // SoA
+                                                                                   data_ptr[(feature_block + feature) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx]);  // SoA
+                                }
+                                temp[internal_i][internal_j] += sum;
+                            }
+                        }
+                    } else {
+                        // perform the feature reduction calculation, the feature is the slowest moving index
+                        for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                            for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                                for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                                    // calculate the indices to access the global data
+                                    const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                                    const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
+
+                                    temp[internal_i][internal_j] += detail::feature_reduce<kernel_function>(data_ptr[(feature_block + feature) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_i_idx],   // SoA
+                                                                                                            data_ptr[(feature_block + feature) * (num_rows + std::size_t{ 1 } + PADDING_SIZE_uz) + global_j_idx]);  // SoA
+                                }
+                            }
+                        }
                     }
                 }
-            }
 
-            // apply the remaining part of the kernel function and store the value in the output kernel matrix
-            for (unsigned internal_row = 0; internal_row < INTERNAL_BLOCK_SIZE; ++internal_row) {
-                for (unsigned internal_col = 0; internal_col < INTERNAL_BLOCK_SIZE; ++internal_col) {
-                    const std::size_t device_global_row = row_idx + static_cast<std::size_t>(internal_row);
-                    const std::size_t global_row = row_offset + row_idx + static_cast<std::size_t>(internal_row);
-                    const std::size_t device_global_col = col_idx + static_cast<std::size_t>(internal_col);
-                    const std::size_t global_col = row_offset + col_idx + static_cast<std::size_t>(internal_col);
-
-                    // be sure to not perform out of bounds accesses for the kernel matrix (only using the upper triangular matrix)
-                    if (device_global_row < (num_rows - row_offset) && device_global_col < device_specific_num_rows && global_row >= global_col) {
-                        real_type temp_ij = temp[internal_row][internal_col];
-                        temp_ij = detail::apply_kernel_function<kernel>(temp_ij, kernel_function_parameter...) + QA_cost - q_ptr[global_row] - q_ptr[global_col];
-                        // apply the cost on the diagonal
-                        if (global_row == global_col) {
-                            temp_ij += cost;
-                            // calculate the values of alpha * A * B
-                            for (std::size_t class_idx = 0; class_idx < num_classes; ++class_idx) {
-                                atomic_ref<real_type>{ C_ptr[global_row * (num_classes + PADDING_SIZE_uz) + class_idx] } += alpha * temp_ij * B_ptr[global_row * (num_classes + PADDING_SIZE_uz) + class_idx];
+                // apply the remaining part of the kernel function and store the value in the output kernel matrix
+                for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                    for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                        // calculate the indices to access the global data and the data with respect to the current device
+                        const auto device_global_i_idx = i_idx + static_cast<std::size_t>(internal_i);
+                        const auto global_i_idx = device_row_offset + device_global_i_idx;
+                        const auto device_global_j_idx = j_idx + static_cast<std::size_t>(internal_j);
+                        const auto global_j_idx = device_row_offset + device_global_j_idx;
+
+                        // be sure to not perform out-of-bounds accesses (only using the upper triangular matrix)
+                        if (device_global_i_idx < (num_rows - device_row_offset) && device_global_j_idx < device_num_rows && global_i_idx >= global_j_idx) {
+                            // apply the final kernel function
+                            temp[internal_i][internal_j] = detail::apply_kernel_function<kernel_function>(temp[internal_i][internal_j], kernel_function_parameter...) + QA_cost - q_ptr[global_i_idx] - q_ptr[global_j_idx];
+                            // apply the cost on the diagonal
+                            if (global_i_idx == global_j_idx) {
+                                temp[internal_i][internal_j] += cost;
                             }
                         } else {
-                            // calculate the values of alpha * A * B
-                            for (std::size_t class_idx = 0; class_idx < num_classes; ++class_idx) {
-                                atomic_ref<real_type>{ C_ptr[global_row * (num_classes + PADDING_SIZE_uz) + class_idx] } += alpha * temp_ij * B_ptr[global_col * (num_classes + PADDING_SIZE_uz) + class_idx];
-                                // symmetry
-                                atomic_ref<real_type>{ C_ptr[global_col * (num_classes + PADDING_SIZE_uz) + class_idx] } += alpha * temp_ij * B_ptr[global_row * (num_classes + PADDING_SIZE_uz) + class_idx];
+                            // be sure to set the value to zero otherwise
+                            temp[internal_i][internal_j] = real_type{ 0.0 };
+                        }
+                    }
+                }
+
+                //*************************************************************************//
+                //                     calculate C += alpha * temp * B                     //
+                //*************************************************************************//
+                for (std::size_t class_block = 0; class_block < num_classes; class_block += THREAD_BLOCK_SIZE_uz) {
+                    for (unsigned internal_i = 0; internal_i < INTERNAL_BLOCK_SIZE; ++internal_i) {
+                        for (unsigned internal_j = 0; internal_j < INTERNAL_BLOCK_SIZE; ++internal_j) {
+                            // calculate the indices to access the global data
+                            const auto global_i_idx = device_row_offset + i_idx + static_cast<std::size_t>(internal_i);
+                            const auto global_j_idx = device_row_offset + j_idx + static_cast<std::size_t>(internal_j);
+
+                            if (global_i_idx == global_j_idx) {
+                                // only apply once to the diagonal
+                                for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
+                                    atomic_ref<real_type>{ C_ptr[global_i_idx * (num_classes + PADDING_SIZE_uz) + class_block + class_idx] } += alpha * temp[internal_i][internal_j] * B_ptr[global_i_idx * (num_classes + PADDING_SIZE_uz) + class_block + class_idx];
+                                }
+                            } else {
+                                // apply it for the upper and lower triangular matrix
+                                for (std::size_t class_idx = 0; class_idx < THREAD_BLOCK_SIZE_uz; ++class_idx) {
+                                    atomic_ref<real_type>{ C_ptr[global_i_idx * (num_classes + PADDING_SIZE_uz) + class_block + class_idx] } += alpha * temp[internal_i][internal_j] * B_ptr[global_j_idx * (num_classes + PADDING_SIZE_uz) + class_block + class_idx];
+                                    // symmetry
+                                    atomic_ref<real_type>{ C_ptr[global_j_idx * (num_classes + PADDING_SIZE_uz) + class_block + class_idx] } += alpha * temp[internal_i][internal_j] * B_ptr[global_i_idx * (num_classes + PADDING_SIZE_uz) + class_block + class_idx];
+                                }
                             }
                         }
                     }
                 }
             }
-        }
-    });
-}
+        });
+    }
+};
 
 }  // namespace plssvm::stdpar::detail
 
diff --git a/include/plssvm/backends/stdpar/kernel/kernel_functions.hpp b/include/plssvm/backends/stdpar/kernel/kernel_functions.hpp
index e652d1160..b77e7a338 100644
--- a/include/plssvm/backends/stdpar/kernel/kernel_functions.hpp
+++ b/include/plssvm/backends/stdpar/kernel/kernel_functions.hpp
@@ -38,42 +38,17 @@ namespace plssvm::stdpar::detail {
 
 /**
  * @brief Fast integer power function. Computes base^exponent and takes advantage of the fact that degree may only be positive integer values.
- * @details Hardcodes the power function for degree <= 6, uses a simple for loop otherwise.
  * @param[in] base the base
  * @param[in] exponent the exponent
  * @return base^exponent (`[[nodiscard]]`)
  */
 [[nodiscard]] inline PLSSVM_STDPAR_KERNEL_FUNCTION real_type powi(const real_type base, const int exponent) {
-    switch (exponent) {
-        case 0: return real_type{ 1.0 };
-        case 1: return base;
-        case 2: return base * base;
-        case 3: return base * base * base;
-        case 4:
-            {
-                const real_type temp = base * base;
-                return temp * temp;
-            }
-        case 5:
-            {
-                const real_type temp = base * base;
-                return temp * temp * base;
-            }
-        case 6:
-            {
-                const real_type temp = base * base * base;
-                return temp * temp;
-            }
-        default:
-            {
-                // generic integer power function
-                real_type result{ 1.0 };
-                for (int i = 0; i < exponent; ++i) {
-                    result *= base;
-                }
-                return result;
-            }
+    // generic integer power function
+    real_type result{ 1.0 };
+    for (int i = 0; i < exponent; ++i) {
+        result *= base;
     }
+    return result;
 }
 
 //***************************************************//
diff --git a/include/plssvm/backends/stdpar/kernel/predict_kernel.hpp b/include/plssvm/backends/stdpar/kernel/predict_kernel.hpp
index ce46e6a1c..1305fadf3 100644
--- a/include/plssvm/backends/stdpar/kernel/predict_kernel.hpp
+++ b/include/plssvm/backends/stdpar/kernel/predict_kernel.hpp
@@ -15,15 +15,16 @@
 
 #include "plssvm/backends/stdpar/detail/utility.hpp"           // plssvm::stdpar::detail::atomic_ref
 #include "plssvm/backends/stdpar/kernel/kernel_functions.hpp"  // plssvm::stdpar::detail::{feature_reduce, apply_kernel_function}
-#include "plssvm/constants.hpp"                                // plssvm::{real_type, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/constants.hpp"                                // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/detail/assert.hpp"                            // PLSSVM_ASSERT
 #include "plssvm/kernel_function_types.hpp"                    // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                                   // plssvm::aos_matrix, plssvm::soa_matrix
 #include "plssvm/shape.hpp"                                    // plssvm::shape
+#include "plssvm/target_platforms.hpp"                         // plssvm::target_platform
 
 #include <algorithm>  // std::for_each
 #include <array>      // std::array
-#include <cmath>      // std::fma
+#include <cmath>      // std::ceil
 #include <cstddef>    // std::size_t
 #include <execution>  // std::execution::par_unseq
 #include <numeric>    // std::iota
@@ -33,230 +34,306 @@ namespace plssvm::stdpar::detail {
 
 /**
  * @brief Calculate the `w` vector used to speedup the prediction using the linear kernel function.
- * @param[out] w the vector to speedup the linear prediction
- * @param[in] alpha the previously learned weights
- * @param[in] support_vectors the support vectors
- * @param[in] device_specific_num_sv the number of support vectors the current device is responsible for
- * @param[in] sv_offset the first row in @p support_vectors the current device is responsible for
+ * @tparam target the target platform
  */
-inline void device_kernel_w_linear(soa_matrix<real_type> &w, const aos_matrix<real_type> &alpha, const soa_matrix<real_type> &support_vectors, const std::size_t device_specific_num_sv, const std::size_t sv_offset) {
-    PLSSVM_ASSERT(alpha.num_cols() == support_vectors.num_rows(), "Size mismatch: {} vs {}!", alpha.num_cols(), support_vectors.num_rows());
-    PLSSVM_ASSERT(w.shape() == (plssvm::shape{ alpha.num_rows(), support_vectors.num_cols() }), "Shape mismatch: {} vs {}!", w.shape(), (plssvm::shape{ alpha.num_rows(), support_vectors.num_cols() }));
-    PLSSVM_ASSERT(support_vectors.num_rows() >= device_specific_num_sv, "The number of place specific sv ({}) cannot be greater the the total number of sv ({})!", device_specific_num_sv, support_vectors.num_rows());
-    PLSSVM_ASSERT(support_vectors.num_rows() >= sv_offset, "The sv offset ({}) cannot be greater the the total number of sv ({})!", sv_offset, support_vectors.num_rows());
-
-    // calculate constants
-    const std::size_t num_classes = alpha.num_rows();
-    const auto blocked_num_classes = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_classes) / INTERNAL_BLOCK_SIZE));
-    const std::size_t num_features = support_vectors.num_cols();
-    const auto blocked_num_features = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_features) / INTERNAL_BLOCK_SIZE));
-    const std::size_t num_support_vectors = support_vectors.num_rows();
-
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-    // define range over which should be iterated
-    std::vector<std::size_t> range(blocked_num_classes * blocked_num_features);
-    std::iota(range.begin(), range.end(), 0);
-
-    std::for_each(std::execution::par_unseq, range.begin(), range.end(), [=, w_ptr = w.data(), alpha_ptr = alpha.data(), sv_ptr = support_vectors.data()](const std::size_t idx) {
-        // calculate the indices used in the current thread
-        const std::size_t feature = idx / blocked_num_classes;
-        const std::size_t c = idx % blocked_num_classes;
-
-        const std::size_t feature_idx = feature * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t class_idx = c * INTERNAL_BLOCK_SIZE_uz;
-
-        // create a thread private array used for internal caching
-        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
-
-        // iterate over all features
-        for (std::size_t sv = 0; sv < device_specific_num_sv; ++sv) {
-            // perform the feature reduction calculation
-            for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
-                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    const std::size_t global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
-                    const std::size_t global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
-
-                    temp[internal_feature][internal_class] += alpha_ptr[global_class_idx * (num_support_vectors + PADDING_SIZE_uz) + sv_offset + sv] * sv_ptr[global_feature_idx * (num_support_vectors + PADDING_SIZE_uz) + sv_offset + sv];
+template <target_platform target>
+struct device_kernel_w_linear {
+    /**
+     * @brief Calculate the `w` vector used to speedup the prediction using the linear kernel function.
+     * @param[out] w the vector to speedup the linear prediction
+     * @param[in] alpha the previously learned weights
+     * @param[in] support_vectors the support vectors
+     * @param[in] device_num_sv the number of support vectors the current device is responsible for
+     * @param[in] device_sv_offset the first row in @p support_vectors the current device is responsible for
+     */
+    void operator()(soa_matrix<real_type> &w, const aos_matrix<real_type> &alpha, const soa_matrix<real_type> &support_vectors, const std::size_t device_num_sv, const std::size_t device_sv_offset) {
+        PLSSVM_ASSERT(alpha.num_cols() == support_vectors.num_rows(), "Size mismatch: {} vs {}!", alpha.num_cols(), support_vectors.num_rows());
+        PLSSVM_ASSERT(w.shape() == (plssvm::shape{ alpha.num_rows(), support_vectors.num_cols() }), "Shape mismatch: {} vs {}!", w.shape(), (plssvm::shape{ alpha.num_rows(), support_vectors.num_cols() }));
+        PLSSVM_ASSERT(support_vectors.num_rows() >= device_num_sv, "The number of place specific sv ({}) cannot be greater the the total number of sv ({})!", device_num_sv, support_vectors.num_rows());
+        PLSSVM_ASSERT(support_vectors.num_rows() >= device_sv_offset, "The sv offset ({}) cannot be greater the the total number of sv ({})!", device_sv_offset, support_vectors.num_rows());
+
+        // calculate constants
+        const std::size_t num_classes = alpha.num_rows();
+        const std::size_t num_features = support_vectors.num_cols();
+        const std::size_t num_sv = support_vectors.num_rows();
+        const auto blocked_num_classes = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_classes) / INTERNAL_BLOCK_SIZE));
+        const auto blocked_num_features = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_features) / INTERNAL_BLOCK_SIZE));
+
+        // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        // define the range over which should be iterated
+        std::vector<std::size_t> range(blocked_num_classes * blocked_num_features);
+        std::iota(range.begin(), range.end(), 0);
+
+        std::for_each(std::execution::par_unseq, range.begin(), range.end(), [=, w_ptr = w.data(), alpha_ptr = alpha.data(), support_vectors_ptr = support_vectors.data()](const std::size_t idx) {
+            // calculate the indices used in the current thread
+            const std::size_t feature_idx = (idx / blocked_num_classes) * INTERNAL_BLOCK_SIZE_uz;  // num_features
+            const std::size_t class_idx = (idx % blocked_num_classes) * INTERNAL_BLOCK_SIZE_uz;    // num_classes
+
+            // create a thread private array used for internal caching
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+            // iterate over all support vectors using blocking
+            for (std::size_t sv_block = 0; sv_block < device_num_sv; sv_block += THREAD_BLOCK_SIZE_uz) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the sv is the fastest moving index
+                    for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                            // calculate the indices to access the global data
+                            const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                            const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                            real_type sum{ 0.0 };
+                            for (std::size_t sv = 0; sv < THREAD_BLOCK_SIZE_uz; ++sv) {
+                                sum += support_vectors_ptr[global_feature_idx * (num_sv + PADDING_SIZE_uz) + device_sv_offset + sv_block + sv] *  // SoA
+                                       alpha_ptr[global_class_idx * (num_sv + PADDING_SIZE_uz) + device_sv_offset + sv_block + sv];               // AoS
+                            }
+                            temp[internal_feature][internal_class] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the sv is the slowest moving index
+                    for (std::size_t sv = 0; sv < THREAD_BLOCK_SIZE_uz; ++sv) {
+                        for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                // calculate the indices to access the global data
+                                const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                                const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                                temp[internal_feature][internal_class] += support_vectors_ptr[global_feature_idx * (num_sv + PADDING_SIZE_uz) + device_sv_offset + sv_block + sv] *  // SoA
+                                                                          alpha_ptr[global_class_idx * (num_sv + PADDING_SIZE_uz) + device_sv_offset + sv_block + sv];               // AoS
+                            }
+                        }
+                    }
                 }
             }
-        }
 
-        // update global array with local one
-        for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
-            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                const std::size_t global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
-                const std::size_t global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+            // store the result back to the w vector
+            for (unsigned internal_feature = 0; internal_feature < INTERNAL_BLOCK_SIZE; ++internal_feature) {
+                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                    // calculate the indices to access the global data
+                    const auto global_feature_idx = feature_idx + static_cast<std::size_t>(internal_feature);
+                    const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                w_ptr[global_feature_idx * (num_classes + PADDING_SIZE_uz) + global_class_idx] = temp[internal_feature][internal_class];
+                    w_ptr[global_feature_idx * (num_classes + PADDING_SIZE_uz) + global_class_idx] = temp[internal_feature][internal_class];  // SoA
+                }
             }
-        }
-    });
-}
+        });
+    }
+};
 
 /**
- * @brief Predict the @p predict_points_d using the linear kernel speeding up the calculation using the @p w_d vector.
- * @param[out] prediction the predicted values
- * @param[in] w the vector to speedup the calculations
- * @param[in] rho the previously learned bias
- * @param[in] predict_points the data points to predict
- * @param[in] device_specific_num_predict_points the number of predict points the current device is responsible for
- * @param[in] row_offset the first row in @p predict_points the current device is responsible for
+ * @brief Predict the @p predict_points using the linear kernel speeding up the calculation using the @p w vector.
+ * @tparam target the target platform
  */
-inline void device_kernel_predict_linear(aos_matrix<real_type> &prediction, const soa_matrix<real_type> &w, const std::vector<real_type> &rho, const soa_matrix<real_type> &predict_points, const std::size_t device_specific_num_predict_points, const std::size_t row_offset) {
-    PLSSVM_ASSERT(w.num_rows() == rho.size(), "Size mismatch: {} vs {}!", w.num_rows(), rho.size());
-    PLSSVM_ASSERT(w.num_cols() == predict_points.num_cols(), "Size mismatch: {} vs {}!", w.num_cols(), predict_points.num_cols());
-    PLSSVM_ASSERT(prediction.shape() == (plssvm::shape{ predict_points.num_rows(), w.num_rows() }), "Shape mismatch: {} vs {}!", prediction.shape(), (plssvm::shape{ predict_points.num_rows(), w.num_rows() }));
-    PLSSVM_ASSERT(predict_points.num_rows() >= device_specific_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_specific_num_predict_points, predict_points.num_rows());
-    PLSSVM_ASSERT(predict_points.num_rows() >= row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", row_offset, predict_points.num_rows());
-
-    // calculate constants
-    const std::size_t num_predict_points = predict_points.num_rows();
-    const auto blocked_device_specific_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_predict_points) / INTERNAL_BLOCK_SIZE));
-    const std::size_t num_classes = prediction.num_cols();
-    const auto blocked_num_classes = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_classes) / INTERNAL_BLOCK_SIZE));
-    const std::size_t num_features = predict_points.num_cols();
-
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-    // define range over which should be iterated
-    std::vector<std::size_t> range(blocked_device_specific_num_predict_points * blocked_num_classes);
-    std::iota(range.begin(), range.end(), 0);
-
-    std::for_each(std::execution::par_unseq, range.begin(), range.end(), [=, prediction_ptr = prediction.data(), w_ptr = w.data(), rho_ptr = rho.data(), pp_ptr = predict_points.data()](const std::size_t idx) {
-        // calculate the indices used in the current thread
-        const std::size_t pp = idx / blocked_num_classes;
-        const std::size_t c = idx % blocked_num_classes;
-
-        const std::size_t pp_idx = pp * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t class_idx = c * INTERNAL_BLOCK_SIZE_uz;
-
-        // create a thread private array used for internal caching
-        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
-
-        // iterate over all features
-        for (std::size_t dim = 0; dim < num_features; ++dim) {
-            // perform the feature reduction calculation
-            for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
-                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                    const std::size_t global_pp_idx = row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
-                    const std::size_t global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
-
-                    temp[internal_pp][internal_class] += w_ptr[dim * (num_classes + PADDING_SIZE_uz) + global_class_idx] * pp_ptr[dim * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx];
+template <target_platform target>
+struct device_kernel_predict_linear {
+    /**
+     * @brief Predict the @p predict_points using the linear kernel speeding up the calculation using the @p w vector.
+     * @param[out] prediction the predicted values
+     * @param[in] w the vector to speedup the calculations
+     * @param[in] rho the previously learned bias
+     * @param[in] predict_points the data points to predict
+     * @param[in] device_num_predict_points the number of predict points the current device is responsible for
+     * @param[in] device_row_offset the first row in @p predict_points the current device is responsible for
+     */
+    void operator()(aos_matrix<real_type> &prediction, const soa_matrix<real_type> &w, const std::vector<real_type> &rho, const soa_matrix<real_type> &predict_points, const std::size_t device_num_predict_points, const std::size_t device_row_offset) {
+        PLSSVM_ASSERT(w.num_rows() == rho.size() - PADDING_SIZE, "Size mismatch: {} vs {}!", w.num_rows(), rho.size() - PADDING_SIZE);
+        PLSSVM_ASSERT(w.num_cols() == predict_points.num_cols(), "Size mismatch: {} vs {}!", w.num_cols(), predict_points.num_cols());
+        PLSSVM_ASSERT(prediction.shape() == (plssvm::shape{ predict_points.num_rows(), w.num_rows() }), "Shape mismatch: {} vs {}!", prediction.shape(), (plssvm::shape{ predict_points.num_rows(), w.num_rows() }));
+        PLSSVM_ASSERT(predict_points.num_rows() >= device_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_num_predict_points, predict_points.num_rows());
+        PLSSVM_ASSERT(predict_points.num_rows() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", device_row_offset, predict_points.num_rows());
+
+        // calculate constants
+        const std::size_t num_predict_points = predict_points.num_rows();
+        const std::size_t num_classes = prediction.num_cols();
+        const std::size_t num_features = predict_points.num_cols();
+        const auto blocked_device_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_predict_points) / INTERNAL_BLOCK_SIZE));
+        const auto blocked_num_classes = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_classes) / INTERNAL_BLOCK_SIZE));
+
+        // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        // define the range over which should be iterated
+        std::vector<std::size_t> range(blocked_device_num_predict_points * blocked_num_classes);
+        std::iota(range.begin(), range.end(), 0);
+
+        std::for_each(std::execution::par_unseq, range.begin(), range.end(), [=, prediction_ptr = prediction.data(), w_ptr = w.data(), rho_ptr = rho.data(), predict_points_ptr = predict_points.data()](const std::size_t idx) {
+            // calculate the indices used in the current thread
+            const std::size_t pp_idx = (idx / blocked_num_classes) * INTERNAL_BLOCK_SIZE_uz;     // num_predict_points
+            const std::size_t class_idx = (idx % blocked_num_classes) * INTERNAL_BLOCK_SIZE_uz;  // num_classes
+
+            // create a thread private array used for internal caching
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+            // iterate over all features using blocking
+            for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the dot product calculation, the feature is the fastest moving index
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                        for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                            // calculate the indices to access the global data
+                            const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                            const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                            real_type sum{ 0.0 };
+                            for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                                sum += w_ptr[(feature_block + feature) * (num_classes + PADDING_SIZE_uz) + global_class_idx] *                  // SoA
+                                       predict_points_ptr[(feature_block + feature) * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx];  // SoA
+                            }
+                            temp[internal_pp][internal_class] += sum;
+                        }
+                    }
+                } else {
+                    // perform the dot product calculation, the feature is the slowest moving index
+                    for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                                // calculate the indices to access the global data
+                                const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                                const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+
+                                temp[internal_pp][internal_class] += w_ptr[(feature_block + feature) * (num_classes + PADDING_SIZE_uz) + global_class_idx] *                  // SoA
+                                                                     predict_points_ptr[(feature_block + feature) * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx];  // SoA
+                            }
+                        }
+                    }
                 }
             }
-        }
 
-        // perform the dot product calculation
-        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
-            for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
-                const std::size_t device_global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
-                const std::size_t global_pp_idx = row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
-                const std::size_t global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
+            // update the global array with the local one
+            for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                for (unsigned internal_class = 0; internal_class < INTERNAL_BLOCK_SIZE; ++internal_class) {
+                    // calculate the indices to access the global data
+                    const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                    const auto global_class_idx = class_idx + static_cast<std::size_t>(internal_class);
 
-                if (device_global_pp_idx < device_specific_num_predict_points && global_class_idx < num_classes) {
-                    prediction_ptr[global_pp_idx * (num_classes + PADDING_SIZE_uz) + global_class_idx] = temp[internal_pp][internal_class] - rho_ptr[global_class_idx];
+                    prediction_ptr[global_pp_idx * (num_classes + PADDING_SIZE_uz) + global_class_idx] = temp[internal_pp][internal_class] - rho_ptr[global_class_idx];  // AoS
                 }
             }
-        }
-    });
-}
+        });
+    }
+};
 
 /**
- * @brief Predict the @p predict_points_d using the @p kernel_function.
- * @tparam kernel the type of the used kernel function
+ * @brief Predict the @p predict_points using the @p kernel_function.
+ * @tparam target the target platform
+ * @tparam kernel_function the type of the used kernel function
  * @tparam Args the types of the parameters necessary for the specific kernel function
- * @param[out] prediction the predicted values
- * @param[in] alpha the previously learned weights
- * @param[in] rho the previously learned bias
- * @param[in] support_vectors the support vectors
- * @param[in] predict_points the data points to predict
- * @param[in] device_specific_num_predict_points the number of predict points the current device is responsible for
- * @param[in] row_offset the first row in @p predict_points the current device is responsible for
- * @param[in] kernel_function_parameter the parameters necessary to apply the @p kernel_function
  */
-template <kernel_function_type kernel, typename... Args>
-inline void device_kernel_predict(aos_matrix<real_type> &prediction, const aos_matrix<real_type> &alpha, const std::vector<real_type> &rho, const soa_matrix<real_type> &support_vectors, const soa_matrix<real_type> &predict_points, const std::size_t device_specific_num_predict_points, const std::size_t row_offset, Args... kernel_function_parameter) {
-    PLSSVM_ASSERT(alpha.num_rows() == rho.size(), "Size mismatch: {} vs {}!", alpha.num_rows(), rho.size());
-    PLSSVM_ASSERT(alpha.num_cols() == support_vectors.num_rows(), "Size mismatch: {} vs {}!", alpha.num_cols(), support_vectors.num_rows());
-    PLSSVM_ASSERT(support_vectors.num_cols() == predict_points.num_cols(), "Size mismatch: {} vs {}!", support_vectors.num_cols(), predict_points.num_cols());
-    PLSSVM_ASSERT(prediction.shape() == (plssvm::shape{ predict_points.num_rows(), alpha.num_rows() }), "Shape mismatch: {} vs {}!", prediction.shape(), (plssvm::shape{ predict_points.num_rows(), alpha.num_rows() }));
-    PLSSVM_ASSERT(predict_points.num_rows() >= device_specific_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_specific_num_predict_points, predict_points.num_rows());
-    PLSSVM_ASSERT(predict_points.num_rows() >= row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", row_offset, predict_points.num_rows());
-
-    // calculate constants
-    const std::size_t num_classes = alpha.num_rows();
-    const std::size_t num_support_vectors = support_vectors.num_rows();
-    const auto blocked_num_support_vectors = static_cast<std::size_t>(std::ceil(static_cast<real_type>(num_support_vectors) / INTERNAL_BLOCK_SIZE));
-    const std::size_t num_predict_points = predict_points.num_rows();
-    const auto blocked_device_specific_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_specific_num_predict_points) / INTERNAL_BLOCK_SIZE));
-    const std::size_t num_features = predict_points.num_cols();
-
-    // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
-    const auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
-    const auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
-
-    // define range over which should be iterated
-    std::vector<std::size_t> range(blocked_device_specific_num_predict_points * blocked_num_support_vectors);
-    std::iota(range.begin(), range.end(), 0);
-
-    std::for_each(std::execution::par_unseq, range.begin(), range.end(), [=, prediction_ptr = prediction.data(), alpha_ptr = alpha.data(), rho_ptr = rho.data(), sv_ptr = support_vectors.data(), pp_ptr = predict_points.data()](const std::size_t idx) {
-        // calculate the indices used in the current thread
-        const std::size_t pp = idx / blocked_num_support_vectors;
-        const std::size_t sv = idx % blocked_num_support_vectors;
-
-        const std::size_t pp_idx = pp * INTERNAL_BLOCK_SIZE_uz;
-        const std::size_t sv_idx = sv * INTERNAL_BLOCK_SIZE_uz;
-
-        // create a thread private array used for internal caching
-        std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
-
-        // iterate over all features
-        for (std::size_t dim = 0; dim < num_features; ++dim) {
-            // perform the feature reduction calculation
-            for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
-                for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                    const std::size_t global_pp_idx = row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
-                    const std::size_t global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
-
-                    temp[internal_pp][internal_sv] += detail::feature_reduce<kernel>(sv_ptr[dim * (num_support_vectors + PADDING_SIZE_uz) + global_sv_idx],
-                                                                                     pp_ptr[dim * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx]);
+template <target_platform target, kernel_function_type kernel_function, typename... Args>
+struct device_kernel_predict {
+    /**
+     * @brief Predict the @p predict_points using the kernel function.
+     * @param[out] prediction the predicted values
+     * @param[in] alpha the previously learned weights
+     * @param[in] rho the previously learned bias
+     * @param[in] support_vectors the support vectors
+     * @param[in] predict_points the data points to predict
+     * @param[in] device_num_predict_points the number of predict points the current device is responsible for
+     * @param[in] device_row_offset the first row in @p predict_points the current device is responsible for
+     * @param[in] kernel_function_parameter the parameters necessary to apply the kernel function
+     */
+    void operator()(aos_matrix<real_type> &prediction, const aos_matrix<real_type> &alpha, const std::vector<real_type> &rho, const soa_matrix<real_type> &support_vectors, const soa_matrix<real_type> &predict_points, const std::size_t device_num_predict_points, const std::size_t device_row_offset, Args... kernel_function_parameter) {
+        PLSSVM_ASSERT(alpha.num_rows() == rho.size(), "Size mismatch: {} vs {}!", alpha.num_rows(), rho.size());
+        PLSSVM_ASSERT(alpha.num_cols() == support_vectors.num_rows(), "Size mismatch: {} vs {}!", alpha.num_cols(), support_vectors.num_rows());
+        PLSSVM_ASSERT(support_vectors.num_cols() == predict_points.num_cols(), "Size mismatch: {} vs {}!", support_vectors.num_cols(), predict_points.num_cols());
+        PLSSVM_ASSERT(prediction.shape() == (plssvm::shape{ predict_points.num_rows(), alpha.num_rows() }), "Shape mismatch: {} vs {}!", prediction.shape(), (plssvm::shape{ predict_points.num_rows(), alpha.num_rows() }));
+        PLSSVM_ASSERT(predict_points.num_rows() >= device_num_predict_points, "The number of place specific predict points ({}) cannot be greater the the total number of predict points ({})!", device_num_predict_points, predict_points.num_rows());
+        PLSSVM_ASSERT(predict_points.num_rows() >= device_row_offset, "The row offset ({}) cannot be greater the the total number of predict points ({})!", device_row_offset, predict_points.num_rows());
+
+        // calculate constants
+        const std::size_t num_classes = alpha.num_rows();
+        const std::size_t device_num_sv = support_vectors.num_rows();
+        const std::size_t num_features = predict_points.num_cols();
+        const std::size_t num_predict_points = predict_points.num_rows();
+        const auto blocked_device_num_sv = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_sv) / INTERNAL_BLOCK_SIZE));
+        const auto blocked_device_num_predict_points = static_cast<std::size_t>(std::ceil(static_cast<real_type>(device_num_predict_points) / INTERNAL_BLOCK_SIZE));
+
+        // cast all values to 64-bit unsigned long long to prevent potential 32-bit overflows
+        constexpr auto INTERNAL_BLOCK_SIZE_uz = static_cast<std::size_t>(INTERNAL_BLOCK_SIZE);
+        constexpr auto THREAD_BLOCK_SIZE_uz = static_cast<std::size_t>(THREAD_BLOCK_SIZE);
+        constexpr auto PADDING_SIZE_uz = static_cast<std::size_t>(PADDING_SIZE);
+
+        // define the range over which should be iterated
+        std::vector<std::size_t> range(blocked_device_num_predict_points * blocked_device_num_sv);
+        std::iota(range.begin(), range.end(), 0);
+
+        std::for_each(std::execution::par_unseq, range.begin(), range.end(), [=, prediction_ptr = prediction.data(), alpha_ptr = alpha.data(), rho_ptr = rho.data(), support_vectors_ptr = support_vectors.data(), predict_points_ptr = predict_points.data()](const std::size_t idx) {
+            // calculate the indices used in the current thread
+            const std::size_t pp_idx = (idx % blocked_device_num_sv) * INTERNAL_BLOCK_SIZE_uz;  // num_predict_points
+            const std::size_t sv_idx = (idx / blocked_device_num_sv) * INTERNAL_BLOCK_SIZE_uz;  // num_support_vectors
+
+            // create a thread private array used for internal caching
+            std::array<std::array<real_type, INTERNAL_BLOCK_SIZE>, INTERNAL_BLOCK_SIZE> temp{};
+
+            // iterate over all features
+            for (std::size_t feature_block = 0; feature_block < num_features; feature_block += THREAD_BLOCK_SIZE_uz) {
+                if constexpr (target == target_platform::cpu) {
+                    // perform the feature reduction calculation, the feature is the fastest moving index
+                    for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                        for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                            // calculate the indices to access the global data
+                            const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                            const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
+
+                            real_type sum{ 0.0 };
+                            for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                                sum += detail::feature_reduce<kernel_function>(support_vectors_ptr[(feature_block + feature) * (device_num_sv + PADDING_SIZE_uz) + global_sv_idx],       // SoA
+                                                                               predict_points_ptr[(feature_block + feature) * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx]);  // SoA
+                            }
+                            temp[internal_pp][internal_sv] += sum;
+                        }
+                    }
+                } else {
+                    // perform the feature reduction calculation, the feature is the slowest moving index
+                    for (std::size_t feature = 0; feature < THREAD_BLOCK_SIZE_uz; ++feature) {
+                        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                            for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                                // calculate the indices to access the global data
+                                const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                                const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
+
+                                temp[internal_pp][internal_sv] += detail::feature_reduce<kernel_function>(support_vectors_ptr[(feature_block + feature) * (device_num_sv + PADDING_SIZE_uz) + global_sv_idx],       // SoA
+                                                                                                          predict_points_ptr[(feature_block + feature) * (num_predict_points + PADDING_SIZE_uz) + global_pp_idx]);  // SoA
+                            }
+                        }
+                    }
                 }
             }
-        }
 
-        // update temp using the respective kernel function
-        for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
-            for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                temp[internal_pp][internal_sv] = detail::apply_kernel_function<kernel>(temp[internal_pp][internal_sv], kernel_function_parameter...);
+            // update temp using the respective kernel function
+            for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
+                for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
+                    temp[internal_pp][internal_sv] = detail::apply_kernel_function<kernel_function>(temp[internal_pp][internal_sv], kernel_function_parameter...);
+                }
             }
-        }
 
-        // add results to prediction
-        for (std::size_t a = 0; a < num_classes; ++a) {
+            // atomically add the results to the prediction
             for (unsigned internal_pp = 0; internal_pp < INTERNAL_BLOCK_SIZE; ++internal_pp) {
                 for (unsigned internal_sv = 0; internal_sv < INTERNAL_BLOCK_SIZE; ++internal_sv) {
-                    const std::size_t device_global_pp_idx = pp_idx + static_cast<std::size_t>(internal_pp);
-                    const std::size_t global_pp_idx = row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
-                    const std::size_t global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
+                    // calculate the indices to access the global data and the data with respect to the current device
+                    const auto global_pp_idx = device_row_offset + pp_idx + static_cast<std::size_t>(internal_pp);
+                    const auto global_sv_idx = sv_idx + static_cast<std::size_t>(internal_sv);
 
-                    // be sure to not perform out of bounds accesses
-                    if (device_global_pp_idx < device_specific_num_predict_points && global_sv_idx < num_support_vectors) {
+                    for (std::size_t class_idx = 0; class_idx < num_classes; ++class_idx) {
                         if (global_sv_idx == 0) {
-                            atomic_ref<real_type>{ prediction_ptr[global_pp_idx * (num_classes + PADDING_SIZE_uz) + a] } += -rho_ptr[a];
+                            atomic_ref<real_type>{ prediction_ptr[global_pp_idx * (num_classes + PADDING_SIZE_uz) + class_idx] } += -rho_ptr[class_idx];
                         }
-                        atomic_ref<real_type>{ prediction_ptr[global_pp_idx * (num_classes + PADDING_SIZE_uz) + a] } +=
-                            temp[internal_pp][internal_sv] * alpha_ptr[a * (num_support_vectors + PADDING_SIZE_uz) + global_sv_idx];
+                        atomic_ref<real_type>{ prediction_ptr[global_pp_idx * (num_classes + PADDING_SIZE_uz) + class_idx] } +=
+                            alpha_ptr[class_idx * (device_num_sv + PADDING_SIZE_uz) + global_sv_idx] *  // AoS
+                            temp[internal_pp][internal_sv];
                     }
                 }
             }
-        }
-    });
-}
+        });
+    }
+};
 
 }  // namespace plssvm::stdpar::detail
 
diff --git a/include/plssvm/classification_report.hpp b/include/plssvm/classification_report.hpp
index eed8fc84b..bc6612379 100644
--- a/include/plssvm/classification_report.hpp
+++ b/include/plssvm/classification_report.hpp
@@ -152,7 +152,7 @@ class classification_report {
 
   private:
     /// The confusion matrix.
-    aos_matrix<unsigned long long> confusion_matrix_{};
+    aos_matrix<unsigned long long> confusion_matrix_;
     /// The metrics for each label: precision, recall, f1 score, and support.
     std::vector<std::pair<std::string, metric>> metrics_;
     /// The global accuracy.
@@ -180,7 +180,7 @@ namespace detail {
 
 template <typename label_type, typename... Args>
 classification_report::classification_report(const std::vector<label_type> &correct_label, const std::vector<label_type> &predicted_label, Args &&...named_args) {
-    // sanity check for input correct sizes
+    // perform sanity checks on the sizes of the input vectors
     if (correct_label.empty()) {
         throw classification_report_exception{ "The correct labels list must not be empty!" };
     }
@@ -191,7 +191,7 @@ classification_report::classification_report(const std::vector<label_type> &corr
         throw classification_report_exception{ fmt::format("The number of correct labels ({}) and predicted labels ({}) must be the same!", correct_label.size(), predicted_label.size()) };
     }
 
-    igor::parser parser{ std::forward<Args>(named_args)... };
+    const igor::parser parser{ std::forward<Args>(named_args)... };
 
     // compile time check: only named parameter are permitted
     static_assert(!parser.has_unnamed_arguments(), "Can only use named parameter!");
diff --git a/include/plssvm/constants.hpp b/include/plssvm/constants.hpp
index e99dbeddd..29833af0f 100644
--- a/include/plssvm/constants.hpp
+++ b/include/plssvm/constants.hpp
@@ -38,16 +38,20 @@ constexpr unsigned INTERNAL_BLOCK_SIZE = PLSSVM_INTERNAL_BLOCK_SIZE;
 constexpr unsigned INTERNAL_BLOCK_SIZE = 4;
 #endif
 
-/// Global compile time constant used for internal feature caching.
-constexpr unsigned FEATURE_BLOCK_SIZE = 2 * THREAD_BLOCK_SIZE;
+/// Padding used for the device arrays and matrices to prevent out-of-bounce accesses without ifs.
+constexpr unsigned PADDING_SIZE = THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE;
 
-/// Padding used for the device w_d matrix to prevent out-of-bounce accesses without ifs.
-constexpr unsigned PADDING_SIZE = FEATURE_BLOCK_SIZE > (THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE) ? FEATURE_BLOCK_SIZE : (THREAD_BLOCK_SIZE *INTERNAL_BLOCK_SIZE);
+/// The default epsilon for the conjugate gradients algorithm.
+constexpr real_type DEFAULT_EPSILON{ 1e-10 };
+
+/// The number of iterations to do until the residual in the conjugate gradients algorithm is explicitly recalculated to reduce the accumulated floating point errors.
+constexpr unsigned long long NUM_ITER_BEFORE_EXPLICIT_CG_RESIDUAL_RECALCULATION{ 50 };
 
 // perform sanity checks
 static_assert(detail::tuple_contains_v<real_type, 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.");
 static_assert(THREAD_BLOCK_SIZE > 0, "THREAD_BLOCK_SIZE must be greater than 0!");
 static_assert(INTERNAL_BLOCK_SIZE > 0, "INTERNAL_BLOCK_SIZE must be greater than 0!");
+static_assert(NUM_ITER_BEFORE_EXPLICIT_CG_RESIDUAL_RECALCULATION > 0, "NUM_ITER_BEFORE_EXPLICIT_CG_RESIDUAL_RECALCULATION must be greater than 0!");
 
 }  // namespace plssvm
 
diff --git a/include/plssvm/core.hpp b/include/plssvm/core.hpp
index 6ec7773c4..8fbcb76b2 100644
--- a/include/plssvm/core.hpp
+++ b/include/plssvm/core.hpp
@@ -13,35 +13,35 @@
 #define PLSSVM_CORE_HPP_
 #pragma once
 
-#include "plssvm/backend_types.hpp"                          // all supported backend types
-#include "plssvm/backends/SYCL/implementation_types.hpp"     // the SYCL implementation type
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // the SYCL specific kernel invocation typ
-#include "plssvm/classification_report.hpp"                  // reports different metrics (precision, recall, f1 score, and support) for the different classes after scoring
-#include "plssvm/classification_types.hpp"                   // all supported multi-class classification strategies
-#include "plssvm/constants.hpp"                              // verbosity flag und compile-time constants
-#include "plssvm/csvm_factory.hpp"                           // a factory function to instantiate a C-SVM using a runtime backend; includes the available backend C-SVMs
-#include "plssvm/data_set/classification_data_set.hpp"       // a classification data set used for training a C-SVC
-#include "plssvm/data_set/min_max_scaler.hpp"                // a min-max scaler for the data sets
-#include "plssvm/data_set/regression_data_set.hpp"           // a regression data set used for training a C-SVR
-#include "plssvm/environment.hpp"                            // environment management functions and classes
-#include "plssvm/exceptions/exceptions.hpp"                  // exception hierarchy
-#include "plssvm/file_format_types.hpp"                      // all supported file format types
-#include "plssvm/gamma.hpp"                                  // the types of the gamma parameter
-#include "plssvm/kernel_function_types.hpp"                  // all supported kernel function types
-#include "plssvm/kernel_functions.hpp"                       // implementation of all supported kernel functions
-#include "plssvm/matrix.hpp"                                 // a custom matrix class
-#include "plssvm/model/classification_model.hpp"             // the model as a result of training a C-SVC
-#include "plssvm/model/regression_model.hpp"                 // the model as a result of training a C-SVR
-#include "plssvm/mpi/communicator.hpp"                       // PLSSVM MPI communicator wrapper
-#include "plssvm/parameter.hpp"                              // the C-SVM parameter
-#include "plssvm/regression_report.hpp"                      // reports different metrics (e.g., mean squared error or R^2 score) for the regression task after scoring
-#include "plssvm/shape.hpp"                                  // shape for a matrix or device pointer
-#include "plssvm/solver_types.hpp"                           // all supported solver types (e.g., Conjugate Gradients with explicit, streaming, or implicit kernel matrix generation)
-#include "plssvm/svm/csvc.hpp"                               // the base C-SVC every backend is inheriting from
-#include "plssvm/svm/csvr.hpp"                               // the base C-SVR every backend is inheriting from
-#include "plssvm/target_platforms.hpp"                       // all supported target platforms
-#include "plssvm/verbosity_levels.hpp"                       // all supported verbosity levels
-#include "plssvm/version/version.hpp"                        // version information
+#include "plssvm/backend_types.hpp"                        // all supported backend types
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // the SYCL specific data parallel kernels
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // the SYCL implementation type
+#include "plssvm/classification_report.hpp"                // reports different metrics (precision, recall, f1 score, and support) for the different classes after scoring
+#include "plssvm/classification_types.hpp"                 // all supported multi-class classification strategies
+#include "plssvm/constants.hpp"                            // verbosity flag und compile-time constants
+#include "plssvm/csvm_factory.hpp"                         // a factory function to instantiate a C-SVM using a runtime backend; includes the available backend C-SVMs
+#include "plssvm/data_set/classification_data_set.hpp"     // a classification data set used for training a C-SVC
+#include "plssvm/data_set/min_max_scaler.hpp"              // a min-max scaler for the data sets
+#include "plssvm/data_set/regression_data_set.hpp"         // a regression data set used for training a C-SVR
+#include "plssvm/environment.hpp"                          // environment management functions and classes
+#include "plssvm/exceptions/exceptions.hpp"                // exception hierarchy
+#include "plssvm/file_format_types.hpp"                    // all supported file format types
+#include "plssvm/gamma.hpp"                                // the types of the gamma parameter
+#include "plssvm/kernel_function_types.hpp"                // all supported kernel function types
+#include "plssvm/kernel_functions.hpp"                     // implementation of all supported kernel functions
+#include "plssvm/matrix.hpp"                               // a custom matrix class
+#include "plssvm/model/classification_model.hpp"           // the model as a result of training a C-SVC
+#include "plssvm/model/regression_model.hpp"               // the model as a result of training a C-SVR
+#include "plssvm/mpi/communicator.hpp"                     // PLSSVM MPI communicator wrapper
+#include "plssvm/parameter.hpp"                            // the C-SVM parameter
+#include "plssvm/regression_report.hpp"                    // reports different metrics (e.g., mean squared error or R^2 score) for the regression task after scoring
+#include "plssvm/shape.hpp"                                // shape for a matrix or device pointer
+#include "plssvm/solver_types.hpp"                         // all supported solver types (e.g., Conjugate Gradients with explicit, streaming, or implicit kernel matrix generation)
+#include "plssvm/svm/csvc.hpp"                             // the base C-SVC every backend is inheriting from
+#include "plssvm/svm/csvr.hpp"                             // the base C-SVR every backend is inheriting from
+#include "plssvm/target_platforms.hpp"                     // all supported target platforms
+#include "plssvm/verbosity_levels.hpp"                     // all supported verbosity levels
+#include "plssvm/version/version.hpp"                      // version information
 
 /// The main namespace containing all public API functions.
 namespace plssvm { }
@@ -73,9 +73,12 @@ namespace plssvm::mpi { }
 /// Namespace containing implementation details for our MPI wrapper functionality. **Should not** directly be used by users.
 namespace plssvm::mpi::detail { }
 
-/// Namespace containing implementation details for the performance tracking and hardware sampling functionality. **Should not** directly be used by users.
+/// Namespace containing implementation details for the performance tracking functionality. **Should not** directly be used by users.
 namespace plssvm::detail::tracking { }
 
+/// Namespace containing implementation details for the performance tracking functionality. **Should not** directly be used by users.
+namespace plssvm::detail::tracking::impl { }
+
 /// Namespace containing implementation details for the custom literals representing memory sizes. **Should not** directly be used by users.
 namespace plssvm::detail::literals { }
 
@@ -119,17 +122,13 @@ namespace plssvm::opencl { }
 namespace plssvm::opencl::detail { }
 
 /// Namespace containing the C-SVM using the SYCL backend with DPC++ as SYCL implementation.
-namespace plssvm::dpcpp {
-using namespace plssvm::sycl;
-}
+namespace plssvm::dpcpp { }
 
 /// Namespace containing the C-SVM using the SYCL backend with DPC++ as SYCL implementation. **Should not** directly be used by users.
 namespace plssvm::dpcpp::detail { }
 
 /// Namespace containing the C-SVM using the SYCL backend with AdaptiveCpp as SYCL implementation.
-namespace plssvm::adaptivecpp {
-using namespace plssvm::sycl;
-}
+namespace plssvm::adaptivecpp { }
 
 /// Namespace containing the C-SVM using the SYCL backend with AdaptiveCpp as SYCL implementation. **Should not** directly be used by users.
 namespace plssvm::adaptivecpp::detail { }
@@ -140,10 +139,25 @@ namespace plssvm::sycl { }
 /// Namespace containing the C-SVM using the SYCL backend with the preferred SYCL implementation. **Should not** directly be used by users.
 namespace plssvm::sycl::detail { }
 
+/// Namespace containing the C-SVM using the SYCL backend with the preferred SYCL implementation. Specific to the basic data parallel kernel. **Should not** directly be used by users.
+namespace plssvm::sycl::detail::basic { }
+
+/// Namespace containing the C-SVM using the SYCL backend with the preferred SYCL implementation. Specific to the work-group data parallel kernel. **Should not** directly be used by users.
+namespace plssvm::sycl::detail::work_group { }
+
+/// Namespace containing the C-SVM using the SYCL backend with the preferred SYCL implementation. Specific to the hierarchical data parallel kernel. **Should not** directly be used by users.
+namespace plssvm::sycl::detail::hierarchical { }
+
+/// Namespace containing the C-SVM using the SYCL backend with the preferred SYCL implementation. Specific to the scoped parallelism kernel. **Should not** directly be used by users.
+namespace plssvm::sycl::detail::scoped { }
+
 /// Namespace containing the C-SVM using the Kokkos backend.
 namespace plssvm::kokkos { }
 
 /// Namespace containing Kokkos backend specific implementation details. **Should not** directly be used by users.
 namespace plssvm::kokkos::detail { }
 
+/// Namespace containing Kokkos backend specific implementation details. **Should not** directly be used by users.
+namespace plssvm::kokkos::detail::impl { }
+
 #endif  // PLSSVM_CORE_HPP_
diff --git a/include/plssvm/csvm_factory.hpp b/include/plssvm/csvm_factory.hpp
index a59f45c86..e5936b9da 100644
--- a/include/plssvm/csvm_factory.hpp
+++ b/include/plssvm/csvm_factory.hpp
@@ -43,7 +43,6 @@
     #include "plssvm/backends/OpenCL/csvm.hpp"  // plssvm::opencl::csvm, plssvm::csvm_backend_exists_v
 #endif
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
-using namespace plssvm::PLSSVM_SYCL_BACKEND_PREFERRED_IMPLEMENTATION;
     #if defined(PLSSVM_SYCL_BACKEND_HAS_DPCPP)
         #include "plssvm/backends/SYCL/DPCPP/csvm.hpp"  // plssvm::dpcpp::csvm, plssvm::csvm_backend_exists_v
     #endif
@@ -103,10 +102,10 @@ template <typename base_csvm_type, typename backend_csvm_type, typename... Args>
 template <typename base_csvm_type, typename... Args>
 [[nodiscard]] inline std::unique_ptr<base_csvm_type> make_csvm_sycl_impl([[maybe_unused]] Args &&...args) {
     // check igor parameter
-    igor::parser parser{ args... };
+    const igor::parser parser{ args... };
 
     // get the SYCL implementation type to use
-    sycl::implementation_type impl_type = sycl::implementation_type::automatic;
+    sycl::implementation_type impl_type = sycl::implementation_type::automatic;  // NOLINT: can be modified in compile-time if later on
     // check whether a specific SYCL implementation type has been requested
     if constexpr (parser.has(sycl_implementation_type)) {
         // compile time check: the value must have the correct type
@@ -174,8 +173,8 @@ template <typename base_csvm_type, typename... Args>
  * @return the C-SVM (`[[nodiscard]]`)
  */
 template <typename csvm_type, typename... Args>
-[[nodiscard]] inline std::unique_ptr<csvm_type> make_csvm(const backend_type backend, Args... args) {
-    return detail::make_csvm_impl<csvm_type>(backend, args...);
+[[nodiscard]] inline std::unique_ptr<csvm_type> make_csvm(const backend_type backend, Args &&...args) {
+    return detail::make_csvm_impl<csvm_type>(backend, std::forward<Args>(args)...);
 }
 
 /**
@@ -186,8 +185,8 @@ template <typename csvm_type, typename... Args>
  * @return the C-SVM (`[[nodiscard]]`)
  */
 template <typename csvm_type, typename... Args>
-[[nodiscard]] inline std::unique_ptr<csvm_type> make_csvm(Args... args) {
-    return detail::make_csvm_impl<csvm_type>(backend_type::automatic, args...);
+[[nodiscard]] inline std::unique_ptr<csvm_type> make_csvm(Args &&...args) {
+    return detail::make_csvm_impl<csvm_type>(backend_type::automatic, std::forward<Args>(args)...);
 }
 
 /**
@@ -199,8 +198,8 @@ template <typename csvm_type, typename... Args>
  * @return the C-SVC (`[[nodiscard]]`)
  */
 template <typename... Args>
-[[nodiscard]] inline std::unique_ptr<csvc> make_csvc(const backend_type backend, Args... args) {
-    return detail::make_csvm_impl<csvc>(backend, args...);
+[[nodiscard]] inline std::unique_ptr<csvc> make_csvc(const backend_type backend, Args &&...args) {
+    return detail::make_csvm_impl<csvc>(backend, std::forward<Args>(args)...);
 }
 
 /**
@@ -211,8 +210,8 @@ template <typename... Args>
  * @return the C-SVC (`[[nodiscard]]`)
  */
 template <typename... Args>
-[[nodiscard]] inline std::unique_ptr<csvc> make_csvc(Args... args) {
-    return detail::make_csvm_impl<csvc>(backend_type::automatic, args...);
+[[nodiscard]] inline std::unique_ptr<csvc> make_csvc(Args &&...args) {
+    return detail::make_csvm_impl<csvc>(backend_type::automatic, std::forward<Args>(args)...);
 }
 
 /**
@@ -224,8 +223,8 @@ template <typename... Args>
  * @return the C-SVR (`[[nodiscard]]`)
  */
 template <typename... Args>
-[[nodiscard]] inline std::unique_ptr<csvr> make_csvr(const backend_type backend, Args... args) {
-    return detail::make_csvm_impl<csvr>(backend, args...);
+[[nodiscard]] inline std::unique_ptr<csvr> make_csvr(const backend_type backend, Args &&...args) {
+    return detail::make_csvm_impl<csvr>(backend, std::forward<Args>(args)...);
 }
 
 /**
@@ -236,8 +235,8 @@ template <typename... Args>
  * @return the C-SVR (`[[nodiscard]]`)
  */
 template <typename... Args>
-[[nodiscard]] inline std::unique_ptr<csvr> make_csvr(Args... args) {
-    return detail::make_csvm_impl<csvr>(backend_type::automatic, args...);
+[[nodiscard]] inline std::unique_ptr<csvr> make_csvr(Args &&...args) {
+    return detail::make_csvm_impl<csvr>(backend_type::automatic, std::forward<Args>(args)...);
 }
 
 }  // namespace plssvm
diff --git a/include/plssvm/data_set/classification_data_set.hpp b/include/plssvm/data_set/classification_data_set.hpp
index 72d5c75b8..fc24891d5 100644
--- a/include/plssvm/data_set/classification_data_set.hpp
+++ b/include/plssvm/data_set/classification_data_set.hpp
@@ -557,9 +557,10 @@ class classification_data_set : public data_set<U> {
     void init();
 
     /**
-     * @copydoc plssvm::data_set::map_label
+     * @brief Create the mapping between the provided labels and the internally used values.
+     * @throws plssvm::data_set_exception any exception of the plssvm::data_set::label_mapper class
      */
-    void map_label() override;
+    void map_label();
 
     /// The mapping used to convert the original label to its mapped value and vice versa; may be `nullptr` if no labels have been provided.
     std::shared_ptr<const label_mapper> mapping_{ nullptr };
@@ -731,8 +732,8 @@ void classification_data_set<U>::map_label() {
     PLSSVM_ASSERT(labels_ptr_ != nullptr, "Can't create mapping if no labels are provided!");
 
     // create vector containing unique classes
-    std::set<label_type> unique_labels(labels_ptr_->cbegin(), labels_ptr_->cend());
-    std::vector<label_type> classes(unique_labels.cbegin(), unique_labels.cend());
+    const std::set<label_type> unique_labels(labels_ptr_->cbegin(), labels_ptr_->cend());
+    const std::vector<label_type> classes(unique_labels.cbegin(), unique_labels.cend());
 
     // create label mapping
     label_mapper mapper{ classes };
diff --git a/include/plssvm/data_set/data_set.hpp b/include/plssvm/data_set/data_set.hpp
index 917222401..7599fc6c1 100644
--- a/include/plssvm/data_set/data_set.hpp
+++ b/include/plssvm/data_set/data_set.hpp
@@ -290,7 +290,7 @@ class data_set {
     /**
      * @brief Virtual destructor to allow derived classes to clean up properly.
      */
-    virtual ~data_set() = default;
+    virtual ~data_set() = 0;
 
     /**
      * @brief Save the data points and potential labels of this data set to the file @p filename using the file @p format type.
@@ -369,12 +369,6 @@ class data_set {
     data_set() :
         data_ptr_{ std::make_shared<soa_matrix<real_type>>() } { }
 
-    /**
-     * @brief Create the mapping between the provided labels and the internally used values.
-     * @throws plssvm::data_set_exception any exception of the plssvm::data_set::label_mapper class
-     */
-    virtual void map_label() = 0;
-
     /**
      * @brief Read the data points and potential labels from the file @p filename assuming the plssvm::file_format_type @p format.
      * @param[in] filename the filename to read the data from
@@ -390,7 +384,7 @@ class data_set {
     size_type num_features_{ 0 };
 
     /// The used MPI communicator.
-    mpi::communicator comm_{};
+    mpi::communicator comm_;
 
     /// A pointer to the two-dimensional data points.
     std::shared_ptr<soa_matrix<real_type>> data_ptr_{ nullptr };
@@ -429,7 +423,7 @@ template <typename U>
 data_set<U>::data_set(mpi::communicator comm, const std::string &filename, min_max_scaler scaler) :
     data_set{ std::move(comm), filename } {
     // check whether the data set and scaler MPI communicators are identical
-    if (comm != scaler.communicator()) {
+    if (comm_ != scaler.communicator()) {
         throw mpi_exception{ "The MPI communicators provided to the data set and scaler must be identical!" };
     }
 
@@ -443,7 +437,7 @@ template <typename U>
 data_set<U>::data_set(mpi::communicator comm, const std::string &filename, file_format_type format, min_max_scaler scaler) :
     data_set{ std::move(comm), filename, format } {
     // check whether the data set and scaler MPI communicators are identical
-    if (comm != scaler.communicator()) {
+    if (comm_ != scaler.communicator()) {
         throw mpi_exception{ "The MPI communicators provided to the data set and scaler must be identical!" };
     }
 
@@ -526,7 +520,7 @@ template <layout_type layout>
 data_set<U>::data_set(mpi::communicator comm, const matrix<real_type, layout> &data_points, min_max_scaler scaler) :
     data_set{ std::move(comm), data_points } {
     // check whether the data set and scaler MPI communicators are identical
-    if (comm != scaler.communicator()) {
+    if (comm_ != scaler.communicator()) {
         throw mpi_exception{ "The MPI communicators provided to the data set and scaler must be identical!" };
     }
 
@@ -541,7 +535,7 @@ template <layout_type layout>
 data_set<U>::data_set(mpi::communicator comm, const matrix<real_type, layout> &data_points, std::vector<label_type> labels, min_max_scaler scaler) :
     data_set{ std::move(comm), data_points, std::move(labels) } {
     // check whether the data set and scaler MPI communicators are identical
-    if (comm != scaler.communicator()) {
+    if (comm_ != scaler.communicator()) {
         throw mpi_exception{ "The MPI communicators provided to the data set and scaler must be identical!" };
     }
 
@@ -598,7 +592,7 @@ template <typename U>
 data_set<U>::data_set(mpi::communicator comm, soa_matrix<real_type> &&data_points, min_max_scaler scaler) :
     data_set{ std::move(comm), std::move(data_points) } {
     // check whether the data set and scaler MPI communicators are identical
-    if (comm != scaler.communicator()) {
+    if (comm_ != scaler.communicator()) {
         throw mpi_exception{ "The MPI communicators provided to the data set and scaler must be identical!" };
     }
 
@@ -612,7 +606,7 @@ template <typename U>
 data_set<U>::data_set(mpi::communicator comm, soa_matrix<real_type> &&data_points, std::vector<label_type> &&labels, min_max_scaler scaler) :
     data_set{ std::move(comm), std::move(data_points), std::move(labels) } {
     // check whether the data set and scaler MPI communicators are identical
-    if (comm != scaler.communicator()) {
+    if (comm_ != scaler.communicator()) {
         throw mpi_exception{ "The MPI communicators provided to the data set and scaler must be identical!" };
     }
 
@@ -622,6 +616,9 @@ data_set<U>::data_set(mpi::communicator comm, soa_matrix<real_type> &&data_point
     scaler_->scale(*data_ptr_);
 }
 
+template <typename U>
+data_set<U>::~data_set() = default;
+
 template <typename U>
 void data_set<U>::save(const std::string &filename, const file_format_type format) const {
     // save the data set
diff --git a/include/plssvm/data_set/min_max_scaler.hpp b/include/plssvm/data_set/min_max_scaler.hpp
index 7935d5c96..f5d2106bb 100644
--- a/include/plssvm/data_set/min_max_scaler.hpp
+++ b/include/plssvm/data_set/min_max_scaler.hpp
@@ -92,14 +92,14 @@ class min_max_scaler {
      * @param[in] filename the filename to read the scaling information from
      * @throws plssvm::invalid_file_format_exception all exceptions thrown by the plssvm::detail::io::parse_scaling_factors function
      */
-    min_max_scaler(const std::string &filename);  // can't be explicit due to the data_set_variant
+    min_max_scaler(const std::string &filename);  // NOLINT: can't be explicit due to the data_set_variant
     /**
      * @brief Read the scaling interval and factors from the provided file @p filename.
      * @param[in] comm the used MPI communicator (**note**: current only used to restrict logging outputs to the main MPI rank)
      * @param[in] filename the filename to read the scaling information from
      * @throws plssvm::invalid_file_format_exception all exceptions thrown by the plssvm::detail::io::parse_scaling_factors function
      */
-    min_max_scaler(mpi::communicator comm, const std::string &filename);  // can't be explicit due to the data_set_variant
+    min_max_scaler(mpi::communicator comm, const std::string &filename);
 
     /**
      * @brief Save the scaling factors to the file @p filename.
@@ -136,9 +136,8 @@ class min_max_scaler {
     [[nodiscard]] std::optional<std::vector<factors>> scaling_factors() const {
         if (scaling_factors_.empty()) {
             return std::nullopt;  // nothing scaled yet
-        } else {
-            return std::make_optional(scaling_factors_);
         }
+        return std::make_optional(scaling_factors_);
     }
 
     /**
@@ -151,12 +150,12 @@ class min_max_scaler {
 
   private:
     /// The user-provided scaling interval. After scaling, all feature values are scaled to [lower, upper].
-    std::pair<real_type, real_type> scaling_interval_{};
+    std::pair<real_type, real_type> scaling_interval_;
     /// The scaling factors for all features.
-    std::vector<factors> scaling_factors_{};
+    std::vector<factors> scaling_factors_;
 
     /// The used MPI communicator.
-    mpi::communicator comm_{};
+    mpi::communicator comm_;
 };
 
 template <layout_type layout>
@@ -186,7 +185,7 @@ void min_max_scaler::scale(plssvm::matrix<real_type, layout> &data) {
             }
 
             // add scaling factor only if min_value != 0.0 AND max_value != 0.0
-            if (!(min_value == real_type{ 0.0 } && max_value == real_type{ 0.0 })) {
+            if (min_value != real_type{ 0.0 } || max_value != real_type{ 0.0 }) {
                 scaling_factors_.emplace_back(feature, min_value, max_value);
             }
         }
diff --git a/include/plssvm/data_set/regression_data_set.hpp b/include/plssvm/data_set/regression_data_set.hpp
index 85f4949a2..fb509210a 100644
--- a/include/plssvm/data_set/regression_data_set.hpp
+++ b/include/plssvm/data_set/regression_data_set.hpp
@@ -30,8 +30,7 @@
 #include <cstddef>  // std::size_t
 #include <memory>   // std::make_shared
 #include <string>   // std::string
-#include <utility>  // std::forward
-#include <utility>  // std::move
+#include <utility>  // std::move, std::forward
 #include <vector>   // std::vector
 
 namespace plssvm {
@@ -534,9 +533,10 @@ class regression_data_set : public data_set<U> {
     void init();
 
     /**
-     * @copydoc plssvm::data_set::map_label
+     * @brief Create the mapping between the provided labels and the internally used values.
+     * @throws plssvm::data_set_exception any exception of the plssvm::data_set::label_mapper class
      */
-    void map_label() override;
+    void map_label();
 };
 
 //*************************************************************************************************************************************//
diff --git a/include/plssvm/detail/arithmetic_type_name.hpp b/include/plssvm/detail/arithmetic_type_name.hpp
index 15cd3850e..c5935ae2e 100644
--- a/include/plssvm/detail/arithmetic_type_name.hpp
+++ b/include/plssvm/detail/arithmetic_type_name.hpp
@@ -15,6 +15,9 @@
 
 #include <string_view>  // std::string_view
 
+// silence false positive "macro argument should be enclosed in parentheses" warning
+// NOLINTBEGIN(bugprone-macro-parentheses)
+
 /**
  * @def PLSSVM_CREATE_ARITHMETIC_TYPE_NAME
  * @brief Defines a macro to create all possible conversion functions from arithmetic types to their name as string representation.
@@ -31,6 +34,8 @@
     template <>                                                                                                         \
     [[nodiscard]] constexpr inline std::string_view arithmetic_type_name<const volatile type>() { return "const volatile " #type; }
 
+// NOLINTEND(bugprone-macro-parentheses)
+
 namespace plssvm::detail {
 
 /**
@@ -40,7 +45,7 @@ namespace plssvm::detail {
  * @return the name of `T` (`[[nodiscard]]`)
  */
 template <typename T>
-[[nodiscard]] constexpr inline std::string_view arithmetic_type_name() = delete;
+[[nodiscard]] constexpr std::string_view arithmetic_type_name() = delete;
 
 PLSSVM_CREATE_ARITHMETIC_TYPE_NAME(bool)
 
diff --git a/include/plssvm/detail/assert.hpp b/include/plssvm/detail/assert.hpp
index 7fb34d0a5..ac8f81c0d 100644
--- a/include/plssvm/detail/assert.hpp
+++ b/include/plssvm/detail/assert.hpp
@@ -50,7 +50,7 @@ inline void check_assertion(const bool cond, const std::string_view cond_str, co
             "  @ line             {}\n\n"
             "{}\n",
             fmt::format(fmt::emphasis::bold | fmt::fg(fmt::color::green), "{}", cond_str),
-            loc.world_rank().has_value() ? fmt::format("  on MPI world rank  {}\n", loc.world_rank().value()) : std::string{},
+            loc.world_rank().has_value() ? fmt::format("  on MPI world rank  {}\n", loc.world_rank().value()) : std::string{},  // NOLINT(bugprone-unchecked-optional-access): false positive, optional access is checked
             loc.file_name(),
             loc.function_name(),
             loc.line(),
diff --git a/include/plssvm/detail/cmd/data_set_variants.hpp b/include/plssvm/detail/cmd/data_set_variants.hpp
index 95325ed0e..46cf0ae1a 100644
--- a/include/plssvm/detail/cmd/data_set_variants.hpp
+++ b/include/plssvm/detail/cmd/data_set_variants.hpp
@@ -69,9 +69,8 @@ template <typename label_type, typename... Args>
 [[nodiscard]] inline min_max_scaler make_scaling_factors(mpi::communicator comm, const cmd::parser_scale &cmd_parser) {
     if (!cmd_parser.restore_filename.empty()) {
         return min_max_scaler{ std::move(comm), cmd_parser.restore_filename };
-    } else {
-        return min_max_scaler{ std::move(comm), cmd_parser.lower, cmd_parser.upper };
     }
+    return min_max_scaler{ std::move(comm), cmd_parser.lower, cmd_parser.upper };
 }
 
 /**
@@ -85,9 +84,8 @@ template <typename label_type, typename... Args>
         case svm_type::csvc:
             if (cmd_parser.strings_as_labels) {
                 return make_classification_data_set<std::string>(std::move(comm), cmd_parser.input_filename);
-            } else {
-                return make_classification_data_set<typename classification_data_set<>::label_type>(std::move(comm), cmd_parser.input_filename);
             }
+            return make_classification_data_set<typename classification_data_set<>::label_type>(std::move(comm), cmd_parser.input_filename);
         case svm_type::csvr:
             return make_regression_data_set<typename regression_data_set<>::label_type>(std::move(comm), cmd_parser.input_filename);
     }
@@ -107,9 +105,8 @@ template <typename label_type, typename... Args>
         case svm_type::csvc:
             if (cmd_parser.strings_as_labels) {
                 return make_classification_data_set<std::string>(std::move(comm), cmd_parser.input_filename);
-            } else {
-                return make_classification_data_set<typename classification_data_set<>::label_type>(std::move(comm), cmd_parser.input_filename);
             }
+            return make_classification_data_set<typename classification_data_set<>::label_type>(std::move(comm), cmd_parser.input_filename);
         case svm_type::csvr:
             return make_regression_data_set<typename regression_data_set<>::label_type>(std::move(comm), cmd_parser.input_filename);
     }
@@ -125,12 +122,14 @@ template <typename label_type, typename... Args>
  * @return the data set based on the provided command line parser (`[[nodiscard]]`)
  */
 [[nodiscard]] inline data_set_variants data_set_factory(mpi::communicator comm, const cmd::parser_scale &cmd_parser) {
+    // create the scaling factors
+    min_max_scaler scaling_factors = make_scaling_factors(comm, cmd_parser);
+    // create the correct classification data set
     if (cmd_parser.strings_as_labels) {
-        return make_classification_data_set<std::string>(comm, cmd_parser.input_filename, make_scaling_factors(comm, cmd_parser));
-    } else {
-        using label_type = typename classification_data_set<>::label_type;
-        return make_classification_data_set<label_type>(comm, cmd_parser.input_filename, make_scaling_factors(comm, cmd_parser));
+        return make_classification_data_set<std::string>(std::move(comm), cmd_parser.input_filename, std::move(scaling_factors));
     }
+    using label_type = typename classification_data_set<>::label_type;
+    return make_classification_data_set<label_type>(std::move(comm), cmd_parser.input_filename, std::move(scaling_factors));
 }
 
 }  // namespace plssvm::detail::cmd
diff --git a/include/plssvm/detail/cmd/parser_predict.hpp b/include/plssvm/detail/cmd/parser_predict.hpp
index 073e92f6c..0d527845b 100644
--- a/include/plssvm/detail/cmd/parser_predict.hpp
+++ b/include/plssvm/detail/cmd/parser_predict.hpp
@@ -13,19 +13,20 @@
 #define PLSSVM_DETAIL_CMD_PARSER_PREDICT_HPP_
 #pragma once
 
-#include "plssvm/backend_types.hpp"                          // plssvm::backend_type
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::execution_space
-#include "plssvm/backends/SYCL/implementation_types.hpp"     // plssvm::sycl::implementation_type
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/mpi/communicator.hpp"                       // plssvm::mpi::communicator
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"     // plssvm::kokkos::execution_space
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::implementation_type
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "fmt/base.h"     // fmt::formatter
 #include "fmt/ostream.h"  // fmt::ostream_formatter
 
-#include <iosfwd>  // forward declare std::ostream
-#include <string>  // std::string
-#include <vector>  // std::vector
+#include <cstddef>  // std::size_t
+#include <iosfwd>   // forward declare std::ostream
+#include <string>   // std::string
+#include <vector>   // std::vector
 
 namespace plssvm::detail::cmd {
 
@@ -47,8 +48,8 @@ struct parser_predict {
     /// The target platform: automatic (depending on the used backend), CPUs or GPUs from NVIDIA, AMD, or Intel.
     target_platform target{ target_platform::automatic };
 
-    /// The kernel invocation type when using SYCL as backend.
-    sycl::kernel_invocation_type sycl_kernel_invocation_type{ sycl::kernel_invocation_type::automatic };
+    /// The data parallel kernel when using SYCL as backend.
+    sycl::data_parallel_kernel sycl_data_parallel_kernel{ sycl::data_parallel_kernel::automatic };
     /// The SYCL implementation to use with `--backend sycl`.
     sycl::implementation_type sycl_implementation_type{ sycl::implementation_type::automatic };
 
@@ -60,17 +61,17 @@ struct parser_predict {
 
     /// Load balancing weights for MPI used if different hardware per MPI process is used. The number must match the number of spawned MPI processes.
     /// Providing [1, 1] means every process gets the same amount of work, providing [1, 3] means that the second process has three times the work to do compared to process zero.
-    std::vector<std::size_t> mpi_load_balancing_weights{};
+    std::vector<std::size_t> mpi_load_balancing_weights;
 
     /// The name of the data file to predict.
-    std::string input_filename{};
+    std::string input_filename;
     /// The name of the model file containing the support vectors and weights used for prediction.
-    std::string model_filename{};
+    std::string model_filename;
     /// The name of the file to write the predicted labels to.
-    std::string predict_filename{};
+    std::string predict_filename;
 
     /// If performance tracking has been enabled, provides the name of the file where the performance tracking results are saved to. If the filename is empty, the results are dumped using std::clog instead.
-    std::string performance_tracking_filename{};
+    std::string performance_tracking_filename;
 };
 
 /**
diff --git a/include/plssvm/detail/cmd/parser_scale.hpp b/include/plssvm/detail/cmd/parser_scale.hpp
index 402b62f8f..42402dc16 100644
--- a/include/plssvm/detail/cmd/parser_scale.hpp
+++ b/include/plssvm/detail/cmd/parser_scale.hpp
@@ -49,16 +49,16 @@ struct parser_scale {
     bool strings_as_labels{ false };
 
     /// The name of the data file to scale.
-    std::string input_filename{};
+    std::string input_filename;
     /// The name of the scaled data file to save.
-    std::string scaled_filename{};
+    std::string scaled_filename;
     /// The name of the file where the scaling factors are saved.
-    std::string save_filename{};
+    std::string save_filename;
     /// The name of the file from which the scaling factors should be restored.
-    std::string restore_filename{};
+    std::string restore_filename;
 
     /// If performance tracking has been enabled, provides the name of the file where the performance tracking results are saved to. If the filename is empty, the results are dumped using std::clog instead.
-    std::string performance_tracking_filename{};
+    std::string performance_tracking_filename;
 };
 
 /**
diff --git a/include/plssvm/detail/cmd/parser_train.hpp b/include/plssvm/detail/cmd/parser_train.hpp
index 6ddae10ac..b3887d861 100644
--- a/include/plssvm/detail/cmd/parser_train.hpp
+++ b/include/plssvm/detail/cmd/parser_train.hpp
@@ -13,17 +13,17 @@
 #define PLSSVM_DETAIL_CMD_PARSER_TRAIN_HPP_
 #pragma once
 
-#include "plssvm/backend_types.hpp"                          // plssvm::backend_type
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::execution_space
-#include "plssvm/backends/SYCL/implementation_types.hpp"     // plssvm::sycl::implementation_type
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/classification_types.hpp"                   // plssvm::classification_type
-#include "plssvm/constants.hpp"                              // plssvm::real_type
-#include "plssvm/mpi/communicator.hpp"                       // plssvm::mpi::communicator
-#include "plssvm/parameter.hpp"                              // plssvm::parameter
-#include "plssvm/solver_types.hpp"                           // plssvm::solving_type
-#include "plssvm/svm_types.hpp"                              // plssvm::svm_type
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"     // plssvm::kokkos::execution_space
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::implementation_type
+#include "plssvm/classification_types.hpp"                 // plssvm::classification_type
+#include "plssvm/constants.hpp"                            // plssvm::real_type, plssvm::DEFAULT_EPSILON
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/parameter.hpp"                            // plssvm::parameter
+#include "plssvm/solver_types.hpp"                         // plssvm::solving_type
+#include "plssvm/svm_types.hpp"                            // plssvm::svm_type
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "fmt/base.h"     // fmt::formatter
 #include "fmt/ostream.h"  // mt::ostream_formatter
@@ -49,10 +49,10 @@ struct parser_train {
     parser_train(const mpi::communicator &comm, int argc, char **argv);
 
     /// Other base C-SVM parameters
-    plssvm::parameter csvm_params{};
+    plssvm::parameter csvm_params;
 
     /// The error tolerance parameter for the CG algorithm.
-    real_type epsilon = static_cast<real_type>(1e-10);
+    real_type epsilon{ DEFAULT_EPSILON };
     /// The maximum number of iterations in the CG algorithm.
     std::size_t max_iter{ 0 };
     /// The multi-class classification strategy used.
@@ -67,8 +67,8 @@ struct parser_train {
     /// The used solver type for the LS-SVM kernel matrix: automatic (depending on the available (V)RAM), cg_explicit, or cg_implicit.
     solver_type solver{ solver_type::automatic };
 
-    /// The kernel invocation type when using SYCL as backend.
-    sycl::kernel_invocation_type sycl_kernel_invocation_type{ sycl::kernel_invocation_type::automatic };
+    /// The data parallel kernel when using SYCL as backend.
+    sycl::data_parallel_kernel sycl_data_parallel_kernel{ sycl::data_parallel_kernel::automatic };
     /// The SYCL implementation to use with --backend=sycl.
     sycl::implementation_type sycl_implementation_type{ sycl::implementation_type::automatic };
 
@@ -81,15 +81,15 @@ struct parser_train {
 
     /// Load balancing weights for MPI used if different hardware per MPI process is used. The number must match the number of spawned MPI processes.
     /// Providing [1, 1] means every process gets the same amount of work, providing [1, 3] means that the second process has three times the work to do compared to process zero.
-    std::vector<std::size_t> mpi_load_balancing_weights{};
+    std::vector<std::size_t> mpi_load_balancing_weights;
 
     /// The name of the data/test file to parse.
-    std::string input_filename{};
+    std::string input_filename;
     /// The name of the model file to write the learned support vectors to/to parse the saved model from.
-    std::string model_filename{};
+    std::string model_filename;
 
     /// If performance tracking has been enabled, provides the name of the file where the performance tracking results are saved to. If the filename is empty, the results are dumped using std::clog instead.
-    std::string performance_tracking_filename{};
+    std::string performance_tracking_filename;
 };
 
 /**
diff --git a/include/plssvm/detail/cmd/utility.hpp b/include/plssvm/detail/cmd/utility.hpp
new file mode 100644
index 000000000..2814c19ff
--- /dev/null
+++ b/include/plssvm/detail/cmd/utility.hpp
@@ -0,0 +1,97 @@
+/**
+ * @file
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Utility functions related to the command line parser functionality.
+ */
+
+#ifndef PLSSVM_DETAIL_CMD_UTILITY_HPP_
+#define PLSSVM_DETAIL_CMD_UTILITY_HPP_
+#pragma once
+
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"     // plssvm::kokkos::execution_space
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernels
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::implementation_type
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
+#include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity_level
+
+#include "cxxopts.hpp"  // cxxopts::ParseResult, cxxopts::Options
+
+#include <cstddef>   // std::size_t
+#include <optional>  // std::optional
+#include <string>    // std::string
+#include <utility>   // std::pair
+#include <vector>    // std::vector
+
+namespace plssvm::detail::cmd {
+
+/// The maximum number of characters in one cmd line.
+constexpr std::size_t max_cmd_width = 150;
+
+/**
+ * @brief Filter the provided command line options starting with the @p prefix_filter.
+ * @details Currently, per default filters out all options starting with "--hpx:" and "--kokkos-".
+ * @attention **ONLY** single command line options are supported! I.e., "--hpx:threads=42" is supported, but not "--hpx:threads 42".
+ * @param[in] argc the number of provided command line options to be filtered
+ * @param[in] argv the command line options to be filtered
+ * @param[in] prefix_filter a list of prefixes that should be filtered
+ * @return a `std::vector` containing all non-filtered command line options (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::vector<char *> filter_argv(int argc, char **argv, const std::vector<std::string> &prefix_filter = { "--hpx:", "--kokkos-" });
+
+/**
+ * @brief Assemble a more detailed help message for the kernel function types also containing their mathematical formula.
+ * @return the kernel functions' help message (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::string kernel_type_help_message();
+
+/**
+ * @brief If a SYCL backend is available, parse the SYCL specific command line options "--sycl_data_parallel_kernel" and "--sycl_implementation_type".
+ * @details If a SYCL backend is available, returns the two parsed command line options wrapped in a `std::pair`, otherwise returns a `std::nullopt`.
+ * @param[in] result the cxxopts parser result encapsulating the command line options
+ * @param[in] comm the MPI communicator
+ * @param[in] backend the requested backend
+ * @param[in] target the requested target platform
+ * @return the parsed, SYCL specific command line options (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::optional<std::pair<sycl::data_parallel_kernel, sycl::implementation_type>> parse_and_check_sycl_options_if_available(const cxxopts::ParseResult &result, const mpi::communicator &comm, backend_type backend, target_platform target);
+
+/**
+ * @brief If the Kokkos backend is available, parse the Kokkos specific command line option "--kokkos_execution_space".
+ * @details If the Kokkos backend is available, returns the parsed command line option, otherwise returns a `std::nullopt`.
+ * @param[in] result the cxxopts parser result encapsulating the command line option
+ * @param[in] comm the MPI communicator
+ * @param[in] backend the requested backend
+ * @param[in] target the requested target platform
+ * @return the parsed, Kokkos specific command line option (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::optional<kokkos::execution_space> parse_and_check_kokkos_options_if_available(const cxxopts::ParseResult &result, const mpi::communicator &comm, backend_type backend, target_platform target);
+
+/**
+ * @brief If MPI is available, parse the MPI specific command line option "--mpi_load_balancing_weights".
+ * @details If MPI is available, returns the parsed command line option, otherwise returns a `std::nullopt`.
+ * @param[in] result the cxxopts parser result encapsulating the command line option
+ * @param[in] options all supported command line options
+ * @param[in] comm the MPI communicator
+ * @return the parsed, MPI specific command line option (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::optional<std::vector<std::size_t>> parse_and_check_mpi_options_if_available(const cxxopts::ParseResult &result, const cxxopts::Options &options, const mpi::communicator &comm);
+
+/**
+ * @brief Parse the verbosity command line option.
+ * @details If it was provided, returns the parsed value, otherwise returns a `std::nullopt`.
+ * @param[in] result the cxxopts parser result encapsulating the command line option
+ * @param[in] comm the MPI communicator
+ * @return the parsed verbosity command line option (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::optional<verbosity_level> parse_verbosity(const cxxopts::ParseResult &result, const mpi::communicator &comm);
+
+}  // namespace plssvm::detail::cmd
+
+#endif  // PLSSVM_DETAIL_CMD_UTILITY_HPP_
diff --git a/include/plssvm/detail/data_distribution.hpp b/include/plssvm/detail/data_distribution.hpp
index af4043a79..e30b5b5c2 100644
--- a/include/plssvm/detail/data_distribution.hpp
+++ b/include/plssvm/detail/data_distribution.hpp
@@ -13,6 +13,7 @@
 #define PLSSVM_DETAIL_DATA_DISTRIBUTION_HPP_
 #pragma once
 
+#include "plssvm/constants.hpp"           // plssvm::real_type, plssvm::THREAD_BLOCK_SIZE, plssvm::INTERNAL_BLOCK_SIZE
 #include "plssvm/detail/memory_size.hpp"  // plssvm:detail::memory_size
 #include "plssvm/mpi/communicator.hpp"    // plssvm::mpi::communicator
 
@@ -89,6 +90,14 @@ class data_distribution {
      */
     [[nodiscard]] std::size_t total_num_places() const noexcept;
 
+    /**
+     * @brief Get the total amount of local memory needed.
+     * @return the total amount of local memory (`[[nodiscard]]`)
+     */
+    [[nodiscard]] constexpr static memory_size maximum_local_memory_needed() noexcept {
+        return memory_size{ 2L * THREAD_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE * sizeof(real_type) };
+    }
+
   protected:
     /**
      * @brief Construct a new data distribution being able to hold the distribution for @p num_places.
diff --git a/include/plssvm/detail/io/classification_libsvm_model_parsing.hpp b/include/plssvm/detail/io/classification_libsvm_model_parsing.hpp
index 69b7ad676..4a8c7eb76 100644
--- a/include/plssvm/detail/io/classification_libsvm_model_parsing.hpp
+++ b/include/plssvm/detail/io/classification_libsvm_model_parsing.hpp
@@ -24,6 +24,7 @@
 #include "plssvm/detail/memory_size.hpp"                // plssvm::memory_size, custom literals
 #include "plssvm/detail/string_conversion.hpp"          // plssvm::detail::{convert_to, split_as}
 #include "plssvm/detail/string_utility.hpp"             // plssvm::detail::{trim, trim_left, to_lower_case}
+#include "plssvm/exceptions/exceptions.hpp"             // plssvm::file_format_exception, plssvm::data_set_exception
 #include "plssvm/gamma.hpp"                             // plssvm::get_gamma_string
 #include "plssvm/kernel_function_types.hpp"             // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                            // plssvm::soa_matrix
@@ -514,7 +515,8 @@ template <typename label_type>
     if (is_oaa && is_oao) {
         // invalid model file
         throw invalid_file_format_exception{ "Can't distinguish between OAA and OAO in the given model file!" };
-    } else if (is_oaa) {
+    }
+    if (is_oaa) {
         // every class has the same number of weights
         // -> use a vector with one entry containing a matrix with all weights!
         classification = classification_type::oaa;
@@ -593,6 +595,8 @@ template <typename label_type>
 template <typename label_type>
 [[nodiscard]] inline std::vector<label_type> write_libsvm_model_header_classification(fmt::ostream &out, const mpi::communicator &comm, const plssvm::parameter &params, const std::vector<real_type> &rho, const classification_data_set<label_type> &data) {
     PLSSVM_ASSERT(data.has_labels(), "Cannot write a model file that does not include labels!");
+    PLSSVM_ASSERT(data.classes().has_value(), "No original labels provided!");
+    PLSSVM_ASSERT(data.labels().has_value(), "No mapped labels provided!");
     PLSSVM_ASSERT(!rho.empty(), "At least one rho value must be provided!");
 
     // save model file header
@@ -615,23 +619,30 @@ template <typename label_type>
     }
 
     // get the original labels (not the mapped once)
-    const std::vector<label_type> classes = data.classes().value();
+    const std::optional<std::vector<label_type>> classes = data.classes();
+
+    // get the mapped labels
+    const auto &labels = data.labels();
+
+    // check that labels are present (should NEVER trigger)
+    if (!classes.has_value() || !labels.has_value()) {
+        throw data_set_exception{ "The data set does not contain any labels, but they are required to output a model file!" };
+    }
 
     // count the occurrence of each label
     std::map<label_type, std::size_t> label_counts_map;
-    const std::vector<label_type> labels = data.labels().value();
-    for (const label_type &l : labels) {
+    for (const label_type &l : labels.value().get()) {
         ++label_counts_map[l];
     }
     // fill vector with number of occurrences in correct order
     std::vector<std::size_t> label_counts(data.num_classes());
     for (typename data_set<label_type>::size_type i = 0; i < data.num_classes(); ++i) {
-        label_counts[i] = label_counts_map[classes[i]];
+        label_counts[i] = label_counts_map[classes.value()[i]];
     }
 
     out_string += fmt::format("nr_class {}\nlabel {}\ntotal_sv {}\nnr_sv {}\nrho {:.10e}\nSV\n",
                               data.num_classes(),
-                              fmt::join(classes, " "),
+                              fmt::join(classes.value(), " "),
                               data.num_data_points(),
                               fmt::join(label_counts, " "),
                               fmt::join(rho, " "));
@@ -644,7 +655,7 @@ template <typename label_type>
     // write model header to file
     out.print("{}", out_string);
 
-    return classes;
+    return classes.value();
 }
 
 /**
@@ -683,6 +694,7 @@ template <typename label_type>
 inline void write_libsvm_model_data_classification(const std::string &filename, const mpi::communicator &comm, const plssvm::parameter &params, const classification_type classification, const std::vector<real_type> &rho, const std::vector<aos_matrix<real_type>> &alpha, const std::vector<std::vector<std::size_t>> &index_sets, const classification_data_set<label_type> &data) {
     PLSSVM_ASSERT(!filename.empty(), "The provided model filename must not be empty!");
     PLSSVM_ASSERT(data.has_labels(), "Cannot write a model file that does not include labels!");
+    PLSSVM_ASSERT(data.labels().has_value(), "No mapped labels provided!");
     PLSSVM_ASSERT(rho.size() == calculate_number_of_classifiers(classification, data.num_classes()),
                   "The number of rho values is {} but must be {} ({})!",
                   rho.size(),
@@ -719,10 +731,17 @@ inline void write_libsvm_model_data_classification(const std::string &filename,
             break;
     }
 #endif
-    using namespace literals;
+    using namespace literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
+
+    const auto &labels_opt = data.labels();
+
+    // check that labels are present (should NEVER trigger)
+    if (!labels_opt.has_value()) {
+        throw data_set_exception{ "The data set does not contain any labels, but they are required to output a model file!" };
+    }
 
     const soa_matrix<real_type> &support_vectors = data.data();
-    const std::vector<label_type> &labels = *data.labels();
+    const std::vector<label_type> &labels = labels_opt.value();
     const std::size_t num_features = data.num_features();
     const std::size_t num_classes = data.num_classes();
     const std::size_t num_alpha_per_point = classification == classification_type::oaa ? num_classes : num_classes - 1;
@@ -767,7 +786,7 @@ inline void write_libsvm_model_data_classification(const std::string &filename,
     };
 
     // initialize volatile array
-    auto counts = std::make_unique<volatile int[]>(label_order.size() + 1);
+    auto counts = std::make_unique<volatile int[]>(label_order.size() + 1);  // NOLINT: can't use STL container due to volatile requirement
     counts[0] = std::numeric_limits<int>::max();
 #pragma omp parallel default(none) shared(counts, alpha, format_libsvm_line, label_order, labels, support_vectors, out, index_sets) firstprivate(STRING_BUFFER_SIZE, num_features, num_classes, num_alpha_per_point, classification)
     {
diff --git a/include/plssvm/detail/io/file_reader.hpp b/include/plssvm/detail/io/file_reader.hpp
index d89fc6152..352f10d4a 100644
--- a/include/plssvm/detail/io/file_reader.hpp
+++ b/include/plssvm/detail/io/file_reader.hpp
@@ -204,11 +204,11 @@ class file_reader {
     /// The content of the file. Pointer to the memory mapped area or to a separately allocated memory area holding the file's content. If the file is empty, corresponds to a `nullptr`!
     char *file_content_{ nullptr };
     /// The content of the file IF memory mapping wasn't available or successful. In this case, `file_content_` points to this std::string's data. Otherwise, this std::string isn't used.
-    std::string fallback_file_content_{};
+    std::string fallback_file_content_;
     /// The number of bytes stored in file_content_.
     std::streamsize num_bytes_{ 0 };
     /// The parsed content of file_content_: a vector of all lines that are not empty and do not start with the provided comment.
-    std::vector<std::string_view> lines_{};
+    std::vector<std::string_view> lines_;
     /// `true` if a file is currently associated wih this file_reader, `false` otherwise.
     bool is_open_{ false };
 };
diff --git a/include/plssvm/detail/io/libsvm_parsing.hpp b/include/plssvm/detail/io/libsvm_parsing.hpp
index 959937090..c0f009140 100644
--- a/include/plssvm/detail/io/libsvm_parsing.hpp
+++ b/include/plssvm/detail/io/libsvm_parsing.hpp
@@ -245,7 +245,7 @@ inline void write_libsvm_data_impl(const std::string &filename, const soa_matrix
     } else {
         PLSSVM_ASSERT(label.empty(), "has_label is 'false' but labels were provided!");
     }
-    using namespace literals;
+    using namespace literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
 
     // create output file
     fmt::ostream out = fmt::output_file(filename);
diff --git a/include/plssvm/detail/io/regression_libsvm_model_parsing.hpp b/include/plssvm/detail/io/regression_libsvm_model_parsing.hpp
index 5cfbb9ae6..2cebcd06e 100644
--- a/include/plssvm/detail/io/regression_libsvm_model_parsing.hpp
+++ b/include/plssvm/detail/io/regression_libsvm_model_parsing.hpp
@@ -24,7 +24,7 @@
 #include "plssvm/detail/string_utility.hpp"             // plssvm::detail::{trim, trim_left, to_lower_case}
 #include "plssvm/gamma.hpp"                             // plssvm::get_gamma_string
 #include "plssvm/kernel_function_types.hpp"             // plssvm::kernel_function_type
-#include "plssvm/matrix.hpp"                            // plssvm::soa_matrix
+#include "plssvm/matrix.hpp"                            // plssvm::soa_matrix, plssvm::aos_matrix
 #include "plssvm/mpi/communicator.hpp"                  // plssvm::mpi::communicator
 #include "plssvm/parameter.hpp"                         // plssvm::parameter
 #include "plssvm/shape.hpp"                             // plssvm::shape
@@ -453,7 +453,7 @@ inline void write_libsvm_model_data_regression(const std::string &filename, cons
     PLSSVM_ASSERT(alpha.front().num_rows() == 1, "The number of rows in the matrix must be 1, but is {}!", alpha.front().num_rows());
     PLSSVM_ASSERT(alpha.front().num_cols() == data.num_data_points(), "The number of weights ({}) must be equal to the number of support vectors ({})!", alpha.front().num_cols(), data.num_data_points());
 #endif
-    using namespace literals;
+    using namespace literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
 
     const soa_matrix<real_type> &support_vectors = data.data();
     const std::size_t num_features = data.num_features();
diff --git a/include/plssvm/detail/logging/log.hpp b/include/plssvm/detail/logging/log.hpp
index f612dee01..fa0a11afa 100644
--- a/include/plssvm/detail/logging/log.hpp
+++ b/include/plssvm/detail/logging/log.hpp
@@ -36,7 +36,13 @@ namespace plssvm::detail {
 template <typename... Args>
 void log(const verbosity_level msg_verbosity, const std::string_view msg, Args &&...args) {
     // first, log the message to the standard output without performance tracking
-    log_untracked(msg_verbosity, msg, args...);
+    log_untracked(msg_verbosity, msg,
+#if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
+                  args...
+#else
+                  std::forward<Args>(args)...
+#endif
+    );
 
     // if performance tracking has been enabled, add tracking entries
 #if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
diff --git a/include/plssvm/detail/logging/log_untracked.hpp b/include/plssvm/detail/logging/log_untracked.hpp
index 4a8ef94af..405e74211 100644
--- a/include/plssvm/detail/logging/log_untracked.hpp
+++ b/include/plssvm/detail/logging/log_untracked.hpp
@@ -39,7 +39,7 @@ void log_untracked(const verbosity_level msg_verbosity, const std::string_view m
     // msg_verbosity = the verbosity of the current message
 
     // if the global verbosity or the message verbosity is 'plssvm::verbosity_level::quiet', nothing should be logged
-    if (!(verbosity == verbosity_level::quiet || msg_verbosity == verbosity_level::quiet)) {
+    if (verbosity != verbosity_level::quiet && msg_verbosity != verbosity_level::quiet) {
         // check whether the provided msg_verbosity is contained in the current active verbosity
         if ((verbosity & msg_verbosity) != verbosity_level::quiet || (verbosity == verbosity_level::full && (msg_verbosity & verbosity_level::libsvm) == verbosity_level::quiet)) {
             // check if it is a warning message, if yes, the output will be colored
diff --git a/include/plssvm/detail/make_unique_for_overwrite.hpp b/include/plssvm/detail/make_unique_for_overwrite.hpp
new file mode 100644
index 000000000..885800c8e
--- /dev/null
+++ b/include/plssvm/detail/make_unique_for_overwrite.hpp
@@ -0,0 +1,126 @@
+/**
+ * @file
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief A C++17 conform implementation of C++20's std::make_unique_for_overwrite.
+ * @details For implementation details see: https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
+ */
+
+#ifndef PLSSVM_DETAIL_MAKE_UNIQUE_FOR_OVERWRITE_HPP_
+#define PLSSVM_DETAIL_MAKE_UNIQUE_FOR_OVERWRITE_HPP_
+#pragma once
+
+#include "plssvm/detail/assert.hpp"  // PLSSVM_ASSERT
+
+#include <cstddef>      // std::size_t
+#include <cstring>      // std::memset
+#include <memory>       // std::unique_ptr
+#include <type_traits>  // std::false_type, std::true_type, std::enable_if_t, std::is_array_v
+
+namespace plssvm::detail {
+
+/**
+ * @brief Helper struct to check whether @p T is an unbounded array.
+ * @tparam T the array type
+ */
+template <typename T>
+struct is_unbounded_array : std::false_type { };
+
+/**
+ * @brief Specialization of plssvm::detail::is_unbounded_array for unbounded arrays.
+ * @tparam T the array type
+ */
+template <typename T>
+struct is_unbounded_array<T[]> : std::true_type { };  // NOLINT: see https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
+
+/**
+ * @brief Shortcut for plssvm::detail::is_unbounded_array.
+ * @tparam T the array type
+ */
+template <typename T>
+constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
+
+/**
+ * @brief Helper struct to check whether @p T is a bounded array.
+ * @tparam T the array type
+ */
+template <typename T>
+struct is_bounded_array : std::false_type { };
+
+/**
+ * @brief Specialization of plssvm::detail::is_bounded_array for unbounded arrays.
+ * @tparam T the array type
+ * @tparam N the size of the array
+ */
+template <typename T, std::size_t N>
+struct is_bounded_array<T[N]> : std::true_type { };  // NOLINT: see https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
+
+/**
+ * @brief Shortcut for plssvm::detail::is_bounded_array.
+ * @tparam T the array type
+ */
+template <typename T>
+constexpr bool is_bounded_array_v = is_bounded_array<T>::value;
+
+/**
+ * @brief A C++17 conform implementation of C++20's std::make_unique_for_overwrite.
+ * @details For implementation details see: https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
+ * @tparam T the type of the object to create
+ * @return a unique pointer to the newly created object (`[[nodiscard]]`)
+ */
+template <typename T, std::enable_if_t<std::is_array_v<T>, bool> = true>
+[[nodiscard]] std::unique_ptr<T> make_unique_for_overwrite() {
+    return std::unique_ptr<T>(new T);
+}
+
+/**
+ * @brief A C++17 conform implementation of C++20's std::make_unique_for_overwrite.
+ * @details For implementation details see: https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
+ * @tparam T the type of the objects to create
+ * @param[in] n the size of the array to create
+ * @return a unique pointer to the newly created object (`[[nodiscard]]`)
+ */
+template <typename T, std::enable_if_t<is_unbounded_array_v<T>, bool> = true>  // NOLINT: see https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
+std::unique_ptr<T> make_unique_for_overwrite(const std::size_t n) {
+    return std::unique_ptr<T>(new std::remove_extent_t<T>[n]);
+}
+
+/**
+ * @brief A C++17 conform implementation of C++20's std::make_unique_for_overwrite.
+ * @details For implementation details see: https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
+ * @tparam T the type of the object to create
+ * @tparam Args the types of the constructor arguments
+ * @param[in] args the arguments to pass to the constructor
+ * @return a unique pointer to the newly created object (`[[nodiscard]]`)
+ */
+template <typename T, typename... Args, std::enable_if_t<is_bounded_array_v<T>, bool> = true>  // NOLINT: see https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
+auto make_unique_for_overwrite(Args &&...args) = delete;
+
+/**
+ * @brief Fill the array @p dest with zeros in parallel using OpenMP if available, otherwise fall back to a sequential memset.
+ * @tparam T the type of the values
+ * @param[in,out] dest the array to fill with zeros
+ * @param[in] count the number of values to fill
+ */
+template <typename T>
+void parallel_zero_memset(T *dest, const std::size_t count) {
+    PLSSVM_ASSERT(dest != nullptr, "The destination pointer may not be a nullptr!");
+
+// initialize the data pointed to by dest to all zeros in parallel using OpenMP if available, otherwise fall back to a sequential memset
+#if defined(_OPENMP)
+    #pragma omp parallel for
+    for (std::size_t i = 0; i < count; ++i) {
+        dest[i] = T{ 0 };
+    }
+#else
+    std::memset(dest, 0, count * sizeof(T));
+#endif
+}
+
+}  // namespace plssvm::detail
+
+#endif  // PLSSVM_DETAIL_MAKE_UNIQUE_FOR_OVERWRITE_HPP_
diff --git a/include/plssvm/detail/move_only_any.hpp b/include/plssvm/detail/move_only_any.hpp
index 8c7e00e2c..c9d5ab94b 100644
--- a/include/plssvm/detail/move_only_any.hpp
+++ b/include/plssvm/detail/move_only_any.hpp
@@ -9,8 +9,8 @@
  * @brief Implements a `move_only_any` class based on [`std::any`](https://en.cppreference.com/w/cpp/utility/any) that works with move-only types.
  */
 
-#ifndef PLSSVM_DETAIL_move_only_any_HPP_
-#define PLSSVM_DETAIL_move_only_any_HPP_
+#ifndef PLSSVM_DETAIL_MOVE_ONLY_ANY_HPP_
+#define PLSSVM_DETAIL_MOVE_ONLY_ANY_HPP_
 #pragma once
 
 #include "plssvm/detail/type_traits.hpp"  // PLSSVM_REQUIRES, plssvm::detail::remove_cvref_t
@@ -48,15 +48,15 @@ class move_only_any {
   private:
     // forward declare cast functions as friends
     template <typename T>
-    friend T move_only_any_cast(const move_only_any &);
+    friend T move_only_any_cast(const move_only_any &operand);
     template <typename T>
-    friend T move_only_any_cast(move_only_any &);
+    friend T move_only_any_cast(move_only_any &operand);
     template <typename T>
-    friend T move_only_any_cast(move_only_any &&);
+    friend T move_only_any_cast(move_only_any &&operand);
     template <typename T>
-    friend const T *move_only_any_cast(const move_only_any *) noexcept;
+    friend const T *move_only_any_cast(const move_only_any *operand) noexcept;
     template <typename T>
-    friend T *move_only_any_cast(move_only_any *) noexcept;
+    friend T *move_only_any_cast(move_only_any *operand) noexcept;
 
     /**
      * @brief Type erase base class, such that `plssvm::detail::move_only_any` does not have to hold a templated member (which is not possible in C++).
@@ -140,8 +140,7 @@ class move_only_any {
      * @tparam ValueType the contained object will have the type `std::decay_t<ValueType>`
      * @param[in,out] value the object to type erase
      */
-    template <typename ValueType,
-              PLSSVM_REQUIRES(!std::is_same_v<std::decay_t<ValueType>, move_only_any>)>
+    template <typename ValueType, PLSSVM_REQUIRES(!std::is_same_v<std::decay_t<ValueType>, move_only_any>)>
     explicit move_only_any(ValueType &&value) :
         object_ptr_{ std::make_unique<type_erasure_wrapper<std::decay_t<ValueType>>>(std::forward<ValueType>(value)) } { }
 
@@ -149,10 +148,11 @@ class move_only_any {
      * @brief Construct a `plssvm::detail::move_only_any` holding an object of type @p ValueType inplace using @p args.
      * @tparam ValueType the contained object will have the type `std::decay_t<ValueType>`
      * @tparam Args the types used to construct @p ValueType
+     * @param[in] in_place_tag used for constructor overloading
      * @param[in,out] args the parameters used to construct an object of type @p ValueType inplace
      */
     template <typename ValueType, typename... Args, PLSSVM_REQUIRES(std::is_constructible_v<std::decay_t<ValueType>, Args...>)>
-    explicit move_only_any(std::in_place_type_t<ValueType>, Args &&...args) :
+    explicit move_only_any([[maybe_unused]] std::in_place_type_t<ValueType> in_place_tag, Args &&...args) :
         object_ptr_{ std::make_unique<type_erasure_wrapper<std::decay_t<ValueType>>>(std::forward<Args>(args)...) } { }
 
     /**
@@ -160,11 +160,12 @@ class move_only_any {
      * @tparam ValueType the contained object will have the type `std::decay_t<ValueType>`
      * @tparam U the types in the `std::initializer_list`
      * @tparam Args the types used to construct @p ValueType
+     * @param[in] in_place_tag used for constructor overloading
      * @param[in] il the `std::initializer_list` to construct an object of type @p ValueType
      * @param[in,out] args the parameters used to construct an object of type @p ValueType inplace
      */
     template <typename ValueType, typename U, typename... Args, PLSSVM_REQUIRES(std::is_constructible_v<std::decay_t<ValueType>, std::initializer_list<U>, Args...>)>
-    explicit move_only_any(std::in_place_type_t<ValueType>, std::initializer_list<U> il, Args &&...args) :
+    explicit move_only_any([[maybe_unused]] std::in_place_type_t<ValueType> in_place_tag, std::initializer_list<U> il, Args &&...args) :
         object_ptr_{ std::make_unique<type_erasure_wrapper<std::decay_t<ValueType>>>(il, std::forward<Args>(args)...) } { }
 
     /**
@@ -283,7 +284,7 @@ template <typename T>
 [[nodiscard]] inline T move_only_any_cast(const move_only_any &operand) {
     using U = detail::remove_cvref_t<T>;
     static_assert(std::is_constructible_v<T, const U &>);
-    if (auto *ptr = move_only_any_cast<U>(&operand)) {
+    if (auto *ptr = move_only_any_cast<U>(&operand); ptr != nullptr) {
         // get the value if possible
         return static_cast<T>(*ptr);
     }
@@ -301,7 +302,7 @@ template <typename T>
 [[nodiscard]] inline T move_only_any_cast(move_only_any &operand) {
     using U = detail::remove_cvref_t<T>;
     static_assert(std::is_constructible_v<T, U &>);
-    if (auto *ptr = move_only_any_cast<U>(&operand)) {
+    if (auto *ptr = move_only_any_cast<U>(&operand); ptr != nullptr) {
         // get the value if possible
         return static_cast<T>(*ptr);
     }
@@ -316,10 +317,10 @@ template <typename T>
  * @return the contained object (`[[nodiscard]]`)
  */
 template <typename T>
-[[nodiscard]] inline T move_only_any_cast(move_only_any &&operand) {
+[[nodiscard]] inline T move_only_any_cast(move_only_any &&operand) {  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved): the object is moved after the cast
     using U = detail::remove_cvref_t<T>;
     static_assert(std::is_constructible_v<T, U>);
-    if (auto *ptr = move_only_any_cast<U>(&operand)) {
+    if (auto *ptr = move_only_any_cast<U>(&operand); ptr != nullptr) {
         // get the value if possible
         return static_cast<T>(std::move(*ptr));
     }
@@ -340,7 +341,8 @@ template <typename T>
     if (operand == nullptr) {
         // return a nullptr if a nullptr is provided
         return nullptr;
-    } else if (auto *ptr = dynamic_cast<const move_only_any::type_erasure_wrapper<U> *>(std::addressof(*operand->object_ptr_))) {
+    }
+    if (auto *ptr = dynamic_cast<const move_only_any::type_erasure_wrapper<U> *>(std::addressof(*operand->object_ptr_)); ptr != nullptr) {
         return std::addressof(ptr->wrapped_object_);
     }
     return nullptr;
@@ -359,7 +361,8 @@ template <typename T>
     if (operand == nullptr) {
         // return a nullptr if a nullptr is provided
         return nullptr;
-    } else if (auto *ptr = dynamic_cast<move_only_any::type_erasure_wrapper<U> *>(std::addressof(*operand->object_ptr_))) {
+    }
+    if (auto *ptr = dynamic_cast<move_only_any::type_erasure_wrapper<U> *>(std::addressof(*operand->object_ptr_)); ptr != nullptr) {
         return std::addressof(ptr->wrapped_object_);
     }
     return nullptr;
@@ -393,4 +396,4 @@ template <typename T, typename U, typename... Args>
 
 }  // namespace plssvm::detail
 
-#endif  // PLSSVM_DETAIL_move_only_any_HPP_
+#endif  // PLSSVM_DETAIL_MOVE_ONLY_ANY_HPP_
diff --git a/include/plssvm/detail/operators.hpp b/include/plssvm/detail/operators.hpp
index adb716bcd..e43a40521 100644
--- a/include/plssvm/detail/operators.hpp
+++ b/include/plssvm/detail/operators.hpp
@@ -19,24 +19,6 @@
 #include <cstddef>  // std::size_t
 #include <vector>   // std::vector
 
-//*************************************************************************************************************************************//
-//                                                          scalar operations                                                          //
-//*************************************************************************************************************************************//
-
-/**
- * @brief Returns +1 if x is positive and -1 if x is negative or 0.
- * @param[in] x the value to calculate the sign for
- * @return the sign value (`[[nodiscard]]`)
- */
-template <typename T>
-[[nodiscard]] inline constexpr T sign(const T x) {
-    return x > T{ 0 } ? T{ +1 } : T{ -1 };
-}
-
-//*************************************************************************************************************************************//
-//                                                        std::vector operations                                                       //
-//*************************************************************************************************************************************//
-
 /**
  * @def PLSSVM_GENERATE_VECTOR_ARITHMETIC_OPERATION
  * @brief Generate arithmetic element-wise operations using @p Op for [`std::vector`](https://en.cppreference.com/w/cpp/container/vector) (and scalars).
@@ -98,6 +80,24 @@ template <typename T>
 
 namespace plssvm::operators {
 
+//*************************************************************************************************************************************//
+//                                                          scalar operations                                                          //
+//*************************************************************************************************************************************//
+
+/**
+ * @brief Returns +1 if x is positive and -1 if x is negative or 0.
+ * @param[in] x the value to calculate the sign for
+ * @return the sign value (`[[nodiscard]]`)
+ */
+template <typename T>
+[[nodiscard]] constexpr T sign(const T x) {
+    return x > T{ 0 } ? T{ +1 } : T{ -1 };
+}
+
+//*************************************************************************************************************************************//
+//                                                        std::vector operations                                                       //
+//*************************************************************************************************************************************//
+
 // define arithmetic operations +-*/ on std::vector
 PLSSVM_GENERATE_VECTOR_ARITHMETIC_OPERATION(+)
 PLSSVM_GENERATE_VECTOR_ARITHMETIC_OPERATION(-)
@@ -119,7 +119,7 @@ PLSSVM_GENERATE_VECTOR_ARITHMETIC_OPERATION(/)
 template <typename T>
 struct transposed {
     /// The encapsulated vector.
-    const std::vector<T> &vec;
+    const std::vector<T> &vec;  // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members): transposed struct only used for function overload selection
 };
 
 /**
diff --git a/include/plssvm/detail/sha256.hpp b/include/plssvm/detail/sha256.hpp
index 9762b87be..0618b4287 100644
--- a/include/plssvm/detail/sha256.hpp
+++ b/include/plssvm/detail/sha256.hpp
@@ -46,7 +46,7 @@ class sha256 {
     template <typename T, PLSSVM_REQUIRES(std::is_unsigned_v<T>)>
     static void unpack(const T x, unsigned char *str) {
         for (std::size_t i = 0; i < sizeof(T); ++i) {
-            str[i] = static_cast<unsigned char>(x >> ((sizeof(T) - i - 1) * 8));
+            str[i] = static_cast<unsigned char>(x >> ((sizeof(T) - i - 1) * 8));  // NOLINT
         }
     }
 
diff --git a/include/plssvm/detail/string_conversion.hpp b/include/plssvm/detail/string_conversion.hpp
index c6dc6ab61..6e4a3a8c6 100644
--- a/include/plssvm/detail/string_conversion.hpp
+++ b/include/plssvm/detail/string_conversion.hpp
@@ -17,7 +17,6 @@
 #include "plssvm/detail/fast_float_wrapper.hpp"    // plssvm::detail::convert_to_floating_point
 #include "plssvm/detail/string_utility.hpp"        // plssvm::detail::{trim, trim_left, as_lower_case, starts_with}
 #include "plssvm/detail/type_traits.hpp"           // PLSSVM_REQUIRES, plssvm::detail::remove_cvref_t
-#include "plssvm/detail/utility.hpp"               // plssvm::detail::unreachable
 
 #include "fmt/format.h"  // fmt::format
 
@@ -27,7 +26,6 @@
 #include <string_view>   // std::string_view
 #include <system_error>  // std:errc
 #include <type_traits>   // std::is_arithmetic_v, std::is_same_v, std::is_floating_point_v, std::is_integral_v
-#include <utility>       // std::pair
 #include <vector>        // std::vector
 
 namespace plssvm::detail {
diff --git a/include/plssvm/detail/tracking/events.hpp b/include/plssvm/detail/tracking/events.hpp
index 7489e1c4b..467a21e0a 100644
--- a/include/plssvm/detail/tracking/events.hpp
+++ b/include/plssvm/detail/tracking/events.hpp
@@ -9,8 +9,8 @@
  * @brief Defines an event type.
  */
 
-#ifndef PLSSVM_DETAIL_TRACKING_EVENT_HPP_
-#define PLSSVM_DETAIL_TRACKING_EVENT_HPP_
+#ifndef PLSSVM_DETAIL_TRACKING_EVENTS_HPP_
+#define PLSSVM_DETAIL_TRACKING_EVENTS_HPP_
 #pragma once
 
 #include "fmt/base.h"     // fmt::formatter
@@ -134,4 +134,4 @@ struct fmt::formatter<plssvm::detail::tracking::events> : fmt::ostream_formatter
 
 /// @endcond
 
-#endif  // PLSSVM_DETAIL_TRACKING_EVENT_HPP_
+#endif  // PLSSVM_DETAIL_TRACKING_EVENTS_HPP_
diff --git a/include/plssvm/detail/tracking/performance_tracker.hpp b/include/plssvm/detail/tracking/performance_tracker.hpp
index ce2394dbd..9c650b639 100644
--- a/include/plssvm/detail/tracking/performance_tracker.hpp
+++ b/include/plssvm/detail/tracking/performance_tracker.hpp
@@ -36,6 +36,7 @@
 
 #include <chrono>       // std::chrono::steady_clock::time_point
 #include <map>          // std::map
+#include <optional>     // std::optional
 #include <ostream>      // std::ostream
 #include <string>       // std::string
 #include <string_view>  // std::string_view
@@ -84,9 +85,9 @@ struct tracking_entry {
     ~tracking_entry() = default;
 
     /// The category to which this tracking entry belongs; used for grouping in the resulting YAML file.
-    const std::string entry_category{};
+    const std::string entry_category;
     /// The name of the tracking entry displayed in the YAML file.
-    const std::string entry_name{};
+    const std::string entry_name;
     /// The tracked value in the YAML file.
     const T entry_value{};
 };
@@ -291,7 +292,7 @@ class performance_tracker {
 
   private:
     /// All tracking entries grouped by their specified categories.
-    std::map<std::string, std::map<std::string, std::vector<std::string>>> tracking_entries_{};
+    std::map<std::string, std::map<std::string, std::vector<std::string>>> tracking_entries_;
     /// The reference time point used for the performance tracking and hardware samples entries.
     std::chrono::steady_clock::time_point reference_time_{ std::chrono::steady_clock::now() };
     /// All special events mainly used for hardware sampling.
@@ -347,6 +348,18 @@ void performance_tracker::add_tracking_entry(const tracking_entry<std::vector<T>
                 byte_values.push_back(mem.num_bytes());
             }
             entry_value_str = fmt::format("[{}]", fmt::join(byte_values, ", "));
+        } else if constexpr (std::is_same_v<T, std::optional<detail::memory_size>>) {
+            // dump all memory sizes in BYTES to the file, pay attention to possible nullopt values
+            std::vector<std::string> byte_values{};
+            byte_values.reserve(entry.entry_value.size());
+            for (const std::optional<memory_size> &mem : entry.entry_value) {
+                if (mem.has_value()) {
+                    byte_values.push_back(fmt::format("{}", mem.value().num_bytes()));
+                } else {
+                    byte_values.emplace_back("nullopt");
+                }
+            }
+            entry_value_str = fmt::format("[{}]", fmt::join(byte_values, ", "));
         } else {
             entry_value_str = fmt::format("[{}]", fmt::join(entry.entry_value, ", "));
         }
diff --git a/include/plssvm/detail/type_traits.hpp b/include/plssvm/detail/type_traits.hpp
index 288f8b80b..e0a74554b 100644
--- a/include/plssvm/detail/type_traits.hpp
+++ b/include/plssvm/detail/type_traits.hpp
@@ -17,8 +17,10 @@
 #include <cstddef>        // std::size_t
 #include <deque>          // std::deque
 #include <forward_list>   // std::forward_list
+#include <functional>     // std::reference_wrapper
 #include <list>           // std::list
 #include <map>            // std::map, std::multimap
+#include <optional>       // std::optional
 #include <set>            // std::set, std::multiset
 #include <string>         // std::basic_string
 #include <type_traits>    // std::enable_if_t, std::remove_cv_t, std::remove_reference_t, std::is_same_v, std::false_type, std::true_type, std::is_same_v
@@ -39,6 +41,12 @@ namespace plssvm::detail {
 template <typename>
 constexpr bool always_false_v = false;
 
+/**
+ * @brief Type-dependent expression that always evaluates to `false`.
+ */
+template <auto>
+constexpr bool always_false_non_type_v = false;
+
 /**
  * @brief Remove the topmost reference- and cv-qualifiers.
  * @details For more information see [`std::remove_cvref_t`](https://en.cppreference.com/w/cpp/types/remove_cvref).
@@ -342,6 +350,44 @@ constexpr bool is_unordered_associative_container_v = is_unordered_set_v<T> || i
 template <typename T>
 constexpr bool is_container_v = is_sequence_container_v<T> || is_associative_container_v<T> || is_unordered_associative_container_v<T>;
 
+/**
+ * @brief Type trait to check whether @p T is a `std::optional`.
+ * @tparam T the type to check
+ */
+template <typename T>
+struct is_optional : std::false_type { };
+
+/**
+ * @copybrief plssvm::detail::is_optional
+ */
+template <typename T>
+struct is_optional<std::optional<T>> : std::true_type { };
+
+/**
+ * @copybrief plssvm::detail::is_optional
+ */
+template <typename T>
+constexpr bool is_optional_v = is_optional<T>::value;
+
+/**
+ * @brief Type trait to check whether @p T is a `std::reference_wrapper`.
+ * @tparam T the type to check
+ */
+template <typename T>
+struct is_reference_wrapper : std::false_type { };
+
+/**
+ * @copybrief plssvm::detail::is_reference_wrapper
+ */
+template <typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type { };
+
+/**
+ * @copybrief plssvm::detail::is_reference_wrapper
+ */
+template <typename T>
+constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value;
+
 /**
  * @brief Check whether @p T is in the type set @p Types.
  */
diff --git a/include/plssvm/detail/utility.hpp b/include/plssvm/detail/utility.hpp
index e81d46ae1..137c8860f 100644
--- a/include/plssvm/detail/utility.hpp
+++ b/include/plssvm/detail/utility.hpp
@@ -19,10 +19,12 @@
 #include <algorithm>    // std::remove_if, std::find
 #include <cstddef>      // std::size_t
 #include <iterator>     // std::distance
+#include <optional>     // std::optional
 #include <string>       // std::string
 #include <string_view>  // std::string_view
 #include <tuple>        // std::forward_as_tuple, std::get
 #include <type_traits>  // std::underlying_type_t, std::is_enum_v
+#include <vector>       // std::vector
 
 /**
  * @brief Helper function for an extra round of macro expansion inside the PLSSVM_IS_DEFINED macro.
@@ -50,6 +52,22 @@
 
 namespace plssvm::detail {
 
+/**
+ * @brief Struct to overload the `operator()` for multiple std::variant members.
+ * @details See: https://en.cppreference.com/w/cpp/utility/variant/visit.
+ * @tparam Ts the overloaded types
+ */
+template <class... Ts>
+struct overloaded : Ts... {
+    using Ts::operator()...;
+};
+
+/**
+ * @brief Custom deduction guide for the `overloaded` struct.
+ */
+template <class... Ts>
+overloaded(Ts...) -> overloaded<Ts...>;
+
 /**
  * @brief Invokes undefined behavior. Used to mark code paths that may never be reachable.
  * @details See: C++23 [`std::unreachable`](https://en.cppreference.com/w/cpp/utility/unreachable)
@@ -128,17 +146,25 @@ inline typename Container::size_type erase_if(Container &c, Pred pred) {
  * @param[in] val the value to check
  * @return `true` if the @p val exists in the container @p c, otherwise `false` (`[[nodiscard]]`)
  */
-template <typename Container, typename T, PLSSVM_REQUIRES(is_container_v<Container> && !is_string_v<Container>)>
+template <typename Container, typename T, PLSSVM_REQUIRES(is_container_v<Container> && !is_string_v<Container>)>  // NOLINT: false positive
 [[nodiscard]] inline bool contains(const Container &c, const T &val) {
     if constexpr (is_sequence_container_v<Container>) {
         // use std::find for sequence containers
         return std::find(c.cbegin(), c.cend(), val) != c.cend();
     } else {
         // use count otherwise
-        return c.count(val) > typename Container::size_type{ 0 };
+        return c.count(val) > typename Container::size_type{ 0 };  // NOLINT: false positive (do not implicitly decay an array into a pointer?)
     }
 }
 
+/**
+ * @brief Check whether the maximum needed local memory, as returned by `plssvm::detail::data_distribution::maximum_local_memory_needed()`,
+ *        does not exceed the available local memory per place provided by @p local_memory.
+ * @param[in] local_memory the available local memory per place; if the respective backend has no notion of local memory, the value is a `std::nullopt`
+ * @throws plssvm::kernel_launch_resources if not enough local memory is available
+ */
+void check_local_memory_usage(const std::vector<std::optional<memory_size>> &local_memory);
+
 /**
  * @brief Return the current date time in the format "YYYY-MM-DD hh:mm:ss".
  * @return the current date time (`[[nodiscard]]`)
@@ -152,6 +178,13 @@ template <typename Container, typename T, PLSSVM_REQUIRES(is_container_v<Contain
  */
 [[nodiscard]] memory_size get_system_memory();
 
+/**
+ * @brief Get the environment variable @p env_variable if it has been set, otherwise returns an empty optional.
+ * @param[in] env_variable the environment variable to retrieve
+ * @return the value of the environment variable if set, otherwise std::nullopt (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::optional<std::string> get_env_variable(const std::string &env_variable);
+
 }  // namespace plssvm::detail
 
 #endif  // PLSSVM_DETAIL_UTILITY_HPP_
diff --git a/include/plssvm/environment.hpp b/include/plssvm/environment.hpp
index 3dec0a5c6..85b990a4d 100644
--- a/include/plssvm/environment.hpp
+++ b/include/plssvm/environment.hpp
@@ -23,12 +23,17 @@
 #include "plssvm/exceptions/exceptions.hpp"  // plssvm::environment_exception
 #include "plssvm/mpi/environment.hpp"        // plssvm::mpi::{is_initialized, init}
 
-#if defined(PLSSVM_HAS_HPX_BACKEND)
+#if defined(PLSSVM_HAS_HPX_BACKEND) || defined(PLSSVM_KOKKOS_BACKEND_ENABLE_HPX)
     #include "hpx/execution.hpp"  // ::hpx::post
+    #if !defined(PLSSVM_HPX_DO_NOT_INCLUDE_HPX_MAIN)
+        #include "hpx/hpx_main.hpp"  // disable support for HPX's short command line aliases
+    #endif
     #include "hpx/hpx_start.hpp"  // ::hpx::{start, stop, finalize}
     #include "hpx/runtime.hpp"    // ::hpx::{is_running, is_stopped}
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
+    #include "plssvm/detail/cmd/utility.hpp"  // plssvm::detail::cmd::filter_argv
+
     #include "Kokkos_Core.hpp"  // Kokkos::is_initialized, Kokkos::is_finalized, Kokkos::initialize, Kokkos::finalize
 #endif
 
@@ -38,7 +43,9 @@
 #include "fmt/ranges.h"   // fmt::join
 
 #include <algorithm>  // std::remove_if
+#include <exception>  // std::exception
 #include <ios>        // std::ios::failbit
+#include <iostream>   // std::cout, std::endl
 #include <istream>    // std::istream
 #include <ostream>    // std::ostream
 #include <string>     // std::string
@@ -118,9 +125,11 @@ namespace detail {
     if (!is_initialized) {
         // Note: ::hpx::is_stopped does return true even before calling finalize once
         return status::uninitialized;
-    } else if (is_initialized && !is_finalized) {
+    }
+    if (is_initialized && !is_finalized) {
         return status::initialized;
-    } else if (is_finalized) {
+    }
+    if (is_finalized) {
         return status::finalized;
     }
     // should never be reached!
@@ -192,7 +201,6 @@ template <auto is_initialized_function, auto is_finalized_function>
  */
 constexpr bool is_initialization_necessary([[maybe_unused]] const backend_type backend) {
     // Note: must be implemented for the backends that need environmental setup
-    // currently false for all available backends
     return backend == backend_type::hpx || backend == backend_type::kokkos;
 }
 
@@ -239,7 +247,13 @@ inline void initialize_backend([[maybe_unused]] const backend_type backend, [[ma
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
     if (backend == backend_type::kokkos) {
-        Kokkos::initialize(argc, argv);
+    #if defined(PLSSVM_KOKKOS_BACKEND_ENABLE_HPX)
+        ::hpx::start(nullptr, argc, argv);
+    #endif
+        // we have to filter out our "--kokkos_execution_space" command line option or Kokkos itself will issue a warning on the command line
+        std::vector<char *> filtered_argv = plssvm::detail::cmd::filter_argv(argc, argv, { "--kokkos_" });
+        int filtered_argc = static_cast<int>(filtered_argv.size());
+        Kokkos::initialize(filtered_argc, filtered_argv.data());
     }
 #endif
 }
@@ -328,10 +342,9 @@ inline void get_filtered_backends(std::vector<backend_type> &backends, const sta
                        if (backend == backend_type::automatic) {
                            // always remove the automatic backend
                            return true;
-                       } else {
-                           // remove all backends for which the filter isn't true
-                           return get_backend_status(backend) != s;
                        }
+                       // remove all backends for which the filter isn't true
+                       return get_backend_status(backend) != s;
                    }),
                    backends.end());
 }
@@ -536,12 +549,18 @@ class [[nodiscard]] scope_guard {
      * @brief Finalize all previously initialized backends.
      */
     ~scope_guard() {
-        finalize(backends_);
+        try {
+            finalize(backends_);
+        } catch (const environment_exception &e) {
+            std::cout << e.what_with_loc() << std::endl;
+        } catch (const std::exception &e) {
+            std::cout << e.what() << std::endl;
+        }
     }
 
   private:
     /// The backends that should be initialized IF it is necessary for them or all available if empty.
-    std::vector<backend_type> backends_{};
+    std::vector<backend_type> backends_;
 };
 
 }  // namespace plssvm::environment
diff --git a/include/plssvm/gamma.hpp b/include/plssvm/gamma.hpp
index 61137ad09..25c47984b 100644
--- a/include/plssvm/gamma.hpp
+++ b/include/plssvm/gamma.hpp
@@ -13,9 +13,9 @@
 #define PLSSVM_GAMMA_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"         // plssvm::real_type
-#include "plssvm/detail/operators.hpp"  // plssvm::operators namespace
-#include "plssvm/matrix.hpp"            // plssvm::matrix, plssvm::layout_type, plssvm::variance
+#include "plssvm/constants.hpp"       // plssvm::real_type
+#include "plssvm/detail/utility.hpp"  // plssvm::detail::overloaded
+#include "plssvm/matrix.hpp"          // plssvm::matrix, plssvm::layout_type, plssvm::variance
 
 #include "fmt/base.h"     // fmt::formatter
 #include "fmt/ostream.h"  // fmt::ostream_formatter
@@ -26,26 +26,6 @@
 
 namespace plssvm {
 
-namespace detail {
-
-/**
- * @brief Struct to overload the `operator()` for multiple std::variant members.
- * @details See: https://en.cppreference.com/w/cpp/utility/variant/visit.
- * @tparam Ts the overloaded types
- */
-template <class... Ts>
-struct overloaded : Ts... {
-    using Ts::operator()...;
-};
-
-/**
- * @brief Custom deduction guide for the `overloaded` struct.
- */
-template <class... Ts>
-overloaded(Ts...) -> overloaded<Ts...>;
-
-}  // namespace detail
-
 /**
  * @brief Enum class for all possible gamma coefficient types.
  */
diff --git a/include/plssvm/kernel_functions.hpp b/include/plssvm/kernel_functions.hpp
index a846d68b2..ef1fef38f 100644
--- a/include/plssvm/kernel_functions.hpp
+++ b/include/plssvm/kernel_functions.hpp
@@ -45,7 +45,7 @@ namespace plssvm {
  */
 template <kernel_function_type kernel, typename T, typename... Args>
 [[nodiscard]] inline T kernel_function(const std::vector<T> &xi, const std::vector<T> &xj, Args... args) {
-    using namespace plssvm::operators;
+    using namespace plssvm::operators;  // NOLINT(google-build-using-namespace): only imports custom math operations on vectors (and scalars)
 
     PLSSVM_ASSERT(xi.size() == xj.size(), "Sizes mismatch!: {} != {}", xi.size(), xj.size());
 
diff --git a/include/plssvm/matrix.hpp b/include/plssvm/matrix.hpp
index 95513f0f5..90f2313f3 100644
--- a/include/plssvm/matrix.hpp
+++ b/include/plssvm/matrix.hpp
@@ -9,8 +9,8 @@
  * @brief Defines a matrix class used to hiding the data linearization using AoS and SoA.
  */
 
-#ifndef PLSSVM_DETAIL_MATRIX_HPP_
-#define PLSSVM_DETAIL_MATRIX_HPP_
+#ifndef PLSSVM_MATRIX_HPP_
+#define PLSSVM_MATRIX_HPP_
 #pragma once
 
 #include "plssvm/detail/assert.hpp"                 // PLSSVM_ASSERT
@@ -273,7 +273,7 @@ class matrix {
      * @brief Checks whether this matrix contains any padding entries.
      * @return `true` if this matrix is padded, `false` otherwise (`[[nodiscard]]`)
      */
-    [[nodiscard]] bool is_padded() const noexcept { return !(padding_.x == 0 && padding_.y == 0); }
+    [[nodiscard]] bool is_padded() const noexcept { return padding_.x != 0 || padding_.y != 0; }
 
     /**
      * @brief Restore the padding entries, i.e., explicitly set all padding entries to `0` again.
@@ -285,7 +285,7 @@ class matrix {
      * @details The layout type is either Array-of-Structs (AoS) or Struct-of-Arrays (SoA).
      * @return the layout type (`[[nodiscard]]`)
      */
-    [[nodiscard]] static constexpr layout_type layout() noexcept { return layout_; }
+    [[nodiscard]] constexpr static layout_type layout() noexcept { return layout_; }
 
     /**
      * @brief Returns the value at @p row and @p col as defined by the matrix's layout type.
@@ -403,9 +403,9 @@ class matrix {
     }
 
     /// The shape of the matrix.
-    plssvm::shape shape_{};
+    plssvm::shape shape_;
     /// The shape of the padding for each row and column.
-    plssvm::shape padding_{};
+    plssvm::shape padding_;
     /// The (linearized, either in AoS or SoA layout) data.
     std::vector<value_type> data_{};
 };
@@ -625,7 +625,7 @@ void matrix<T, layout_>::restore_padding() noexcept {
 }
 
 template <typename T, layout_type layout_>
-auto matrix<T, layout_>::operator()(const size_type row, const size_type col) const -> value_type {
+typename matrix<T, layout_>::value_type matrix<T, layout_>::operator()(const size_type row, const size_type col) const {
     PLSSVM_ASSERT(row < this->num_rows_padded(), fmt::format("The current row ({}) must be smaller than the number of padded rows ({})!", row, this->num_rows_padded()));
     PLSSVM_ASSERT(col < this->num_cols_padded(), fmt::format("The current column ({}) must be smaller than the number of padded columns ({})!", col, this->num_cols_padded()));
     if constexpr (layout_ == layout_type::aos) {
@@ -639,7 +639,7 @@ auto matrix<T, layout_>::operator()(const size_type row, const size_type col) co
 }
 
 template <typename T, layout_type layout_>
-auto matrix<T, layout_>::operator()(const size_type row, const size_type col) -> reference {
+typename matrix<T, layout_>::reference matrix<T, layout_>::operator()(const size_type row, const size_type col) {
     PLSSVM_ASSERT(row < this->num_rows_padded(), fmt::format("The current row ({}) must be smaller than the number of padded rows ({})!", row, this->num_rows_padded()));
     PLSSVM_ASSERT(col < this->num_cols_padded(), fmt::format("The current column ({}) must be smaller than the number of padded columns ({})!", col, this->num_cols_padded()));
     if constexpr (layout_ == layout_type::aos) {
@@ -653,10 +653,11 @@ auto matrix<T, layout_>::operator()(const size_type row, const size_type col) ->
 }
 
 template <typename T, layout_type layout_>
-auto matrix<T, layout_>::at(const size_type row, const size_type col) const -> value_type {
+typename matrix<T, layout_>::value_type matrix<T, layout_>::at(const size_type row, const size_type col) const {
     if (row >= this->num_rows_padded()) {
         throw matrix_exception{ fmt::format("The current row ({}) must be smaller than the number of rows including padding ({} + {})!", row, this->num_rows(), padding_.x) };
-    } else if (row >= this->num_rows()) {
+    }
+    if (row >= this->num_rows()) {
         detail::log_untracked(verbosity_level::full | verbosity_level::warning,
                               "WARNING: attempting to access padding row {} (only {} real rows exist)!\n",
                               row,
@@ -664,7 +665,8 @@ auto matrix<T, layout_>::at(const size_type row, const size_type col) const -> v
     }
     if (col >= this->num_cols_padded()) {
         throw matrix_exception{ fmt::format("The current column ({}) must be smaller than the number of columns including padding ({} + {})!", col, this->num_cols(), padding_.y) };
-    } else if (col >= this->num_cols()) {
+    }
+    if (col >= this->num_cols()) {
         detail::log_untracked(verbosity_level::full | verbosity_level::warning,
                               "WARNING: attempting to access padding column {} (only {} real columns exist)!\n",
                               col,
@@ -675,10 +677,11 @@ auto matrix<T, layout_>::at(const size_type row, const size_type col) const -> v
 }
 
 template <typename T, layout_type layout_>
-auto matrix<T, layout_>::at(const size_type row, const size_type col) -> reference {
+typename matrix<T, layout_>::reference matrix<T, layout_>::at(const size_type row, const size_type col) {
     if (row >= this->num_rows_padded()) {
         throw matrix_exception{ fmt::format("The current row ({}) must be smaller than the number of rows including padding ({} + {})!", row, this->num_rows(), padding_.x) };
-    } else if (row >= this->num_rows()) {
+    }
+    if (row >= this->num_rows()) {
         detail::log_untracked(verbosity_level::full | verbosity_level::warning,
                               "WARNING: attempting to access padding row {} (only {} real rows exist)!\n",
                               row,
@@ -686,7 +689,8 @@ auto matrix<T, layout_>::at(const size_type row, const size_type col) -> referen
     }
     if (col >= this->num_cols_padded()) {
         throw matrix_exception{ fmt::format("The current column ({}) must be smaller than the number of columns including padding ({} + {})!", col, this->num_cols(), padding_.y) };
-    } else if (col >= this->num_cols()) {
+    }
+    if (col >= this->num_cols()) {
         detail::log_untracked(verbosity_level::full | verbosity_level::warning,
                               "WARNING: attempting to access padding column {} (only {} real columns exist)!\n",
                               col,
@@ -697,19 +701,19 @@ auto matrix<T, layout_>::at(const size_type row, const size_type col) -> referen
 }
 
 template <typename T, layout_type layout_>
-auto matrix<T, layout_>::operator[](const size_type idx) const -> value_type {
+typename matrix<T, layout_>::value_type matrix<T, layout_>::operator[](const size_type idx) const {
     PLSSVM_ASSERT(idx < this->size_padded(), fmt::format("The current index ({}) must be smaller than the total number of matrix entries ({})!", idx, this->size_padded()));
     return data_[idx];
 }
 
 template <typename T, layout_type layout_>
-auto matrix<T, layout_>::operator[](const size_type idx) -> reference {
+typename matrix<T, layout_>::reference matrix<T, layout_>::operator[](const size_type idx) {
     PLSSVM_ASSERT(idx < this->size_padded(), fmt::format("The current index ({}) must be smaller than the total number of matrix entries ({})!", idx, this->size_padded()));
     return data_[idx];
 }
 
 template <typename T, layout_type layout_>
-auto matrix<T, layout_>::at(const size_type idx) const -> value_type {
+typename matrix<T, layout_>::value_type matrix<T, layout_>::at(const size_type idx) const {
     if (idx >= this->size_padded()) {
         throw matrix_exception{ fmt::format("The current index ({}) must be smaller than the total number of matrix entries ({})!", idx, this->size_padded()) };
     }
@@ -717,7 +721,7 @@ auto matrix<T, layout_>::at(const size_type idx) const -> value_type {
 }
 
 template <typename T, layout_type layout_>
-auto matrix<T, layout_>::at(const size_type idx) -> reference {
+typename matrix<T, layout_>::reference matrix<T, layout_>::at(const size_type idx) {
     if (idx >= this->size_padded()) {
         throw matrix_exception{ fmt::format("The current index ({}) must be smaller than the total number of matrix entries ({})!", idx, this->size_padded()) };
     }
@@ -883,7 +887,8 @@ template <typename T, layout_type layout>
  */
 template <typename T, layout_type layout>
 [[nodiscard]] matrix<T, layout> operator*(const T scale, matrix<T, layout> matr) {
-    return matr * scale;
+    matr *= scale;
+    return matr;
 }
 
 /**
@@ -1143,8 +1148,8 @@ struct fmt::formatter<plssvm::matrix<T, layout>> {
      */
     template <typename ParseContext>
     constexpr auto parse(ParseContext &ctx) {
-        auto it = ctx.begin(), end = ctx.end();
-        if (it == end) {
+        auto it = ctx.begin();
+        if (it == ctx.end()) {
             return it;
         }
         // check whether the format specifier p has been provided
@@ -1199,4 +1204,4 @@ struct fmt::formatter<plssvm::matrix<T, layout>> {
 
 /// @endcond
 
-#endif  // PLSSVM_DETAIL_MATRIX_HPP_
+#endif  // PLSSVM_MATRIX_HPP_
diff --git a/include/plssvm/model/classification_model.hpp b/include/plssvm/model/classification_model.hpp
index c63081a39..8fa301b01 100644
--- a/include/plssvm/model/classification_model.hpp
+++ b/include/plssvm/model/classification_model.hpp
@@ -16,14 +16,14 @@
 #include "plssvm/classification_types.hpp"                           // plssvm::classification_type
 #include "plssvm/constants.hpp"                                      // plssvm::real_type
 #include "plssvm/data_set/classification_data_set.hpp"               // plssvm::classification_data_set
-#include "plssvm/data_set/data_set.hpp"                              // plssvm::data_set
 #include "plssvm/detail/assert.hpp"                                  // PLSSVM_ASSERT
 #include "plssvm/detail/io/classification_libsvm_model_parsing.hpp"  // plssvm::detail::io::{parse_libsvm_model_header_classification, parse_libsvm_model_data_classification, write_libsvm_model_data_classification}
 #include "plssvm/detail/io/file_reader.hpp"                          // plssvm::detail::io::file_reader
 #include "plssvm/detail/logging/mpi_log.hpp"                         // plssvm::detail::log
 #include "plssvm/detail/tracking/performance_tracker.hpp"            // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY, plssvm::detail::tracking::tracking_entry
 #include "plssvm/detail/type_list.hpp"                               // plssvm::detail::{supported_label_types, tuple_contains_v}
-#include "plssvm/matrix.hpp"                                         // plssvm::soa_matrix, plssvm::aos_matrix
+#include "plssvm/exceptions/exceptions.hpp"                          // plssvm::exception
+#include "plssvm/matrix.hpp"                                         // plssvm::soa_matrix
 #include "plssvm/model/model.hpp"                                    // plssvm::model
 #include "plssvm/mpi/communicator.hpp"                               // plssvm::mpi::communicator
 #include "plssvm/parameter.hpp"                                      // plssvm::parameter
@@ -109,14 +109,20 @@ class classification_model : public model<U> {
      *          It is the same as: `model.classes().size()`
      * @return the number of classes (`[[nodiscard]]`)
      */
-    [[nodiscard]] size_type num_classes() const noexcept { return dynamic_cast<classification_data_set<label_type> &>(*data_).num_classes(); }
+    [[nodiscard]] size_type num_classes() const noexcept { return dynamic_cast<const classification_data_set<label_type> &>(*data_).num_classes(); }
 
     /**
      * @brief Returns the classes of the support vectors.
      * @details If the support vectors contain the labels `std::vector<int>{ -1, 1, 1, -1, -1, 1 }`, this function returns the classes `{ -1, 1 }`.
      * @return all classes (`[[nodiscard]]`)
      */
-    [[nodiscard]] std::vector<label_type> classes() const { return dynamic_cast<classification_data_set<label_type> &>(*data_).classes().value(); }
+    [[nodiscard]] std::vector<label_type> classes() const {
+        const auto classes_opt = dynamic_cast<const classification_data_set<label_type> &>(*data_).classes();
+        if (!classes_opt.has_value()) {
+            throw exception{ "No classes provided (this should NEVER be the case)!" };
+        }
+        return classes_opt.value();
+    }
 
     /**
      * @brief Returns the multi-class classification strategy used to ft this model.
diff --git a/include/plssvm/model/model.hpp b/include/plssvm/model/model.hpp
index af35982dc..a80f2cca8 100644
--- a/include/plssvm/model/model.hpp
+++ b/include/plssvm/model/model.hpp
@@ -157,7 +157,7 @@ class model {
     model(parameter params, std::shared_ptr<data_set<label_type>> data);
 
     /// The SVM parameter used to learn this model.
-    parameter params_{};
+    parameter params_;
     /// The data (support vectors + respective label) used to learn this model.
     std::shared_ptr<data_set<label_type>> data_{};
     /// The number of support vectors representing this model.
@@ -165,10 +165,10 @@ class model {
     /// The number of features per support vector.
     size_type num_features_{ 0 };
     /// The number of iterations needed to fit this model.
-    std::optional<std::vector<unsigned long long>> num_iters_{};
+    std::optional<std::vector<unsigned long long>> num_iters_;
 
     /// The used MPI communicator.
-    mpi::communicator comm_{};
+    mpi::communicator comm_;
 
     /**
      * @brief The learned weights for each support vector.
@@ -199,7 +199,7 @@ model<U>::model(mpi::communicator comm) :
 
 template <typename U>
 model<U>::model(parameter params, std::shared_ptr<data_set<label_type>> data) :
-    params_{ std::move(params) },
+    params_{ params },
     data_{ std::move(data) },
     num_support_vectors_{ data_->num_data_points() },
     num_features_{ data_->num_features() },
diff --git a/include/plssvm/model/regression_model.hpp b/include/plssvm/model/regression_model.hpp
index 77bb78aee..c3dc61611 100644
--- a/include/plssvm/model/regression_model.hpp
+++ b/include/plssvm/model/regression_model.hpp
@@ -14,14 +14,13 @@
 #pragma once
 
 #include "plssvm/constants.hpp"                                  // plssvm::real_type
-#include "plssvm/data_set/data_set.hpp"                          // plssvm::data_set
 #include "plssvm/data_set/regression_data_set.hpp"               // plssvm::regression_data_set
 #include "plssvm/detail/io/file_reader.hpp"                      // plssvm::detail::io::file_reader
 #include "plssvm/detail/io/regression_libsvm_model_parsing.hpp"  // plssvm::detail::io::{parse_libsvm_model_header_regression, parse_libsvm_model_data_regression, write_libsvm_model_data_regression}
 #include "plssvm/detail/logging/mpi_log.hpp"                     // plssvm::detail::log
 #include "plssvm/detail/tracking/performance_tracker.hpp"        // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY, plssvm::detail::tracking::tracking_entry
 #include "plssvm/detail/type_list.hpp"                           // plssvm::detail::{supported_label_types, tuple_contains_v}
-#include "plssvm/matrix.hpp"                                     // plssvm::soa_matrix, plssvm::aos_matrix
+#include "plssvm/matrix.hpp"                                     // plssvm::soa_matrix
 #include "plssvm/model/model.hpp"                                // plssvm::model
 #include "plssvm/mpi/communicator.hpp"                           // plssvm::mpi::communicator
 #include "plssvm/parameter.hpp"                                  // plssvm::parameter
diff --git a/include/plssvm/mpi/communicator.hpp b/include/plssvm/mpi/communicator.hpp
index 886d13427..e88d874b6 100644
--- a/include/plssvm/mpi/communicator.hpp
+++ b/include/plssvm/mpi/communicator.hpp
@@ -198,7 +198,7 @@ class communicator {
      * @brief Add implicit conversion operator back to a native MPI communicator.
      * @return The wrapped MPI communicator (`[[nodiscard]]`)
      */
-    [[nodiscard]] operator MPI_Comm() const { return comm_; }
+    [[nodiscard]] operator MPI_Comm() const { return comm_; }  // NOLINT: implicit conversion desired
 #endif
 
     /**
@@ -236,7 +236,7 @@ class communicator {
     MPI_Comm comm_{ MPI_COMM_WORLD };
 #endif
     /// The MPI load balancing weights. Always guaranteed to be the same size as the communicator size.
-    std::optional<std::vector<std::size_t>> load_balancing_weights_{ std::nullopt };
+    std::optional<std::vector<std::size_t>> load_balancing_weights_;
 };
 
 }  // namespace plssvm::mpi
diff --git a/include/plssvm/mpi/detail/mpi_datatype.hpp b/include/plssvm/mpi/detail/mpi_datatype.hpp
index c9efa2e43..8f30bd12c 100644
--- a/include/plssvm/mpi/detail/mpi_datatype.hpp
+++ b/include/plssvm/mpi/detail/mpi_datatype.hpp
@@ -39,7 +39,7 @@ namespace plssvm::mpi::detail {
  * @return the corresponding MPI_Datatype (`[[nodiscard]]`)
  */
 template <typename T, std::enable_if_t<!std::is_enum_v<T>, bool> = true>
-[[nodiscard]] inline MPI_Datatype mpi_datatype() = delete;
+[[nodiscard]] MPI_Datatype mpi_datatype() = delete;
 
 PLSSVM_CREATE_MPI_DATATYPE_MAPPING(bool, MPI_C_BOOL)
 
diff --git a/include/plssvm/mpi/detail/version.hpp b/include/plssvm/mpi/detail/version.hpp
index 2fb5aff69..b87eecd65 100644
--- a/include/plssvm/mpi/detail/version.hpp
+++ b/include/plssvm/mpi/detail/version.hpp
@@ -11,6 +11,7 @@
 
 #ifndef PLSSVM_MPI_DETAIL_VERSION_HPP_
 #define PLSSVM_MPI_DETAIL_VERSION_HPP_
+#pragma once
 
 #include <string>  // std::string
 
diff --git a/include/plssvm/parameter.hpp b/include/plssvm/parameter.hpp
index 378c3d3ea..3b0b7822a 100644
--- a/include/plssvm/parameter.hpp
+++ b/include/plssvm/parameter.hpp
@@ -30,6 +30,7 @@
 
 #include <iosfwd>       // forward declare std::ostream and std::istream
 #include <string_view>  // std::string_view
+#include <type_traits>  // std::underlying_type_t
 #include <utility>      // std::forward
 #include <variant>      // std::variant, std::holds_alternative, std::get
 
@@ -57,8 +58,8 @@ IGOR_MAKE_NAMED_ARGUMENT(solver);
 IGOR_MAKE_NAMED_ARGUMENT(classification);
 /// Create a named argument for the SYCL backend specific SYCL implementation type (DPC++ or AdaptiveCpp).
 IGOR_MAKE_NAMED_ARGUMENT(sycl_implementation_type);
-/// Create a named argument for the SYCL backend specific kernel invocation type.
-IGOR_MAKE_NAMED_ARGUMENT(sycl_kernel_invocation_type);
+/// Create a named argument for the SYCL backend specific data parallel kernels.
+IGOR_MAKE_NAMED_ARGUMENT(sycl_data_parallel_kernel);
 /// Create a named argument for the Kokkos backend specific execution space.
 IGOR_MAKE_NAMED_ARGUMENT(kokkos_execution_space);
 
@@ -76,13 +77,13 @@ constexpr bool has_only_parameter_named_args_v = !igor::has_other_than<Args...>(
  * @brief Trait to check whether @p Args only contains named-parameter that can be used to initialize a `plssvm::parameter` struct including SYCL specific named-parameters.
  */
 template <typename... Args>
-constexpr bool has_only_sycl_parameter_named_args_v = !igor::has_other_than<Args...>(plssvm::kernel_type, plssvm::gamma, plssvm::degree, plssvm::coef0, plssvm::cost, plssvm::sycl_implementation_type, plssvm::sycl_kernel_invocation_type);
+constexpr bool has_only_sycl_parameter_named_args_v = !igor::has_other_than<Args...>(plssvm::kernel_type, plssvm::gamma, plssvm::degree, plssvm::coef0, plssvm::cost, plssvm::sycl_implementation_type, plssvm::sycl_data_parallel_kernel);
 
 /**
  * @brief Trait to check whether @p Args only contains SYCL specific named-parameters.
  */
 template <typename... Args>
-constexpr bool has_only_sycl_named_args_v = !igor::has_other_than<Args...>(plssvm::sycl_implementation_type, plssvm::sycl_kernel_invocation_type);
+constexpr bool has_only_sycl_named_args_v = !igor::has_other_than<Args...>(plssvm::sycl_implementation_type, plssvm::sycl_data_parallel_kernel);
 
 /**
  * @brief Trait to check whether @p Args only contains named-parameter that can be used to initialize a `plssvm::parameter` struct including Kokkos specific named-parameters.
@@ -126,7 +127,7 @@ struct parameter {
         gamma{ gamma_p },
         coef0{ coef0_p },
         cost{ cost_p } {
-        // sanity check the provided parameter values
+        // check the provided parameter values
         this->sanity_check_parameter();
     }
 
@@ -140,7 +141,7 @@ struct parameter {
     explicit parameter(const parameter &params, Args &&...named_args) :
         parameter{ params } {
         this->set_named_arguments(std::forward<Args>(named_args)...);
-        // sanity check the provided parameter values
+        // check the provided parameter values
         this->sanity_check_parameter();
     }
 
@@ -152,7 +153,7 @@ struct parameter {
     template <typename... Args, PLSSVM_REQUIRES(detail::has_only_named_args_v<Args...>)>
     constexpr explicit parameter(Args &&...named_args) {
         this->set_named_arguments(std::forward<Args>(named_args)...);
-        // sanity check the provided parameter values
+        // check the provided parameter values
         this->sanity_check_parameter();
     }
 
@@ -175,7 +176,7 @@ struct parameter {
      * @param[in] other the other parameter set compared to this one
      * @return `true` if both parameter sets are equivalent, `false` otherwise (`[[nodiscard]]`)
      */
-    [[nodiscard]] constexpr bool equivalent(const parameter &other) const noexcept {
+    [[nodiscard]] constexpr bool equivalent(const parameter &other) const {
         // equality check, but only the member variables that a necessary for the current kernel type are compared!
         // cannot be equal if both parameters have different kernel types
         if (kernel_type != other.kernel_type) {
@@ -208,14 +209,14 @@ struct parameter {
      */
     template <typename... Args>
     void set_named_arguments(Args &&...named_args) {
-        igor::parser parser{ std::forward<Args>(named_args)... };
+        const igor::parser parser{ std::forward<Args>(named_args)... };
 
         // compile time check: only named parameter are permitted
         static_assert(!parser.has_unnamed_arguments(), "Can only use named parameter!");
         // compile time check: each named parameter must only be passed once
         static_assert(!parser.has_duplicates(), "Can only use each named parameter once!");
         // compile time check: only some named parameters are allowed
-        static_assert(!parser.has_other_than(plssvm::kernel_type, plssvm::gamma, plssvm::degree, plssvm::coef0, plssvm::cost, plssvm::sycl_implementation_type, plssvm::sycl_kernel_invocation_type, plssvm::kokkos_execution_space),
+        static_assert(!parser.has_other_than(plssvm::kernel_type, plssvm::gamma, plssvm::degree, plssvm::coef0, plssvm::cost, plssvm::sycl_implementation_type, plssvm::sycl_data_parallel_kernel, plssvm::kokkos_execution_space),
                       "An illegal named parameter has been passed!");
 
         // shorthand function for emitting a warning if a provided parameter is not used by the current kernel function
@@ -276,9 +277,10 @@ struct parameter {
      * @throws plssvm::invalid_parameter_exception if the gamma value for the polynomial or radial basis function kernel is **not** greater than zero
      */
     void sanity_check_parameter() const {
+        constexpr static std::underlying_type_t<kernel_function_type> num_kernel_functions = 6;
         // kernel: valid kernel function
         const auto kernel_type_value = detail::to_underlying(kernel_type);
-        if (kernel_type_value < 0 || kernel_type_value >= 6) {
+        if (kernel_type_value < 0 || kernel_type_value >= num_kernel_functions) {
             throw invalid_parameter_exception{ fmt::format("Invalid kernel function with value {} given!", kernel_type_value) };
         }
 
@@ -308,7 +310,7 @@ struct parameter {
  * @param[in] rhs the second parameter set
  * @return `true` if both parameter sets are equal, `false` otherwise (`[[nodiscard]]`)
  */
-[[nodiscard]] constexpr bool operator==(const parameter &lhs, const parameter &rhs) noexcept {
+[[nodiscard]] constexpr bool operator==(const parameter &lhs, const parameter &rhs) {
     return lhs.kernel_type == rhs.kernel_type && lhs.degree == rhs.degree && lhs.gamma == rhs.gamma && lhs.coef0 == rhs.coef0 && lhs.cost == rhs.cost;
 }
 
@@ -319,7 +321,7 @@ struct parameter {
  * @param[in] rhs the second parameter set
  * @return `true` if both parameter sets are unequal, `false` otherwise (`[[nodiscard]]`)
  */
-[[nodiscard]] constexpr bool operator!=(const parameter &lhs, const parameter &rhs) noexcept {
+[[nodiscard]] constexpr bool operator!=(const parameter &lhs, const parameter &rhs) {
     return !(lhs == rhs);
 }
 
@@ -332,7 +334,7 @@ struct parameter {
  * @param[in] rhs the second parameter set
  * @return `true` if both parameter sets are equivalent, `false` otherwise (`[[nodiscard]]`)
  */
-[[nodiscard]] constexpr bool equivalent(const parameter &lhs, const parameter &rhs) noexcept {
+[[nodiscard]] constexpr bool equivalent(const parameter &lhs, const parameter &rhs) {
     return lhs.equivalent(rhs);
 }
 
diff --git a/include/plssvm/regression_report.hpp b/include/plssvm/regression_report.hpp
index b8f6cc230..a1b330100 100644
--- a/include/plssvm/regression_report.hpp
+++ b/include/plssvm/regression_report.hpp
@@ -21,11 +21,12 @@
 #include "fmt/ostream.h"  // fmt::ostream_formatter
 #include "igor/igor.hpp"  // IGOR_MAKE_NAMED_ARGUMENT, igor::parser, igor::has_unnamed_arguments, igor::has_other_than
 
-#include <algorithm>  // std::clamp
-#include <cmath>      // std::abs
-#include <cstddef>    // std::size_t
-#include <iosfwd>     // std::ostream
-#include <vector>     // std::vector
+#include <cmath>    // std::abs, std::isnan
+#include <cstddef>  // std::size_t
+#include <iosfwd>   // std::ostream
+#include <limits>   // std::numeric_limits::infinity
+#include <utility>  // std::forward
+#include <vector>   // std::vector
 
 namespace plssvm {
 
@@ -83,7 +84,7 @@ class regression_report {
 
 template <typename label_type, typename... Args>
 regression_report::regression_report(const std::vector<label_type> &correct_label, const std::vector<label_type> &predicted_label, Args &&...named_args) {
-    // sanity check for input correct sizes
+    // perform sanity checks on the sizes of the input vectors
     if (correct_label.empty()) {
         throw regression_report_exception{ "The correct labels list must not be empty!" };
     }
@@ -94,7 +95,7 @@ regression_report::regression_report(const std::vector<label_type> &correct_labe
         throw regression_report_exception{ fmt::format("The number of correct labels ({}) and predicted labels ({}) must be the same!", correct_label.size(), predicted_label.size()) };
     }
 
-    igor::parser parser{ std::forward<Args>(named_args)... };
+    const igor::parser parser{ std::forward<Args>(named_args)... };
 
     // compile time check: only named parameter are permitted
     static_assert(!parser.has_unnamed_arguments(), "Can only use named parameter!");
@@ -103,7 +104,7 @@ regression_report::regression_report(const std::vector<label_type> &correct_labe
     // compile time check: only some named parameters are allowed
     static_assert(!parser.has_other_than(plssvm::regression_report::force_finite), "An illegal named parameter has been passed!");
 
-    bool force_finite_value{ true };
+    bool force_finite_value{ true };  // NOLINT: can be modified in compile-time if later on
     // compile time/runtime check: the values must have the correct types
     if constexpr (parser.has(plssvm::regression_report::force_finite)) {
         // get the value of the provided named parameter
diff --git a/include/plssvm/shape.hpp b/include/plssvm/shape.hpp
index fb6c4e671..c5595bc43 100644
--- a/include/plssvm/shape.hpp
+++ b/include/plssvm/shape.hpp
@@ -40,7 +40,7 @@ struct [[nodiscard]] shape {
     explicit shape(std::size_t x_p, std::size_t y_p) noexcept;
 
     /**
-     * @brief Swap the shape dimensions of `*this* with the ones of @p other.
+     * @brief Swap the shape dimensions of `*this` with the ones of @p other.
      * @param[in,out] other the other shape
      */
     void swap(shape &other) noexcept;
@@ -108,7 +108,7 @@ struct hash<plssvm::shape> {
     std::size_t operator()(const plssvm::shape &s) const noexcept {
         // based on boost::hash<std::pair<T, U>>>
         const auto hash_combine = [](std::size_t &seed, const std::size_t val) {
-            seed ^= std::hash<std::size_t>{}(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+            seed ^= std::hash<std::size_t>{}(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);  // NOLINT: taken from boost::hash_combine
         };
 
         std::size_t seed = 0;
diff --git a/include/plssvm/solver_types.hpp b/include/plssvm/solver_types.hpp
index 3bcbe68f9..2a246823b 100644
--- a/include/plssvm/solver_types.hpp
+++ b/include/plssvm/solver_types.hpp
@@ -6,11 +6,11 @@
  * @license This file is part of the PLSSVM project which is released under the MIT license.
  *          See the LICENSE.md file in the project root for full license information.
  *
- * @brief Defines an enumeration holding all possible algorithm variations used to solve the LSSVM's system of linear equations.
+ * @brief Defines an enumeration holding all possible algorithm variations used to solve the LS-SVM's system of linear equations.
  */
 
-#ifndef PLSSVM_SOLVING_TYPES_HPP_
-#define PLSSVM_SOLVING_TYPES_HPP_
+#ifndef PLSSVM_SOLVER_TYPES_HPP_
+#define PLSSVM_SOLVER_TYPES_HPP_
 #pragma once
 
 #include "fmt/base.h"     // fmt::formatter
@@ -61,4 +61,4 @@ struct fmt::formatter<plssvm::solver_type> : fmt::ostream_formatter { };
 
 /// @endcond
 
-#endif  // PLSSVM_SOLVING_TYPES_HPP_
+#endif  // PLSSVM_SOLVER_TYPES_HPP_
diff --git a/include/plssvm/svm/csvc.hpp b/include/plssvm/svm/csvc.hpp
index 5a1de4ff5..4d5606e4e 100644
--- a/include/plssvm/svm/csvc.hpp
+++ b/include/plssvm/svm/csvc.hpp
@@ -21,7 +21,7 @@
 #include "plssvm/detail/logging/mpi_log.hpp"               // plssvm::detail::log
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"     // plssvm::detail::log_untracked
 #include "plssvm/detail/tracking/performance_tracker.hpp"  // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT, plssvm::detail::tracking::tracking_entry
-#include "plssvm/detail/utility.hpp"                       // plssvm::detail::contains
+#include "plssvm/detail/utility.hpp"                       // plssvm::detail::{contains, check_local_memory_usage}
 #include "plssvm/exceptions/exceptions.hpp"                // plssvm::invalid_parameter_exception, plssvm::mpi_exception
 #include "plssvm/gamma.hpp"                                // plssvm::calculate_gamma_value
 #include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
@@ -32,6 +32,7 @@
 #include "plssvm/svm/csvm.hpp"                             // plssvm::csvm
 #include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity_level
 
+#include "fmt/format.h"   // fmt::format
 #include "igor/igor.hpp"  // igor::parser
 
 #include <algorithm>    // std::all_of, std::merge
@@ -100,7 +101,7 @@ class csvc : virtual public csvm {
     /**
      * @copydoc plssvm::csvm::~csvm() noexcept
      */
-    ~csvc() noexcept = default;
+    ~csvc() noexcept override = default;
 
     //*************************************************************************************************************************************//
     //                                                              fit model                                                              //
@@ -143,7 +144,7 @@ class csvc : virtual public csvm {
 
         PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT("fit start");
 
-        igor::parser parser{ named_args... };
+        const igor::parser parser{ named_args... };
 
         // set default values
         // note: if the default value is changed, they must also be changed in the Python bindings!
@@ -260,7 +261,7 @@ class csvc : virtual public csvm {
                                               data.mapping_->get_label_by_mapped_index(j),
                                               pos + 1,
                                               calculate_number_of_classifiers(classification_type::oao, num_classes));
-                        const auto &[alpha, rho, num_iter] = this->solve_lssvm_system_of_linear_equations(binary_data, binary_y, params, std::forward<Args>(named_args)...);
+                        const auto &[alpha, rho, num_iter] = this->solve_lssvm_system_of_linear_equations(binary_data, binary_y, params, named_args...);
                         (*csvc_model.alpha_ptr_)[pos] = std::move(alpha);
                         (*csvc_model.rho_ptr_)[pos] = rho.front();  // prevents std::tie
                         num_iters.push_back(num_iter.front());
@@ -335,6 +336,9 @@ class csvc : virtual public csvm {
             throw mpi_exception{ "The MPI communicators provided to the C-SVC and data set must be identical!" };
         }
 
+        // determine the used local memory and check whether it exceeds the maximum necessary value!
+        detail::check_local_memory_usage(this->get_local_memory());
+
         PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT("predict start");
 
         // convert predicted values to the correct labels
@@ -412,12 +416,12 @@ class csvc : virtual public csvm {
                         if (num_classes == 2) {
                             // no special assembly needed in binary case
                             return model.support_vectors();
-                        } else {
-                            // note: if this is changed, it must also be changed in the libsvm_model_parsing.hpp in the calculate_alpha_idx function!!!
-                            // order the indices in increasing order
-                            soa_matrix<real_type> temp{ shape{ num_data_points_in_sub_matrix, num_features }, shape{ PADDING_SIZE, PADDING_SIZE } };
-                            std::vector<std::size_t> sorted_indices(num_data_points_in_sub_matrix);
-                            std::merge(index_sets[i].cbegin(), index_sets[i].cend(), index_sets[j].cbegin(), index_sets[j].cend(), sorted_indices.begin());
+                        }
+                        // note: if this is changed, it must also be changed in the libsvm_model_parsing.hpp in the calculate_alpha_idx function!!!
+                        // order the indices in increasing order
+                        soa_matrix<real_type> temp{ shape{ num_data_points_in_sub_matrix, num_features }, shape{ PADDING_SIZE, PADDING_SIZE } };
+                        std::vector<std::size_t> sorted_indices(num_data_points_in_sub_matrix);
+                        std::merge(index_sets[i].cbegin(), index_sets[i].cend(), index_sets[j].cbegin(), index_sets[j].cend(), sorted_indices.begin());
 // copy the support vectors to the binary support vectors
 // NOTE: it seems that MSVC doesn't like the collapse clause inside a lambda function
 #if defined(_MSC_VER)
@@ -425,13 +429,12 @@ class csvc : virtual public csvm {
 #else
     #pragma omp parallel for collapse(2)
 #endif
-                            for (std::size_t si = 0; si < num_data_points_in_sub_matrix; ++si) {
-                                for (std::size_t dim = 0; dim < num_features; ++dim) {
-                                    temp(si, dim) = model.support_vectors()(sorted_indices[si], dim);
-                                }
+                        for (std::size_t si = 0; si < num_data_points_in_sub_matrix; ++si) {
+                            for (std::size_t dim = 0; dim < num_features; ++dim) {
+                                temp(si, dim) = model.support_vectors()(sorted_indices[si], dim);
                             }
-                            return temp;
                         }
+                        return temp;
                     }();
 
                     // predict binary pair
@@ -532,7 +535,8 @@ class csvc : virtual public csvm {
     template <typename label_type>
     [[nodiscard]] real_type score(const classification_model<label_type> &model, const classification_data_set<label_type> &data) const {
         // the data set must contain labels in order to score the learned model
-        if (!data.has_labels()) {
+        const std::optional<std::vector<label_type>> &correct_labels_opt = data.labels();
+        if (!correct_labels_opt.has_value()) {
             throw invalid_parameter_exception{ "The data set to score must have labels!" };
         }
         // the number of features must be equal
@@ -551,7 +555,7 @@ class csvc : virtual public csvm {
         // predict labels
         const std::vector<label_type> predicted_labels = this->predict(model, data);
         // correct labels
-        const std::vector<label_type> &correct_labels = *data.labels();
+        const std::vector<label_type> &correct_labels = correct_labels_opt.value();
 
         // calculate the accuracy
         typename std::vector<label_type>::size_type correct{ 0 };
diff --git a/include/plssvm/svm/csvm.hpp b/include/plssvm/svm/csvm.hpp
index 1acd4738e..5c5efa83e 100644
--- a/include/plssvm/svm/csvm.hpp
+++ b/include/plssvm/svm/csvm.hpp
@@ -13,10 +13,9 @@
 #define PLSSVM_SVM_CSVM_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"                            // plssvm::real_type, plssvm::PADDING_SIZE
+#include "plssvm/constants.hpp"                            // plssvm::real_type, plssvm::PADDING_SIZE, plssvm::DEFAULT_EPSILON
 #include "plssvm/detail/assert.hpp"                        // PLSSVM_ASSERT
-#include "plssvm/detail/data_distribution.hpp"             // plssvm::detail::triangular_data_distribution
-#include "plssvm/detail/data_distribution.hpp"             // plssvm::detail::data_distribution
+#include "plssvm/detail/data_distribution.hpp"             // plssvm::detail::{data_distribution, triangular_data_distribution}
 #include "plssvm/detail/igor_utility.hpp"                  // plssvm::detail::{get_value_from_named_parameter, has_only_parameter_named_args_v}
 #include "plssvm/detail/logging/mpi_log.hpp"               // plssvm::detail::log
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"     // plssvm::detail::log_untracked
@@ -24,6 +23,7 @@
 #include "plssvm/detail/move_only_any.hpp"                 // plssvm::detail::move_only_any
 #include "plssvm/detail/tracking/performance_tracker.hpp"  // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT, plssvm::detail::tracking::tracking_entry
 #include "plssvm/detail/type_traits.hpp"                   // PLSSVM_REQUIRES, plssvm::detail::remove_cvref_t
+#include "plssvm/detail/utility.hpp"                       // plssvm::detail::{check_local_memory_usage, get_system_memory}
 #include "plssvm/exceptions/exceptions.hpp"                // plssvm::invalid_parameter_exception
 #include "plssvm/matrix.hpp"                               // plssvm::aos_matrix
 #include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
@@ -42,6 +42,7 @@
 #include <chrono>       // std::chrono::{time_point, steady_clock, duration_cast, milliseconds}
 #include <cstddef>      // std::size_t
 #include <memory>       // std::unique_ptr
+#include <optional>     // std::optional
 #include <ratio>        // std::milli
 #include <string>       // std::string
 #include <tuple>        // std::tie, std::tuple, std::make_tuple
@@ -158,6 +159,12 @@ class csvm {
      * @return the maximum (single) allocation size per device (`[[nodiscard]]`)
      */
     [[nodiscard]] virtual std::vector<detail::memory_size> get_max_mem_alloc_size() const = 0;
+    /**
+     * @brief Calculate the total available local memory for all devices based on the used backend.
+     * @details If the backend has no notion of local memory, returns a std::nullopt.
+     * @return the total local memory per device (`[[nodiscard]]`)
+     */
+    [[nodiscard]] virtual std::vector<std::optional<detail::memory_size>> get_local_memory() const = 0;
 
     /**
      * @brief Explicitly assemble the kernel matrix using potentially multiple devices. Backend specific!
@@ -223,7 +230,7 @@ class csvm {
      * @details Reduces the resulting dimension by `2` compared to the original LS-SVM formulation.
      * @param[in] params the parameter used for the kernel matrix
      * @param[in] A the data used for the kernel matrix
-     * @return the reduction vector ´q_red` and the bottom-right value `QA_cost` (`[[nodiscard]]`)
+     * @return the reduction vector `q_red` and the bottom-right value `QA_cost` (`[[nodiscard]]`)
      */
     [[nodiscard]] std::pair<std::vector<real_type>, real_type> perform_dimensional_reduction(const parameter &params, const soa_matrix<real_type> &A) const;
 
@@ -241,13 +248,13 @@ class csvm {
     [[nodiscard]] aos_matrix<real_type> run_predict_values(const parameter &params, const soa_matrix<real_type> &support_vectors, const aos_matrix<real_type> &alpha, const std::vector<real_type> &rho, soa_matrix<real_type> &w, const soa_matrix<real_type> &predict_points) const;
 
     /// The SVM parameter (e.g., cost, degree, gamma, coef0) currently in use.
-    parameter params_{};
+    parameter params_;
     /// The target platform of this SVM.
     target_platform target_{ plssvm::target_platform::automatic };
     /// The data distribution on the available devices.
-    mutable std::unique_ptr<detail::data_distribution> data_distribution_{};
+    mutable std::unique_ptr<detail::data_distribution> data_distribution_;
     /// The used MPI communicator.
-    mpi::communicator comm_{};
+    mpi::communicator comm_;
 };
 
 inline csvm::csvm(mpi::communicator comm, parameter params) :
@@ -284,12 +291,12 @@ std::tuple<aos_matrix<real_type>, std::vector<real_type>, std::vector<unsigned l
     PLSSVM_ASSERT(!B.empty(), "The B matrix must not be empty!");
     PLSSVM_ASSERT(A.num_rows() == B.num_cols(), "The number of data points in A ({}) and B ({}) must be the same!", A.num_rows(), B.num_cols());
 
-    igor::parser parser{ std::forward<Args>(named_args)... };
+    const igor::parser parser{ std::forward<Args>(named_args)... };
 
     // set default values
-    // note: if the default values are changed, they must also be changed in the Python bindings!
-    auto used_epsilon{ plssvm::real_type{ 1e-10 } };
-    unsigned long long used_max_iter{ A.num_rows() - 1 };  // account for later dimensional reduction
+    auto used_epsilon{ DEFAULT_EPSILON };
+    // NOTE: account for later dimensional reduction
+    unsigned long long used_max_iter{ A.num_rows() - 1 };  // NOLINT: can be modified in compile-time if later on
     solver_type used_solver{ solver_type::automatic };
 
     // compile time check: only named parameters are permitted
@@ -326,16 +333,19 @@ std::tuple<aos_matrix<real_type>, std::vector<real_type>, std::vector<unsigned l
     const std::size_t num_rows_reduced = num_rows - 1;
     const std::size_t num_rhs = B.num_rows();
 
+    // determine the used local memory and check whether it exceeds the maximum necessary value!
+    detail::check_local_memory_usage(this->get_local_memory());
+
     // determine the correct solver type, if the automatic solver type has been provided
     if (used_solver == solver_type::automatic) {
-        using namespace detail::literals;
+        using namespace detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
 
         // define used safety margin constants
         constexpr detail::memory_size minimal_safety_margin = 512_MiB;
         constexpr long double percentual_safety_margin = 0.05L;
         const auto reduce_total_memory = [=](const detail::memory_size total_memory) {
-            if (total_memory < 512_MiB) {
-                throw kernel_launch_resources{ fmt::format("At least {} of memory must be available, but available are only {}!", 512_MiB, total_memory) };
+            if (total_memory < minimal_safety_margin) {
+                throw kernel_launch_resources{ fmt::format("At least {} of memory must be available, but available are only {}!", minimal_safety_margin, total_memory) };
             }
             return total_memory - std::max(total_memory * percentual_safety_margin, minimal_safety_margin);
         };
@@ -363,9 +373,8 @@ std::tuple<aos_matrix<real_type>, std::vector<real_type>, std::vector<unsigned l
         const auto format_vector = [](const auto &vec) -> std::string {
             if (vec.size() == 1) {
                 return fmt::format("{}", vec.front());
-            } else {
-                return fmt::format("[{}]", fmt::join(vec, ", "));
             }
+            return fmt::format("[{}]", fmt::join(vec, ", "));
         };
 
         if (comm_.size() <= 1) {
@@ -379,19 +388,19 @@ std::tuple<aos_matrix<real_type>, std::vector<real_type>, std::vector<unsigned l
                         "  - usable device memory (with safety margin of min({0} %, {1}): {5}\n"
                         "  - maximum memory needed (cg_explicit): {6}\n"
                         "  - maximum memory needed (cg_implicit): {7}\n",
-                        static_cast<double>(percentual_safety_margin * 100.0L),
+                        static_cast<double>(percentual_safety_margin * 100.0L),  // NOLINT: convert float to percent by multiplying it with 100
                         minimal_safety_margin,
-                        detail::tracking::tracking_entry{ "solver", "system_memory", total_system_memory },
-                        detail::tracking::tracking_entry{ "solver", "usable_system_memory_with_safety_margin", usable_system_memory },
+                        detail::tracking::tracking_entry{ "resource_constraints", "system_memory", total_system_memory },
+                        detail::tracking::tracking_entry{ "resource_constraints", "usable_system_memory_with_safety_margin", usable_system_memory },
                         format_vector(total_device_memory_per_device),
                         format_vector(usable_device_memory_per_device),
                         format_vector(total_memory_needed_explicit_per_device),
                         format_vector(total_memory_needed_implicit_per_device));
         }
-        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "solver", "device_memory", total_device_memory_per_device }));
-        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "solver", "usable_device_memory_with_safety_margin", usable_device_memory_per_device }));
-        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "solver", "needed_device_memory_cg_explicit", total_memory_needed_explicit_per_device }));
-        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "solver", "needed_device_memory_cg_implicit", total_memory_needed_implicit_per_device }));
+        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "resource_constraints", "device_memory", total_device_memory_per_device }));
+        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "resource_constraints", "usable_device_memory_with_safety_margin", usable_device_memory_per_device }));
+        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "resource_constraints", "needed_device_memory_cg_explicit", total_memory_needed_explicit_per_device }));
+        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "resource_constraints", "needed_device_memory_cg_implicit", total_memory_needed_implicit_per_device }));
 
         // helper function to check whether ALL devices fulfill the requested memory constraint for the specific solver type
         const auto check_sizes = [](const auto &needed_memory_per_device, const auto &memory_constraint) -> std::vector<std::size_t> {
@@ -450,9 +459,9 @@ std::tuple<aos_matrix<real_type>, std::vector<real_type>, std::vector<unsigned l
                                   format_vector(max_single_allocation_cg_explicit_size_per_device),
                                   format_vector(max_single_allocation_cg_implicit_size_per_device));
         }
-        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "solver", "device_max_single_mem_alloc_size", max_mem_alloc_size_per_device }));
-        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "solver", "device_max_mem_alloc_size_cg_explicit", max_single_allocation_cg_explicit_size_per_device }));
-        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "solver", "device_max_mem_alloc_size_cg_implicit", max_single_allocation_cg_implicit_size_per_device }));
+        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "resource_constraints", "device_max_single_mem_alloc_size", max_mem_alloc_size_per_device }));
+        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "resource_constraints", "device_max_mem_alloc_size_cg_explicit", max_single_allocation_cg_explicit_size_per_device }));
+        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "resource_constraints", "device_max_mem_alloc_size_cg_implicit", max_single_allocation_cg_implicit_size_per_device }));
 
         // check whether the maximum single memory allocation sizes per device can be satisfied
         // check whether the maximum single cg_explicit memory allocation size can be satisfied
diff --git a/include/plssvm/svm/csvr.hpp b/include/plssvm/svm/csvr.hpp
index b35d55cfb..85880eb26 100644
--- a/include/plssvm/svm/csvr.hpp
+++ b/include/plssvm/svm/csvr.hpp
@@ -18,6 +18,7 @@
 #include "plssvm/detail/assert.hpp"                        // PLSSVM_ASSERT
 #include "plssvm/detail/logging/mpi_log.hpp"               // plssvm::detail::log
 #include "plssvm/detail/tracking/performance_tracker.hpp"  // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT, plssvm::detail::tracking::tracking_entry
+#include "plssvm/detail/utility.hpp"                       // plssvm::detail::check_local_memory_usage
 #include "plssvm/exceptions/exceptions.hpp"                // plssvm::invalid_parameter_exception, plssvm::mpi_exception
 #include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                               // plssvm::aos_matrix
@@ -27,6 +28,7 @@
 #include "plssvm/svm/csvm.hpp"                             // plssvm::csvm
 #include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity_level
 
+#include "fmt/format.h"   // fmt::format
 #include "igor/igor.hpp"  // igor::parser
 
 #include <algorithm>    // std::all_of
@@ -89,7 +91,7 @@ class csvr : virtual public csvm {
     /**
      * @copydoc plssvm::csvm::~csvm() noexcept
      */
-    ~csvr() noexcept = default;
+    ~csvr() noexcept override = default;
 
     //*************************************************************************************************************************************//
     //                                                              fit model                                                              //
@@ -132,7 +134,7 @@ class csvr : virtual public csvm {
 
         PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT("fit start");
 
-        igor::parser parser{ named_args... };
+        const igor::parser parser{ named_args... };
 
         // compile time check: only named parameters are permitted
         static_assert(!parser.has_unnamed_arguments(), "Can only use named parameter!");
@@ -218,6 +220,9 @@ class csvr : virtual public csvm {
             throw mpi_exception{ "The MPI communicators provided to the C-SVR and data set must be identical!" };
         }
 
+        // determine the used local memory and check whether it exceeds the maximum necessary value!
+        detail::check_local_memory_usage(this->get_local_memory());
+
         PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT("predict start");
 
         // convert predicted values to the correct labels
@@ -288,7 +293,8 @@ class csvr : virtual public csvm {
     template <typename label_type>
     [[nodiscard]] real_type score(const regression_model<label_type> &model, const regression_data_set<label_type> &data) const {
         // the data set must contain labels in order to score the learned model
-        if (!data.has_labels()) {
+        const std::optional<std::vector<label_type>> &correct_labels_opt = data.labels();
+        if (!correct_labels_opt.has_value()) {
             throw invalid_parameter_exception{ "The data set to score must have labels!" };
         }
         // the number of features must be equal
@@ -307,7 +313,7 @@ class csvr : virtual public csvm {
         // predict labels
         const std::vector<label_type> predicted_labels = this->predict(model, data);
         // correct labels
-        const std::vector<label_type> &correct_labels = *data.labels();
+        const std::vector<label_type> &correct_labels = correct_labels_opt.value();
 
         return regression_report{ correct_labels, predicted_labels }.loss().r2_score;
     }
diff --git a/include/plssvm/verbosity_levels.hpp b/include/plssvm/verbosity_levels.hpp
index 54e23705e..6a85dc99a 100644
--- a/include/plssvm/verbosity_levels.hpp
+++ b/include/plssvm/verbosity_levels.hpp
@@ -39,7 +39,7 @@ enum class verbosity_level {
 };
 
 /// The verbosity level used in the logging function. My be changed by the user.
-PLSSVM_EXTERN verbosity_level verbosity;
+PLSSVM_EXTERN verbosity_level verbosity;  // NOLINT: variable must be global or too many interfaces would change
 
 /**
  * @brief Output the @p verb to the given output-stream @p out.
diff --git a/src/main_predict.cpp b/src/main_predict.cpp
index ee16daba2..732f7874f 100644
--- a/src/main_predict.cpp
+++ b/src/main_predict.cpp
@@ -8,44 +8,66 @@
  * @brief Main function compiled to the `plssvm-predict` executable used for predicting a data set using a previously computed C-SVM model.
  */
 
-#include "plssvm/core.hpp"
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type, plssvm::determin_default_backend
+#include "plssvm/classification_report.hpp"                // plssvm::classification_report
+#include "plssvm/csvm_factory.hpp"                         // plssvm::make_csvm
 #include "plssvm/detail/cmd/data_set_variants.hpp"         // plssvm::detail::cmd::data_set_factory
 #include "plssvm/detail/cmd/parser_predict.hpp"            // plssvm::detail::cmd::parser_predict
 #include "plssvm/detail/logging/mpi_log.hpp"               // plssvm::detail::log
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"     // plssvm::detail::log_untracked
-#include "plssvm/detail/tracking/performance_tracker.hpp"  // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_SAVE,
-                                                           // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_HWS_ENTRY
-                                                           // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_SET_REFERENCE_TIME
-#include "plssvm/detail/assert.hpp"                        // PLSSVM_ASSERT
+#include "plssvm/detail/tracking/performance_tracker.hpp"  // plssvm::detail::tracking::tracking_entry, performance tracking macros
 #include "plssvm/detail/utility.hpp"                       // PLSSVM_IS_DEFINED
-#include "plssvm/mpi/environment.hpp"                      // plssvm::mpi::is_executed_via_mpirun
+#include "plssvm/environment.hpp"                          // plssvm::environment::scope_guard
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::exception, plssvm::cmd_parser_exit
+#include "plssvm/gamma.hpp"                                // plssvm::get_gamma_string
+#include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type, plssvm::kernel_function_type_to_math_string
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/parameter.hpp"                            // plssvm::parameter, plssvm::kokkos_execution_space, plssvm::sycl_data_parallel_kernel, plssvm::sycl_implementation_type
+#include "plssvm/regression_report.hpp"                    // plssvm::regression_report
+#include "plssvm/svm/csvc.hpp"                             // plssvm::csvc
+#include "plssvm/svm/csvr.hpp"                             // plssvm::csvr
+#include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity_level
 
 #if defined(PLSSVM_HARDWARE_SAMPLING_ENABLED)
     #include "hws/system_hardware_sampler.hpp"  // hws::system_hardware_sampler
 #endif
 
-#include "fmt/format.h"  // fmt::format
+#if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "fmt/format.h"  // fmt::format
+
+    #include <filesystem>  // std::filesystem::path
+#endif
+
+#if !defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/mpi/environment.hpp"  // plssvm::mpi::is_executed_via_mpirun
+#endif
+
 #include "fmt/os.h"      // fmt::ostream, fmt::output_file
 #include "fmt/ranges.h"  // fmt::join
 
 #include <chrono>       // std::chrono::{time_point, steady_clock, duration_cast, milliseconds}, std::chrono_literals namespace
 #include <cstdlib>      // EXIT_SUCCESS, EXIT_FAILURE
 #include <exception>    // std::exception
-#include <filesystem>   // std::filesystem::path
 #include <iostream>     // std::cerr, std::endl
 #include <memory>       // std::unique_ptr, std::make_unique
 #include <string>       // std::string
 #include <string_view>  // std::string_view
 #include <type_traits>  // std::remove_reference_t, std::is_same_v
-#include <utility>      // std::pair
 #include <variant>      // std::visit
 #include <vector>       // std::vector
 
 using namespace std::chrono_literals;
 
-int main(int argc, char *argv[]) {
-    // initialize MPI environment only via the plssvm::scope_guard (by explicitly specifying NO backend)
-    [[maybe_unused]] plssvm::environment::scope_guard mpi_guard{ {} };
+int main(int argc, char **argv) {
+    // may throw an exception if the required level of MPI parallelism isn't available (really rare)
+    std::unique_ptr<plssvm::environment::scope_guard> mpi_guard{};
+    try {
+        // initialize MPI environment only via the plssvm::scope_guard (by explicitly specifying NO backend)
+        mpi_guard = std::make_unique<plssvm::environment::scope_guard>(std::vector<plssvm::backend_type>{});
+    } catch (const plssvm::mpi_exception &e) {
+        std::cerr << "An exception occurred while setting up MPI!: " << e.what_with_loc() << std::endl;
+    }
+
     // create a PLSSVM communicator -> use MPI_COMM_WORLD for our executables
     // if MPI is not supported, does nothing
     plssvm::mpi::communicator comm{};
@@ -124,17 +146,17 @@ int main(int argc, char *argv[]) {
             if (use_kokkos_as_backend) {
                 backends_to_initialize.push_back(plssvm::backend_type::kokkos);
             }
-            environment_guard = std::make_unique<plssvm::environment::scope_guard>(backends_to_initialize);
+            environment_guard = std::make_unique<plssvm::environment::scope_guard>(argc, argv, backends_to_initialize);
 
             // create default csvm
             const std::unique_ptr<csvm_type> svm = [&]() {
                 if (use_sycl_as_backend) {
-                    return plssvm::make_csvm<csvm_type>(cmd_parser.backend, comm, cmd_parser.target, plssvm::sycl_implementation_type = cmd_parser.sycl_implementation_type, plssvm::sycl_kernel_invocation_type = cmd_parser.sycl_kernel_invocation_type);
-                } else if (use_kokkos_as_backend) {
+                    return plssvm::make_csvm<csvm_type>(cmd_parser.backend, comm, cmd_parser.target, plssvm::sycl_implementation_type = cmd_parser.sycl_implementation_type, plssvm::sycl_data_parallel_kernel = cmd_parser.sycl_data_parallel_kernel);
+                }
+                if (use_kokkos_as_backend) {
                     return plssvm::make_csvm<csvm_type>(cmd_parser.backend, comm, cmd_parser.target, plssvm::kokkos_execution_space = cmd_parser.kokkos_execution_space);
-                } else {
-                    return plssvm::make_csvm<csvm_type>(cmd_parser.backend, comm, cmd_parser.target);
                 }
+                return plssvm::make_csvm<csvm_type>(cmd_parser.backend, comm, cmd_parser.target);
             }();
 
             // create model
@@ -149,6 +171,8 @@ int main(int argc, char *argv[]) {
                                               "  kernel_type: {} -> {}\n",
                                               params.kernel_type,
                                               plssvm::kernel_function_type_to_math_string(params.kernel_type));
+                PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "parameter", "", params }));
+
                 switch (params.kernel_type) {
                     case plssvm::kernel_function_type::linear:
                         break;
@@ -275,10 +299,18 @@ int main(int argc, char *argv[]) {
         // -> don't call std::exit directly to gracefully tear down the environment
         return e.exit_code();
     } catch (const plssvm::exception &e) {
+#if defined(PLSSVM_HAS_MPI_ENABLED)
         std::cerr << fmt::format("An exception occurred on MPI rank {}!: {}", comm.rank(), e.what_with_loc()) << std::endl;
+#else
+        std::cerr << "An exception occurred!: " << e.what_with_loc() << std::endl;
+#endif
         return EXIT_FAILURE;
     } catch (const std::exception &e) {
+#if defined(PLSSVM_HAS_MPI_ENABLED)
         std::cerr << fmt::format("An exception occurred on MPI rank {}!: {}", comm.rank(), e.what()) << std::endl;
+#else
+        std::cerr << "An exception occurred!: " << e.what() << std::endl;
+#endif
         return EXIT_FAILURE;
     }
 
diff --git a/src/main_scale.cpp b/src/main_scale.cpp
index 413ca4d72..d0927bf16 100644
--- a/src/main_scale.cpp
+++ b/src/main_scale.cpp
@@ -8,34 +8,51 @@
  * @brief Main function compiled to the `plssvm-scale` executable used for scaling a data set to a specified range.
  */
 
-#include "plssvm/core.hpp"
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type
+#include "plssvm/constants.hpp"                            // plssvm::real_type
+#include "plssvm/data_set/data_set.hpp"                    // plssvm::optional_ref
 #include "plssvm/detail/cmd/data_set_variants.hpp"         // plssvm::detail::cmd::data_set_factory
 #include "plssvm/detail/cmd/parser_scale.hpp"              // plssvm::detail::cmd::parser_scale
 #include "plssvm/detail/logging/mpi_log.hpp"               // plssvm::detail::log
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"     // plssvm::detail::log_untracked
 #include "plssvm/detail/tracking/performance_tracker.hpp"  // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_SAVE,
+#include "plssvm/detail/type_traits.hpp"                   // plssvm::detail::remove_cvref_t
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::exception, plssvm::cmd_parser_exit
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity_level
                                                            // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_HWS_ENTRY, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_SET_REFERENCE_TIME
 #include "plssvm/detail/utility.hpp"                       // PLSSVM_IS_DEFINED
+#include "plssvm/environment.hpp"                          // plssvm::environment_scope_guard
 
 #if defined(PLSSVM_HARDWARE_SAMPLING_ENABLED)
     #include "hws/system_hardware_sampler.hpp"  // hws::system_hardware_sampler
 #endif
 
-#include "fmt/format.h"  // fmt::format
+#include "fmt/base.h"     // fmt::print
+#include "fmt/compile.h"  // FMT_COMPILE
+#include "fmt/format.h"   // fmt::format
 
 #include <chrono>     // std::chrono::{steady_clock, duration}, std::chrono_literals namespace
 #include <cstddef>    // std::size_t
 #include <cstdlib>    // EXIT_SUCCESS, EXIT_FAILURE
 #include <exception>  // std::exception
 #include <iostream>   // std::cerr, std::endl
+#include <memory>     // std::unique_ptr, std::make_unique
 #include <variant>    // std::visit
 #include <vector>     // std::vector
 
 using namespace std::chrono_literals;
 
 int main(int argc, char *argv[]) {
-    // initialize MPI environment only via the plssvm::scope_guard (by explicitly specifying NO backend)
-    [[maybe_unused]] plssvm::environment::scope_guard mpi_guard{ {} };
+    // may throw an exception if the required level of MPI parallelism isn't available (really rare)
+    std::unique_ptr<plssvm::environment::scope_guard> mpi_guard{};
+    try {
+        // initialize MPI environment only via the plssvm::scope_guard (by explicitly specifying NO backend)
+        mpi_guard = std::make_unique<plssvm::environment::scope_guard>(std::vector<plssvm::backend_type>{});
+    } catch (const plssvm::mpi_exception &e) {
+        std::cerr << "An exception occurred while setting up MPI!: " << e.what_with_loc() << std::endl;
+    }
+
     // create a PLSSVM communicator -> use MPI_COMM_WORLD for our executables
     // if MPI is not supported, does nothing
     const plssvm::mpi::communicator comm{};
@@ -126,10 +143,18 @@ int main(int argc, char *argv[]) {
         // -> don't call std::exit directly to gracefully tear down the environment
         return e.exit_code();
     } catch (const plssvm::exception &e) {
+#if defined(PLSSVM_HAS_MPI_ENABLED)
         std::cerr << fmt::format("An exception occurred on MPI rank {}!: {}", comm.rank(), e.what_with_loc()) << std::endl;
+#else
+        std::cerr << "An exception occurred!: " << e.what_with_loc() << std::endl;
+#endif
         return EXIT_FAILURE;
     } catch (const std::exception &e) {
+#if defined(PLSSVM_HAS_MPI_ENABLED)
         std::cerr << fmt::format("An exception occurred on MPI rank {}!: {}", comm.rank(), e.what()) << std::endl;
+#else
+        std::cerr << "An exception occurred!: " << e.what() << std::endl;
+#endif
         return EXIT_FAILURE;
     }
 
diff --git a/src/main_train.cpp b/src/main_train.cpp
index cf4893946..784143946 100644
--- a/src/main_train.cpp
+++ b/src/main_train.cpp
@@ -8,31 +8,49 @@
  * @brief Main function compiled to the `plssvm-train` executable used for training a C-SVM model.
  */
 
-#include "plssvm/core.hpp"
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type, plssvm::determine_default_backend
+#include "plssvm/csvm_factory.hpp"                         // plssvm::make_csvm
+#include "plssvm/data_set/classification_data_set.hpp"     // plssvm::classification_data_set
+#include "plssvm/data_set/regression_data_set.hpp"         // plssvm::regression_data_set
 #include "plssvm/detail/cmd/data_set_variants.hpp"         // plssvm::detail::cmd::data_set_factory
 #include "plssvm/detail/cmd/parser_train.hpp"              // plssvm::detail::cmd::parser_train
 #include "plssvm/detail/logging/mpi_log.hpp"               // plssvm::detail::log
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"     // plssvm::detail::log_untracked
 #include "plssvm/detail/tracking/performance_tracker.hpp"  // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_SAVE,
+#include "plssvm/environment.hpp"                          // plssvm::environment::scope_guard
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::exception
+#include "plssvm/model/classification_model.hpp"           // plssvm::classification_model
+#include "plssvm/model/regression_model.hpp"               // plssvm::regression_model
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/parameter.hpp"                            // plssvm::epsilon, plssvm::classification, plssvm::solver, plssvm::max_iter
+                                                           // plssvm::kokkos_execution_space, plssvm::sycl_data_parallel_kernel, plssvm::sycl_implementation_type
+#include "plssvm/svm/csvc.hpp"                             // plssvm::csvc
+#include "plssvm/svm/csvr.hpp"                             // plssvm::csvr
+#include "plssvm/svm_types.hpp"                            // plssvm::svm_type, plssvm::svm_type_to_task_name
+#include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity_level
                                                            // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_HWS_ENTRY, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_SET_REFERENCE_TIME
-#include "plssvm/detail/assert.hpp"                        // PLSSVM_ASSERT
 #include "plssvm/detail/utility.hpp"                       // PLSSVM_IS_DEFINED
-#include "plssvm/mpi/environment.hpp"                      // plssvm::mpi::is_executed_via_mpirun
 
 #if defined(PLSSVM_HARDWARE_SAMPLING_ENABLED)
     #include "hws/system_hardware_sampler.hpp"  // hws::system_hardware_sampler
 #endif
 
-#include "fmt/format.h"  // fmt::format
+#if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "fmt/format.h"  // fmt::format
+
+    #include <filesystem>  // std::filesystem::path
+#endif
+
+#if !defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/mpi/environment.hpp"  // plssvm::mpi::is_executed_via_mpirun
+#endif
 
 #include <chrono>       // std::chrono::{time_point, steady_clock, duration_cast, milliseconds}, std::chrono_literals namespace
 #include <cstddef>      // std::size_t
 #include <cstdlib>      // EXIT_SUCCESS, EXIT_FAILURE
 #include <exception>    // std::exception
-#include <filesystem>   // std::filesystem::path
 #include <iostream>     // std::cerr, std::endl
 #include <memory>       // std::unique_ptr, std::make_unique
-#include <string>       // std::string
 #include <string_view>  // std::string_view
 #include <type_traits>  // std::remove_reference_t
 #include <variant>      // std::visit
@@ -40,6 +58,8 @@
 
 using namespace std::chrono_literals;
 
+namespace {
+
 /**
  * @brief Fit a C-SVC model using the provided C-SVC, classification data set and command line parser.
  * @tparam svm_type the type of the C-SVC
@@ -53,9 +73,8 @@ template <typename svm_type, typename label_type>
 [[nodiscard]] plssvm::classification_model<label_type> fit_csvc(const svm_type &svm, const plssvm::classification_data_set<label_type> &data, const plssvm::detail::cmd::parser_train &cmd_parser) {
     if (cmd_parser.max_iter == std::size_t{ 0 }) {
         return svm.fit(data, plssvm::epsilon = cmd_parser.epsilon, plssvm::classification = cmd_parser.classification, plssvm::solver = cmd_parser.solver);
-    } else {
-        return svm.fit(data, plssvm::epsilon = cmd_parser.epsilon, plssvm::max_iter = cmd_parser.max_iter, plssvm::classification = cmd_parser.classification, plssvm::solver = cmd_parser.solver);
     }
+    return svm.fit(data, plssvm::epsilon = cmd_parser.epsilon, plssvm::max_iter = cmd_parser.max_iter, plssvm::classification = cmd_parser.classification, plssvm::solver = cmd_parser.solver);
 }
 
 /**
@@ -71,14 +90,22 @@ template <typename svm_type, typename label_type>
 [[nodiscard]] plssvm::regression_model<label_type> fit_csvr(const svm_type &svm, const plssvm::regression_data_set<label_type> &data, const plssvm::detail::cmd::parser_train &cmd_parser) {
     if (cmd_parser.max_iter == std::size_t{ 0 }) {
         return svm.fit(data, plssvm::epsilon = cmd_parser.epsilon, plssvm::solver = cmd_parser.solver);
-    } else {
-        return svm.fit(data, plssvm::epsilon = cmd_parser.epsilon, plssvm::max_iter = cmd_parser.max_iter, plssvm::solver = cmd_parser.solver);
     }
+    return svm.fit(data, plssvm::epsilon = cmd_parser.epsilon, plssvm::max_iter = cmd_parser.max_iter, plssvm::solver = cmd_parser.solver);
 }
 
-int main(int argc, char *argv[]) {
-    // initialize MPI environment only via the plssvm::scope_guard (by explicitly specifying NO backend)
-    [[maybe_unused]] plssvm::environment::scope_guard mpi_guard{ {} };
+}  // namespace
+
+int main(int argc, char **argv) {
+    // may throw an exception if the required level of MPI parallelism isn't available (really rare)
+    std::unique_ptr<plssvm::environment::scope_guard> mpi_guard{};
+    try {
+        // initialize MPI environment only via the plssvm::scope_guard (by explicitly specifying NO backend)
+        mpi_guard = std::make_unique<plssvm::environment::scope_guard>(std::vector<plssvm::backend_type>{});
+    } catch (const plssvm::mpi_exception &e) {
+        std::cerr << "An exception occurred while setting up MPI!: " << e.what_with_loc() << std::endl;
+    }
+
     // create a PLSSVM communicator -> use MPI_COMM_WORLD for our executables
     // if MPI is not supported, does nothing
     plssvm::mpi::communicator comm{};
@@ -158,17 +185,17 @@ int main(int argc, char *argv[]) {
             if (use_kokkos_as_backend) {
                 backends_to_initialize.push_back(plssvm::backend_type::kokkos);
             }
-            environment_guard = std::make_unique<plssvm::environment::scope_guard>(backends_to_initialize);
+            environment_guard = std::make_unique<plssvm::environment::scope_guard>(argc, argv, backends_to_initialize);
 
             // create SVM
             const std::unique_ptr<csvm_type> svm = [&]() {
                 if (use_sycl_as_backend) {
-                    return plssvm::make_csvm<csvm_type>(cmd_parser.backend, comm, cmd_parser.target, cmd_parser.csvm_params, plssvm::sycl_implementation_type = cmd_parser.sycl_implementation_type, plssvm::sycl_kernel_invocation_type = cmd_parser.sycl_kernel_invocation_type);
-                } else if (use_kokkos_as_backend) {
+                    return plssvm::make_csvm<csvm_type>(cmd_parser.backend, comm, cmd_parser.target, cmd_parser.csvm_params, plssvm::sycl_implementation_type = cmd_parser.sycl_implementation_type, plssvm::sycl_data_parallel_kernel = cmd_parser.sycl_data_parallel_kernel);
+                }
+                if (use_kokkos_as_backend) {
                     return plssvm::make_csvm<csvm_type>(cmd_parser.backend, comm, cmd_parser.target, cmd_parser.csvm_params, plssvm::kokkos_execution_space = cmd_parser.kokkos_execution_space);
-                } else {
-                    return plssvm::make_csvm<csvm_type>(cmd_parser.backend, comm, cmd_parser.target, cmd_parser.csvm_params);
                 }
+                return plssvm::make_csvm<csvm_type>(cmd_parser.backend, comm, cmd_parser.target, cmd_parser.csvm_params);
             }();
 
             // only specify the named arguments available for the respective SVM type
@@ -225,10 +252,18 @@ int main(int argc, char *argv[]) {
         // -> don't call std::exit directly to gracefully tear down the environment
         return e.exit_code();
     } catch (const plssvm::exception &e) {
+#if defined(PLSSVM_HAS_MPI_ENABLED)
         std::cerr << fmt::format("An exception occurred on MPI rank {}!: {}", comm.rank(), e.what_with_loc()) << std::endl;
+#else
+        std::cerr << "An exception occurred!: " << e.what_with_loc() << std::endl;
+#endif
         return EXIT_FAILURE;
     } catch (const std::exception &e) {
+#if defined(PLSSVM_HAS_MPI_ENABLED)
         std::cerr << fmt::format("An exception occurred on MPI rank {}!: {}", comm.rank(), e.what()) << std::endl;
+#else
+        std::cerr << "An exception occurred!: " << e.what() << std::endl;
+#endif
         return EXIT_FAILURE;
     }
 
diff --git a/src/plssvm/backends/CUDA/.clang-tidy b/src/plssvm/backends/CUDA/.clang-tidy
new file mode 100644
index 000000000..0f3a77316
--- /dev/null
+++ b/src/plssvm/backends/CUDA/.clang-tidy
@@ -0,0 +1,12 @@
+---
+Checks: '
+-cppcoreguidelines-avoid-c-arrays,
+
+-hicpp-avoid-c-arrays,
+
+-misc-use-internal-linkage,
+
+-modernize-avoid-c-arrays,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/src/plssvm/backends/CUDA/CMakeLists.txt b/src/plssvm/backends/CUDA/CMakeLists.txt
index 1408f0a8a..c5eef5647 100644
--- a/src/plssvm/backends/CUDA/CMakeLists.txt
+++ b/src/plssvm/backends/CUDA/CMakeLists.txt
@@ -53,6 +53,11 @@ if (CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
     endif ()
     # set OpenMP specific flags
     if (OpenMP_FOUND)
+        if (CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
+            message(WARNING "Intel's icpx compiler as CXX host compiler together with nvcc is the CUDA compiler while OpenMP is enabled "
+                            "may not work due to the OpenMP target setting -fiopenmp!"
+            )
+        endif ()
         set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler '-fopenmp'")
     endif ()
 elseif (CMAKE_CUDA_COMPILER_ID STREQUAL "Clang")
diff --git a/src/plssvm/backends/CUDA/csvm.cu b/src/plssvm/backends/CUDA/csvm.cu
index 93db10d36..c66428736 100644
--- a/src/plssvm/backends/CUDA/csvm.cu
+++ b/src/plssvm/backends/CUDA/csvm.cu
@@ -9,8 +9,7 @@
 #include "plssvm/backends/CUDA/csvm.hpp"
 
 #include "plssvm/backend_types.hpp"                                                 // plssvm::backend_type
-#include "plssvm/backends/CUDA/detail/device_ptr.cuh"                               // plssvm::cuda::detail::device_ptr
-#include "plssvm/backends/CUDA/detail/utility.cuh"                                  // PLSSVM_CUDA_ERROR_CHECK, plssvm::cuda::detail::{dim_type_to_native, device_synchronize, get_device_count, set_device, peek_at_last_error, get_runtime_version}
+#include "plssvm/backends/CUDA/detail/utility.cuh"                                  // PLSSVM_CUDA_ERROR_CHECK, plssvm::cuda::detail::{dim_type_to_native, device_synchronize, get_device_count, set_device, peek_at_last_error, get_device_name, get_runtime_version}
 #include "plssvm/backends/CUDA/exceptions.hpp"                                      // plssvm::cuda::backend_exception
 #include "plssvm/backends/CUDA/kernel/cg_explicit/blas.cuh"                         // plssvm::cuda::detail::{device_kernel_symm, device_kernel_symm_mirror, device_kernel_inplace_matrix_add, device_kernel_inplace_matrix_scale}
 #include "plssvm/backends/CUDA/kernel/cg_explicit/kernel_matrix_assembly.cuh"       // plssvm::cuda::detail::device_kernel_assembly
@@ -24,7 +23,6 @@
 #include "plssvm/detail/memory_size.hpp"                                            // plssvm::detail::memory_size
 #include "plssvm/detail/tracking/performance_tracker.hpp"                           // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
 #include "plssvm/exceptions/exceptions.hpp"                                         // plssvm::exception
-#include "plssvm/gamma.hpp"                                                         // plssvm::gamma_type
 #include "plssvm/kernel_function_types.hpp"                                         // plssvm::kernel_function_type
 #include "plssvm/mpi/communicator.hpp"                                              // plssvm::mpi::communicator
 #include "plssvm/mpi/detail/information.hpp"                                        // plssvm::mpi::detail::gather_and_print_csvm_information
@@ -33,21 +31,20 @@
 #include "plssvm/target_platforms.hpp"                                              // plssvm::target_platform
 #include "plssvm/verbosity_levels.hpp"                                              // plssvm::verbosity_level
 
-#include "cuda.h"              // cuda runtime
-#include "cuda_runtime.h"      // cuda runtime
 #include "cuda_runtime_api.h"  // cuda runtime functions
+#include "driver_types.h"      // cudaDeviceProp
+#include "vector_types.h"      // dim3
 
 #include "fmt/format.h"  // fmt::format
 
 #include <chrono>     // std::chrono::{steady_clock, duration_cast}
-#include <cmath>      // std::sqrt, std::ceil
 #include <cstddef>    // std::size_t
 #include <exception>  // std::terminate
 #include <iostream>   // std::cout, std::endl
 #include <numeric>    // std::iota
+#include <optional>   // std::optional
 #include <string>     // std::string
-#include <utility>    // std::move
-#include <variant>    // std::get
+#include <utility>    // std::move, std::get
 #include <vector>     // std:vector
 
 namespace plssvm::cuda {
@@ -56,11 +53,10 @@ csvm::csvm(const target_platform target) {
     // check if supported target platform has been selected
     if (target != target_platform::automatic && target != target_platform::gpu_nvidia) {
         throw backend_exception{ fmt::format("Invalid target platform '{}' for the CUDA backend!", target) };
-    } else {
+    }
 #if !defined(PLSSVM_HAS_NVIDIA_TARGET)
-        throw backend_exception{ "Requested target platform 'gpu_nvidia' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!" };
+    throw backend_exception{ "Requested target platform 'gpu_nvidia' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!" };
 #endif
-    }
 
     // update the target platform
     target_ = plssvm::target_platform::gpu_nvidia;
@@ -80,9 +76,7 @@ csvm::csvm(const target_platform target) {
     if (comm_.size() > 1) {
         // use MPI rank specific command line output
         for (const queue_type &device : devices_) {
-            cudaDeviceProp prop{};
-            PLSSVM_CUDA_ERROR_CHECK(cudaGetDeviceProperties(&prop, device))
-            device_names.emplace_back(prop.name);
+            device_names.push_back(detail::get_device_name(device));
         }
 
         mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::cuda, target_, device_names);
@@ -96,16 +90,16 @@ csvm::csvm(const target_platform target) {
                                       devices_.size());
 
         for (const queue_type &device : devices_) {
+            device_names.push_back(detail::get_device_name(device));
             cudaDeviceProp prop{};
             PLSSVM_CUDA_ERROR_CHECK(cudaGetDeviceProperties(&prop, device))
             plssvm::detail::log_untracked(verbosity_level::full,
                                           comm_,
                                           "  [{}, {}, {}.{}]\n",
                                           device,
-                                          prop.name,
+                                          device_names.back(),
                                           prop.major,
                                           prop.minor);
-            device_names.emplace_back(prop.name);
         }
     }
 
@@ -146,6 +140,16 @@ std::vector<::plssvm::detail::memory_size> csvm::get_max_mem_alloc_size() const
     return this->get_device_memory();
 }
 
+std::vector<std::optional<::plssvm::detail::memory_size>> csvm::get_local_memory() const {
+    cudaDeviceProp prop{};
+    std::vector<std::optional<::plssvm::detail::memory_size>> res(this->num_available_devices());
+    for (std::size_t device_id = 0; device_id < this->num_available_devices(); ++device_id) {
+        PLSSVM_CUDA_ERROR_CHECK(cudaGetDeviceProperties(&prop, devices_[device_id]))
+        res[device_id] = ::plssvm::detail::memory_size{ static_cast<unsigned long long>(prop.sharedMemPerBlock) };
+    }
+    return res;
+}
+
 std::size_t csvm::get_max_work_group_size(const std::size_t device_id) const {
     PLSSVM_ASSERT(device_id < this->num_available_devices(), "Invalid device {} requested!", device_id);
     cudaDeviceProp prop{};
diff --git a/src/plssvm/backends/CUDA/detail/device_ptr.cu b/src/plssvm/backends/CUDA/detail/device_ptr.cu
index 5d7ba74bb..2d875cdfd 100644
--- a/src/plssvm/backends/CUDA/detail/device_ptr.cu
+++ b/src/plssvm/backends/CUDA/detail/device_ptr.cu
@@ -15,6 +15,8 @@
 #include "plssvm/exceptions/exceptions.hpp"                    // plssvm::exception
 #include "plssvm/shape.hpp"                                    // plssvm::shape
 
+#include "driver_types.h"  // cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, cudaMemcpyDeviceToDevice
+
 #include "fmt/format.h"  // fmt::format
 
 #include <algorithm>  // std::min
@@ -35,12 +37,16 @@ device_ptr<T>::device_ptr(const plssvm::shape shape, const queue_type device) :
 template <typename T>
 device_ptr<T>::device_ptr(const plssvm::shape shape, const plssvm::shape padding, const queue_type device) :
     base_type{ shape, padding, device } {
-    if (queue_ < 0 || queue_ >= static_cast<int>(get_device_count())) {
+    if (queue_ < 0 || queue_ >= get_device_count()) {
         throw backend_exception{ fmt::format("Illegal device ID! Must be in range: [0, {}) but is {}.", get_device_count(), queue_) };
     }
     detail::set_device(queue_);
     PLSSVM_CUDA_ERROR_CHECK(cudaMalloc(&data_, this->size_padded() * sizeof(value_type)))
-    this->memset(0);
+
+    // only non-empty pointers must be memset in the constructor
+    if (this->size_padded() != std::size_t{ 0 }) {
+        this->memset(0);
+    }
 }
 
 template <typename T>
diff --git a/src/plssvm/backends/CUDA/detail/pinned_memory.cu b/src/plssvm/backends/CUDA/detail/pinned_memory.cu
index f576519a8..14d93ad3d 100644
--- a/src/plssvm/backends/CUDA/detail/pinned_memory.cu
+++ b/src/plssvm/backends/CUDA/detail/pinned_memory.cu
@@ -15,13 +15,13 @@
 #include "plssvm/exceptions/exceptions.hpp"                // plssvm::exception
 
 #include "cuda_runtime_api.h"  // cudaHostRegister
+#include "driver_types.h"      // cudaHostRegisterDefault
 
-#include "driver_types.h"  // cudaHostRegisterDefault
-#include <chrono>          // std::chrono::steady_clock::{now, time_point}, std::chrono::duration_cast
-#include <cstddef>         // std::size_t
-#include <exception>       // std::terminate
-#include <iostream>        // std::cerr, std::endl
-#include <vector>          // std::vector
+#include <chrono>     // std::chrono::steady_clock::{now, time_point}, std::chrono::duration_cast
+#include <cstddef>    // std::size_t
+#include <exception>  // std::terminate
+#include <iostream>   // std::cerr, std::endl
+#include <vector>     // std::vector
 
 namespace plssvm::cuda::detail {
 
diff --git a/src/plssvm/backends/CUDA/detail/utility.cu b/src/plssvm/backends/CUDA/detail/utility.cu
index 5570f3426..1fb8a3672 100644
--- a/src/plssvm/backends/CUDA/detail/utility.cu
+++ b/src/plssvm/backends/CUDA/detail/utility.cu
@@ -9,6 +9,11 @@
 #include "plssvm/backends/CUDA/detail/utility.cuh"
 
 #include "plssvm/backends/execution_range.hpp"  // plssvm::detail::dim_type
+#include "plssvm/detail/string_utility.hpp"     // plssvm::detail::trim
+
+#include "cuda_runtime_api.h"  // cudaGetDeviceCount, cudaSetDevice, cudaPeekAtLastError, cudaDeviceSynchronize, cudaGetDeviceProperties, cudaRuntimeGetVersion
+#include "driver_types.h"      // cudaError_t
+#include "vector_types.h"      // dim3, cudaDeviceProp
 
 #include "fmt/format.h"  // fmt::format
 
@@ -46,13 +51,21 @@ void device_synchronize(const int device) {
     PLSSVM_CUDA_ERROR_CHECK(cudaDeviceSynchronize())
 }
 
+std::string get_device_name(const int device) {
+    cudaDeviceProp prop{};
+    PLSSVM_CUDA_ERROR_CHECK(cudaGetDeviceProperties(&prop, device))
+    return std::string{ ::plssvm::detail::trim(static_cast<const char *>(prop.name)) };
+}
+
 std::string get_runtime_version() {
     // get the CUDA runtime version
     int runtime_version{};
     PLSSVM_CUDA_ERROR_CHECK(cudaRuntimeGetVersion(&runtime_version))
     // parse it to a more useful string
-    int major_version = runtime_version / 1000;
-    int minor_version = runtime_version % 1000 / 10;
+    constexpr int major_version_mask = 1000;
+    constexpr int minor_version_mask = 10;
+    const int major_version = runtime_version / major_version_mask;
+    const int minor_version = runtime_version % major_version_mask / minor_version_mask;
     return fmt::format("{}.{}", major_version, minor_version);
 }
 
diff --git a/src/plssvm/backends/HIP/csvm.hip b/src/plssvm/backends/HIP/csvm.hip
index 312ad3122..d5bf7f75e 100644
--- a/src/plssvm/backends/HIP/csvm.hip
+++ b/src/plssvm/backends/HIP/csvm.hip
@@ -11,7 +11,7 @@
 #include "plssvm/backend_types.hpp"                                                    // plssvm::backend_type
 #include "plssvm/backends/execution_range.hpp"                                         // plssvm::detail::{dim_type, execution_range}
 #include "plssvm/backends/HIP/detail/device_ptr.hip.hpp"                               // plssvm::hip::detail::device_ptr
-#include "plssvm/backends/HIP/detail/utility.hip.hpp"                                  // PLSSVM_HIP_ERROR_CHECK, plssvm::hip::detail::{device_synchronize, get_device_count, set_device, peek_at_last_error, get_runtime_version}
+#include "plssvm/backends/HIP/detail/utility.hip.hpp"                                  // PLSSVM_HIP_ERROR_CHECK, plssvm::hip::detail::{device_synchronize, get_device_count, set_device, peek_at_last_error, get_device_name, get_runtime_version}
 #include "plssvm/backends/HIP/exceptions.hpp"                                          // plssvm::hip::backend_exception
 #include "plssvm/backends/HIP/kernel/cg_explicit/blas.hip.hpp"                         // plssvm::hip::detail::{device_kernel_symm, device_kernel_symm_mirror, device_kernel_inplace_matrix_add, device_kernel_inplace_matrix_scale}
 #include "plssvm/backends/HIP/kernel/cg_explicit/kernel_matrix_assembly.hip.hpp"       // plssvm::hip::detail::device_kernel_assembly
@@ -24,11 +24,10 @@
 #include "plssvm/detail/memory_size.hpp"                                               // plssvm::detail::memory_size
 #include "plssvm/detail/tracking/performance_tracker.hpp"                              // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
 #include "plssvm/exceptions/exceptions.hpp"                                            // plssvm::exception
-#include "plssvm/gamma.hpp"                                                            // plssvm::gamma_type
 #include "plssvm/kernel_function_types.hpp"                                            // plssvm::kernel_function_type
 #include "plssvm/mpi/communicator.hpp"                                                 // plssvm::mpi::communicator
 #include "plssvm/mpi/detail/information.hpp"                                           // plssvm::mpi::detail::gather_and_print_csvm_information
-#include "plssvm/parameter.hpp"                                                        // plssvm::parameter, plssvm::detail::parameter
+#include "plssvm/parameter.hpp"                                                        // plssvm::parameter
 #include "plssvm/shape.hpp"                                                            // plssvm::shape
 #include "plssvm/target_platforms.hpp"                                                 // plssvm::target_platform
 #include "plssvm/verbosity_levels.hpp"                                                 // plssvm::verbosity_level
@@ -38,11 +37,11 @@
 #include "fmt/format.h"  // fmt::format
 
 #include <chrono>     // std::chrono::{steady_clock, duration_cast}
-#include <cmath>      // std::ceil
 #include <cstddef>    // std::size_t
 #include <exception>  // std::terminate
 #include <iostream>   // std::cout, std::endl
 #include <numeric>    // std::iota
+#include <optional>   // std::optional
 #include <string>     // std::string
 #include <variant>    // std::get
 #include <vector>     // std::vector
@@ -94,9 +93,7 @@ csvm::csvm(const target_platform target) {
     if (comm_.size() > 1) {
         // use MPI rank specific command line output
         for (const queue_type &device : devices_) {
-            hipDeviceProp_t prop{};
-            PLSSVM_HIP_ERROR_CHECK(hipGetDeviceProperties(&prop, device))
-            device_names.emplace_back(prop.name);
+            device_names.push_back(detail::get_device_name(device));
         }
 
         mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::hip, target_, device_names);
@@ -111,16 +108,16 @@ csvm::csvm(const target_platform target) {
                                       devices_.size());
 
         for (const queue_type &device : devices_) {
+            device_names.push_back(detail::get_device_name(device));
             hipDeviceProp_t prop{};
             PLSSVM_HIP_ERROR_CHECK(hipGetDeviceProperties(&prop, device))
             plssvm::detail::log_untracked(verbosity_level::full,
                                           comm_,
                                           "  [{}, {}, {}.{}]\n",
                                           device,
-                                          prop.name,
+                                          device_names.back(),
                                           prop.major,
                                           prop.minor);
-            device_names.emplace_back(prop.name);
         }
     }
 
@@ -162,6 +159,16 @@ std::vector<::plssvm::detail::memory_size> csvm::get_max_mem_alloc_size() const
     return this->get_device_memory();
 }
 
+std::vector<std::optional<::plssvm::detail::memory_size>> csvm::get_local_memory() const {
+    hipDeviceProp_t prop{};
+    std::vector<std::optional<::plssvm::detail::memory_size>> res(this->num_available_devices());
+    for (std::size_t device_id = 0; device_id < this->num_available_devices(); ++device_id) {
+        PLSSVM_HIP_ERROR_CHECK(hipGetDeviceProperties(&prop, devices_[device_id]))
+        res[device_id] = ::plssvm::detail::memory_size{ static_cast<unsigned long long>(prop.sharedMemPerBlock) };
+    }
+    return res;
+}
+
 std::size_t csvm::get_max_work_group_size(const std::size_t device_id) const {
     PLSSVM_ASSERT(device_id < this->num_available_devices(), "Invalid device {} requested!", device_id);
     hipDeviceProp_t prop{};
diff --git a/src/plssvm/backends/HIP/detail/device_ptr.hip b/src/plssvm/backends/HIP/detail/device_ptr.hip
index 560783097..84cf81420 100644
--- a/src/plssvm/backends/HIP/detail/device_ptr.hip
+++ b/src/plssvm/backends/HIP/detail/device_ptr.hip
@@ -39,12 +39,16 @@ device_ptr<T>::device_ptr(const plssvm::shape shape, const queue_type device) :
 template <typename T>
 device_ptr<T>::device_ptr(const plssvm::shape shape, const plssvm::shape padding, const queue_type device) :
     base_type{ shape, padding, device } {
-    if (queue_ < 0 || queue_ >= static_cast<int>(get_device_count())) {
+    if (queue_ < 0 || queue_ >= get_device_count()) {
         throw backend_exception{ fmt::format("Illegal device ID! Must be in range: [0, {}) but is {}.", get_device_count(), queue_) };
     }
     detail::set_device(queue_);
     PLSSVM_HIP_ERROR_CHECK(hipMalloc(&data_, this->size_padded() * sizeof(value_type)))
-    this->memset(0);
+
+    // only non-empty pointers must be memset in the constructor
+    if (this->size_padded() != std::size_t{ 0 }) {
+        this->memset(0);
+    }
 }
 
 template <typename T>
@@ -80,16 +84,29 @@ void device_ptr<T>::fill(const value_type value, const size_type pos, const size
         throw backend_exception{ fmt::format("Illegal access in fill!: {} >= {}", pos, this->size_padded()) };
     }
 
+    const size_type rcount = std::min(count, this->size_padded() - pos);
+
+#if defined(PLSSVM_HIP_BACKEND_USE_CUDA_RUNTIME)
+    // TODO: For some reason, the HIP kernel is NOT called in the tests when running HIP on an NVIDIA GPU (the separate kernel test, however, passes...)
+    //       However, this is not a big deal since the fill function is never used inside the actual application code.
+    std::vector<value_type> temp(this->size_padded());
+    this->copy_to_host(temp);
+    #pragma omp parallel for
+    for (std::size_t i = 0; i < rcount; ++i) {
+        temp[pos + i] = value;
+    }
+    this->copy_to_device(temp);
+#else
     detail::set_device(queue_);
 
     // run GPU kernel
-    const size_type rcount = std::min(count, this->size_padded() - pos);
     constexpr unsigned int block_size = 512;
     const unsigned int grid_size = (static_cast<unsigned int>(rcount) + block_size - 1) / block_size;
     detail::fill_array<<<grid_size, block_size>>>(data_, value, pos, rcount);
 
     detail::peek_at_last_error();
     detail::device_synchronize(queue_);
+#endif
 }
 
 template <typename T>
diff --git a/src/plssvm/backends/HIP/detail/utility.hip b/src/plssvm/backends/HIP/detail/utility.hip
index d045f7f62..3d142ffb0 100644
--- a/src/plssvm/backends/HIP/detail/utility.hip
+++ b/src/plssvm/backends/HIP/detail/utility.hip
@@ -10,6 +10,7 @@
 // main header
 
 #include "plssvm/backends/execution_range.hpp"  // plssvm::detail::dim_type
+#include "plssvm/detail/string_utility.hpp"     // plssvm::detail::trim
 
 #include "hip/hip_runtime_api.h"  // hipGetDeviceCount, hipSetDevice, hipPeekAtLastError, hipDeviceSynchronize, hipRuntimeGetVersion
 
@@ -30,7 +31,7 @@ dim3 dim_type_to_native(const ::plssvm::detail::dim_type &dims) {
 }
 
 void set_device(const int device) {
-    if (device < 0 || device >= static_cast<int>(get_device_count())) {
+    if (device < 0 || device >= get_device_count()) {
         throw backend_exception{ fmt::format("Illegal device ID! Must be in range: [0, {}) but is {}!", get_device_count(), device) };
     }
     PLSSVM_HIP_ERROR_CHECK(hipSetDevice(device))
@@ -41,7 +42,7 @@ void peek_at_last_error() {
 }
 
 void device_synchronize(const int device) {
-    if (device < 0 || device >= static_cast<int>(get_device_count())) {
+    if (device < 0 || device >= get_device_count()) {
         throw backend_exception{ fmt::format("Illegal device ID! Must be in range: [0, {}) but is {}!", get_device_count(), device) };
     }
     peek_at_last_error();
@@ -55,19 +56,29 @@ std::string get_runtime_version() {
     PLSSVM_HIP_ERROR_CHECK(hipRuntimeGetVersion(&runtime_version))
 #if defined(PLSSVM_HIP_BACKEND_USE_HIP_RUNTIME)
     // parse it to a more useful string
-    int major_version = runtime_version / 10'000'000;
-    int minor_version = runtime_version % 10'000'000 / 100'000;
+    constexpr int major_version_mask = 10'000'000;
+    constexpr int minor_version_mask = 100'000;
+    const int major_version = runtime_version / major_version_mask;
+    const int minor_version = runtime_version % major_version_mask / minor_version_mask;
     return fmt::format("{}.{}", major_version, minor_version);
 #elif defined(PLSSVM_HIP_BACKEND_USE_CUDA_RUNTIME)
     // parse it to a more useful string
-    int major_version = runtime_version / 1000;
-    int minor_version = runtime_version % 1000 / 10;
+    constexpr int major_version_mask = 1000;
+    constexpr int minor_version_mask = 10;
+    const int major_version = runtime_version / major_version_mask;
+    const int minor_version = runtime_version % major_version_mask / minor_version_mask;
     return fmt::format("{}.{}", major_version, minor_version);
 #else
     return "unknown";
 #endif
 }
 
+std::string get_device_name(const int device) {
+    hipDeviceProp_t prop{};
+    PLSSVM_HIP_ERROR_CHECK(hipGetDeviceProperties(&prop, device))
+    return std::string{ ::plssvm::detail::trim(prop.name) };
+}
+
 std::string get_runtime() {
 #if defined(PLSSVM_HIP_BACKEND_USE_HIP_RUNTIME)
     return "HIP";
diff --git a/src/plssvm/backends/HPX/.clang-tidy b/src/plssvm/backends/HPX/.clang-tidy
new file mode 100644
index 000000000..cdf2ade2d
--- /dev/null
+++ b/src/plssvm/backends/HPX/.clang-tidy
@@ -0,0 +1,6 @@
+---
+Checks: '
+-misc-include-cleaner,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/src/plssvm/backends/HPX/csvm.cpp b/src/plssvm/backends/HPX/csvm.cpp
index 71f651688..16062ab89 100644
--- a/src/plssvm/backends/HPX/csvm.cpp
+++ b/src/plssvm/backends/HPX/csvm.cpp
@@ -9,15 +9,18 @@
 
 #include "plssvm/backends/HPX/csvm.hpp"
 
+#include "plssvm/backend_types.hpp"                                                // plssvm::backend_type
+#include "plssvm/backends/HPX/detail/utility.hpp"                                  // plssvm::hpx::detail::{get_hpx_version, get_num_threads}
 #include "plssvm/backends/HPX/exceptions.hpp"                                      // plssvm::hpx::backend_exception
 #include "plssvm/backends/HPX/kernel/cg_explicit/blas.hpp"                         // plssvm::hpx::detail::device_kernel_symm
 #include "plssvm/backends/HPX/kernel/cg_explicit/kernel_matrix_assembly.hpp"       // plssvm::hpx::detail::device_kernel_assembly
 #include "plssvm/backends/HPX/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp"  // plssvm::hpx::detail::device_kernel_assembly_symm
 #include "plssvm/backends/HPX/kernel/predict_kernel.hpp"                           // plssvm::hpx::detail::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
-#include "plssvm/constants.hpp"                                                    // plssvm::real_type
+#include "plssvm/constants.hpp"                                                    // plssvm::real_type, plssvm::PADDING_SIZE
 #include "plssvm/detail/assert.hpp"                                                // PLSSVM_ASSERT
 #include "plssvm/detail/data_distribution.hpp"                                     // plssvm::detail::triangular_data_distribution
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"                             // plssvm::detail::log_untracked
+#include "plssvm/detail/make_unique_for_overwrite.hpp"                             // plssvm::detail::{make_unique_for_overwrite, parallel_zero_memset}
 #include "plssvm/detail/memory_size.hpp"                                           // plssvm::detail::memory_size
 #include "plssvm/detail/move_only_any.hpp"                                         // plssvm::detail::{move_only_any, move_only_any_cast}
 #include "plssvm/detail/tracking/performance_tracker.hpp"                          // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
@@ -29,16 +32,23 @@
 #include "plssvm/parameter.hpp"                                                    // plssvm::parameter
 #include "plssvm/shape.hpp"                                                        // plssvm::shape
 #include "plssvm/solver_types.hpp"                                                 // plssvm::solver_type
-#include "plssvm/svm/csvm.hpp"                                                     // plssvm::csvm
 #include "plssvm/target_platforms.hpp"                                             // plssvm::target_platform
+#include "plssvm/verbosity_levels.hpp"                                             // plssvm::verbosity_level
 
-#include "hpx/future.hpp"  // hpx::future, hpx::async
+#include "hpx/async.hpp"   // hpx::async
+#include "hpx/future.hpp"  // hpx::future
 
-#include <chrono>   // std::chrono::{steady_clock, duration_cast}
-#include <cstddef>  // std::size_t
-#include <tuple>    // std::tuple, std::make_tuple
-#include <utility>  // std::move
-#include <vector>   // std::vector
+#include "fmt/format.h"  // fmt::format
+
+#include <chrono>      // std::chrono::{steady_clock, duration_cast}
+#include <cstddef>     // std::size_t
+#include <cstring>     // std::memcpy
+#include <functional>  // std::cref
+#include <memory>      // std::make_unique, std::unique_ptr
+#include <optional>    // std::optional, std::nullopt
+#include <tuple>       // std::tuple, std::make_tuple
+#include <utility>     // std::move
+#include <vector>      // std::vector
 
 namespace plssvm::hpx {
 
@@ -73,19 +83,23 @@ csvm::csvm(const target_platform target) {
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "backend", plssvm::backend_type::hpx }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "target_platform", target_ }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_threads", detail::get_num_threads() }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));  // NOLINT: safe to call this virtual function in the constructor
 }
 
 csvm::~csvm() = default;
 
 std::vector<::plssvm::detail::memory_size> csvm::get_device_memory() const {
-    return { ::plssvm::detail::get_system_memory() };
+    return std::vector<::plssvm::detail::memory_size>(this->num_available_devices(), ::plssvm::detail::get_system_memory());
 }
 
 std::vector<::plssvm::detail::memory_size> csvm::get_max_mem_alloc_size() const {
     return this->get_device_memory();
 }
 
+std::vector<std::optional<::plssvm::detail::memory_size>> csvm::get_local_memory() const {
+    return std::vector<std::optional<::plssvm::detail::memory_size>>(this->num_available_devices(), std::nullopt);
+}
+
 //***************************************************//
 //                        fit                        //
 //***************************************************//
@@ -120,26 +134,33 @@ std::vector<::plssvm::detail::move_only_any> csvm::assemble_kernel_matrix(const
                         // get the offset of the data points this device is responsible for
                         const std::size_t row_offset = dist.place_row_offset(0);
 
-                        std::vector<real_type> kernel_matrix(dist.calculate_explicit_kernel_matrix_num_entries_padded(0));  // only explicitly store the upper triangular matrix
+                        // get the number of kernel matrix entries
+                        const std::size_t num_entries = dist.calculate_explicit_kernel_matrix_num_entries_padded(0);
+
+                        // only explicitly store the upper triangular matrix
+                        auto kernel_matrix = ::plssvm::detail::make_unique_for_overwrite<real_type[]>(num_entries);  // NOLINT: C-style array must be used with make_unique_for_overwrite
+                        // initialize kernel matrix to all zeros in parallel
+                        ::plssvm::detail::parallel_zero_memset(kernel_matrix.get(), num_entries);
+
                         const auto start = std::chrono::steady_clock::now();
                         switch (params.kernel_type) {
                             case kernel_function_type::linear:
-                                detail::device_kernel_assembly<kernel_function_type::linear>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost);
+                                detail::device_kernel_assembly<kernel_function_type::linear>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost);
                                 break;
                             case kernel_function_type::polynomial:
-                                detail::device_kernel_assembly<kernel_function_type::polynomial>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, params.degree, std::get<real_type>(params.gamma), params.coef0);
+                                detail::device_kernel_assembly<kernel_function_type::polynomial>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, params.degree, std::get<real_type>(params.gamma), params.coef0);
                                 break;
                             case kernel_function_type::rbf:
-                                detail::device_kernel_assembly<kernel_function_type::rbf>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
+                                detail::device_kernel_assembly<kernel_function_type::rbf>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
                                 break;
                             case kernel_function_type::sigmoid:
-                                detail::device_kernel_assembly<kernel_function_type::sigmoid>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma), params.coef0);
+                                detail::device_kernel_assembly<kernel_function_type::sigmoid>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma), params.coef0);
                                 break;
                             case kernel_function_type::laplacian:
-                                detail::device_kernel_assembly<kernel_function_type::laplacian>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
+                                detail::device_kernel_assembly<kernel_function_type::laplacian>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
                                 break;
                             case kernel_function_type::chi_squared:
-                                detail::device_kernel_assembly<kernel_function_type::chi_squared>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
+                                detail::device_kernel_assembly<kernel_function_type::chi_squared>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
                                 break;
                         }
                         const auto end = std::chrono::steady_clock::now();
@@ -152,7 +173,7 @@ std::vector<::plssvm::detail::move_only_any> csvm::assemble_kernel_matrix(const
                 case solver_type::cg_implicit:
                     {
                         // simply return data since in implicit we don't assembly the kernel matrix here!
-                        kernel_matrices_parts[0] = ::plssvm::detail::move_only_any{ std::make_tuple(std::move(A), params, std::move(q_red), QA_cost) };
+                        kernel_matrices_parts[0] = ::plssvm::detail::move_only_any{ std::make_tuple(std::cref(A), params, std::cref(q_red), QA_cost) };
                     }
                     break;
             }
@@ -173,7 +194,7 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
     PLSSVM_ASSERT(B.shape() == C.shape(), "The B ({}) and C ({}) matrices must have the same shape!", B.shape(), C.shape());
     PLSSVM_ASSERT(B.padding() == C.padding(), "The B ({}) and C ({}) matrices must have the same padding!", B.padding(), C.padding());
 
-    using namespace operators;
+    using namespace operators;  // NOLINT(google-build-using-namespace): only imports custom math operations on vectors (and scalars)
 
     // get the triangular data distribution
     const ::plssvm::detail::triangular_data_distribution &dist = dynamic_cast<::plssvm::detail::triangular_data_distribution &>(*data_distribution_);
@@ -200,16 +221,16 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
                     break;
                 case solver_type::cg_explicit:
                     {
-                        const auto &explicit_A = ::plssvm::detail::move_only_any_cast<const std::vector<real_type> &>(A.front());
-                        PLSSVM_ASSERT(!explicit_A.empty(), "The A matrix must not be empty!");
+                        const auto &explicit_A = ::plssvm::detail::move_only_any_cast<const std::unique_ptr<real_type[]> &>(A.front());  // NOLINT: C-style array must be used
+                        PLSSVM_ASSERT(explicit_A != nullptr, "The A matrix must not be empty!");
 
                         const auto start = std::chrono::steady_clock::now();
 
-                        detail::device_kernel_symm(num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, explicit_A, B, beta, C);
+                        detail::device_kernel_symm(num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, explicit_A.get(), B, beta, C);
 
                         const std::size_t num_mirror_rows = num_rows - row_offset - device_specific_num_rows;
                         if (num_mirror_rows > std::size_t{ 0 }) {
-                            detail::device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, explicit_A, B, beta, C);
+                            detail::device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, explicit_A.get(), B, beta, C);
                         }
 
                         const auto end = std::chrono::steady_clock::now();
@@ -219,7 +240,7 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
                     break;
                 case solver_type::cg_implicit:
                     {
-                        const auto &[matr_A, params, q_red, QA_cost] = ::plssvm::detail::move_only_any_cast<const std::tuple<soa_matrix<real_type>, parameter, std::vector<real_type>, real_type> &>(A.front());
+                        const auto &[matr_A, params, q_red, QA_cost] = ::plssvm::detail::move_only_any_cast<const std::tuple<const soa_matrix<real_type> &, parameter, const std::vector<real_type> &, real_type> &>(A.front());
                         PLSSVM_ASSERT(!matr_A.empty(), "The A matrix must not be empty!");
                         PLSSVM_ASSERT(!q_red.empty(), "The q_red vector must not be empty!");
                         const real_type cost = real_type{ 1.0 } / params.cost;
@@ -261,6 +282,8 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
     });
     // wait until operation is completed
     wait.get();
+    // restore padding entries by setting them to zero
+    C.restore_padding();
 }
 
 //***************************************************//
@@ -317,6 +340,8 @@ aos_matrix<real_type> csvm::predict_values(const parameter &params,
                     [[maybe_unused]] const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
                     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "predict_values", "w_kernel", duration }));
                 }
+                // restore padding entries by setting them to zero
+                w.restore_padding();
 
                 // reduce w on all MPI ranks
                 comm_.allreduce_inplace(w);
@@ -332,8 +357,12 @@ aos_matrix<real_type> csvm::predict_values(const parameter &params,
             // call the predict kernels
             switch (params.kernel_type) {
                 case kernel_function_type::linear:
-                    // predict the values using the w vector
-                    detail::device_kernel_predict_linear(out, w, rho, predict_points, device_specific_num_predict_points, row_offset);
+                    {
+                        // predict the values using the w vector
+                        std::vector<real_type> rho_padded(rho.size() + PADDING_SIZE, real_type{ 0.0 });
+                        std::memcpy(rho_padded.data(), rho.data(), rho.size() * sizeof(real_type));
+                        detail::device_kernel_predict_linear(out, w, rho_padded, predict_points, device_specific_num_predict_points, row_offset);
+                    }
                     break;
                 case kernel_function_type::polynomial:
                     detail::device_kernel_predict<kernel_function_type::polynomial>(out, alpha, rho, support_vectors, predict_points, device_specific_num_predict_points, row_offset, params.degree, std::get<real_type>(params.gamma), params.coef0);
@@ -358,6 +387,9 @@ aos_matrix<real_type> csvm::predict_values(const parameter &params,
     });
     // wait until operation is completed
     wait.get();
+
+    // restore padding entries by setting them to zero
+    out.restore_padding();
     return out;
 }
 
diff --git a/src/plssvm/backends/HPX/detail/utility.cpp b/src/plssvm/backends/HPX/detail/utility.cpp
index 9cd2265fc..8bd8a01f7 100644
--- a/src/plssvm/backends/HPX/detail/utility.cpp
+++ b/src/plssvm/backends/HPX/detail/utility.cpp
@@ -9,8 +9,8 @@
 
 #include "plssvm/backends/HPX/detail/utility.hpp"
 
-#include "hpx/runtime_distributed.hpp"  // ::hpx::get_num_worker_threads
-#include "hpx/version.hpp"              // ::hpx::full_version_as_string
+#include "hpx/runtime_local/runtime_local.hpp"  // ::hpx::get_num_worker_threads
+#include "hpx/version.hpp"                      // ::hpx::full_version_as_string
 
 #include <string>  // std::string
 
@@ -24,4 +24,5 @@ int get_num_threads() {
     // get the number of used HPX threads
     return static_cast<int>(::hpx::get_num_worker_threads());
 }
+
 }  // namespace plssvm::hpx::detail
diff --git a/src/plssvm/backends/Kokkos/.clang-tidy b/src/plssvm/backends/Kokkos/.clang-tidy
new file mode 100644
index 000000000..8e67f7580
--- /dev/null
+++ b/src/plssvm/backends/Kokkos/.clang-tidy
@@ -0,0 +1,10 @@
+---
+Checks: '
+-cppcoreguidelines-avoid-const-or-ref-data-members,
+
+-misc-include-cleaner,
+
+-performance-unnecessary-value-param,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/src/plssvm/backends/Kokkos/csvm.cpp b/src/plssvm/backends/Kokkos/csvm.cpp
index 2bf512433..f8d8e2a18 100644
--- a/src/plssvm/backends/Kokkos/csvm.cpp
+++ b/src/plssvm/backends/Kokkos/csvm.cpp
@@ -11,16 +11,15 @@
 #include "plssvm/backend_types.hpp"                                                   // plssvm::backend_type
 #include "plssvm/backends/execution_range.hpp"                                        // plssvm::detail::{execution_range, dim_type}
 #include "plssvm/backends/Kokkos/detail/conditional_execution.hpp"                    // PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_*, PLSSVM_KOKKOS_BACKEND_INVOKE_IF_
-#include "plssvm/backends/Kokkos/detail/device_ptr.hpp"                               // plssvm::kokkos::detail::device_ptr
 #include "plssvm/backends/Kokkos/detail/device_wrapper.hpp"                           // plssvm::kokkos::detail::{device_wrapper, get_device_list}
 #include "plssvm/backends/Kokkos/detail/utility.hpp"                                  // plssvm::kokkos::detail::{available_target_platform_to_execution_space_mapping, get_kokkos_version, dim_type_to_native, get_device_name, device_synchronize}
 #include "plssvm/backends/Kokkos/exceptions.hpp"                                      // plssvm::kokkos::backend_exception
-#include "plssvm/backends/Kokkos/execution_space.hpp"                                 // plssvm::kokkos::{execution_space, list_available_execution_spaces}
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"                                // plssvm::kokkos::{execution_space, list_available_execution_spaces}
 #include "plssvm/backends/Kokkos/kernel/cg_explicit/blas.hpp"                         // plssvm::kokkos::detail::{device_kernel_symm, device_kernel_symm_mirror, device_kernel_inplace_matrix_add, device_kernel_inplace_matrix_scale}
 #include "plssvm/backends/Kokkos/kernel/cg_explicit/kernel_matrix_assembly.hpp"       // plssvm::kokkos::detail::device_kernel_assembly
 #include "plssvm/backends/Kokkos/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp"  // plssvm::kokkos::detail::device_kernel_assembly_symm
 #include "plssvm/backends/Kokkos/kernel/predict_kernel.hpp"                           // plssvm::kokkos::detail::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
-#include "plssvm/constants.hpp"                                                       // plssvm::THREAD_BLOCK_SIZE, plssvm::INTERNAL_BLOCK_SIZE, plssvm::FEATURE_BLOCK_SIZE
+#include "plssvm/constants.hpp"                                                       // plssvm::THREAD_BLOCK_SIZE, plssvm::INTERNAL_BLOCK_SIZE
 #include "plssvm/detail/assert.hpp"                                                   // PLSSVM_ASSERT
 #include "plssvm/detail/data_distribution.hpp"                                        // plssvm::detail::triangular_data_distribution
 #include "plssvm/detail/logging/log_untracked.hpp"                                    // plssvm::detail::log_untracked
@@ -40,8 +39,8 @@
 #include "Kokkos_Core.hpp"  // Kokkos::TeamPolicy, Kokkos::ParallelForTag, Kokkos::parallel_for, Kokkos::PerTeam
                             // Kokkos::Experimental::HPX::impl_max_hardware_threads, Kokkos::OpenMP::impl_max_hardware_threads, Kokkos::Threads::impl_max_hardware_threads
 
-#include "fmt/core.h"    // fmt::format
 #include "fmt/format.h"  // fmt::format
+#include "fmt/ranges.h"  // fmt::join
 
 #include <chrono>     // std::chrono::{steady_clock, duration_cast}
 #include <cmath>      // std::sqrt
@@ -50,17 +49,125 @@
 #include <iostream>   // std::cout, std::endl
 #include <limits>     // std::numeric_limits::max
 #include <map>        // std::map
+#include <optional>   // std::optional
 #include <string>     // std::string
-#include <utility>    // std::move
+#include <utility>    // std::move, std::forward
 #include <vector>     // std::vector
 
+namespace {
+
 // a dummy class used as functor to the team_size_max function
 template <typename ExecutionSpace>
 struct dummy {
     KOKKOS_INLINE_FUNCTION
-    void operator()(const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &) const { }
+    void operator()([[maybe_unused]] const typename Kokkos::TeamPolicy<ExecutionSpace>::member_type &policy) const { }
 };
 
+/**
+ * @brief Run the kernel functor on the given device.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam Args the types of the parameters necessary for the specific kernel functor
+ * @param[in] partial_grid the number of work-groups in each dimension of the execution grid
+ * @param[in] block the number of work-items in each dimension per work-group
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <typename KernelFunctor, typename TeamPolicy, typename... Args>
+void run_kernel_functor(const std::string &kernel_name, const TeamPolicy &policy, Args &&...args) {
+    Kokkos::parallel_for(kernel_name, policy, KernelFunctor{ std::forward<Args>(args)... });
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct kernel function type.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam ExecutionSpace the used Kokkos execution space
+ * @tparam target the target platform to run the kernel on
+ * @tparam Args the types of the parameters necessary for the specific kernel functor
+ * @param[in] params the parameters used to determine the kernel function type
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <typename, plssvm::target_platform, plssvm::kernel_function_type, typename...> typename KernelFunctor, typename ExecutionSpace, plssvm::target_platform target, typename... Args>
+void dispatch_kernel_function_type(const plssvm::parameter &params, Args &&...args) {
+    switch (params.kernel_type) {
+        case plssvm::kernel_function_type::linear:
+            run_kernel_functor<KernelFunctor<ExecutionSpace, target, plssvm::kernel_function_type::linear>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::kernel_function_type::polynomial:
+            run_kernel_functor<KernelFunctor<ExecutionSpace, target, plssvm::kernel_function_type::polynomial, int, plssvm::real_type, plssvm::real_type>>(std::forward<Args>(args)..., params.degree, std::get<plssvm::real_type>(params.gamma), params.coef0);
+            break;
+        case plssvm::kernel_function_type::rbf:
+            run_kernel_functor<KernelFunctor<ExecutionSpace, target, plssvm::kernel_function_type::rbf, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+        case plssvm::kernel_function_type::sigmoid:
+            run_kernel_functor<KernelFunctor<ExecutionSpace, target, plssvm::kernel_function_type::sigmoid, plssvm::real_type, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma), params.coef0);
+            break;
+        case plssvm::kernel_function_type::laplacian:
+            run_kernel_functor<KernelFunctor<ExecutionSpace, target, plssvm::kernel_function_type::laplacian, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+        case plssvm::kernel_function_type::chi_squared:
+            run_kernel_functor<KernelFunctor<ExecutionSpace, target, plssvm::kernel_function_type::chi_squared, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+    }
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct target platform and kernel function type.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam ExecutionSpace the used Kokkos execution space
+ * @tparam Args the types of the parameters necessary for the specific kernel functor; stored in a `std::tuple`
+ * @param[in] target the target platform to run the kernel on
+ * @param[in] params the parameters used to determine the kernel function type
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <typename, plssvm::target_platform, plssvm::kernel_function_type, typename...> typename KernelFunctor, typename ExecutionSpace, typename... Args>
+void dispatch_target_platform(const plssvm::target_platform target, const plssvm::parameter &params, Args &&...args) {
+    switch (target) {
+        case plssvm::target_platform::automatic:
+            throw plssvm::kokkos::backend_exception{ "Can't determine the target platform!" };
+        case plssvm::target_platform::gpu_nvidia:
+            dispatch_kernel_function_type<KernelFunctor, ExecutionSpace, plssvm::target_platform::gpu_nvidia>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            dispatch_kernel_function_type<KernelFunctor, ExecutionSpace, plssvm::target_platform::gpu_amd>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            dispatch_kernel_function_type<KernelFunctor, ExecutionSpace, plssvm::target_platform::gpu_intel>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::cpu:
+            dispatch_kernel_function_type<KernelFunctor, ExecutionSpace, plssvm::target_platform::cpu>(params, std::forward<Args>(args)...);
+            break;
+    }
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct target platform.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam ExecutionSpace the used Kokkos execution space
+ * @tparam Args the types of the parameters necessary for the specific kernel functor; stored in a `std::tuple`
+ * @param[in] target the target platform to run the kernel on
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <typename, plssvm::target_platform> typename KernelFunctor, typename ExecutionSpace, typename... Args>
+void dispatch_target_platform(const plssvm::target_platform target, Args &&...args) {
+    switch (target) {
+        case plssvm::target_platform::automatic:
+            throw plssvm::kokkos::backend_exception{ "Can't determine the target platform!" };
+        case plssvm::target_platform::gpu_nvidia:
+            run_kernel_functor<KernelFunctor<ExecutionSpace, plssvm::target_platform::gpu_nvidia>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            run_kernel_functor<KernelFunctor<ExecutionSpace, plssvm::target_platform::gpu_amd>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            run_kernel_functor<KernelFunctor<ExecutionSpace, plssvm::target_platform::gpu_intel>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::cpu:
+            run_kernel_functor<KernelFunctor<ExecutionSpace, plssvm::target_platform::cpu>>(std::forward<Args>(args)...);
+            break;
+    }
+}
+
+}  // namespace
+
 namespace plssvm::kokkos {
 
 void csvm::init(const target_platform target) {
@@ -187,7 +294,7 @@ void csvm::init(const target_platform target) {
     if (comm_.size() > 1) {
         // use MPI rank specific command line output
         for (const queue_type &device : devices_) {
-            device_names.emplace_back(detail::get_device_name(device));
+            device_names.push_back(detail::get_device_name(device));
         }
 
         mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::kokkos, target_, device_names, fmt::format("{}", space_));
@@ -211,12 +318,11 @@ void csvm::init(const target_platform target) {
                                       target_);
 
         for (typename std::vector<queue_type>::size_type device = 0; device < devices_.size(); ++device) {
-            const std::string device_name = detail::get_device_name(devices_[device]);
+            device_names.push_back(detail::get_device_name(devices_[device]));
             plssvm::detail::log_untracked(verbosity_level::full,
                                           "  [{}, {}]\n",
                                           device,
-                                          device_name);
-            device_names.emplace_back(device_name);
+                                          device_names.back());
         }
     }
 
@@ -226,7 +332,7 @@ void csvm::init(const target_platform target) {
 
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "kokkos_version", detail::get_kokkos_version() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "backend", plssvm::backend_type::kokkos }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "kokkos_execution_space", space_ }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "kokkos_execution_space", space_ }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "target_platform", target_ }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", devices_.size() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names }));
@@ -320,6 +426,48 @@ std::vector<::plssvm::detail::memory_size> csvm::get_max_mem_alloc_size() const
     return max_mem_alloc_size;
 }
 
+std::vector<std::optional<::plssvm::detail::memory_size>> csvm::get_local_memory() const {
+    PLSSVM_ASSERT(space_ != execution_space::automatic, "The automatic execution_space may not be provided to this function!");
+
+    std::vector<std::optional<::plssvm::detail::memory_size>> local_mem_size(this->num_available_devices());
+    switch (space_) {
+        case execution_space::automatic:
+            throw backend_exception{ "Unsupported execution_space::automatic provided!" };
+        case execution_space::cuda:
+            PLSSVM_KOKKOS_BACKEND_INVOKE_IF_CUDA([&]() {
+                for (std::size_t device_id = 0; device_id < this->num_available_devices(); ++device_id) {
+                    local_mem_size[device_id] = ::plssvm::detail::memory_size{ static_cast<unsigned long long>(devices_[device_id].get<execution_space::cuda>().cuda_device_prop().sharedMemPerBlock) };
+                }
+            });
+            break;
+        case execution_space::hip:
+            PLSSVM_KOKKOS_BACKEND_INVOKE_IF_HIP([&]() {
+                for (std::size_t device_id = 0; device_id < this->num_available_devices(); ++device_id) {
+                    local_mem_size[device_id] = ::plssvm::detail::memory_size{ static_cast<unsigned long long>(devices_[device_id].get<execution_space::hip>().hip_device_prop().sharedMemPerBlock) };
+                }
+            });
+            break;
+        case execution_space::sycl:
+            PLSSVM_KOKKOS_BACKEND_INVOKE_IF_SYCL([&]() {
+                for (std::size_t device_id = 0; device_id < this->num_available_devices(); ++device_id) {
+                    local_mem_size[device_id] = ::plssvm::detail::memory_size{ static_cast<unsigned long long>(devices_[device_id].get<execution_space::sycl>().sycl_queue().get_device().get_info<::sycl::info::device::local_mem_size>()) };
+                }
+            });
+            break;
+        case execution_space::hpx:
+        case execution_space::openmp:
+        case execution_space::threads:
+        case execution_space::serial:
+            local_mem_size = std::vector<std::optional<::plssvm::detail::memory_size>>(this->num_available_devices(), std::nullopt);
+            break;
+        // TODO: implement for Kokkos::Experimental::OpenMPTarget and Kokkos::Experimental::OpenACC
+        case execution_space::openmp_target:
+        case execution_space::openacc:
+            throw backend_exception{ fmt::format("Currently not implemented for the execution space: {}!", space_) };
+    }
+    return local_mem_size;
+}
+
 std::size_t csvm::get_max_work_group_size(const std::size_t device_id) const {
     PLSSVM_ASSERT(device_id < this->num_available_devices(), "Invalid device {} requested!", device_id);
     PLSSVM_ASSERT(space_ != execution_space::automatic, "The automatic execution_space may not be provided to this function!");
@@ -330,7 +478,7 @@ std::size_t csvm::get_max_work_group_size(const std::size_t device_id) const {
         // NOTE: CUDA + HIP + SYCL: returns the maximum possible number of threads, due to no further limitations in the dummy functor (like, e.g., scratch memory)
         // NOTE: HPX + Serial: hardcoded to 1
         // NOTE: OpenMP: should be 1-2; most likely 1
-        // NOTE: Threads: should be equal to number of hardware threads IF hwloc is enabled; otherwise 1
+        // NOTE: Threads: should be 1; however, always only uses a single core if Kokkos wasn't built with hwloc support
         // NOTE: OpenMPTarget: hardcoded to 256
         // NOTE: OpenACC: hardcoded to 512
 
@@ -414,7 +562,7 @@ auto csvm::run_assemble_kernel_matrix_explicit(const std::size_t device_id, cons
 
     device_ptr_type kernel_matrix_d{ num_entries_padded, devices_[device_id] };  // only explicitly store the upper triangular matrix
     const real_type cost_factor = real_type{ 1.0 } / params.cost;
-    const std::size_t scratch_memory_size = static_cast<std::size_t>(2u * FEATURE_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE) * sizeof(real_type);
+    const std::size_t scratch_memory_size = static_cast<std::size_t>(2u * THREAD_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE) * sizeof(real_type);
 
     // save the team size
     const int team_size = detail::dim_type_to_native(exec.block);
@@ -431,44 +579,7 @@ auto csvm::run_assemble_kernel_matrix_explicit(const std::size_t device_id, cons
             // create a Kokkos TeamPolicy
             Kokkos::TeamPolicy<kokkos_execution_space_type> team_policy{ device, native_partial_grid, team_size };
 
-            switch (params.kernel_type) {
-                case kernel_function_type::linear:
-                    {
-                        using functor_type = detail::device_kernel_assembly<kokkos_execution_space_type, kernel_function_type::linear>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_explicit_linear", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ kernel_matrix_d.get().get<space>(), data_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get().get<space>(), QA_cost, cost_factor, offsets.x, offsets.y, partial_grid.x });
-                    }
-                    break;
-                case kernel_function_type::polynomial:
-                    {
-                        using functor_type = detail::device_kernel_assembly<kokkos_execution_space_type, kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_explicit_polynomial", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ kernel_matrix_d.get().get<space>(), data_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get().get<space>(), QA_cost, cost_factor, offsets.x, offsets.y, partial_grid.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                    }
-                    break;
-                case kernel_function_type::rbf:
-                    {
-                        using functor_type = detail::device_kernel_assembly<kokkos_execution_space_type, kernel_function_type::rbf, real_type>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_explicit_rbf", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ kernel_matrix_d.get().get<space>(), data_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get().get<space>(), QA_cost, cost_factor, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma) });
-                    }
-                    break;
-                case kernel_function_type::sigmoid:
-                    {
-                        using functor_type = detail::device_kernel_assembly<kokkos_execution_space_type, kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_explicit_sigmoid", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ kernel_matrix_d.get().get<space>(), data_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get().get<space>(), QA_cost, cost_factor, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma), params.coef0 });
-                    }
-                    break;
-                case kernel_function_type::laplacian:
-                    {
-                        using functor_type = detail::device_kernel_assembly<kokkos_execution_space_type, kernel_function_type::laplacian, real_type>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_explicit_laplacian", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ kernel_matrix_d.get().get<space>(), data_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get().get<space>(), QA_cost, cost_factor, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma) });
-                    }
-                    break;
-                case kernel_function_type::chi_squared:
-                    {
-                        using functor_type = detail::device_kernel_assembly<kokkos_execution_space_type, kernel_function_type::chi_squared, real_type>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_explicit_chi_squared", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ kernel_matrix_d.get().get<space>(), data_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get().get<space>(), QA_cost, cost_factor, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma) });
-                    }
-                    break;
-            }
+            dispatch_target_platform<detail::device_kernel_assembly, kokkos_execution_space_type>(target_, params, fmt::format("assemble_kernel_matrix_explicit_{}", params.kernel_type), team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), kernel_matrix_d.get().get<space>(), data_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get().get<space>(), QA_cost, cost_factor, offsets.x, offsets.y, partial_grid.x);
         }
         detail::device_synchronize(device);
         const auto end = std::chrono::steady_clock::now();
@@ -492,7 +603,7 @@ void csvm::run_blas_level_3_kernel_explicit(const std::size_t device_id, const :
         // get the offset of the data points this device is responsible for
         const unsigned long long row_offset = data_distribution_->place_row_offset(device_id);
         // the necessary amount of scratch memory for the kernels
-        const std::size_t scratch_memory_size = static_cast<std::size_t>(2u * FEATURE_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE) * sizeof(real_type);
+        const std::size_t scratch_memory_size = static_cast<std::size_t>(2u * THREAD_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE) * sizeof(real_type);
 
         // save the team size
         const int team_size = detail::dim_type_to_native(exec.block);
@@ -505,7 +616,7 @@ void csvm::run_blas_level_3_kernel_explicit(const std::size_t device_id, const :
             // create a Kokkos TeamPolicy
             Kokkos::TeamPolicy<kokkos_execution_space_type> team_policy{ device, native_partial_grid, team_size };
 
-            Kokkos::parallel_for("blas_level_3_kernel_explicit", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), detail::device_kernel_symm<kokkos_execution_space_type>{ num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get().get<space>(), B_d.get().get<space>(), beta, C_d.get().get<space>(), offsets.x, offsets.y, partial_grid.x });
+            dispatch_target_platform<detail::device_kernel_symm, kokkos_execution_space_type>(target_, std::string{ "blas_level_3_kernel_explicit" }, team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get().get<space>(), B_d.get().get<space>(), beta, C_d.get().get<space>(), offsets.x, offsets.y, partial_grid.x);
         }
 
         // save the team size
@@ -521,7 +632,7 @@ void csvm::run_blas_level_3_kernel_explicit(const std::size_t device_id, const :
                 // create a Kokkos TeamPolicy
                 Kokkos::TeamPolicy<kokkos_execution_space_type> team_policy{ device, native_partial_grid, mirror_team_size };
 
-                Kokkos::parallel_for("blas_level_3_kernel_explicit_mirror", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), detail::device_kernel_symm_mirror<kokkos_execution_space_type>{ num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get().get<space>(), B_d.get().get<space>(), beta, C_d.get().get<space>(), offsets.x, offsets.y, partial_grid.x });
+                dispatch_target_platform<detail::device_kernel_symm_mirror, kokkos_execution_space_type>(target_, std::string{ "blas_level_3_kernel_explicit_mirror" }, team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get().get<space>(), B_d.get().get<space>(), beta, C_d.get().get<space>(), offsets.x, offsets.y, partial_grid.x);
             }
         }
         detail::device_synchronize(device);
@@ -592,7 +703,7 @@ void csvm::run_assemble_kernel_matrix_implicit_blas_level_3(const std::size_t de
         const unsigned long long row_offset = data_distribution_->place_row_offset(device_id);
 
         const real_type cost_factor = real_type{ 1.0 } / params.cost;
-        const std::size_t scratch_memory_size = static_cast<std::size_t>(2u * FEATURE_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE) * sizeof(real_type);
+        const std::size_t scratch_memory_size = static_cast<std::size_t>(2u * THREAD_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE) * sizeof(real_type);
 
         // save the team size
         const int team_size = detail::dim_type_to_native(exec.block);
@@ -605,44 +716,7 @@ void csvm::run_assemble_kernel_matrix_implicit_blas_level_3(const std::size_t de
             // create a Kokkos TeamPolicy
             Kokkos::TeamPolicy<kokkos_execution_space_type> team_policy{ device, native_partial_grid, team_size };
 
-            switch (params.kernel_type) {
-                case kernel_function_type::linear:
-                    {
-                        using functor_type = detail::device_kernel_assembly_symm<kokkos_execution_space_type, kernel_function_type::linear>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_implicit_blas_level_3_linear", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ alpha, q_red.get().get<space>(), A_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get().get<space>(), C_d.get().get<space>(), num_classes, offsets.x, offsets.y, partial_grid.x });
-                    }
-                    break;
-                case kernel_function_type::polynomial:
-                    {
-                        using functor_type = detail::device_kernel_assembly_symm<kokkos_execution_space_type, kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_implicit_blas_level_3_polynomial", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ alpha, q_red.get().get<space>(), A_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get().get<space>(), C_d.get().get<space>(), num_classes, offsets.x, offsets.y, partial_grid.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                    }
-                    break;
-                case kernel_function_type::rbf:
-                    {
-                        using functor_type = detail::device_kernel_assembly_symm<kokkos_execution_space_type, kernel_function_type::rbf, real_type>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_implicit_blas_level_3_rbf", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ alpha, q_red.get().get<space>(), A_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get().get<space>(), C_d.get().get<space>(), num_classes, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma) });
-                    }
-                    break;
-                case kernel_function_type::sigmoid:
-                    {
-                        using functor_type = detail::device_kernel_assembly_symm<kokkos_execution_space_type, kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_implicit_blas_level_3_sigmoid", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ alpha, q_red.get().get<space>(), A_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get().get<space>(), C_d.get().get<space>(), num_classes, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma), params.coef0 });
-                    }
-                    break;
-                case kernel_function_type::laplacian:
-                    {
-                        using functor_type = detail::device_kernel_assembly_symm<kokkos_execution_space_type, kernel_function_type::laplacian, real_type>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_implicit_blas_level_3_laplacian", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ alpha, q_red.get().get<space>(), A_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get().get<space>(), C_d.get().get<space>(), num_classes, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma) });
-                    }
-                    break;
-                case kernel_function_type::chi_squared:
-                    {
-                        using functor_type = detail::device_kernel_assembly_symm<kokkos_execution_space_type, kernel_function_type::chi_squared, real_type>;
-                        Kokkos::parallel_for("assemble_kernel_matrix_implicit_blas_level_3_chi_squared", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ alpha, q_red.get().get<space>(), A_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get().get<space>(), C_d.get().get<space>(), num_classes, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma) });
-                    }
-                    break;
-            }
+            dispatch_target_platform<detail::device_kernel_assembly_symm, kokkos_execution_space_type>(target_, params, fmt::format("assemble_kernel_matrix_implicit_blas_level_3_{}", params.kernel_type), team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), alpha, q_red.get().get<space>(), A_d.get().get<space>(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get().get<space>(), C_d.get().get<space>(), num_classes, offsets.x, offsets.y, partial_grid.x);
         }
         detail::device_synchronize(device);
         const auto end = std::chrono::steady_clock::now();
@@ -683,7 +757,7 @@ auto csvm::run_w_kernel(const std::size_t device_id, const ::plssvm::detail::exe
             // create a Kokkos TeamPolicy
             Kokkos::TeamPolicy<kokkos_execution_space_type> team_policy{ device, native_partial_grid, team_size };
 
-            Kokkos::parallel_for("w_kernel", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), detail::device_kernel_w_linear<kokkos_execution_space_type>{ w_d.get().get<space>(), alpha_d.get().get<space>(), sv_d.get().get<space>(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets.x, offsets.y, partial_grid.x });
+            dispatch_target_platform<detail::device_kernel_w_linear, kokkos_execution_space_type>(target_, std::string{ "w_kernel" }, team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), w_d.get().get<space>(), alpha_d.get().get<space>(), sv_d.get().get<space>(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets.x, offsets.y, partial_grid.x);
         }
         detail::device_synchronize(device);
         const auto end = std::chrono::steady_clock::now();
@@ -702,7 +776,7 @@ auto csvm::run_predict_kernel(const std::size_t device_id, const ::plssvm::detai
 
     device_ptr_type out_d{ shape{ num_predict_points, num_classes }, shape{ PADDING_SIZE, PADDING_SIZE }, devices_[device_id] };
 
-    const std::size_t scratch_memory_size = static_cast<std::size_t>(2u * FEATURE_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE) * sizeof(real_type);
+    const std::size_t scratch_memory_size = static_cast<std::size_t>(2u * THREAD_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE) * sizeof(real_type);
 
     // save the team size
     const int team_size = detail::dim_type_to_native(exec.block);
@@ -719,43 +793,10 @@ auto csvm::run_predict_kernel(const std::size_t device_id, const ::plssvm::detai
             // create a Kokkos TeamPolicy
             Kokkos::TeamPolicy<kokkos_execution_space_type> team_policy{ device, native_partial_grid, team_size };
 
-            switch (params.kernel_type) {
-                case kernel_function_type::linear:
-                    {
-                        using functor_type = detail::device_kernel_predict_linear<kokkos_execution_space_type>;
-                        Kokkos::parallel_for("predict_kernel_linear", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ out_d.get().get<space>(), sv_or_w_d.get().get<space>(), rho_d.get().get<space>(), predict_points_d.get().get<space>(), num_classes, num_predict_points, num_features, offsets.x, offsets.y, partial_grid.x });
-                    }
-                    break;
-                case kernel_function_type::polynomial:
-                    {
-                        using functor_type = detail::device_kernel_predict<kokkos_execution_space_type, kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                        Kokkos::parallel_for("predict_kernel_polynomial", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ out_d.get().get<space>(), alpha_d.get().get<space>(), rho_d.get().get<space>(), sv_or_w_d.get().get<space>(), predict_points_d.get().get<space>(), num_classes, num_sv, num_predict_points, num_features, offsets.x, offsets.y, partial_grid.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                    }
-                    break;
-                case kernel_function_type::rbf:
-                    {
-                        using functor_type = detail::device_kernel_predict<kokkos_execution_space_type, kernel_function_type::rbf, real_type>;
-                        Kokkos::parallel_for("predict_kernel_rbf", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ out_d.get().get<space>(), alpha_d.get().get<space>(), rho_d.get().get<space>(), sv_or_w_d.get().get<space>(), predict_points_d.get().get<space>(), num_classes, num_sv, num_predict_points, num_features, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma) });
-                    }
-                    break;
-                case kernel_function_type::sigmoid:
-                    {
-                        using functor_type = detail::device_kernel_predict<kokkos_execution_space_type, kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                        Kokkos::parallel_for("predict_kernel_sigmoid", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ out_d.get().get<space>(), alpha_d.get().get<space>(), rho_d.get().get<space>(), sv_or_w_d.get().get<space>(), predict_points_d.get().get<space>(), num_classes, num_sv, num_predict_points, num_features, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma), params.coef0 });
-                    }
-                    break;
-                case kernel_function_type::laplacian:
-                    {
-                        using functor_type = detail::device_kernel_predict<kokkos_execution_space_type, kernel_function_type::laplacian, real_type>;
-                        Kokkos::parallel_for("predict_kernel_laplacian", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ out_d.get().get<space>(), alpha_d.get().get<space>(), rho_d.get().get<space>(), sv_or_w_d.get().get<space>(), predict_points_d.get().get<space>(), num_classes, num_sv, num_predict_points, num_features, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma) });
-                    }
-                    break;
-                case kernel_function_type::chi_squared:
-                    {
-                        using functor_type = detail::device_kernel_predict<kokkos_execution_space_type, kernel_function_type::chi_squared, real_type>;
-                        Kokkos::parallel_for("predict_kernel_chi_squared", team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), functor_type{ out_d.get().get<space>(), alpha_d.get().get<space>(), rho_d.get().get<space>(), sv_or_w_d.get().get<space>(), predict_points_d.get().get<space>(), num_classes, num_sv, num_predict_points, num_features, offsets.x, offsets.y, partial_grid.x, std::get<real_type>(params.gamma) });
-                    }
-                    break;
+            if (params.kernel_type == kernel_function_type::linear) {
+                dispatch_target_platform<detail::device_kernel_predict_linear, kokkos_execution_space_type>(target_, std::string{ "predict_kernel_linear" }, team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), out_d.get().get<space>(), sv_or_w_d.get().get<space>(), rho_d.get().get<space>(), predict_points_d.get().get<space>(), num_classes, num_predict_points, num_features, offsets.x, offsets.y, partial_grid.x);
+            } else {
+                dispatch_target_platform<detail::device_kernel_predict, kokkos_execution_space_type>(target_, params, fmt::format("predict_kernel_linear_{}", params.kernel_type), team_policy.set_scratch_size(0, Kokkos::PerTeam(scratch_memory_size)), out_d.get().get<space>(), alpha_d.get().get<space>(), rho_d.get().get<space>(), sv_or_w_d.get().get<space>(), predict_points_d.get().get<space>(), num_classes, num_sv, num_predict_points, num_features, offsets.x, offsets.y, partial_grid.x);
             }
         }
         detail::device_synchronize(device);
diff --git a/src/plssvm/backends/Kokkos/detail/device_ptr.cpp b/src/plssvm/backends/Kokkos/detail/device_ptr.cpp
index 0dfe9adc0..aada5ac4f 100644
--- a/src/plssvm/backends/Kokkos/detail/device_ptr.cpp
+++ b/src/plssvm/backends/Kokkos/detail/device_ptr.cpp
@@ -18,7 +18,7 @@
 
 #include "Kokkos_Core.hpp"  // Kokkos::View, Kokkos::HostSpace, Kokkos::MemoryUnmanaged, Kokkos::subview, Kokkos::parallel_for, Kokkos::deep_copy
 
-#include "fmt/core.h"  // fmt::format
+#include "fmt/format.h"  // fmt::format
 
 #include <algorithm>  // std::min
 #include <cstddef>    // std::size_t
@@ -46,8 +46,11 @@ device_ptr<T>::device_ptr(const plssvm::shape shape, const device_wrapper &devic
 template <typename T>
 device_ptr<T>::device_ptr(const plssvm::shape shape, const plssvm::shape padding, const device_wrapper &device) :
     base_type{ shape, padding, device } {
-    data_ = make_device_view_wrapper<T *>(device, this->size_padded());
-    this->memset(0);
+    // only non-empty pointers must be initialized (and memset)
+    if (this->size_padded() != std::size_t{ 0 }) {
+        data_ = make_device_view_wrapper<T *>(device, this->size_padded());
+        this->memset(0);
+    }
 }
 
 template <typename T>
@@ -64,6 +67,7 @@ void device_ptr<T>::memset(const int pattern, const size_type pos, const size_ty
             using kokkos_execution_space_type = ::plssvm::detail::remove_cvref_t<decltype(exec)>;
 
             // create view of the device data cast to unsigned char
+            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast): reinterpret_cast necessary (only set values on a byte level)
             const Kokkos::View<unsigned char *, kokkos_execution_space_type> view{ reinterpret_cast<unsigned char *>(data.data() + pos), rnum_bytes };
             // fill the view with the pattern -> acts like a memset
             Kokkos::deep_copy(exec, view, static_cast<unsigned char>(pattern));
diff --git a/src/plssvm/backends/Kokkos/detail/device_wrapper.cpp b/src/plssvm/backends/Kokkos/detail/device_wrapper.cpp
index 00202edf7..127542aa9 100644
--- a/src/plssvm/backends/Kokkos/detail/device_wrapper.cpp
+++ b/src/plssvm/backends/Kokkos/detail/device_wrapper.cpp
@@ -10,15 +10,24 @@
 
 #include "plssvm/backends/Kokkos/detail/conditional_execution.hpp"  // PLSSVM_KOKKOS_BACKEND_INVOKE_IF_*
 #include "plssvm/backends/Kokkos/exceptions.hpp"                    // plssvm::kokkos::backend_exception
-#include "plssvm/backends/Kokkos/execution_space.hpp"               // plssvm::kokkos::execution_space
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"              // plssvm::kokkos::execution_space
 #include "plssvm/detail/assert.hpp"                                 // PLSSVM_ASSERT
-#include "plssvm/detail/logging/log_untracked.hpp"                  // plssvm::detail::log_untracked
-#include "plssvm/detail/logging/mpi_log_untracked.hpp"              // plssvm::detail::log_untracked
-#include "plssvm/detail/string_utility.hpp"                         // plssvm::detail::as_lower_case
-#include "plssvm/detail/utility.hpp"                                // plssvm::detail::contains
 #include "plssvm/mpi/communicator.hpp"                              // plssvm::mpi::communicator
 #include "plssvm/target_platforms.hpp"                              // plssvm::target_platform
-#include "plssvm/verbosity_levels.hpp"                              // plssvm::verbosity_level
+
+#if defined(KOKKOS_ENABLE_SYCL)
+    #include "plssvm/detail/string_utility.hpp"  // plssvm::detail::as_lower_case
+    #include "plssvm/detail/utility.hpp"         // plssvm::detail::contains
+#endif
+
+#if !defined(PLSSVM_KOKKOS_BACKEND_SYCL_ENABLE_MULTI_GPU)
+    #include "plssvm/detail/logging/log_untracked.hpp"  // plssvm::detail::log_untracked
+    #include "plssvm/verbosity_levels.hpp"              // plssvm::verbosity_level
+#endif
+
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+    #include "fmt/format.h"  // fmt::format
+#endif
 
 #include "Kokkos_Core.hpp"  // Kokkos::num_devices, Kokkos::ExecutionSpace
 
@@ -102,12 +111,10 @@ std::vector<device_wrapper> get_device_list(const execution_space space, [[maybe
 
 #if !defined(PLSSVM_KOKKOS_BACKEND_SYCL_ENABLE_MULTI_GPU)
                 if (devices.size() > 1) {
-                    ::plssvm::detail::log_untracked(plssvm::verbosity_level::full | plssvm::verbosity_level::warning,
-                                                    "\nFound {} devices on MPI rank {} for the Kokkos::SYCL execution space, but multi-GPU support is disabled. Using only device 1. This behavior can be disabled using the PLSSVM_KOKKOS_BACKEND_SYCL_ENABLE_MULTI_GPU CMake option.",
-                                                    devices.size(),
-                                                    comm.rank());
-                    // only use the first GPU found (which most likely is the default device)
-                    devices.resize(1);
+                    throw backend_exception{ fmt::format("\nFound {} devices on MPI rank {} for the Kokkos::SYCL execution space, but multi-GPU support is disabled. "
+                                                         "This behavior can be disabled using the PLSSVM_KOKKOS_BACKEND_SYCL_ENABLE_MULTI_GPU CMake option but may not work until it is support by Kokkos itself.",
+                                                         devices.size(),
+                                                         comm.rank()) };
                 }
 #endif
             }));
@@ -119,15 +126,8 @@ std::vector<device_wrapper> get_device_list(const execution_space space, [[maybe
             break;
         case execution_space::openmp:
             PLSSVM_KOKKOS_BACKEND_INVOKE_IF_OPENMP([&]() {
-                // Note: if OpenMP should be used as device  must be set in order for it to work!
-                if (omp_get_nested() == 0) {
-                    ::plssvm::detail::log_untracked(verbosity_level::full | verbosity_level::warning,
-                                                    comm,
-                                                    "WARNING: In order for Kokkos::OpenMP to work properly, we have to set \"omp_set_nested(1)\"!\n");
-                    // enable OMP_NESTED support
-                    // Note: function is officially deprecated but still necessary for Kokkos::OpenMP to work properly
-                    omp_set_nested(1);
-                }
+                // Note: if OpenMP should be used as device OMP_NESTED must be set in order for it to work!
+                omp_set_max_active_levels(2);
                 devices.emplace_back(Kokkos::OpenMP{});
             });
             break;
diff --git a/src/plssvm/backends/Kokkos/detail/utility.cpp b/src/plssvm/backends/Kokkos/detail/utility.cpp
index e8b8ada6d..7178d3bd1 100644
--- a/src/plssvm/backends/Kokkos/detail/utility.cpp
+++ b/src/plssvm/backends/Kokkos/detail/utility.cpp
@@ -11,21 +11,24 @@
 #include "plssvm/backends/execution_range.hpp"                      // plssvm::detail::dim_type
 #include "plssvm/backends/Kokkos/detail/conditional_execution.hpp"  // PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_*
 #include "plssvm/backends/Kokkos/detail/device_wrapper.hpp"         // plssvm::kokkos::detail::device_wrapper
-#include "plssvm/backends/Kokkos/execution_space.hpp"               // plssvm::kokkos::execution_space
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"              // plssvm::kokkos::execution_space
 #include "plssvm/detail/assert.hpp"                                 // PLSSVM_ASSERT
-#include "plssvm/detail/string_utility.hpp"                         // plssvm::detail::as_lower_case
+#include "plssvm/detail/string_utility.hpp"                         // plssvm::detail::{as_lower_case, trim}
 #include "plssvm/detail/utility.hpp"                                // plssvm::detail::contains
 #include "plssvm/target_platforms.hpp"                              // plssvm::target_platform
 
+#if defined(KOKKOS_ENABLE_SYCL)
+    #include <unordered_set>  // std::unordered_set
+#endif
+
 #include "Kokkos_Core.hpp"    // Kokkos::ExecutionSpace, Kokkos::Impl::ManageStream
 #include "Kokkos_Macros.hpp"  // Kokkos macros
 
-#include "fmt/core.h"  // fmt::format
+#include "fmt/format.h"  // fmt::format
 
-#include <map>            // std::map
-#include <string>         // std::string
-#include <unordered_set>  // std::unordered_set
-#include <vector>         // std::vector
+#include <map>     // std::map
+#include <string>  // std::string
+#include <vector>  // std::vector
 
 namespace plssvm::kokkos::detail {
 
@@ -126,15 +129,15 @@ std::string get_device_name([[maybe_unused]] const device_wrapper &dev) {
             throw backend_exception{ "Unsupported execution_space::automatic provided!" };
         case execution_space::cuda:
             PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_CUDA([&]() {
-                return std::string{ dev.get<execution_space::cuda>().cuda_device_prop().name };
+                return std::string{ ::plssvm::detail::trim(static_cast<const char *>(dev.get<execution_space::cuda>().cuda_device_prop().name)) };
             });
         case execution_space::hip:
             PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_HIP([&]() {
-                return std::string{ dev.get<execution_space::hip>().hip_device_prop().name };
+                return std::string{ ::plssvm::detail::trim(static_cast<const char *>(dev.get<execution_space::hip>().hip_device_prop().name)) };
             });
         case execution_space::sycl:
             PLSSVM_KOKKOS_BACKEND_INVOKE_RETURN_IF_SYCL([&]() {
-                return dev.get<execution_space::sycl>().sycl_queue().get_device().get_info<::sycl::info::device::name>();
+                return std::string{ ::plssvm::detail::trim(dev.get<execution_space::sycl>().sycl_queue().get_device().get_info<::sycl::info::device::name>()) };
             });
         case execution_space::hpx:
             return "HPX CPU host device";
diff --git a/src/plssvm/backends/Kokkos/execution_space.cpp b/src/plssvm/backends/Kokkos/execution_space.cpp
index 0caae212f..bf7c716fc 100644
--- a/src/plssvm/backends/Kokkos/execution_space.cpp
+++ b/src/plssvm/backends/Kokkos/execution_space.cpp
@@ -6,10 +6,9 @@
  *          See the LICENSE.md file in the project root for full license information.
  */
 
-#include "plssvm/backends/Kokkos/execution_space.hpp"
-
 #include "plssvm/backends/Kokkos/detail/constexpr_available_execution_spaces.hpp"  // plssvm::kokkos::detail::constexpr_available_execution_spaces
-#include "plssvm/detail/string_utility.hpp"                                        // plssvm::detail::to_lower_case
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"
+#include "plssvm/detail/string_utility.hpp"  // plssvm::detail::to_lower_case
 
 #include <array>    // std::array
 #include <ios>      // std::ios::failbit
diff --git a/src/plssvm/backends/OpenCL/CMakeLists.txt b/src/plssvm/backends/OpenCL/CMakeLists.txt
index c79869c05..04c63b213 100644
--- a/src/plssvm/backends/OpenCL/CMakeLists.txt
+++ b/src/plssvm/backends/OpenCL/CMakeLists.txt
@@ -47,6 +47,9 @@ target_sources(
             BASE_DIRS
             "${PROJECT_SOURCE_DIR}/include/plssvm/backends/OpenCL/kernel"
             FILES
+            "${PROJECT_SOURCE_DIR}/include/plssvm/backends/OpenCL/kernel/detail/atomics.cl"
+            "${PROJECT_SOURCE_DIR}/include/plssvm/backends/OpenCL/kernel/detail/fill_kernel.cl"
+            "${PROJECT_SOURCE_DIR}/include/plssvm/backends/OpenCL/kernel/detail/memset_kernel.cl"
             "${PROJECT_SOURCE_DIR}/include/plssvm/backends/OpenCL/kernel/cg_explicit/blas.cl"
             "${PROJECT_SOURCE_DIR}/include/plssvm/backends/OpenCL/kernel/cg_explicit/kernel_matrix_assembly.cl"
             "${PROJECT_SOURCE_DIR}/include/plssvm/backends/OpenCL/kernel/cg_implicit/kernel_matrix_assembly_blas.cl"
diff --git a/src/plssvm/backends/OpenCL/csvm.cpp b/src/plssvm/backends/OpenCL/csvm.cpp
index 0f69a606c..359a48c74 100644
--- a/src/plssvm/backends/OpenCL/csvm.cpp
+++ b/src/plssvm/backends/OpenCL/csvm.cpp
@@ -8,32 +8,29 @@
 
 #include "plssvm/backends/OpenCL/csvm.hpp"
 
-#include "plssvm/backend_types.hpp"                         // plssvm::backend_type
-#include "plssvm/backends/execution_range.hpp"              // plssvm::detail::{dim_type, execution_range}
-#include "plssvm/backends/OpenCL/detail/command_queue.hpp"  // plssvm::opencl::detail::command_queue
-#include "plssvm/backends/OpenCL/detail/context.hpp"        // plssvm::opencl::detail::context
-#include "plssvm/backends/OpenCL/detail/device_ptr.hpp"     // plssvm::opencl::detail::device_ptr
-#include "plssvm/backends/OpenCL/detail/jit_info.hpp"       // plssvm::opencl::detail::create_jit_report
-#include "plssvm/backends/OpenCL/detail/kernel.hpp"         // plssvm::opencl::detail::{compute_kernel_name, kernel}
-#include "plssvm/backends/OpenCL/detail/utility.hpp"        // PLSSVM_OPENCL_ERROR_CHECK, plssvm::opencl::detail::{get_contexts, create_command_queues, run_kernel, kernel_type_to_function_name, device_synchronize, get_opencl_target_version, get_driver_version}
-#include "plssvm/backends/OpenCL/exceptions.hpp"            // plssvm::opencl::backend_exception
-#include "plssvm/constants.hpp"                             // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
-#include "plssvm/detail/assert.hpp"                         // PLSSVM_ASSERT
-#include "plssvm/detail/data_distribution.hpp"              // plssvm::detail::{data_distribution, triangular_data_distribution, rectangular_data_distribution}
-#include "plssvm/detail/logging/log_untracked.hpp"          // plssvm::detail::log_untracked
-#include "plssvm/detail/logging/mpi_log_untracked.hpp"      // plssvm::detail::log_untracked
-#include "plssvm/detail/memory_size.hpp"                    // plssvm::detail::memory_size
-#include "plssvm/detail/tracking/performance_tracker.hpp"   // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
-#include "plssvm/detail/utility.hpp"                        // plssvm::detail::contains
-#include "plssvm/exceptions/exceptions.hpp"                 // plssvm::exception
-#include "plssvm/gamma.hpp"                                 // plssvm::gamma_type
-#include "plssvm/kernel_function_types.hpp"                 // plssvm::kernel_function_type
-#include "plssvm/mpi/communicator.hpp"                      // plssvm::mpi::communicator
-#include "plssvm/mpi/detail/information.hpp"                // plssvm::mpi::detail::gather_and_print_csvm_information
-#include "plssvm/parameter.hpp"                             // plssvm::parameter, plssvm::detail::parameter
-#include "plssvm/shape.hpp"                                 // plssvm::shape
-#include "plssvm/target_platforms.hpp"                      // plssvm::target_platform
-#include "plssvm/verbosity_levels.hpp"                      // plssvm::verbosity_level
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type
+#include "plssvm/backends/execution_range.hpp"             // plssvm::detail::{dim_type, execution_range}
+#include "plssvm/backends/OpenCL/detail/jit_info.hpp"      // plssvm::opencl::detail::create_jit_report
+#include "plssvm/backends/OpenCL/detail/kernel.hpp"        // plssvm::opencl::detail::{compute_kernel_name, kernel}
+#include "plssvm/backends/OpenCL/detail/utility.hpp"       // PLSSVM_OPENCL_ERROR_CHECK, plssvm::opencl::detail::{get_contexts, create_command_queues, run_kernel, kernel_type_to_function_name, device_synchronize, get_opencl_target_version, get_driver_version}
+#include "plssvm/backends/OpenCL/exceptions.hpp"           // plssvm::opencl::backend_exception
+#include "plssvm/constants.hpp"                            // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/detail/assert.hpp"                        // PLSSVM_ASSERT
+#include "plssvm/detail/data_distribution.hpp"             // plssvm::detail::{data_distribution, triangular_data_distribution, rectangular_data_distribution}
+#include "plssvm/detail/logging/log_untracked.hpp"         // NOLINT: plssvm::detail::log_untracked
+#include "plssvm/detail/logging/mpi_log_untracked.hpp"     // plssvm::detail::log_untracked
+#include "plssvm/detail/memory_size.hpp"                   // plssvm::detail::memory_size
+#include "plssvm/detail/operators.hpp"                     // operator overloads for std::vector (+ scalars)
+#include "plssvm/detail/tracking/performance_tracker.hpp"  // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
+#include "plssvm/detail/utility.hpp"                       // plssvm::detail::{contains, check_local_memory_usage}
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::exception
+#include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/mpi/detail/information.hpp"               // plssvm::mpi::detail::gather_and_print_csvm_information
+#include "plssvm/parameter.hpp"                            // plssvm::parameter, plssvm::detail::parameter
+#include "plssvm/shape.hpp"                                // plssvm::shape
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
+#include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity_level
 
 #include "CL/cl.h"           // CL_QUEUE_DEVICE, CL_DEVICE_GLOBAL_MEM_SIZE, CL_DEVICE_MAX_MEM_ALLOC_SIZE, CL_DEVICE_MAX_WORK_GROUP_SIZE
                              // clGetCommandQueueInfo, clGetDeviceInfo, cl_device_id
@@ -49,14 +46,16 @@
 #include <exception>  // std::terminate
 #include <iostream>   // std::cout, std::endl
 #include <limits>     // std::numeric_limits::max
+#include <optional>   // std::optional
 #include <string>     // std::string
-#include <tuple>      // std::tie
+#include <tuple>      // std::tie, std::get
 #include <utility>    // std::pair, std::make_pair, std::move
-#include <variant>    // std::get
 #include <vector>     // std::vector
 
 namespace plssvm::opencl {
 
+using namespace plssvm::operators;  // NOLINT(google-build-using-namespace): only imports custom math operations on vectors (and scalars)
+
 csvm::csvm(const target_platform target) {
     // check whether the requested target platform has been enabled
     switch (target) {
@@ -87,6 +86,11 @@ csvm::csvm(const target_platform target) {
     // get all available OpenCL contexts for the current target including devices with respect to the requested target platform
     std::tie(contexts_, target_) = detail::get_contexts(target);
 
+    // determine the used local memory and check whether it exceeds the maximum necessary value!
+    // NOTE: must be before the JIT compilation. Otherwise, it may already fail there which leads to failing tests since the wrong error is created.
+    // TODO: better solution: rewrite the OpenCL backend JIT compilation that all kernels are only JIT compiled right before they are used and not in the constructor itself!
+    ::plssvm::detail::check_local_memory_usage(this->get_local_memory());
+
     // At this point, target_ may NEVER be target_platform::automatic!
     PLSSVM_ASSERT(target_ != target_platform::automatic, "At this point, the target platform must be determined and must NOT be automatic!");
 
@@ -97,7 +101,10 @@ csvm::csvm(const target_platform target) {
 
     // create command_queues and JIT compile OpenCL kernels; compile all kernels for float and double
     detail::jit_info info{};
-    std::tie(devices_, info) = detail::create_command_queues(comm_, contexts_, params_.kernel_type);
+    std::tie(devices_, info) = detail::create_command_queues(comm_, contexts_, target_, params_.kernel_type);
+
+    // for each context exactly ONE command queue must exist!
+    PLSSVM_ASSERT(contexts_.size() == devices_.size(), "For each context ({}), exactly ONE command queue ({}) must exist!", contexts_.size(), devices_.size());
 
     std::vector<std::string> device_names{};
     device_names.reserve(devices_.size());
@@ -107,9 +114,9 @@ csvm::csvm(const target_platform target) {
     if (comm_.size() > 1) {
         // use MPI rank specific command line output
         for (const queue_type &device : devices_) {
-            device_names.emplace_back(detail::get_device_name(device));
+            device_names.push_back(detail::get_device_name(device));
             // get the target platform's driver version
-            driver_versions.emplace_back(detail::get_driver_version(device));
+            driver_versions.push_back(detail::get_driver_version(device));
         }
 
         mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::opencl, target_, device_names, detail::create_jit_report(info));
@@ -136,13 +143,12 @@ csvm::csvm(const target_platform target) {
                                       target_);
 
         for (typename std::vector<queue_type>::size_type device = 0; device < devices_.size(); ++device) {
-            const std::string device_name = detail::get_device_name(devices_[device]);
+            device_names.push_back(detail::get_device_name(devices_[device]));
             plssvm::detail::log_untracked(verbosity_level::full,
                                           comm_,
                                           "  [{}, {}]\n",
                                           device,
-                                          device_name);
-            device_names.emplace_back(device_name);
+                                          device_names.back());
 
             // get the target platform's driver version
             driver_versions.emplace_back(detail::get_driver_version(devices_[device]));
@@ -163,8 +169,18 @@ csvm::csvm(const target_platform target) {
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "jit_compilation_time", info.duration }));
 
     // sanity checks for the number of the OpenCL kernels
-    PLSSVM_ASSERT(std::all_of(devices_.begin(), devices_.end(), [](const queue_type &queue) { return queue.kernels.size() == 13; }),
-                  "Every command queue must have exactly thirteen associated kernels!");
+    PLSSVM_ASSERT(std::all_of(devices_.begin(), devices_.end(), [](const queue_type &queue) { return queue.kernels.size() == 17; }),
+                  "Every command queue must have exactly 17 associated kernels!");
+
+    PLSSVM_ASSERT(std::all_of(devices_.begin(), devices_.end(), [](const queue_type &queue) { return ::plssvm::detail::contains(queue.kernels, detail::compute_kernel_name::fill_kernel_float); }),
+                  "The double device pointer fill kernel is missing!");
+    PLSSVM_ASSERT(std::all_of(devices_.begin(), devices_.end(), [](const queue_type &queue) { return ::plssvm::detail::contains(queue.kernels, detail::compute_kernel_name::fill_kernel_double); }),
+                  "The float device pointer fill kernel is missing!");
+
+    PLSSVM_ASSERT(std::all_of(devices_.begin(), devices_.end(), [](const queue_type &queue) { return ::plssvm::detail::contains(queue.kernels, detail::compute_kernel_name::memset_kernel_float); }),
+                  "The double device pointer memset kernel is missing!");
+    PLSSVM_ASSERT(std::all_of(devices_.begin(), devices_.end(), [](const queue_type &queue) { return ::plssvm::detail::contains(queue.kernels, detail::compute_kernel_name::memset_kernel_double); }),
+                  "The float device pointer memset kernel is missing!");
 
     PLSSVM_ASSERT(std::all_of(devices_.begin(), devices_.end(), [](const queue_type &queue) { return ::plssvm::detail::contains(queue.kernels, detail::compute_kernel_name::assemble_kernel_matrix_explicit); }),
                   "The explicit kernel matrix assembly device kernel is missing!");
@@ -210,11 +226,10 @@ csvm::~csvm() {
 }
 
 std::vector<::plssvm::detail::memory_size> csvm::get_device_memory() const {
-    std::vector<::plssvm::detail::memory_size> res(this->num_available_devices());
-    for (std::size_t device_id = 0; device_id < this->num_available_devices(); ++device_id) {
+    std::vector<::plssvm::detail::memory_size> res(contexts_.size());
+    for (std::size_t device_id = 0; device_id < contexts_.size(); ++device_id) {
         // get device
-        cl_device_id device{};
-        PLSSVM_OPENCL_ERROR_CHECK(clGetCommandQueueInfo(devices_[device_id], CL_QUEUE_DEVICE, sizeof(cl_device_id), static_cast<void *>(&device), nullptr), "error obtaining device")
+        cl_device_id device = contexts_[device_id].device;
 
         // get device global memory size
         cl_ulong total_device_memory{};
@@ -225,11 +240,10 @@ std::vector<::plssvm::detail::memory_size> csvm::get_device_memory() const {
 }
 
 std::vector<::plssvm::detail::memory_size> csvm::get_max_mem_alloc_size() const {
-    std::vector<::plssvm::detail::memory_size> res(this->num_available_devices());
-    for (std::size_t device_id = 0; device_id < this->num_available_devices(); ++device_id) {
+    std::vector<::plssvm::detail::memory_size> res(contexts_.size());
+    for (std::size_t device_id = 0; device_id < contexts_.size(); ++device_id) {
         // get device
-        cl_device_id device{};
-        PLSSVM_OPENCL_ERROR_CHECK(clGetCommandQueueInfo(devices_[device_id], CL_QUEUE_DEVICE, sizeof(cl_device_id), static_cast<void *>(&device), nullptr), "error obtaining device")
+        cl_device_id device = contexts_[device_id].device;
 
         // get maximum allocation size
         cl_ulong max_alloc_size{};
@@ -239,11 +253,24 @@ std::vector<::plssvm::detail::memory_size> csvm::get_max_mem_alloc_size() const
     return res;
 }
 
+std::vector<std::optional<::plssvm::detail::memory_size>> csvm::get_local_memory() const {
+    std::vector<std::optional<::plssvm::detail::memory_size>> res(contexts_.size());
+    for (std::size_t device_id = 0; device_id < contexts_.size(); ++device_id) {
+        // get device
+        cl_device_id device = contexts_[device_id].device;
+
+        // get the local memory size
+        cl_ulong total_local_memory{};
+        PLSSVM_OPENCL_ERROR_CHECK(clGetDeviceInfo(device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(cl_ulong), &total_local_memory, nullptr), "error obtaining device's local memory size")
+        res[device_id] = ::plssvm::detail::memory_size{ static_cast<unsigned long long>(total_local_memory) };
+    }
+    return res;
+}
+
 std::size_t csvm::get_max_work_group_size(const std::size_t device_id) const {
-    PLSSVM_ASSERT(device_id < this->num_available_devices(), "Invalid device {} requested!", device_id);
+    PLSSVM_ASSERT(device_id < contexts_.size(), "Invalid device {} requested!", device_id);
     // get device
-    cl_device_id device{};
-    PLSSVM_OPENCL_ERROR_CHECK(clGetCommandQueueInfo(devices_[device_id], CL_QUEUE_DEVICE, sizeof(cl_device_id), static_cast<void *>(&device), nullptr), "error obtaining device")
+    cl_device_id device = contexts_[device_id].device;
     // get maximum work group size
     cl_ulong max_work_group_size{};
     PLSSVM_OPENCL_ERROR_CHECK(clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(cl_ulong), &max_work_group_size, nullptr), "error obtaining device's global memory size")
@@ -251,7 +278,7 @@ std::size_t csvm::get_max_work_group_size(const std::size_t device_id) const {
 }
 
 ::plssvm::detail::dim_type csvm::get_max_grid_size([[maybe_unused]] const std::size_t device_id) const {
-    PLSSVM_ASSERT(device_id < this->num_available_devices(), "Invalid device {} requested!", device_id);
+    PLSSVM_ASSERT(device_id < contexts_.size(), "Invalid device {} requested!", device_id);
 
     // TODO: replace with function if there will be one in the future
     // fallback to maximum theoretical value, may break at runtime!
@@ -291,8 +318,6 @@ auto csvm::run_assemble_kernel_matrix_explicit(const std::size_t device_id, cons
     // convert execution range block to OpenCL's native std::vector
     const std::vector<std::size_t> native_block = detail::dim_type_to_native<2>(exec.block);
 
-    using namespace plssvm::operators;
-
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
         // convert execution range partial_grid to OpenCL's native std::vector
@@ -344,8 +369,6 @@ void csvm::run_blas_level_3_kernel_explicit(const std::size_t device_id, const :
     // convert execution range block to OpenCL's native std::vector
     const std::vector<std::size_t> native_block = detail::dim_type_to_native<2>(exec.block);
 
-    using namespace plssvm::operators;
-
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
         // convert execution range grid[i] to OpenCL's native std::vector
@@ -388,8 +411,6 @@ void csvm::run_inplace_matrix_addition(const std::size_t device_id, const ::plss
     // convert execution range block to OpenCL's native std::vector
     const std::vector<std::size_t> native_block = detail::dim_type_to_native<2>(exec.block);
 
-    using namespace plssvm::operators;
-
     for (const auto &[partial_grid, offsets] : exec.grids) {
         // convert execution range partial_grid to OpenCL's native std::vector
         const std::vector<std::size_t> native_partial_grid = detail::dim_type_to_native<2>(partial_grid) * native_block;
@@ -410,8 +431,6 @@ void csvm::run_inplace_matrix_scale(const std::size_t device_id, const ::plssvm:
     // convert execution range block to OpenCL's native std::vector
     const std::vector<std::size_t> native_block = detail::dim_type_to_native<2>(exec.block);
 
-    using namespace plssvm::operators;
-
     for (const auto &[partial_grid, offsets] : exec.grids) {
         // convert execution range partial_grid to OpenCL's native std::vector
         const std::vector<std::size_t> native_partial_grid = detail::dim_type_to_native<2>(partial_grid) * native_block;
@@ -441,8 +460,6 @@ void csvm::run_assemble_kernel_matrix_implicit_blas_level_3(const std::size_t de
     // convert execution range block to OpenCL's native std::vector
     const std::vector<std::size_t> native_block = detail::dim_type_to_native<2>(exec.block);
 
-    using namespace plssvm::operators;
-
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
         // convert execution range partial_grid to OpenCL's native std::vector
@@ -498,8 +515,6 @@ auto csvm::run_w_kernel(const std::size_t device_id, const ::plssvm::detail::exe
     // convert execution range block to OpenCL's native std::vector
     const std::vector<std::size_t> native_block = detail::dim_type_to_native<2>(exec.block);
 
-    using namespace plssvm::operators;
-
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
         // convert execution range partial_grid to OpenCL's native std::vector
@@ -531,8 +546,6 @@ auto csvm::run_predict_kernel(const std::size_t device_id, const ::plssvm::detai
     // convert execution range block to OpenCL's native std::vector
     const std::vector<std::size_t> native_block = detail::dim_type_to_native<2>(exec.block);
 
-    using namespace plssvm::operators;
-
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
         // convert execution range partial_grid to OpenCL's native std::vector
diff --git a/src/plssvm/backends/OpenCL/detail/command_queue.cpp b/src/plssvm/backends/OpenCL/detail/command_queue.cpp
index 642f7409a..1a6ab5cff 100644
--- a/src/plssvm/backends/OpenCL/detail/command_queue.cpp
+++ b/src/plssvm/backends/OpenCL/detail/command_queue.cpp
@@ -12,15 +12,14 @@
 #include "plssvm/backends/OpenCL/detail/kernel.hpp"      // plssvm::opencl::detail::kernel
 #include "plssvm/backends/OpenCL/detail/utility.hpp"     // PLSSVM_OPENCL_ERROR_CHECK
 #include "plssvm/detail/assert.hpp"                      // PLSSVM_ASSERT
-#include "plssvm/detail/type_traits.hpp"                 // plssvm::detail::always_false_v
+#include "plssvm/exceptions/exceptions.hpp"              // plssvm::exception
 
 #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 <memory>       // std::addressof
-#include <type_traits>  // std::is_same_v
-#include <utility>      // std::exchange, std::move
+#include <exception>  // std::terminate
+#include <iostream>   // std::cerr, std::endl
+#include <memory>     // std::addressof
+#include <utility>    // std::exchange, std::move
 
 namespace plssvm::opencl::detail {
 
@@ -51,7 +50,7 @@ command_queue &command_queue::operator=(command_queue &&other) noexcept {
 command_queue::~command_queue() {
     // avoid compiler warnings
     try {
-        if (queue) {
+        if (static_cast<bool>(queue)) {
             PLSSVM_OPENCL_ERROR_CHECK(clReleaseCommandQueue(queue), "error releasing cl_command_queue")
         }
     } catch (const plssvm::exception &e) {
diff --git a/src/plssvm/backends/OpenCL/detail/context.cpp b/src/plssvm/backends/OpenCL/detail/context.cpp
index 8922b34b4..a04da38f2 100644
--- a/src/plssvm/backends/OpenCL/detail/context.cpp
+++ b/src/plssvm/backends/OpenCL/detail/context.cpp
@@ -18,24 +18,24 @@ namespace plssvm::opencl::detail {
 context::context(cl_context p_device_context, cl_platform_id p_platform, cl_device_id p_device) :
     device_context{ p_device_context },
     platform{ p_platform },
-    device{ std::move(p_device) } { }
+    device{ p_device } { }
 
 context::context(context &&other) noexcept :
-    device_context{ std::exchange(other.device_context, nullptr) },
-    platform{ std::exchange(other.platform, nullptr) },
-    device{ std::move(other.device) } { }
+    device_context{ std::exchange(other.device_context, cl_context{}) },
+    platform{ std::exchange(other.platform, cl_platform_id{}) },
+    device{ std::exchange(other.device, cl_device_id{}) } { }
 
 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);
-        device = std::move(other.device);
+        other.device_context = std::exchange(other.device_context, cl_context{});
+        platform = std::exchange(other.platform, cl_platform_id{});
+        device = std::exchange(other.device, cl_device_id{});
     }
     return *this;
 }
 
 context::~context() {
-    if (device_context) {
+    if (static_cast<bool>(device_context)) {
         clReleaseContext(device_context);
     }
 }
diff --git a/src/plssvm/backends/OpenCL/detail/device_ptr.cpp b/src/plssvm/backends/OpenCL/detail/device_ptr.cpp
index 032a6b8b6..4af347116 100644
--- a/src/plssvm/backends/OpenCL/detail/device_ptr.cpp
+++ b/src/plssvm/backends/OpenCL/detail/device_ptr.cpp
@@ -8,25 +8,28 @@
 
 #include "plssvm/backends/OpenCL/detail/device_ptr.hpp"
 
-#include "plssvm/backends/gpu_device_ptr.hpp"               // plssvm::detail::gpu_device_ptr
 #include "plssvm/backends/OpenCL/detail/command_queue.hpp"  // plssvm::opencl::detail::command_queue
 #include "plssvm/backends/OpenCL/detail/error_code.hpp"     // plssvm::opencl::detail::error_code
+#include "plssvm/backends/OpenCL/detail/kernel.hpp"         // plssvm::opencl::detail::{kernel, compute_kernel_name}
 #include "plssvm/backends/OpenCL/detail/utility.hpp"        // PLSSVM_OPENCL_ERROR_CHECK
 #include "plssvm/backends/OpenCL/exceptions.hpp"            // plssvm::opencl::backend_exception
 #include "plssvm/detail/assert.hpp"                         // PLSSVM_ASSERT
+#include "plssvm/detail/type_traits.hpp"                    // plssvm::detail::always_false_v
 #include "plssvm/exceptions/exceptions.hpp"                 // plssvm::exception
 #include "plssvm/shape.hpp"                                 // plssvm::shape
 
-#include "CL/cl.h"  // CL_MEM_READ_WRITE, CL_TRUE, clFinish, clCreateBuffer, clReleaseMemObject, clEnqueueFillBuffer, clEnqueueWriteBuffer, clEnqueueReadBuffer
+#include "CL/cl.h"           // cl_mem, CL_MEM_READ_WRITE, CL_TRUE, clFinish, clCreateBuffer, clReleaseMemObject, clEnqueueFillBuffer, clEnqueueWriteBuffer, clEnqueueReadBuffer, clSetKernelArg, clEnqueueNDRangeKernel
+#include "CL/cl_platform.h"  // cl_uchar, cl_ulong
 
 #include "fmt/format.h"  // fmt::format
 
-#include <algorithm>  // std::min
-#include <array>      // std::array
-#include <cstddef>    // std::size_t
-#include <exception>  // std::terminate
-#include <iostream>   // std::cerr, std::endl
-#include <vector>     // std::vector
+#include <algorithm>    // std::min
+#include <array>        // std::array
+#include <cstddef>      // std::size_t
+#include <exception>    // std::terminate
+#include <iostream>     // std::cerr, std::endl
+#include <type_traits>  // std::is_same_v
+#include <vector>       // NOLINT: std::vector
 
 namespace plssvm::opencl::detail {
 
@@ -41,12 +44,15 @@ device_ptr<T>::device_ptr(const plssvm::shape shape, const command_queue &queue)
 template <typename T>
 device_ptr<T>::device_ptr(const plssvm::shape shape, const plssvm::shape padding, const command_queue &queue) :
     base_type{ shape, padding, &queue } {
-    error_code err{};
-    cl_context cont{};
-    PLSSVM_OPENCL_ERROR_CHECK(clGetCommandQueueInfo(queue_->queue, CL_QUEUE_CONTEXT, sizeof(cl_context), static_cast<void *>(&cont), nullptr), "error retrieving the command queue context")
-    data_ = clCreateBuffer(cont, CL_MEM_READ_WRITE, this->size_padded() * sizeof(value_type), nullptr, &err);
-    PLSSVM_OPENCL_ERROR_CHECK(err, "error creating the buffer")
-    this->memset(0);
+    // only non-empty pointers must be initialized (and memset)
+    if (this->size_padded() != std::size_t{ 0 }) {
+        error_code err{};
+        cl_context cont{};
+        PLSSVM_OPENCL_ERROR_CHECK(clGetCommandQueueInfo(queue_->queue, CL_QUEUE_CONTEXT, sizeof(cl_context), static_cast<void *>(&cont), nullptr), "error retrieving the command queue context")
+        data_ = clCreateBuffer(cont, CL_MEM_READ_WRITE, this->size_padded() * sizeof(value_type), nullptr, &err);
+        PLSSVM_OPENCL_ERROR_CHECK(err, "error creating the buffer")
+        this->memset(0);
+    }
 }
 
 template <typename T>
@@ -70,10 +76,29 @@ void device_ptr<T>::memset(const int pattern, const size_type pos, const size_ty
         throw backend_exception{ fmt::format("Illegal access in memset!: {} >= {}", pos, this->size_padded()) };
     }
     const size_type rnum_bytes = std::min(num_bytes, (this->size_padded() - pos) * sizeof(value_type));
-    error_code err;
-    const auto correct_value = static_cast<unsigned char>(pattern);
-    err = clEnqueueFillBuffer(queue_->queue, data_, &correct_value, sizeof(unsigned char), pos * sizeof(value_type), rnum_bytes, 0, nullptr, nullptr);
-    PLSSVM_OPENCL_ERROR_CHECK(err, "error filling the buffer via memset")
+
+    // we have to use ul_char for the correct pattern
+    const auto correct_pattern = static_cast<cl_uchar>(pattern);
+    // we have to use the number of elements and not the number of bytes
+    const auto rcount = static_cast<cl_ulong>(rnum_bytes / sizeof(value_type));
+
+    // get the correct device kernel based on the current value_type
+    const kernel *device_kernel = nullptr;
+    if constexpr (std::is_same_v<value_type, float>) {
+        device_kernel = &queue_->get_kernel(detail::compute_kernel_name::memset_kernel_float);
+    } else if constexpr (std::is_same_v<value_type, double>) {
+        device_kernel = &queue_->get_kernel(detail::compute_kernel_name::memset_kernel_double);
+    } else {
+        static_assert(plssvm::detail::always_false_v<T>, "Unsupported value type!");
+    }
+    PLSSVM_ASSERT(device_kernel != nullptr, "The device kernel pointer is invalid!");
+
+    // set the kernel arguments and run the kernel
+    PLSSVM_OPENCL_ERROR_CHECK(clSetKernelArg(*device_kernel, cl_uint{ 0 }, sizeof(cl_mem), static_cast<const void *>(&data_)), "error setting device_ptr memset data_ argument");
+    PLSSVM_OPENCL_ERROR_CHECK(clSetKernelArg(*device_kernel, cl_uint{ 1 }, sizeof(cl_uchar), &correct_pattern), "error setting device_ptr memset pattern argument");
+    PLSSVM_OPENCL_ERROR_CHECK(clSetKernelArg(*device_kernel, cl_uint{ 2 }, sizeof(cl_ulong), &pos), "error setting device_ptr memset pos argument");
+    PLSSVM_OPENCL_ERROR_CHECK(clSetKernelArg(*device_kernel, cl_uint{ 3 }, sizeof(cl_ulong), &rcount), "error setting device_ptr memset size argument");
+    PLSSVM_OPENCL_ERROR_CHECK(clEnqueueNDRangeKernel(queue_->queue, *device_kernel, cl_uint{ 1 }, nullptr, &rcount, nullptr, 0, nullptr, nullptr), "error running device_ptr memset kernel");
     detail::device_synchronize(*queue_);
 }
 
@@ -84,12 +109,25 @@ void device_ptr<T>::fill(const value_type value, const size_type pos, const size
     if (pos >= this->size_padded()) {
         throw backend_exception{ fmt::format("Illegal access in fill!: {} >= {}", pos, this->size_padded()) };
     }
-
-    // run GPU kernel
     const size_type rcount = std::min(count, this->size_padded() - pos);
-    error_code err;
-    err = clEnqueueFillBuffer(queue_->queue, data_, &value, sizeof(value_type), pos * sizeof(value_type), rcount * sizeof(value_type), 0, nullptr, nullptr);
-    PLSSVM_OPENCL_ERROR_CHECK(err, "error filling the buffer via fill")
+
+    // get the correct device kernel based on the current value_type
+    const kernel *device_kernel = nullptr;
+    if constexpr (std::is_same_v<value_type, float>) {
+        device_kernel = &queue_->get_kernel(detail::compute_kernel_name::fill_kernel_float);
+    } else if constexpr (std::is_same_v<value_type, double>) {
+        device_kernel = &queue_->get_kernel(detail::compute_kernel_name::fill_kernel_double);
+    } else {
+        static_assert(plssvm::detail::always_false_v<T>, "Unsupported value type!");
+    }
+    PLSSVM_ASSERT(device_kernel != nullptr, "The device kernel pointer is invalid!");
+
+    // set the kernel arguments and run the kernel
+    PLSSVM_OPENCL_ERROR_CHECK(clSetKernelArg(*device_kernel, cl_uint{ 0 }, sizeof(cl_mem), static_cast<const void *>(&data_)), "error setting device_ptr fill data_ argument");
+    PLSSVM_OPENCL_ERROR_CHECK(clSetKernelArg(*device_kernel, cl_uint{ 1 }, sizeof(value_type), &value), "error setting device_ptr fill pattern argument");
+    PLSSVM_OPENCL_ERROR_CHECK(clSetKernelArg(*device_kernel, cl_uint{ 2 }, sizeof(cl_ulong), &pos), "error setting device_ptr fill pos argument");
+    PLSSVM_OPENCL_ERROR_CHECK(clSetKernelArg(*device_kernel, cl_uint{ 3 }, sizeof(cl_ulong), &rcount), "error setting device_ptr fill size argument");
+    PLSSVM_OPENCL_ERROR_CHECK(clEnqueueNDRangeKernel(queue_->queue, *device_kernel, cl_uint{ 1 }, nullptr, &rcount, nullptr, 0, nullptr, nullptr), "error running device_ptr fill kernel");
     detail::device_synchronize(*queue_);
 }
 
diff --git a/src/plssvm/backends/OpenCL/detail/error_code.cpp b/src/plssvm/backends/OpenCL/detail/error_code.cpp
index 10b30a61b..2db0bdbd3 100644
--- a/src/plssvm/backends/OpenCL/detail/error_code.cpp
+++ b/src/plssvm/backends/OpenCL/detail/error_code.cpp
@@ -8,7 +8,8 @@
 
 #include "plssvm/backends/OpenCL/detail/error_code.hpp"
 
-#include "CL/cl.h"  // cl_int, CL_SUCCESS
+#include "CL/cl.h"           // CL_SUCCESS
+#include "CL/cl_platform.h"  // cl_int
 
 #include <ostream>      // std::ostream
 #include <string_view>  // std::string_view
@@ -35,6 +36,8 @@ cl_int error_code::value() const noexcept {
     return err_;
 }
 
+// NOLINTBEGIN: magic numbers are intentional (OpenCL error codes)
+
 std::string_view error_code::message() const noexcept {
     switch (err_) {
         case 0:
@@ -168,10 +171,13 @@ std::string_view error_code::message() const noexcept {
     }
 }
 
+// NOLINTEND
+
 error_code::operator bool() const noexcept {
     return err_ == CL_SUCCESS;
 }
 
+// NOLINTNEXTLINE(google-runtime-operator): overload is intentional to reduce explicit casts in OpenCL interfaces
 cl_int *error_code::operator&() noexcept {
     return &err_;
 }
diff --git a/src/plssvm/backends/OpenCL/detail/jit_info.cpp b/src/plssvm/backends/OpenCL/detail/jit_info.cpp
index 118925dac..01305c96a 100644
--- a/src/plssvm/backends/OpenCL/detail/jit_info.cpp
+++ b/src/plssvm/backends/OpenCL/detail/jit_info.cpp
@@ -8,10 +8,10 @@
 
 #include "plssvm/backends/OpenCL/detail/jit_info.hpp"
 
-#include "fmt/chrono.h"  // format std::chrono types
+#include "fmt/chrono.h"  // NOLINT(misc-include-cleaner): format std::chrono types
 #include "fmt/format.h"  // fmt::format
 
-#include <chrono>   // std::chrono::milliseconds
+#include <chrono>   // NOLINT(misc-include-cleaner): std::chrono::milliseconds
 #include <ostream>  // std::ostream
 #include <string>   // std::string
 
diff --git a/src/plssvm/backends/OpenCL/detail/kernel.cpp b/src/plssvm/backends/OpenCL/detail/kernel.cpp
index fde397912..b105d7fa9 100644
--- a/src/plssvm/backends/OpenCL/detail/kernel.cpp
+++ b/src/plssvm/backends/OpenCL/detail/kernel.cpp
@@ -9,6 +9,7 @@
 #include "plssvm/backends/OpenCL/detail/kernel.hpp"
 
 #include "plssvm/backends/OpenCL/detail/utility.hpp"  // PLSSVM_OPENCL_ERROR_CHECK
+#include "plssvm/exceptions/exceptions.hpp"           // plssvm::exception
 
 #include "CL/cl.h"  // cl_kernel, clReleaseKernel
 
@@ -35,7 +36,7 @@ kernel &kernel::operator=(kernel &&other) noexcept {
 kernel::~kernel() {
     // avoid compiler warnings
     try {
-        if (compute_kernel) {
+        if (static_cast<bool>(compute_kernel)) {
             PLSSVM_OPENCL_ERROR_CHECK(clReleaseKernel(compute_kernel), "error releasing cl_kernel")
         }
     } catch (const plssvm::exception &e) {
diff --git a/src/plssvm/backends/OpenCL/detail/utility.cpp b/src/plssvm/backends/OpenCL/detail/utility.cpp
index 6b3f686ae..514559a7c 100644
--- a/src/plssvm/backends/OpenCL/detail/utility.cpp
+++ b/src/plssvm/backends/OpenCL/detail/utility.cpp
@@ -13,15 +13,16 @@
 #include "plssvm/backends/OpenCL/detail/error_code.hpp"     // plssvm::opencl::detail::error_code
 #include "plssvm/backends/OpenCL/detail/jit_info.hpp"       // plssvm::opencl::detail::jit_info
 #include "plssvm/backends/OpenCL/detail/kernel.hpp"         // plssvm::opencl::detail::compute_kernel_name, plssvm::opencl::detail::kernel
-#include "plssvm/constants.hpp"                             // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, FEATURE_BLOCK_SIZE, PADDING_SIZE}
+#include "plssvm/backends/OpenCL/exceptions.hpp"            // plssvm::opencl::backend_exception
+#include "plssvm/constants.hpp"                             // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/detail/arithmetic_type_name.hpp"           // plssvm::detail::arithmetic_type_name
 #include "plssvm/detail/assert.hpp"                         // PLSSVM_ASSERT
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"      // plssvm::detail::log_untracked
 #include "plssvm/detail/sha256.hpp"                         // plssvm::detail::sha256
 #include "plssvm/detail/string_conversion.hpp"              // plssvm::detail::extract_first_integer_from_string
-#include "plssvm/detail/string_utility.hpp"                 // plssvm::detail::replace_all, plssvm::detail::to_lower_case, plssvm::detail::contains
+#include "plssvm/detail/string_utility.hpp"                 // plssvm::detail::{replace_all, to_lower_case, contains, trim}
 #include "plssvm/detail/tracking/performance_tracker.hpp"   // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY, plssvm::detail::tracking::tracking_entry
-#include "plssvm/detail/utility.hpp"                        // plssvm::detail::erase_if
+#include "plssvm/detail/utility.hpp"                        // plssvm::detail::{erase_if, get_env_variable}
 #include "plssvm/exceptions/exceptions.hpp"                 // plssvm::platform_devices_empty
 #include "plssvm/kernel_function_types.hpp"                 // plssvm::kernel_function_type
 #include "plssvm/mpi/communicator.hpp"                      // plssvm::mpi::communicator
@@ -31,12 +32,12 @@
 #include "CL/cl.h"           // cl_program, cl_platform_id, cl_device_id, cl_uint, cl_device_type, cl_context,
                              // CL_DEVICE_NAME, CL_QUEUE_DEVICE, CL_DEVICE_TYPE_ALL, CL_DEVICE_TYPE_CPU, CL_DEVICE_TYPE_GPU, CL_DEVICE_VENDOR, CL_PROGRAM_BUILD_LOG, CL_PROGRAM_BINARY_SIZES, CL_PROGRAM_BINARIES, CL_PLATFORM_VENDOR, CL_DRIVER_VERSION,
                              // clCreateProgramWithSource, clBuildProgram, clGetProgramBuildInfo, clGetProgramInfo, clCreateKernel, clReleaseProgram, clCreateProgramWithBinary,
-                             // clSetKernelArg, clEnqueueNDRangeKernel, clFinish, clGetPlatformIDs, clGetDeviceIDs, clGetDeviceInfo, clCreateContext, clGetPlatformInfo
+                             // clFinish, clGetPlatformIDs, clGetDeviceIDs, clGetDeviceInfo, clCreateContext, clGetPlatformInfo
 #include "CL/cl_platform.h"  // cl_uint
 
 #include "fmt/format.h"  // fmt::format
 #include "fmt/ranges.h"  // fmt::join
-#include "fmt/std.h"     // format std::filesystem::path
+#include "fmt/std.h"     // NOLINT: format std::filesystem::path
 
 #include <algorithm>     // std::count_if
 #include <array>         // std::array
@@ -49,6 +50,9 @@
 #include <iterator>      // std::istreambuf_iterator
 #include <limits>        // std::numeric_limits
 #include <map>           // std::map
+#include <optional>      // std::optional
+#include <regex>         // std::regex, std::regex::ECMAScript
+#include <sstream>       // std::istringstream
 #include <string>        // std::string
 #include <string_view>   // std::string_view
 #include <system_error>  // std::error_code
@@ -56,13 +60,80 @@
 #include <utility>       // std::pair, std::make_pair, std::move
 #include <vector>        // std::vector
 
+namespace {
+
+/**
+ * @brief Given a @p filter element represented as a string like `"gpu_nvidia:0"`, convert it to the corresponding plssvm::target_platform and device ID as `std::size_t`.
+ * @param[in] filter the device filter
+ * @return { the plssvm::target_platform, the device ID } (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::pair<plssvm::target_platform, std::size_t> extract_filter_information(const std::string_view filter) {
+    const std::vector<std::string_view> split = plssvm::detail::split(filter, ':');
+    // exactly two entries must be present: target_platform and device_num
+    PLSSVM_ASSERT(split.size() == 2, "The filter must by of form, e.g., gpu_nvidia:0, i.e., splitting it by : must return two elements.");
+
+    // parse the target platform
+    std::istringstream iss{ std::string{ split[0] } };
+    plssvm::target_platform target{};
+    iss >> target;
+
+    // parse the device number
+    const auto device_num = plssvm::detail::convert_to<std::size_t>(split[1]);
+
+    return std::make_pair(target, device_num);
+}
+
+}  // namespace
+
 namespace plssvm::opencl::detail {
 
 [[nodiscard]] std::pair<std::vector<context>, target_platform> get_contexts(target_platform target) {
     error_code err;
 
+    // check if the PLSSVM OpenCL device filter env variable is set
+    std::optional<std::map<target_platform, std::vector<std::size_t>>> opt_filters_to_apply{ std::nullopt };
+    const std::optional<std::string> &device_filter_env = ::plssvm::detail::get_env_variable("PLSSVM_OPENCL_DEVICE_FILTER");
+    if (device_filter_env.has_value()) {
+        // check that the device filter has the correct format
+        constexpr static const char *regex_pattern = R"(^((gpu_nvidia|gpu_amd|gpu_intel|cpu):[0-9]+)(;((gpu_nvidia|gpu_amd|gpu_intel|cpu):[0-9]+))*$)";
+        if (!std::regex_match(device_filter_env.value(), std::regex{ regex_pattern, std::regex::ECMAScript })) {
+            throw backend_exception{ fmt::format(R"(Invalid device filter "{}". The filter must be of form: "{}".)", device_filter_env.value(), regex_pattern) };
+        }
+
+        // parse the provided filter
+        std::map<target_platform, std::vector<std::size_t>> filters_to_apply{};
+        for (const std::string_view filter : ::plssvm::detail::split(device_filter_env.value(), ';')) {
+            // filter is of the form: target_platform:device_num
+            const auto &[filter_target, filter_device_id] = extract_filter_information(filter);
+            filters_to_apply[filter_target].push_back(filter_device_id);
+        }
+
+        // update the filter
+        opt_filters_to_apply = std::make_optional(std::move(filters_to_apply));
+    }
+
+    // a map that counts all occurrences of devices per target platform IGNORING potentially different OpenCL platforms
+    std::map<target_platform, std::size_t> device_count_per_platform{};
+
+    // utility function to check whether a filter applies; if PLSSVM_OPENCL_DEVICE_FILTER isn't set, always returns true
+    const auto &does_opt_filter_apply = [&opt_filters_to_apply, &device_count_per_platform](const target_platform t) {
+        if (!opt_filters_to_apply.has_value()) {
+            // no filter available -> applies per definition
+            return true;
+        }
+        // filter available -> check if the filter itself applies
+        if (::plssvm::detail::contains(opt_filters_to_apply.value(), t)) {
+            for (const std::size_t id : opt_filters_to_apply.value()[t]) {
+                if (device_count_per_platform[t] == id) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+
     // iterate over all platforms and save all available devices
-    std::map<std::pair<cl_platform_id, target_platform>, std::vector<cl_device_id>> platform_devices;
+    std::map<std::pair<cl_platform_id, target_platform>, std::vector<cl_device_id>> platform_devices{};
     // get number of platforms
     cl_uint num_platforms{};
     PLSSVM_OPENCL_ERROR_CHECK(clGetPlatformIDs(0, nullptr, &num_platforms), "error retrieving the number of available platforms")
@@ -87,13 +158,18 @@ namespace plssvm::opencl::detail {
             cl_device_type device_type{};
             PLSSVM_OPENCL_ERROR_CHECK(clGetDeviceInfo(device, CL_DEVICE_TYPE, sizeof(cl_device_type), &device_type, nullptr), "error retrieving the device type")
 
-            if (device_type == CL_DEVICE_TYPE_CPU) {
+            if (device_type == (CL_DEVICE_TYPE_CPU)) {
                 // the current device is a CPU
                 // -> check if the CPU target has been enabled
                 if (::plssvm::detail::contains(available_target_platforms, target_platform::cpu)) {
-                    platform_devices[std::make_pair(platform, target_platform::cpu)].push_back(device);
+                    // check if a filter is provided and matches this device
+                    if (does_opt_filter_apply(target_platform::cpu)) {
+                        platform_devices[std::make_pair(platform, target_platform::cpu)].push_back(device);
+                    }
+                    // increment the CPU device count
+                    ++device_count_per_platform[target_platform::cpu];
                 }
-            } else if (device_type == CL_DEVICE_TYPE_GPU) {
+            } else if (device_type == (CL_DEVICE_TYPE_GPU)) {
                 // the current device is a GPU
                 // get vendor string
                 std::size_t vendor_string_size{};
@@ -105,12 +181,27 @@ namespace plssvm::opencl::detail {
 
                 // check vendor string and insert to correct target platform
                 if (::plssvm::detail::contains(vendor_string, "nvidia") && ::plssvm::detail::contains(available_target_platforms, target_platform::gpu_nvidia)) {
-                    platform_devices[std::make_pair(platform, target_platform::gpu_nvidia)].push_back(device);
+                    // check if a filter is provided and matches this device
+                    if (does_opt_filter_apply(target_platform::gpu_nvidia)) {
+                        platform_devices[std::make_pair(platform, target_platform::gpu_nvidia)].push_back(device);
+                    }
+                    // increment the NVIDIA GPU device count
+                    ++device_count_per_platform[target_platform::gpu_nvidia];
                 } else if ((::plssvm::detail::contains(vendor_string, "amd") || ::plssvm::detail::contains(vendor_string, "advanced micro devices"))
                            && ::plssvm::detail::contains(available_target_platforms, target_platform::gpu_amd)) {
-                    platform_devices[std::make_pair(platform, target_platform::gpu_amd)].push_back(device);
+                    // check if a filter is provided and matches this device
+                    if (does_opt_filter_apply(target_platform::gpu_amd)) {
+                        platform_devices[std::make_pair(platform, target_platform::gpu_amd)].push_back(device);
+                    }
+                    // increment the AMD GPU device count
+                    ++device_count_per_platform[target_platform::gpu_amd];
                 } else if (::plssvm::detail::contains(vendor_string, "intel") && ::plssvm::detail::contains(available_target_platforms, target_platform::gpu_intel)) {
-                    platform_devices[std::make_pair(platform, target_platform::gpu_intel)].push_back(device);
+                    // check if a filter is provided and matches this device
+                    if (does_opt_filter_apply(target_platform::gpu_intel)) {
+                        platform_devices[std::make_pair(platform, target_platform::gpu_intel)].push_back(device);
+                    }
+                    // increment the Intel GPU device count
+                    ++device_count_per_platform[target_platform::gpu_intel];
                 }
             }
         }
@@ -126,6 +217,11 @@ namespace plssvm::opencl::detail {
         }
         // the system devices should not be empty!
         if (system_devices.empty()) {
+            if (device_filter_env.has_value()) {
+                // add a more concrete error message in case of a PLSSVM_OPENCL_DEVICE_FILTER was provided
+                // since a wrong device filter may lead to no found device
+                throw platform_devices_empty{ fmt::format("No appropriate devices could be found! Maybe the PLSSVM_OPENCL_DEVICE_FILTER=\"{}\" is incorrect?", device_filter_env.value()) };
+            }
             throw platform_devices_empty{ "No appropriate devices could be found!" };
         }
         // determine the target_platform
@@ -142,7 +238,11 @@ namespace plssvm::opencl::detail {
     std::vector<context> contexts;
     for (auto &[platform, devices] : platform_devices) {
         // create context and associated OpenCL platform with it
-        std::array<cl_context_properties, 3> context_properties = { CL_CONTEXT_PLATFORM, reinterpret_cast<cl_context_properties>(platform.first), 0 };
+        std::array<cl_context_properties, 3> context_properties = {
+            CL_CONTEXT_PLATFORM,
+            reinterpret_cast<cl_context_properties>(platform.first),  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast): recommended way to do this
+            0
+        };
         for (auto &device : devices) {
             cl_context cont = clCreateContext(context_properties.data(), cl_uint{ 1 }, &device, nullptr, nullptr, &err);
             PLSSVM_OPENCL_ERROR_CHECK(err, "error creating the OpenCL context")
@@ -159,8 +259,10 @@ void device_synchronize(const command_queue &queue) {
 }
 
 std::string get_opencl_target_version() {
-    int major_version = CL_TARGET_OPENCL_VERSION / 100;
-    int minor_version = CL_TARGET_OPENCL_VERSION % 100 / 10;
+    constexpr int major_version_mask = 100;
+    constexpr int minor_version_mask = 10;
+    const int major_version = CL_TARGET_OPENCL_VERSION / major_version_mask;
+    const int minor_version = CL_TARGET_OPENCL_VERSION % major_version_mask / minor_version_mask;
     return fmt::format("{}.{}", major_version, minor_version);
 }
 
@@ -185,12 +287,18 @@ std::string get_device_name(const command_queue &queue) {
     PLSSVM_OPENCL_ERROR_CHECK(clGetDeviceInfo(device_id, CL_DEVICE_NAME, 0, nullptr, &name_length), "error obtaining device name size")
     std::string device_name(name_length - 1, '\0');
     PLSSVM_OPENCL_ERROR_CHECK(clGetDeviceInfo(device_id, CL_DEVICE_NAME, name_length, device_name.data(), nullptr), "error obtaining device name")
-    return device_name;
+    return std::string{ ::plssvm::detail::trim(device_name) };
 }
 
 std::vector<std::pair<compute_kernel_name, std::string>> kernel_type_to_function_names() {
     // since the correct predict kernel function cannot be determined during construction, add all predict kernels
     std::vector<std::pair<compute_kernel_name, std::string>> kernels{
+        // fill_kernel.cl
+        std::make_pair(compute_kernel_name::fill_kernel_float, "device_fill_kernel_float"),
+        std::make_pair(compute_kernel_name::fill_kernel_double, "device_fill_kernel_double"),
+        // memset_kernel.cl
+        std::make_pair(compute_kernel_name::memset_kernel_float, "device_memset_kernel_float"),
+        std::make_pair(compute_kernel_name::memset_kernel_double, "device_memset_kernel_double"),
         // kernel_matrix_assembly.cl
         std::make_pair(compute_kernel_name::assemble_kernel_matrix_explicit, "device_kernel_assembly"),
         // blas.cl
@@ -213,7 +321,7 @@ std::vector<std::pair<compute_kernel_name, std::string>> kernel_type_to_function
     return kernels;
 }
 
-std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi::communicator &comm, const std::vector<context> &contexts, const kernel_function_type kernel_function) {
+std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi::communicator &comm, const std::vector<context> &contexts, const target_platform target, const kernel_function_type kernel_function) {
     jit_info info{};
     const auto jit_start_time = std::chrono::steady_clock::now();
 
@@ -237,7 +345,7 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
     //**************************************************************************//
 
     // determine OpenCL compile options per device
-    std::string global_compile_options{ "-cl-mad-enable -cl-no-signed-zeros" };
+    std::string global_compile_options{ "-cl-mad-enable -cl-no-signed-zeros" };  // NOLINT: can be modified if fast-math is enabled
 #if defined(PLSSVM_ENABLE_FAST_MATH)
     global_compile_options += " -cl-fast-relaxed-math";
 #endif
@@ -248,7 +356,7 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
     // only use PTX inline assembly if enabled during CMake configuration
 #if defined(PLSSVM_OPENCL_BACKEND_USE_PTX_INLINE_ASSEMBLY)
     for (std::size_t idx = 0; idx < contexts.size(); ++idx) {
-        auto &context = contexts[idx];
+        const auto &context = contexts[idx];
 
         std::size_t platform_vendor_size{ 0 };
         clGetPlatformInfo(context.platform, CL_PLATFORM_VENDOR, 0, nullptr, &platform_vendor_size);
@@ -281,6 +389,8 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
     std::string kernel_src_string{};
     // note: the detail/atomics.cl file must be included first!
     for (const auto &path : { base_path / "detail/atomics.cl",
+                              base_path / "detail/fill_kernel.cl",
+                              base_path / "detail/memset_kernel.cl",
                               base_path / "kernel_functions.cl",
                               base_path / "cg_explicit/blas.cl",
                               base_path / "cg_explicit/kernel_matrix_assembly.cl",
@@ -336,6 +446,8 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
     // replace the generic strings in the kernel_src_string
     replace_kernel_function_type_placeholders(kernel_src_string, kernel_function);
 
+    // TODO: use defines? -DTHREAD_BLOCK_SIZE=32 ...
+
     // read generic predict kernel
     std::ifstream predict_file{ base_path / "predict_kernel.cl" };
     std::string predict_kernel_src_string{};
@@ -349,7 +461,7 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
         replace_kernel_function_type_placeholders(temp, predict_kernel_functions);
 
         // append correct kernel sources to final string
-        kernel_src_string.append(std::move(temp));
+        kernel_src_string.append(temp);
     }
 
     // replace types in kernel_src_string
@@ -358,19 +470,24 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
 
     // replace constants in kernel_src_string
     // replace the size_t variants -> BEFORE replacing the "normal" values
-    ::plssvm::detail::replace_all(kernel_src_string, "THREAD_BLOCK_SIZE_ul", fmt::format("(ulong) {}", THREAD_BLOCK_SIZE));
-    ::plssvm::detail::replace_all(kernel_src_string, "FEATURE_BLOCK_SIZE_ul", fmt::format("(ulong) {}", FEATURE_BLOCK_SIZE));
-    ::plssvm::detail::replace_all(kernel_src_string, "INTERNAL_BLOCK_SIZE_ul", fmt::format("(ulong) {}", INTERNAL_BLOCK_SIZE));
-    ::plssvm::detail::replace_all(kernel_src_string, "PADDING_SIZE_ul", fmt::format("(ulong) {}", PADDING_SIZE));
+    ::plssvm::detail::replace_all(kernel_src_string, "THREAD_BLOCK_SIZE_uz", fmt::format("(ulong) {}", THREAD_BLOCK_SIZE));
+    ::plssvm::detail::replace_all(kernel_src_string, "INTERNAL_BLOCK_SIZE_uz", fmt::format("(ulong) {}", INTERNAL_BLOCK_SIZE));
+    ::plssvm::detail::replace_all(kernel_src_string, "PADDING_SIZE_uz", fmt::format("(ulong) {}", PADDING_SIZE));
     // replace the normal variants
     ::plssvm::detail::replace_all(kernel_src_string, "THREAD_BLOCK_SIZE", fmt::format("{}", THREAD_BLOCK_SIZE));
-    ::plssvm::detail::replace_all(kernel_src_string, "FEATURE_BLOCK_SIZE", fmt::format("{}", FEATURE_BLOCK_SIZE));
     ::plssvm::detail::replace_all(kernel_src_string, "INTERNAL_BLOCK_SIZE", fmt::format("{}", INTERNAL_BLOCK_SIZE));
     ::plssvm::detail::replace_all(kernel_src_string, "PADDING_SIZE", fmt::format("{}", PADDING_SIZE));
 
+    // set compile definition checking whether we are executing on a CPU or not
+    for (std::string &options : compile_options) {
+        if (target == target_platform::cpu) {
+            options += " -DPLSSVM_OPENCL_TARGET_CPUS";
+        }
+    }
+
     // get all device names
     std::vector<std::string> device_names{};
-    for (auto &context : contexts) {
+    for (const auto &context : contexts) {
         // get device name
         std::size_t name_length{};
         PLSSVM_OPENCL_ERROR_CHECK(clGetDeviceInfo(context.device, CL_DEVICE_NAME, 0, nullptr, &name_length), "error obtaining device name size")
@@ -420,6 +537,7 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
         // get directory iterator
         auto dirIter = std::filesystem::directory_iterator(cache_dir_name);
         // get files in directory -> account for stored preprocessed source file
+        // NOLINTNEXTLINE(misc-include-cleaner): false positive -> included via <filesystem>
         if (static_cast<std::size_t>(std::count_if(std::filesystem::begin(dirIter), std::filesystem::end(dirIter), [](const auto &entry) { return entry.is_regular_file(); })) != contexts.size() + 1) {
             info.cache_state = jit_info::caching_status::error_invalid_number_of_cached_files;
         }
@@ -434,7 +552,8 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
     std::vector<std::vector<unsigned char>> binaries(contexts.size());
     std::vector<unsigned char *> binaries_ptr(binaries.size());
 
-    error_code err, err_bin;
+    error_code err;
+    error_code err_bin;
 
     if (info.cache_state != jit_info::caching_status::success) {
         if (comm.size() == 1) {
@@ -445,8 +564,8 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
         }
 
         for (std::size_t idx = 0; idx < contexts.size(); ++idx) {
-            auto &context = contexts[idx];
-            auto &device = context.device;
+            const auto &context = contexts[idx];
+            const auto &device = context.device;
 
             // create and build program
             cl_program program = clCreateProgramWithSource(context, 1, &kernel_src_ptr, nullptr, &err);
@@ -467,11 +586,11 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
             binaries_ptr[idx] = binaries[idx].data();  // only necessary for OpenCL's void ** calls!
 
             // get binaries
-            err = clGetProgramInfo(program, CL_PROGRAM_BINARIES, sizeof(unsigned char *), &binaries_ptr[idx], nullptr);
+            err = clGetProgramInfo(program, CL_PROGRAM_BINARIES, sizeof(unsigned char *), static_cast<void *>(&binaries_ptr[idx]), nullptr);
             PLSSVM_OPENCL_ERROR_CHECK(err, "error retrieving the kernel binaries")
 
             // release resource
-            if (program) {
+            if (static_cast<bool>(program)) {
                 PLSSVM_OPENCL_ERROR_CHECK(clReleaseProgram(program), "error releasing OpenCL program resources")
             }
         }
@@ -490,7 +609,7 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
         for (std::vector<std::size_t>::size_type i = 0; i < binary_sizes.size(); ++i) {
             std::ofstream out{ cache_dir_name / fmt::format("device_{}.bin", i) };
             PLSSVM_ASSERT(out.good(), fmt::format("couldn't create binary cache file ({}) for device {}", cache_dir_name / fmt::format("device_{}.bin", i), i));
-            out.write(reinterpret_cast<char *>(binaries_ptr[i]), static_cast<std::streamsize>(binary_sizes[i]));
+            out.write(reinterpret_cast<const char *>(binaries_ptr[i]), static_cast<std::streamsize>(binary_sizes[i]));  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast): recommended way to do this
         }
         {
             // save preprocessed source string in temporary directory
@@ -527,7 +646,7 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
             // allocate the necessary buffer
             std::vector<unsigned char> file_content(num_bytes);
             // read the whole file in one go
-            f.read(reinterpret_cast<char *>(file_content.data()), num_bytes);
+            f.read(reinterpret_cast<char *>(file_content.data()), num_bytes);  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast): recommended way to do this
             return std::make_pair(file_content, static_cast<std::size_t>(num_bytes));
         };
 
@@ -544,11 +663,11 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
     }
 
     std::vector<command_queue> queues{};
-    // compile kernels for each context, i.e., each device
 
+    // compile kernels for each context, i.e., each device
     for (std::size_t idx = 0; idx < contexts.size(); ++idx) {
-        auto &context = contexts[idx];
-        auto &device = context.device;
+        const auto &context = contexts[idx];
+        const auto &device = context.device;
 
         // build from binaries
         cl_program binary_program = clCreateProgramWithBinary(context, static_cast<cl_uint>(1), &device, binary_sizes.data(), const_cast<const unsigned char **>(&binaries_ptr[idx]), &err_bin, &err);
@@ -572,7 +691,7 @@ std::pair<std::vector<command_queue>, jit_info> create_command_queues(const mpi:
         }
 
         // release resource
-        if (binary_program) {
+        if (static_cast<bool>(binary_program)) {
             PLSSVM_OPENCL_ERROR_CHECK(clReleaseProgram(binary_program), "error releasing OpenCL binary program resources")
         }
 
diff --git a/src/plssvm/backends/OpenMP/csvm.cpp b/src/plssvm/backends/OpenMP/csvm.cpp
index 7a7c17ef2..7610b5533 100644
--- a/src/plssvm/backends/OpenMP/csvm.cpp
+++ b/src/plssvm/backends/OpenMP/csvm.cpp
@@ -15,15 +15,16 @@
 #include "plssvm/backends/OpenMP/kernel/cg_explicit/kernel_matrix_assembly.hpp"       // plssvm::openmp::detail::device_kernel_assembly
 #include "plssvm/backends/OpenMP/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp"  // plssvm::openmp::detail::device_kernel_assembly_symm
 #include "plssvm/backends/OpenMP/kernel/predict_kernel.hpp"                           // plssvm::openmp::detail::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
-#include "plssvm/constants.hpp"                                                       // plssvm::real_type
+#include "plssvm/constants.hpp"                                                       // plssvm::real_type, plssvm::PADDING_SIZE
 #include "plssvm/detail/assert.hpp"                                                   // PLSSVM_ASSERT
 #include "plssvm/detail/data_distribution.hpp"                                        // plssvm::detail::triangular_data_distribution
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"                                // plssvm::detail::log_untracked
+#include "plssvm/detail/make_unique_for_overwrite.hpp"                                // plssvm::detail::{make_unique_for_overwrite, parallel_zero_memset}
 #include "plssvm/detail/memory_size.hpp"                                              // plssvm::detail::memory_size
 #include "plssvm/detail/move_only_any.hpp"                                            // plssvm::detail::{move_only_any, move_only_any_cast}
+#include "plssvm/detail/operators.hpp"                                                // NOLINT: operator overloads for std::vector (+ scalars)
 #include "plssvm/detail/tracking/performance_tracker.hpp"                             // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
 #include "plssvm/detail/utility.hpp"                                                  // plssvm::detail::get_system_memory
-#include "plssvm/gamma.hpp"                                                           // plssvm::gamma_type
 #include "plssvm/kernel_function_types.hpp"                                           // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                                                          // plssvm::aos_matrix, plssvm::soa_matrix
 #include "plssvm/mpi/communicator.hpp"                                                // plssvm::mpi::communicator
@@ -31,20 +32,21 @@
 #include "plssvm/parameter.hpp"                                                       // plssvm::parameter
 #include "plssvm/shape.hpp"                                                           // plssvm::shape
 #include "plssvm/solver_types.hpp"                                                    // plssvm::solver_type
-#include "plssvm/svm/csvm.hpp"                                                        // plssvm::csvm
 #include "plssvm/target_platforms.hpp"                                                // plssvm::target_platform
 #include "plssvm/verbosity_levels.hpp"                                                // plssvm::verbosity_level
 
 #include "fmt/format.h"  // fmt::format
 
-#include <chrono>   // std::chrono::{steady_clock, duration_cast}
-#include <cmath>    // std::fma
-#include <cstddef>  // std::size_t
-#include <cstring>  // std::memset
-#include <tuple>    // std::tuple, std::make_tuple
-#include <utility>  // std::pair, std::make_pair, std::move
-#include <variant>  // std::get
-#include <vector>   // std::vector
+#include <chrono>      // std::chrono::{steady_clock, duration_cast}
+#include <cmath>       // std::fma
+#include <cstddef>     // std::size_t
+#include <cstring>     // std::memset, std::memcpy
+#include <functional>  // std::cref
+#include <memory>      // std::make_unique
+#include <optional>    // std::optional, std::nullopt
+#include <tuple>       // std::tuple, std::make_tuple
+#include <utility>     // std::pair, std::make_pair, std::move, std::get
+#include <vector>      // std::vector
 
 namespace plssvm::openmp {
 
@@ -79,19 +81,23 @@ csvm::csvm(const target_platform target) {
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "backend", plssvm::backend_type::openmp }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "target_platform", target_ }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_threads", detail::get_num_threads() }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));  // NOLINT: safe to call this virtual function in the constructor
 }
 
 csvm::~csvm() = default;
 
 std::vector<::plssvm::detail::memory_size> csvm::get_device_memory() const {
-    return { ::plssvm::detail::get_system_memory() };
+    return std::vector<::plssvm::detail::memory_size>(this->num_available_devices(), ::plssvm::detail::get_system_memory());
 }
 
 std::vector<::plssvm::detail::memory_size> csvm::get_max_mem_alloc_size() const {
     return this->get_device_memory();
 }
 
+std::vector<std::optional<::plssvm::detail::memory_size>> csvm::get_local_memory() const {
+    return std::vector<std::optional<::plssvm::detail::memory_size>>(this->num_available_devices(), std::nullopt);
+}
+
 //***************************************************//
 //                        fit                        //
 //***************************************************//
@@ -125,26 +131,33 @@ std::vector<::plssvm::detail::move_only_any> csvm::assemble_kernel_matrix(const
                     // get the offset of the data points this device is responsible for
                     const std::size_t row_offset = dist.place_row_offset(0);
 
-                    std::vector<real_type> kernel_matrix(dist.calculate_explicit_kernel_matrix_num_entries_padded(0));  // only explicitly store the upper triangular matrix
+                    // get the number of kernel matrix entries
+                    const std::size_t num_entries = dist.calculate_explicit_kernel_matrix_num_entries_padded(0);
+
+                    // only explicitly store the upper triangular matrix
+                    auto kernel_matrix = ::plssvm::detail::make_unique_for_overwrite<real_type[]>(num_entries);  // NOLINT: C-style array must be used with make_unique_for_overwrite
+                    // initialize kernel matrix to all zeros in parallel
+                    ::plssvm::detail::parallel_zero_memset(kernel_matrix.get(), num_entries);
+
                     const auto start = std::chrono::steady_clock::now();
                     switch (params.kernel_type) {
                         case kernel_function_type::linear:
-                            detail::device_kernel_assembly<kernel_function_type::linear>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost);
+                            detail::device_kernel_assembly<kernel_function_type::linear>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost);
                             break;
                         case kernel_function_type::polynomial:
-                            detail::device_kernel_assembly<kernel_function_type::polynomial>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, params.degree, std::get<real_type>(params.gamma), params.coef0);
+                            detail::device_kernel_assembly<kernel_function_type::polynomial>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, params.degree, std::get<real_type>(params.gamma), params.coef0);
                             break;
                         case kernel_function_type::rbf:
-                            detail::device_kernel_assembly<kernel_function_type::rbf>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
+                            detail::device_kernel_assembly<kernel_function_type::rbf>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
                             break;
                         case kernel_function_type::sigmoid:
-                            detail::device_kernel_assembly<kernel_function_type::sigmoid>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma), params.coef0);
+                            detail::device_kernel_assembly<kernel_function_type::sigmoid>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma), params.coef0);
                             break;
                         case kernel_function_type::laplacian:
-                            detail::device_kernel_assembly<kernel_function_type::laplacian>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
+                            detail::device_kernel_assembly<kernel_function_type::laplacian>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
                             break;
                         case kernel_function_type::chi_squared:
-                            detail::device_kernel_assembly<kernel_function_type::chi_squared>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
+                            detail::device_kernel_assembly<kernel_function_type::chi_squared>(kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
                             break;
                     }
                     const auto end = std::chrono::steady_clock::now();
@@ -157,7 +170,7 @@ std::vector<::plssvm::detail::move_only_any> csvm::assemble_kernel_matrix(const
             case solver_type::cg_implicit:
                 {
                     // simply return data since in implicit we don't assembly the kernel matrix here!
-                    kernel_matrices_parts[0] = ::plssvm::detail::move_only_any{ std::make_tuple(std::move(A), params, std::move(q_red), QA_cost) };
+                    kernel_matrices_parts[0] = ::plssvm::detail::move_only_any{ std::make_tuple(std::cref(A), params, std::cref(q_red), QA_cost) };
                 }
                 break;
         }
@@ -176,7 +189,7 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
     PLSSVM_ASSERT(B.shape() == C.shape(), "The B ({}) and C ({}) matrices must have the same shape!", B.shape(), C.shape());
     PLSSVM_ASSERT(B.padding() == C.padding(), "The B ({}) and C ({}) matrices must have the same padding!", B.padding(), C.padding());
 
-    using namespace operators;
+    using namespace operators;  // NOLINT(google-build-using-namespace): only imports custom math operations on vectors (and scalars)
 
     // get the triangular data distribution
     const ::plssvm::detail::triangular_data_distribution &dist = dynamic_cast<::plssvm::detail::triangular_data_distribution &>(*data_distribution_);
@@ -202,16 +215,16 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
                 break;
             case solver_type::cg_explicit:
                 {
-                    const auto &explicit_A = ::plssvm::detail::move_only_any_cast<const std::vector<real_type> &>(A.front());
-                    PLSSVM_ASSERT(!explicit_A.empty(), "The A matrix must not be empty!");
+                    const auto &explicit_A = ::plssvm::detail::move_only_any_cast<const std::unique_ptr<real_type[]> &>(A.front());  // NOLINT: C-style array must be used
+                    PLSSVM_ASSERT(explicit_A != nullptr, "The A matrix must not be empty!");
 
                     const auto start = std::chrono::steady_clock::now();
 
-                    detail::device_kernel_symm(num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, explicit_A, B, beta, C);
+                    detail::device_kernel_symm(num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, explicit_A.get(), B, beta, C);
 
                     const std::size_t num_mirror_rows = num_rows - row_offset - device_specific_num_rows;
                     if (num_mirror_rows > std::size_t{ 0 }) {
-                        detail::device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, explicit_A, B, beta, C);
+                        detail::device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, explicit_A.get(), B, beta, C);
                     }
 
                     const auto end = std::chrono::steady_clock::now();
@@ -221,7 +234,7 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
                 break;
             case solver_type::cg_implicit:
                 {
-                    const auto &[matr_A, params, q_red, QA_cost] = ::plssvm::detail::move_only_any_cast<const std::tuple<soa_matrix<real_type>, parameter, std::vector<real_type>, real_type> &>(A.front());
+                    const auto &[matr_A, params, q_red, QA_cost] = ::plssvm::detail::move_only_any_cast<const std::tuple<const soa_matrix<real_type> &, parameter, const std::vector<real_type> &, real_type> &>(A.front());
                     PLSSVM_ASSERT(!matr_A.empty(), "The A matrix must not be empty!");
                     PLSSVM_ASSERT(!q_red.empty(), "The q_red vector must not be empty!");
                     const real_type cost = real_type{ 1.0 } / params.cost;
@@ -260,6 +273,8 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
                 break;
         }
     }
+    // restore padding entries by setting them to zero
+    C.restore_padding();
 }
 
 //***************************************************//
@@ -315,6 +330,8 @@ aos_matrix<real_type> csvm::predict_values(const parameter &params,
                 [[maybe_unused]] const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
                 PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "predict_values", "w_kernel", duration }));
             }
+            // restore padding entries by setting them to zero
+            w.restore_padding();
 
             // reduce w on all MPI ranks
             comm_.allreduce_inplace(w);
@@ -330,8 +347,12 @@ aos_matrix<real_type> csvm::predict_values(const parameter &params,
         // call the predict kernels
         switch (params.kernel_type) {
             case kernel_function_type::linear:
-                // predict the values using the w vector
-                detail::device_kernel_predict_linear(out, w, rho, predict_points, device_specific_num_predict_points, row_offset);
+                {
+                    // predict the values using the w vector
+                    std::vector<real_type> rho_padded(rho.size() + PADDING_SIZE, real_type{ 0.0 });
+                    std::memcpy(rho_padded.data(), rho.data(), rho.size() * sizeof(real_type));
+                    detail::device_kernel_predict_linear(out, w, rho_padded, predict_points, device_specific_num_predict_points, row_offset);
+                }
                 break;
             case kernel_function_type::polynomial:
                 detail::device_kernel_predict<kernel_function_type::polynomial>(out, alpha, rho, support_vectors, predict_points, device_specific_num_predict_points, row_offset, params.degree, std::get<real_type>(params.gamma), params.coef0);
@@ -354,6 +375,8 @@ aos_matrix<real_type> csvm::predict_values(const parameter &params,
         PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "predict_values", "predict_kernel", duration }));
     }
 
+    // restore padding entries by setting them to zero
+    out.restore_padding();
     return out;
 }
 
diff --git a/src/plssvm/backends/OpenMP/detail/utility.cpp b/src/plssvm/backends/OpenMP/detail/utility.cpp
index a39e0e348..7f92ae400 100644
--- a/src/plssvm/backends/OpenMP/detail/utility.cpp
+++ b/src/plssvm/backends/OpenMP/detail/utility.cpp
@@ -6,6 +6,8 @@
  *          See the LICENSE.md file in the project root for full license information.
  */
 
+#include "plssvm/backends/OpenMP/detail/utility.hpp"
+
 #include "plssvm/detail/utility.hpp"  // plssvm::detail::contains
 
 #include "omp.h"  // omp_get_num_threads, _OPENMP
@@ -48,9 +50,8 @@ std::string get_openmp_version() {
     // return sanitized version or plain _OPENMP if the version isn't found
     if (::plssvm::detail::contains(version_map, _OPENMP)) {
         return version_map.at(_OPENMP);
-    } else {
-        return fmt::format("{}", _OPENMP);
     }
+    return fmt::format("{}", _OPENMP);
 }
 
 }  // namespace plssvm::openmp::detail
diff --git a/src/plssvm/backends/SYCL/AdaptiveCpp/.clang-tidy b/src/plssvm/backends/SYCL/AdaptiveCpp/.clang-tidy
new file mode 100644
index 000000000..269419787
--- /dev/null
+++ b/src/plssvm/backends/SYCL/AdaptiveCpp/.clang-tidy
@@ -0,0 +1,10 @@
+---
+Checks: '
+-cppcoreguidelines-avoid-const-or-ref-data-members,
+
+-clang-analyzer-core.CallAndMessage,
+
+-misc-include-cleaner,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/src/plssvm/backends/SYCL/AdaptiveCpp/CMakeLists.txt b/src/plssvm/backends/SYCL/AdaptiveCpp/CMakeLists.txt
index 07b18e4f4..ae3e0b050 100644
--- a/src/plssvm/backends/SYCL/AdaptiveCpp/CMakeLists.txt
+++ b/src/plssvm/backends/SYCL/AdaptiveCpp/CMakeLists.txt
@@ -20,9 +20,11 @@ if (PLSSVM_SYCL_BACKEND_ADAPTIVECPP_USE_GENERIC_SSCP)
     set(ACPP_TARGETS "generic" CACHE STRING "" FORCE)
     if (PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS)
         message(
-            WARNING "Enabled SYCL's hierarchical and AdapitveCpp's scoped kernels in AdaptiveCpp while using its SSCP compilation flow. "
-                    "SSCP, however, does currently not implement these kernel invocation types resulting in a runtime exception. "
+            WARNING "Enabled SYCL's hierarchical and AdaptiveCpp's scoped kernels in AdaptiveCpp while using its SSCP compilation flow. "
+                    "SSCP, however, does currently not implement these data parallel kernels resulting in a runtime exception. "
                     "If you wish to use them, set \"PLSSVM_SYCL_BACKEND_ADAPTIVECPP_USE_GENERIC_SSCP\" to \"OFF\" and use one of the legacy compilation flows. "
+                    "Alternatively, SYCL's hierarchical and AdaptiveCpp's scoped kernels can be disabled by setting "
+                    "\"PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS\" to \"OFF\"."
         )
     endif ()
 else ()
diff --git a/src/plssvm/backends/SYCL/AdaptiveCpp/csvm.cpp b/src/plssvm/backends/SYCL/AdaptiveCpp/csvm.cpp
index 6f0772db0..4f225e504 100644
--- a/src/plssvm/backends/SYCL/AdaptiveCpp/csvm.cpp
+++ b/src/plssvm/backends/SYCL/AdaptiveCpp/csvm.cpp
@@ -12,7 +12,8 @@
 #include "plssvm/backends/execution_range.hpp"                                                   // plssvm::detail::{dim_type, execution_range}
 #include "plssvm/backends/SYCL/AdaptiveCpp/detail/device_ptr.hpp"                                // plssvm::adaptivecpp::detail::::device_ptr
 #include "plssvm/backends/SYCL/AdaptiveCpp/detail/queue_impl.hpp"                                // plssvm::adaptivecpp::detail::queue (PImpl implementation)
-#include "plssvm/backends/SYCL/AdaptiveCpp/detail/utility.hpp"                                   // plssvm::adaptivecpp::detail::{get_device_list, device_synchronize, get_adaptivecpp_version_short, get_adaptivecpp_version}
+#include "plssvm/backends/SYCL/AdaptiveCpp/detail/utility.hpp"                                   // plssvm::adaptivecpp::detail::{get_device_list, device_synchronize, get_device_name, get_adaptivecpp_version_short, get_adaptivecpp_version}
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"                                        // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/exceptions.hpp"                                                   // plssvm::adaptivecpp::backend_exception
 #include "plssvm/backends/SYCL/implementation_types.hpp"                                         // plssvm::sycl::implementation_type
 #include "plssvm/backends/SYCL/kernel/cg_explicit/basic/blas.hpp"                                // plssvm::sycl::detail::basic::{device_kernel_symm, device_kernel_symm_mirror, device_kernel_inplace_matrix_add, device_kernel_inplace_matrix_scale}
@@ -31,7 +32,6 @@
 #include "plssvm/backends/SYCL/kernel/predict/hierarchical/predict_kernel.hpp"                   // plssvm::sycl::detail::hierarchical::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
 #include "plssvm/backends/SYCL/kernel/predict/scoped/predict_kernel.hpp"                         // plssvm::sycl::detail::scoped::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
 #include "plssvm/backends/SYCL/kernel/predict/work_group/predict_kernel.hpp"                     // plssvm::sycl::detail::work_group::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"                                      // plssvm::kernel_invocation_type
 #include "plssvm/constants.hpp"                                                                  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/detail/assert.hpp"                                                              // PLSSVM_ASSERT
 #include "plssvm/detail/data_distribution.hpp"                                                   // plssvm::detail::{data_distribution, triangular_data_distribution, rectangular_data_distribution}
@@ -41,8 +41,6 @@
 #include "plssvm/detail/memory_size.hpp"                                                         // plssvm::detail::memory_size
 #include "plssvm/detail/tracking/performance_tracker.hpp"                                        // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
 #include "plssvm/detail/utility.hpp"                                                             // plssvm::detail::get_system_memory
-#include "plssvm/exceptions/exceptions.hpp"                                                      // plssvm::exception
-#include "plssvm/gamma.hpp"                                                                      // plssvm::gamma_type
 #include "plssvm/kernel_function_types.hpp"                                                      // plssvm::kernel_type
 #include "plssvm/mpi/communicator.hpp"                                                           // plssvm::mpi::communicator
 #include "plssvm/mpi/detail/information.hpp"                                                     // plssvm::mpi::detail::gather_and_print_csvm_information
@@ -62,11 +60,150 @@
 #include <exception>  // std::terminate
 #include <iostream>   // std::cout, std::endl
 #include <limits>     // std::numeric_limits::max
+#include <optional>   // std::optional
 #include <string>     // std::string
-#include <tuple>      // std::tie
-#include <variant>    // std::get
+#include <tuple>      // std::tie, std::get
+#include <utility>    // std::forward
 #include <vector>     // std::vector
 
+namespace {
+
+/**
+ * @brief Run the kernel functor on the given device.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam QueueType the type of the SYCL queue to run the kernel on
+ * @tparam Args the types of the parameters necessary for the specific kernel functor
+ * @param[in] device the SYCL queue to run the kernel on
+ * @param[in] partial_grid the number of work-groups in each dimension of the execution grid
+ * @param[in] block the number of work-items in each dimension per work-group
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <typename KernelFunctor, typename QueueType, typename... Args>
+void run_kernel_functor(const QueueType &device, const plssvm::detail::dim_type partial_grid, const plssvm::detail::dim_type block, Args &&...args) {
+    constexpr plssvm::sycl::data_parallel_kernel data_parallel_kernel_type = KernelFunctor::data_parallel_kernel_type;
+
+    if constexpr (data_parallel_kernel_type == plssvm::sycl::data_parallel_kernel::basic) {
+        device.impl->sycl_queue.submit([&](::sycl::handler &cgh) {
+            cgh.parallel_for(plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::basic>(partial_grid, block),
+                             KernelFunctor{ std::forward<Args>(args)... });
+        });
+    } else if constexpr (data_parallel_kernel_type == plssvm::sycl::data_parallel_kernel::work_group) {
+        device.impl->sycl_queue.submit([&](::sycl::handler &cgh) {
+            cgh.parallel_for(plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::work_group>(partial_grid, block),
+                             KernelFunctor{ cgh, std::forward<Args>(args)... });
+        });
+    } else if constexpr (data_parallel_kernel_type == plssvm::sycl::data_parallel_kernel::hierarchical) {
+#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
+        device.impl->sycl_queue.submit([&](::sycl::handler &cgh) {
+            const auto exec_range = plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::hierarchical>(partial_grid, block);
+            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), KernelFunctor{ std::forward<Args>(args)... });
+        });
+#else
+        throw plssvm::adaptivecpp::backend_exception{ "Support for sycl::data_parallel_kernel::hierarchical was disabled!" };
+#endif
+    } else if constexpr (data_parallel_kernel_type == plssvm::sycl::data_parallel_kernel::scoped) {
+#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
+        device.impl->sycl_queue.submit([&](::sycl::handler &cgh) {
+            const auto exec_range = plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::scoped>(partial_grid, block);
+            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), KernelFunctor{ std::forward<Args>(args)... });
+        });
+#else
+        throw plssvm::adaptivecpp::backend_exception{ "Support for sycl::data_parallel_kernel::scoped was disabled!" };
+#endif
+    } else {
+        static_assert(::plssvm::detail::always_false_v<Args...>, "Unsupported kernel function!");
+    }
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct kernel function type.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam target the target platform to run the kernel on
+ * @tparam Args the types of the parameters necessary for the specific kernel functor; stored in a `std::tuple`
+ * @param[in] params the parameters used to determine the kernel function type
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <plssvm::target_platform, plssvm::kernel_function_type, typename...> typename KernelFunctor, plssvm::target_platform target, typename... Args>
+void dispatch_kernel_function_type(const plssvm::parameter &params, Args &&...args) {
+    switch (params.kernel_type) {
+        case plssvm::kernel_function_type::linear:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::linear>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::kernel_function_type::polynomial:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::polynomial, int, plssvm::real_type, plssvm::real_type>>(std::forward<Args>(args)..., params.degree, std::get<plssvm::real_type>(params.gamma), params.coef0);
+            break;
+        case plssvm::kernel_function_type::rbf:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::rbf, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+        case plssvm::kernel_function_type::sigmoid:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::sigmoid, plssvm::real_type, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma), params.coef0);
+            break;
+        case plssvm::kernel_function_type::laplacian:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::laplacian, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+        case plssvm::kernel_function_type::chi_squared:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::chi_squared, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+    }
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct target platform and kernel function type.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam Args the types of the parameters necessary for the specific kernel functor; stored in a `std::tuple`
+ * @param[in] target the target platform to run the kernel on
+ * @param[in] params the parameters used to determine the kernel function type
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <plssvm::target_platform, plssvm::kernel_function_type, typename...> typename KernelFunctor, typename... Args>
+void dispatch_target_platform(const plssvm::target_platform target, const plssvm::parameter &params, Args &&...args) {
+    switch (target) {
+        case plssvm::target_platform::automatic:
+            throw plssvm::adaptivecpp::backend_exception{ "Can't determine the target platform!" };
+        case plssvm::target_platform::gpu_nvidia:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::gpu_nvidia>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::gpu_amd>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::gpu_intel>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::cpu:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::cpu>(params, std::forward<Args>(args)...);
+            break;
+    }
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct target platform.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam Args the types of the parameters necessary for the specific kernel functor; stored in a `std::tuple`
+ * @param[in] target the target platform to run the kernel on
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <plssvm::target_platform> typename KernelFunctor, typename... Args>
+void dispatch_target_platform(const plssvm::target_platform target, Args &&...args) {
+    switch (target) {
+        case plssvm::target_platform::automatic:
+            throw plssvm::adaptivecpp::backend_exception{ "Can't determine the target platform!" };
+        case plssvm::target_platform::gpu_nvidia:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::gpu_nvidia>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::gpu_amd>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::gpu_intel>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::cpu:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::cpu>>(std::forward<Args>(args)...);
+            break;
+    }
+}
+
+}  // namespace
+
 namespace plssvm::adaptivecpp {
 
 void csvm::init(const target_platform target) {
@@ -107,11 +244,11 @@ void csvm::init(const target_platform target) {
         throw backend_exception{ fmt::format("SYCL backend selected but no devices for the target {} were found!", target_) };
     }
 
-    // set correct kernel invocation type if "automatic" has been provided
-    if (invocation_type_ == sycl::kernel_invocation_type::automatic) {
+    // set the correct data parallel kernel if "automatic" has been provided
+    if (data_parallel_kernel_type_ == sycl::data_parallel_kernel::automatic) {
         // always use work_group for AdaptiveCpp
-        invocation_type_ = sycl::kernel_invocation_type::work_group;
-        if (target_ == target_platform::cpu) {  // TODO: set to hierarchical or scoped?!
+        data_parallel_kernel_type_ = sycl::data_parallel_kernel::work_group;
+        if (target_ == target_platform::cpu) {
 #if !defined(__ACPP_USE_ACCELERATED_CPU__) && defined(__ACPP_ENABLE_OMPHOST_TARGET__)
             plssvm::detail::log_untracked(verbosity_level::full | verbosity_level::warning,
                                           "WARNING: the AdaptiveCpp automatic target for the CPU is set to work_group, but AdaptiveCpp hasn't been build with the \"omp.accelerated\" compilation flow resulting in major performance losses!\n");
@@ -125,18 +262,18 @@ void csvm::init(const target_platform target) {
     if (comm_.size() > 1) {
         // use MPI rank specific command line output
         for (const queue_type &device : devices_) {
-            device_names.emplace_back(device.impl->sycl_queue.get_device().template get_info<::sycl::info::device::name>());
+            device_names.push_back(detail::get_device_name(device));
         }
 
-        mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::sycl, target_, device_names, fmt::format("{}", invocation_type_));
+        mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::sycl, target_, device_names, fmt::format("{}", data_parallel_kernel_type_));
     } else {
         // use more detailed single rank command line output
         plssvm::detail::log_untracked(verbosity_level::full,
                                       comm_,
-                                      "\nUsing AdaptiveCpp ({}; {}) as SYCL backend with the kernel invocation type \"{}\".\n",
+                                      "\nUsing AdaptiveCpp ({}; {}) as SYCL backend with the data parallel kernel \"{}\".\n",
                                       detail::get_adaptivecpp_version_short(),
                                       PLSSVM_ACPP_TARGETS,
-                                      invocation_type_);
+                                      data_parallel_kernel_type_);
         if (target == target_platform::automatic) {
             plssvm::detail::log_untracked(verbosity_level::full,
                                           comm_,
@@ -150,13 +287,12 @@ void csvm::init(const target_platform target) {
                                       target_);
 
         for (typename std::vector<queue_type>::size_type device = 0; device < devices_.size(); ++device) {
-            const std::string device_name = devices_[device].impl->sycl_queue.get_device().template get_info<::sycl::info::device::name>();
+            device_names.push_back(detail::get_device_name(devices_[device]));
             plssvm::detail::log_untracked(verbosity_level::full,
                                           comm_,
                                           "  [{}, {}]\n",
                                           device,
-                                          device_name);
-            device_names.emplace_back(device_name);
+                                          device_names.back());
         }
     }
 
@@ -167,7 +303,7 @@ void csvm::init(const target_platform target) {
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "adaptivecpp_version", detail::get_adaptivecpp_version() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "backend", plssvm::backend_type::sycl }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "sycl_implementation_type", plssvm::sycl::implementation_type::adaptivecpp }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "sycl_kernel_invocation_type", invocation_type_ }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "sycl_data_parallel_kernel", data_parallel_kernel_type_ }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "target_platform", target_ }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", devices_.size() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names }));
@@ -210,6 +346,14 @@ std::vector<::plssvm::detail::memory_size> csvm::get_max_mem_alloc_size() const
     return res;
 }
 
+std::vector<std::optional<::plssvm::detail::memory_size>> csvm::get_local_memory() const {
+    std::vector<std::optional<::plssvm::detail::memory_size>> res(this->num_available_devices());
+    for (std::size_t device_id = 0; device_id < this->num_available_devices(); ++device_id) {
+        res[device_id] = ::plssvm::detail::memory_size{ static_cast<unsigned long long>(devices_[device_id].impl->sycl_queue.get_device().get_info<::sycl::info::device::local_mem_size>()) };
+    }
+    return res;
+}
+
 std::size_t csvm::get_max_work_group_size(const std::size_t device_id) const {
     PLSSVM_ASSERT(device_id < this->num_available_devices(), "Invalid device {} requested!", device_id);
     return devices_[device_id].impl->sycl_queue.get_device().get_info<::sycl::info::device::max_work_group_size>();
@@ -257,273 +401,21 @@ auto csvm::run_assemble_kernel_matrix_explicit(const std::size_t device_id, cons
 
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (params.kernel_type) {
-            //***************************************************//
-            //               linear kernel function              //
-            //***************************************************//
-            case kernel_function_type::linear:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             sycl::detail::basic::device_kernel_assembly<kernel_function_type::linear>{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             sycl::detail::work_group::device_kernel_assembly<kernel_function_type::linear>{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::linear>{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::scoped::device_kernel_assembly<kernel_function_type::linear>{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
                 break;
-            //***************************************************//
-            //             polynomial kernel function            //
-            //***************************************************//
-            case kernel_function_type::polynomial:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_assembly<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
-                break;
-            //***************************************************//
-            //            radial-basis kernel function           //
-            //***************************************************//
-            case kernel_function_type::rbf:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::rbf, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_assembly<kernel_function_type::rbf, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
-                break;
-            //***************************************************//
-            //              sigmoid kernel function              //
-            //***************************************************//
-            case kernel_function_type::sigmoid:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_assembly<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
+            case sycl::data_parallel_kernel::basic:
+                dispatch_target_platform<sycl::detail::basic::device_kernel_assembly>(target_, params, device, partial_grid, exec.block, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets.y, offsets.x);
                 break;
-            //***************************************************//
-            //             laplacian kernel function             //
-            //***************************************************//
-            case kernel_function_type::laplacian:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::laplacian, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_assembly<kernel_function_type::laplacian, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
+            case sycl::data_parallel_kernel::work_group:
+                dispatch_target_platform<sycl::detail::work_group::device_kernel_assembly>(target_, params, device, partial_grid, exec.block, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets.y, offsets.x);
                 break;
-            //***************************************************//
-            //            chi-squared kernel function            //
-            //***************************************************//
-            case kernel_function_type::chi_squared:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::chi_squared, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_assembly<kernel_function_type::chi_squared, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
+            case sycl::data_parallel_kernel::hierarchical:
+                dispatch_target_platform<sycl::detail::hierarchical::device_kernel_assembly>(target_, params, device, partial_grid, exec.block, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets.y, offsets.x);
                 break;
+            case sycl::data_parallel_kernel::scoped:
+                dispatch_target_platform<sycl::detail::scoped::device_kernel_assembly>(target_, params, device, partial_grid, exec.block, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets.y, offsets.x);
         }
     }
     detail::device_synchronize(device);
@@ -546,41 +438,20 @@ void csvm::run_blas_level_3_kernel_explicit(const std::size_t device_id, const :
 
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (invocation_type_) {
-            case sycl::kernel_invocation_type::automatic:
-                throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-            case sycl::kernel_invocation_type::basic:
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                     sycl::detail::basic::device_kernel_symm{ num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                });
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+            case sycl::data_parallel_kernel::basic:
+                dispatch_target_platform<sycl::detail::basic::device_kernel_symm>(target_, device, partial_grid, exec.block, num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::work_group:
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                     sycl::detail::work_group::device_kernel_symm{ cgh, num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                });
-                break;
-            case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                    cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_symm{ num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                });
-#else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
+            case sycl::data_parallel_kernel::work_group:
+                dispatch_target_platform<sycl::detail::work_group::device_kernel_symm>(target_, device, partial_grid, exec.block, num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                    cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::scoped::device_kernel_symm{ num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                });
-#else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
+            case sycl::data_parallel_kernel::hierarchical:
+                dispatch_target_platform<sycl::detail::hierarchical::device_kernel_symm>(target_, device, partial_grid, exec.block, num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                 break;
+            case sycl::data_parallel_kernel::scoped:
+                dispatch_target_platform<sycl::detail::scoped::device_kernel_symm>(target_, device, partial_grid, exec.block, num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
         }
     }
 
@@ -588,41 +459,20 @@ void csvm::run_blas_level_3_kernel_explicit(const std::size_t device_id, const :
         const unsigned long long num_mirror_rows = num_rows - row_offset - device_specific_num_rows;
 
         if (num_mirror_rows > 0) {
-            switch (invocation_type_) {
-                case sycl::kernel_invocation_type::automatic:
-                    throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                case sycl::kernel_invocation_type::basic:
-                    device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                        cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, mirror_exec.block),
-                                         sycl::detail::basic::device_kernel_symm_mirror{ num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                    });
+            switch (data_parallel_kernel_type_) {
+                case sycl::data_parallel_kernel::automatic:
+                    throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+                case sycl::data_parallel_kernel::basic:
+                    dispatch_target_platform<sycl::detail::basic::device_kernel_symm_mirror>(target_, device, partial_grid, exec.block, num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                     break;
-                case sycl::kernel_invocation_type::work_group:
-                    device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                        cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, mirror_exec.block),
-                                         sycl::detail::work_group::device_kernel_symm_mirror{ cgh, num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                    });
+                case sycl::data_parallel_kernel::work_group:
+                    dispatch_target_platform<sycl::detail::work_group::device_kernel_symm_mirror>(target_, device, partial_grid, exec.block, num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                     break;
-                case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                    device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                        const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, mirror_exec.block);
-                        cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_symm_mirror{ num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                    });
-#else
-                    throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                    break;
-                case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                    device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                        const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, mirror_exec.block);
-                        cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::scoped::device_kernel_symm_mirror{ num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                    });
-#else
-                    throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
+                case sycl::data_parallel_kernel::hierarchical:
+                    dispatch_target_platform<sycl::detail::hierarchical::device_kernel_symm_mirror>(target_, device, partial_grid, exec.block, num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                     break;
+                case sycl::data_parallel_kernel::scoped:
+                    dispatch_target_platform<sycl::detail::scoped::device_kernel_symm_mirror>(target_, device, partial_grid, exec.block, num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
             }
         }
     }
@@ -637,39 +487,39 @@ void csvm::run_inplace_matrix_addition(const std::size_t device_id, const ::plss
     const queue_type &device = devices_[device_id];
 
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (invocation_type_) {
-            case sycl::kernel_invocation_type::automatic:
-                throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-            case sycl::kernel_invocation_type::basic:
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+            case sycl::data_parallel_kernel::basic:
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
+                    cgh.parallel_for(detail::get_execution_range<sycl::data_parallel_kernel::basic>(partial_grid_ref, exec.block),
                                      sycl::detail::basic::device_kernel_inplace_matrix_add{ num_rhs, lhs_d.get(), rhs_d.get(), offsets_ref.y, offsets_ref.x });
                 });
                 break;
-            case sycl::kernel_invocation_type::work_group:
+            case sycl::data_parallel_kernel::work_group:
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
+                    cgh.parallel_for(detail::get_execution_range<sycl::data_parallel_kernel::work_group>(partial_grid_ref, exec.block),
                                      sycl::detail::work_group::device_kernel_inplace_matrix_add{ num_rhs, lhs_d.get(), rhs_d.get(), offsets_ref.y, offsets_ref.x });
                 });
                 break;
-            case sycl::kernel_invocation_type::hierarchical:
+            case sycl::data_parallel_kernel::hierarchical:
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
+                    const auto exec_range = detail::get_execution_range<sycl::data_parallel_kernel::hierarchical>(partial_grid_ref, exec.block);
                     cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_inplace_matrix_add{ num_rhs, lhs_d.get(), rhs_d.get(), offsets_ref.y, offsets_ref.x });
                 });
 #else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
+                throw backend_exception{ "Support for sycl::data_parallel_kernel::hierarchical was disabled!" };
 #endif
                 break;
-            case sycl::kernel_invocation_type::scoped:
+            case sycl::data_parallel_kernel::scoped:
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
+                    const auto exec_range = detail::get_execution_range<sycl::data_parallel_kernel::scoped>(partial_grid_ref, exec.block);
                     cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::scoped::device_kernel_inplace_matrix_add{ num_rhs, lhs_d.get(), rhs_d.get(), offsets_ref.y, offsets_ref.x });
                 });
 #else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
+                throw backend_exception{ "Support for sycl::data_parallel_kernel::scoped was disabled!" };
 #endif
                 break;
         }
@@ -682,39 +532,39 @@ void csvm::run_inplace_matrix_scale(const std::size_t device_id, const ::plssvm:
     const queue_type &device = devices_[device_id];
 
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (invocation_type_) {
-            case sycl::kernel_invocation_type::automatic:
-                throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-            case sycl::kernel_invocation_type::basic:
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+            case sycl::data_parallel_kernel::basic:
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
+                    cgh.parallel_for(detail::get_execution_range<sycl::data_parallel_kernel::basic>(partial_grid_ref, exec.block),
                                      sycl::detail::basic::device_kernel_inplace_matrix_scale{ num_rhs, lhs_d.get(), scale, offsets_ref.y, offsets_ref.x });
                 });
                 break;
-            case sycl::kernel_invocation_type::work_group:
+            case sycl::data_parallel_kernel::work_group:
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
+                    cgh.parallel_for(detail::get_execution_range<sycl::data_parallel_kernel::work_group>(partial_grid_ref, exec.block),
                                      sycl::detail::work_group::device_kernel_inplace_matrix_scale{ num_rhs, lhs_d.get(), scale, offsets_ref.y, offsets_ref.x });
                 });
                 break;
-            case sycl::kernel_invocation_type::hierarchical:
+            case sycl::data_parallel_kernel::hierarchical:
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
+                    const auto exec_range = detail::get_execution_range<sycl::data_parallel_kernel::hierarchical>(partial_grid_ref, exec.block);
                     cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_inplace_matrix_scale{ num_rhs, lhs_d.get(), scale, offsets_ref.y, offsets_ref.x });
                 });
 #else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
+                throw backend_exception{ "Support for sycl::data_parallel_kernel::hierarchical was disabled!" };
 #endif
                 break;
-            case sycl::kernel_invocation_type::scoped:
+            case sycl::data_parallel_kernel::scoped:
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
+                    const auto exec_range = detail::get_execution_range<sycl::data_parallel_kernel::scoped>(partial_grid_ref, exec.block);
                     cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::scoped::device_kernel_inplace_matrix_scale{ num_rhs, lhs_d.get(), scale, offsets_ref.y, offsets_ref.x });
                 });
 #else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
+                throw backend_exception{ "Support for sycl::data_parallel_kernel::scoped was disabled!" };
 #endif
                 break;
         }
@@ -737,273 +587,21 @@ void csvm::run_assemble_kernel_matrix_implicit_blas_level_3(const std::size_t de
 
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (params.kernel_type) {
-            //***************************************************//
-            //               linear kernel function              //
-            //***************************************************//
-            case kernel_function_type::linear:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::linear>{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::linear>{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::linear>{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::scoped::device_kernel_assembly_symm<kernel_function_type::linear>{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
-                break;
-            //***************************************************//
-            //             polynomial kernel function            //
-            //***************************************************//
-            case kernel_function_type::polynomial:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_assembly_symm<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
                 break;
-            //***************************************************//
-            //            radial-basis kernel function           //
-            //***************************************************//
-            case kernel_function_type::rbf:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::rbf, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_assembly_symm<kernel_function_type::rbf, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
-                break;
-            //***************************************************//
-            //              sigmoid kernel function              //
-            //***************************************************//
-            case kernel_function_type::sigmoid:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_assembly_symm<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
+            case sycl::data_parallel_kernel::basic:
+                dispatch_target_platform<sycl::detail::basic::device_kernel_assembly_symm>(target_, params, device, partial_grid, exec.block, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets.y, offsets.x);
                 break;
-            //***************************************************//
-            //             laplacian kernel function             //
-            //***************************************************//
-            case kernel_function_type::laplacian:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::laplacian, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_assembly_symm<kernel_function_type::laplacian, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
+            case sycl::data_parallel_kernel::work_group:
+                dispatch_target_platform<sycl::detail::work_group::device_kernel_assembly_symm>(target_, params, device, partial_grid, exec.block, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets.y, offsets.x);
                 break;
-            //***************************************************//
-            //            chi-squared kernel function            //
-            //***************************************************//
-            case kernel_function_type::chi_squared:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::chi_squared, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_assembly_symm<kernel_function_type::chi_squared, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
+            case sycl::data_parallel_kernel::hierarchical:
+                dispatch_target_platform<sycl::detail::hierarchical::device_kernel_assembly_symm>(target_, params, device, partial_grid, exec.block, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets.y, offsets.x);
                 break;
+            case sycl::data_parallel_kernel::scoped:
+                dispatch_target_platform<sycl::detail::scoped::device_kernel_assembly_symm>(target_, params, device, partial_grid, exec.block, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets.y, offsets.x);
         }
     }
     detail::device_synchronize(device);
@@ -1030,40 +628,20 @@ auto csvm::run_w_kernel(const std::size_t device_id, const ::plssvm::detail::exe
 
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (invocation_type_) {
-            case sycl::kernel_invocation_type::automatic:
-                throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-            case sycl::kernel_invocation_type::basic:
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                     sycl::detail::basic::device_kernel_w_linear{ w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets_ref.y, offsets_ref.x });
-                });
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+            case sycl::data_parallel_kernel::basic:
+                dispatch_target_platform<sycl::detail::basic::device_kernel_w_linear>(target_, device, partial_grid, exec.block, w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::work_group:
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                     sycl::detail::work_group::device_kernel_w_linear{ cgh, w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets_ref.y, offsets_ref.x });
-                });
+            case sycl::data_parallel_kernel::work_group:
+                dispatch_target_platform<sycl::detail::work_group::device_kernel_w_linear>(target_, device, partial_grid, exec.block, w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                    cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_w_linear{ w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets_ref.y, offsets_ref.x });
-                });
-#else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
+            case sycl::data_parallel_kernel::hierarchical:
+                dispatch_target_platform<sycl::detail::hierarchical::device_kernel_w_linear>(target_, device, partial_grid, exec.block, w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                    cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::scoped::device_kernel_w_linear{ w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets_ref.y, offsets_ref.x });
-                });
-#else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
+            case sycl::data_parallel_kernel::scoped:
+                dispatch_target_platform<sycl::detail::scoped::device_kernel_w_linear>(target_, device, partial_grid, exec.block, w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets.y, offsets.x);
         }
     }
     detail::device_synchronize(device);
@@ -1085,273 +663,38 @@ auto csvm::run_predict_kernel(const std::size_t device_id, const ::plssvm::detai
 
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (params.kernel_type) {
-            //***************************************************//
-            //               linear kernel function              //
-            //***************************************************//
-            case kernel_function_type::linear:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             sycl::detail::basic::device_kernel_predict_linear{ out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             sycl::detail::work_group::device_kernel_predict_linear{ cgh, out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_predict_linear{ out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets_ref.y, offsets_ref.x });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::scoped::device_kernel_predict_linear{ out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets_ref.y, offsets_ref.x });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
-                break;
-            //***************************************************//
-            //             polynomial kernel function            //
-            //***************************************************//
-            case kernel_function_type::polynomial:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_predict<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_predict<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_predict<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_predict<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
-                break;
-            //***************************************************//
-            //            radial-basis kernel function           //
-            //***************************************************//
-            case kernel_function_type::rbf:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_predict<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_predict<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_predict<kernel_function_type::rbf, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_predict<kernel_function_type::rbf, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
-                break;
-            //***************************************************//
-            //              sigmoid kernel function              //
-            //***************************************************//
-            case kernel_function_type::sigmoid:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_predict<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_predict<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_predict<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_predict<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
-                break;
-            //***************************************************//
-            //             laplacian kernel function             //
-            //***************************************************//
-            case kernel_function_type::laplacian:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_predict<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_predict<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_predict<kernel_function_type::laplacian, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_predict<kernel_function_type::laplacian, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
-                break;
-            //***************************************************//
-            //            chi-squared kernel function            //
-            //***************************************************//
-            case kernel_function_type::chi_squared:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_predict<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_predict<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_predict<kernel_function_type::chi_squared, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::scoped::device_kernel_predict<kernel_function_type::chi_squared, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::scoped>(partial_grid_ref, exec.block);
-                            cgh.parallel(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::scoped was disabled!" };
-#endif
-                        break;
-                }
-                break;
+        if (params.kernel_type == kernel_function_type::linear) {
+            switch (data_parallel_kernel_type_) {
+                case sycl::data_parallel_kernel::automatic:
+                    throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+                case sycl::data_parallel_kernel::basic:
+                    dispatch_target_platform<sycl::detail::basic::device_kernel_predict_linear>(target_, device, partial_grid, exec.block, out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::work_group:
+                    dispatch_target_platform<sycl::detail::work_group::device_kernel_predict_linear>(target_, device, partial_grid, exec.block, out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::hierarchical:
+                    dispatch_target_platform<sycl::detail::hierarchical::device_kernel_predict_linear>(target_, device, partial_grid, exec.block, out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::scoped:
+                    dispatch_target_platform<sycl::detail::scoped::device_kernel_predict_linear>(target_, device, partial_grid, exec.block, out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets.y, offsets.x);
+            }
+        } else {
+            switch (data_parallel_kernel_type_) {
+                case sycl::data_parallel_kernel::automatic:
+                    throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+                case sycl::data_parallel_kernel::basic:
+                    dispatch_target_platform<sycl::detail::basic::device_kernel_predict>(target_, params, device, partial_grid, exec.block, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::work_group:
+                    dispatch_target_platform<sycl::detail::work_group::device_kernel_predict>(target_, params, device, partial_grid, exec.block, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::hierarchical:
+                    dispatch_target_platform<sycl::detail::hierarchical::device_kernel_predict>(target_, params, device, partial_grid, exec.block, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::scoped:
+                    dispatch_target_platform<sycl::detail::scoped::device_kernel_predict>(target_, params, device, partial_grid, exec.block, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets.y, offsets.x);
+            }
         }
     }
     detail::device_synchronize(device);
diff --git a/src/plssvm/backends/SYCL/AdaptiveCpp/detail/device_ptr.cpp b/src/plssvm/backends/SYCL/AdaptiveCpp/detail/device_ptr.cpp
index 0338d10c9..800c6e353 100644
--- a/src/plssvm/backends/SYCL/AdaptiveCpp/detail/device_ptr.cpp
+++ b/src/plssvm/backends/SYCL/AdaptiveCpp/detail/device_ptr.cpp
@@ -12,6 +12,7 @@
 #include "plssvm/backends/SYCL/AdaptiveCpp/detail/queue_impl.hpp"  // plssvm::adaptivecpp::detail::queue (PImpl implementation)
 #include "plssvm/backends/SYCL/exceptions.hpp"                     // plssvm::adaptivecpp::backend_exception
 #include "plssvm/detail/assert.hpp"                                // PLSSVM_ASSERT
+#include "plssvm/detail/make_unique_for_overwrite.hpp"             // plssvm::detail::parallel_zero_memset
 #include "plssvm/matrix.hpp"                                       // plssvm::aos_matrix
 #include "plssvm/shape.hpp"                                        // plssvm::shape
 
@@ -20,6 +21,7 @@
 #include "fmt/format.h"  // fmt::format
 
 #include <algorithm>  // std::min
+#include <cstddef>    // std::size_t
 #include <cstring>    // std::memcpy
 #include <vector>     // std::vector
 
@@ -37,7 +39,11 @@ template <typename T>
 device_ptr<T>::device_ptr(const plssvm::shape shape, const plssvm::shape padding, const queue &q) :
     base_type{ shape, padding, q } {
     data_ = ::sycl::malloc_device<value_type>(this->size_padded(), queue_.impl->sycl_queue);
-    this->memset(0);
+
+    // only non-empty pointers must be memset in the constructor
+    if (this->size_padded() != std::size_t{ 0 }) {
+        this->memset(0);
+    }
 }
 
 template <typename T>
@@ -56,7 +62,14 @@ void device_ptr<T>::memset(const int pattern, const size_type pos, const size_ty
         throw backend_exception{ fmt::format("Illegal access in memset!: {} >= {}", pos, this->size_padded()) };
     }
     const size_type rnum_bytes = std::min(num_bytes, (this->size_padded() - pos) * sizeof(value_type));
-    queue_.impl->sycl_queue.memset(static_cast<void *>(data_ + pos), pattern, rnum_bytes).wait();
+
+    ::sycl::queue &queue = queue_.impl->sycl_queue;
+    // using our OpenMP enhanced 0 memset functions has dramatically better performance on the OpenMP CPU backend
+    if (pattern == 0 && queue.get_device().is_cpu() && queue.get_device().get_backend() == ::sycl::backend::omp) {
+        ::plssvm::detail::parallel_zero_memset(data_ + pos, rnum_bytes / sizeof(value_type));
+    } else {
+        queue.memset(static_cast<void *>(data_ + pos), pattern, rnum_bytes).wait();
+    }
 }
 
 template <typename T>
diff --git a/src/plssvm/backends/SYCL/AdaptiveCpp/detail/utility.cpp b/src/plssvm/backends/SYCL/AdaptiveCpp/detail/utility.cpp
index b3bfe7b67..b519c194f 100644
--- a/src/plssvm/backends/SYCL/AdaptiveCpp/detail/utility.cpp
+++ b/src/plssvm/backends/SYCL/AdaptiveCpp/detail/utility.cpp
@@ -10,7 +10,7 @@
 
 #include "plssvm/backends/SYCL/AdaptiveCpp/detail/queue.hpp"       // plssvm::adaptivecpp::detail::queue
 #include "plssvm/backends/SYCL/AdaptiveCpp/detail/queue_impl.hpp"  // plssvm::adaptivecpp::detail::queue (PImpl implementation)
-#include "plssvm/detail/string_utility.hpp"                        // plssvm::detail::{as_lower_case, contains}
+#include "plssvm/detail/string_utility.hpp"                        // plssvm::detail::{as_lower_case, contains, trim}
 #include "plssvm/detail/utility.hpp"                               // plssvm::detail::contains
 #include "plssvm/exceptions/exceptions.hpp"                        // plssvm::platform_devices_empty
 #include "plssvm/target_platforms.hpp"                             // plssvm::target_platform, plssvm::determine_default_target_platform
@@ -19,6 +19,7 @@
 
 #include "fmt/format.h"  // fmt::format
 
+#include <cstddef>  // std::size_t
 #include <map>      // std::multimap
 #include <memory>   // std::make_shared
 #include <string>   // std::string
@@ -62,6 +63,24 @@ namespace plssvm::adaptivecpp::detail {
         }
     }
 
+    // check CPU devices: if there are multiple, remove the AdaptiveCpp OpenMP host device
+    // reason: it is enabled ALWAYS and if AdaptiveCpp is built with OpenCL support, two CPUs will be found!
+    if (platform_devices.count(target_platform::cpu) > std::size_t{ 1 }) {
+        // we found more than one CPU device -> remove the host device
+
+        // get all CPU devices
+        auto range = platform_devices.equal_range(target_platform::cpu);
+        // iterate over them and remove the AdaptiveCpp OpenMP host device
+        for (auto it = range.first; it != range.second;) {
+            if (::plssvm::detail::contains(it->second.get_info<::sycl::info::device::name>(), "AdaptiveCpp OpenMP host device")) {
+                // erase returns the iterator to the next element
+                it = platform_devices.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
     // determine target if provided target_platform is automatic
     if (target == target_platform::automatic) {
         // get the target_platforms available on this system from the platform_devices map
@@ -99,6 +118,10 @@ queue get_default_queue() {
     return q;
 }
 
+std::string get_device_name(const queue &q) {
+    return std::string{ ::plssvm::detail::trim(q.impl->sycl_queue.get_device().get_info<::sycl::info::device::name>()) };
+}
+
 std::string get_adaptivecpp_version_short() {
     return fmt::format("{}.{}.{}", ACPP_VERSION_MAJOR, ACPP_VERSION_MINOR, ACPP_VERSION_PATCH);
 }
diff --git a/src/plssvm/backends/SYCL/CMakeLists.txt b/src/plssvm/backends/SYCL/CMakeLists.txt
index d0de8c7f2..7fa57bf79 100644
--- a/src/plssvm/backends/SYCL/CMakeLists.txt
+++ b/src/plssvm/backends/SYCL/CMakeLists.txt
@@ -20,10 +20,10 @@ set(PLSSVM_SYCL_BACKEND_FOUND_IMPLEMENTATIONS "")
 #                                             check if SYCL can be enabled                                             #
 ########################################################################################################################
 
-# enable kernel invocation types
-option(PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS "Enables SYCL's hierarchical and AdaptiveCpp's scoped kernel invocation types." ON)
+# enable data parallel kernels
+option(PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS "Enables SYCL's hierarchical data parallel kernel and AdaptiveCpp's scoped parallelism." ON)
 if (PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS)
-    message(STATUS "Enable SYCL's hierarchical and AdaptiveCpp's scoped kernel invocation types.")
+    message(STATUS "Enable SYCL's hierarchical data parallel kernel and AdaptiveCpp's scoped parallelism.")
 endif ()
 
 # add AdaptiveCpp
@@ -114,7 +114,7 @@ if (TARGET ${PLSSVM_SYCL_BACKEND_DPCPP_LIBRARY_NAME})
     )
 endif ()
 
-# add kernel invocation type compile definitions
+# add data parallel kernel compile definitions
 if (PLSSVM_ENABLE_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS)
     target_compile_definitions(${PLSSVM_SYCL_BACKEND_LIBRARY_NAME} INTERFACE PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
     target_compile_definitions(${PLSSVM_BASE_LIBRARY_NAME} PRIVATE PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
@@ -143,7 +143,7 @@ append_local_and_parent(PLSSVM_TARGETS_TO_INSTALL ${PLSSVM_SYCL_BACKEND_LIBRARY_
 
 # set manpage strings
 set_local_and_parent(PLSSVM_SYCL_BACKEND_NAME_LIST "automatic;${PLSSVM_SYCL_BACKEND_FOUND_IMPLEMENTATIONS}")
-set_local_and_parent(PLSSVM_SYCL_KERNEL_INVOCATION_TYPE_NAME_LIST "automatic;basic;work_group${PLSSVM_SYCL_KERNEL_HIERARCHICAL_AND_SCOPED_NAME_LIST}")
+set_local_and_parent(PLSSVM_SYCL_DATA_PARALLEL_KERNEL_NAME_LIST "automatic;basic;work_group${PLSSVM_SYCL_KERNEL_HIERARCHICAL_AND_SCOPED_NAME_LIST}")
 
 # populate transformed ACPP_TARGETS for tests
 if (TARGET ${PLSSVM_SYCL_BACKEND_ADAPTIVECPP_LIBRARY_NAME})
diff --git a/src/plssvm/backends/SYCL/DPCPP/.clang-tidy b/src/plssvm/backends/SYCL/DPCPP/.clang-tidy
new file mode 100644
index 000000000..bc7a15143
--- /dev/null
+++ b/src/plssvm/backends/SYCL/DPCPP/.clang-tidy
@@ -0,0 +1,9 @@
+---
+Checks: '
+-cppcoreguidelines-avoid-const-or-ref-data-members,
+-cppcoreguidelines-pro-type-member-init,
+
+-hicpp-member-init,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/src/plssvm/backends/SYCL/DPCPP/csvm.cpp b/src/plssvm/backends/SYCL/DPCPP/csvm.cpp
index 7c56bcd91..9a5cd8b51 100644
--- a/src/plssvm/backends/SYCL/DPCPP/csvm.cpp
+++ b/src/plssvm/backends/SYCL/DPCPP/csvm.cpp
@@ -10,9 +10,10 @@
 
 #include "plssvm/backend_types.hpp"                                                              // plssvm::backend_type
 #include "plssvm/backends/execution_range.hpp"                                                   // plssvm::detail::{dim_type, execution_range}
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"                                        // plssvm::sycl::data_parallel_kernel
 #include "plssvm/backends/SYCL/DPCPP/detail/device_ptr.hpp"                                      // plssvm::dpcpp::detail::::device_ptr
 #include "plssvm/backends/SYCL/DPCPP/detail/queue_impl.hpp"                                      // plssvm::dpcpp::detail::queue (PImpl implementation)
-#include "plssvm/backends/SYCL/DPCPP/detail/utility.hpp"                                         // plssvm::dpcpp::detail::{get_device_list, device_synchronize, get_dpcpp_version}
+#include "plssvm/backends/SYCL/DPCPP/detail/utility.hpp"                                         // plssvm::dpcpp::detail::{get_device_list, device_synchronize, get_device_name, get_dpcpp_version}
 #include "plssvm/backends/SYCL/exceptions.hpp"                                                   // plssvm::dpcpp::backend_exception
 #include "plssvm/backends/SYCL/implementation_types.hpp"                                         // plssvm::sycl::implementation_type
 #include "plssvm/backends/SYCL/kernel/cg_explicit/basic/blas.hpp"                                // plssvm::sycl::detail::basic::{device_kernel_symm, device_kernel_symm_mirror, device_kernel_inplace_matrix_add, device_kernel_inplace_matrix_scale}
@@ -27,17 +28,13 @@
 #include "plssvm/backends/SYCL/kernel/predict/basic/predict_kernel.hpp"                          // plssvm::sycl::detail::basic::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
 #include "plssvm/backends/SYCL/kernel/predict/hierarchical/predict_kernel.hpp"                   // plssvm::sycl::detail::hierarchical::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
 #include "plssvm/backends/SYCL/kernel/predict/work_group/predict_kernel.hpp"                     // plssvm::sycl::detail::work_group::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"                                      // plssvm::kernel_invocation_type
 #include "plssvm/constants.hpp"                                                                  // plssvm::{real_type, THREAD_BLOCK_SIZE, INTERNAL_BLOCK_SIZE, PADDING_SIZE}
 #include "plssvm/detail/assert.hpp"                                                              // PLSSVM_ASSERT
 #include "plssvm/detail/data_distribution.hpp"                                                   // plssvm::detail::{data_distribution, triangular_data_distribution, rectangular_data_distribution}
 #include "plssvm/detail/logging/log_untracked.hpp"                                               // plssvm::detail::log_untracked
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"                                           // plssvm::detail::log_untracked
 #include "plssvm/detail/memory_size.hpp"                                                         // plssvm::detail::memory_size
-#include "plssvm/detail/string_utility.hpp"                                                      // plssvm::detail::trim
 #include "plssvm/detail/tracking/performance_tracker.hpp"                                        // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
-#include "plssvm/exceptions/exceptions.hpp"                                                      // plssvm::exception
-#include "plssvm/gamma.hpp"                                                                      // plssvm::gamma_type
 #include "plssvm/kernel_function_types.hpp"                                                      // plssvm::kernel_type
 #include "plssvm/mpi/communicator.hpp"                                                           // plssvm::mpi::communicator
 #include "plssvm/mpi/detail/information.hpp"                                                     // plssvm::mpi::detail::gather_and_print_csvm_information
@@ -51,17 +48,146 @@
 #include "fmt/color.h"   // fmt::fg, fmt::color::orange
 #include "fmt/format.h"  // fmt::format
 
-#include <chrono>       // std::chrono::{steady_clock, duration_cast}
-#include <cstddef>      // std::size_t
-#include <cstdint>      // std::int32_t, std::uint16_t
-#include <exception>    // std::terminate
-#include <iostream>     // std::cout, std::endl
-#include <limits>       // std::numeric_limits::max
-#include <string>       // std::string
-#include <string_view>  // std::string_view
-#include <tuple>        // std::tie
-#include <variant>      // std::get
-#include <vector>       // std::vector
+#include <chrono>     // std::chrono::{steady_clock, duration_cast}
+#include <cstddef>    // std::size_t
+#include <cstdint>    // std::int32_t, std::uint16_t
+#include <exception>  // std::terminate
+#include <iostream>   // std::cout, std::endl
+#include <limits>     // std::numeric_limits::max
+#include <optional>   // std::optional
+#include <string>     // std::string
+#include <tuple>      // std::tie, std::get
+#include <utility>    // std::forward
+#include <vector>     // std::vector
+
+namespace {
+
+/**
+ * @brief Run the kernel functor on the given device.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam QueueType the type of the SYCL queue to run the kernel on
+ * @tparam Args the types of the parameters necessary for the specific kernel functor
+ * @param[in] device the SYCL queue to run the kernel on
+ * @param[in] partial_grid the number of work-groups in each dimension of the execution grid
+ * @param[in] block the number of work-items in each dimension per work-group
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <typename KernelFunctor, typename QueueType, typename... Args>
+void run_kernel_functor(const QueueType &device, const plssvm::detail::dim_type partial_grid, const plssvm::detail::dim_type block, Args &&...args) {
+    constexpr plssvm::sycl::data_parallel_kernel data_parallel_kernel_type = KernelFunctor::data_parallel_kernel_type;
+
+    if constexpr (data_parallel_kernel_type == plssvm::sycl::data_parallel_kernel::basic) {
+        device.impl->sycl_queue.submit([&](::sycl::handler &cgh) {
+            cgh.parallel_for(plssvm::dpcpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::basic>(partial_grid, block),
+                             KernelFunctor{ std::forward<Args>(args)... });
+        });
+    } else if constexpr (data_parallel_kernel_type == plssvm::sycl::data_parallel_kernel::work_group) {
+        device.impl->sycl_queue.submit([&](::sycl::handler &cgh) {
+            cgh.parallel_for(plssvm::dpcpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::work_group>(partial_grid, block),
+                             KernelFunctor{ cgh, std::forward<Args>(args)... });
+        });
+    } else if constexpr (data_parallel_kernel_type == plssvm::sycl::data_parallel_kernel::hierarchical) {
+#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
+        device.impl->sycl_queue.submit([&](::sycl::handler &cgh) {
+            const auto exec_range = plssvm::dpcpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::hierarchical>(partial_grid, block);
+            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), KernelFunctor{ std::forward<Args>(args)... });
+        });
+#else
+        throw plssvm::dpcpp::backend_exception{ "Support for sycl::data_parallel_kernel::hierarchical was disabled!" };
+#endif
+    } else {
+        static_assert(::plssvm::detail::always_false_v<Args...>, "Unsupported kernel function!");
+    }
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct kernel function type.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam target the target platform to run the kernel on
+ * @tparam Args the types of the parameters necessary for the specific kernel functor; stored in a `std::tuple`
+ * @param[in] params the parameters used to determine the kernel function type
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <plssvm::target_platform, plssvm::kernel_function_type, typename...> typename KernelFunctor, plssvm::target_platform target, typename... Args>
+void dispatch_kernel_function_type(const plssvm::parameter &params, Args &&...args) {
+    switch (params.kernel_type) {
+        case plssvm::kernel_function_type::linear:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::linear>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::kernel_function_type::polynomial:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::polynomial, int, plssvm::real_type, plssvm::real_type>>(std::forward<Args>(args)..., params.degree, std::get<plssvm::real_type>(params.gamma), params.coef0);
+            break;
+        case plssvm::kernel_function_type::rbf:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::rbf, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+        case plssvm::kernel_function_type::sigmoid:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::sigmoid, plssvm::real_type, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma), params.coef0);
+            break;
+        case plssvm::kernel_function_type::laplacian:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::laplacian, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+        case plssvm::kernel_function_type::chi_squared:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::chi_squared, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+    }
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct target platform and kernel function type.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam Args the types of the parameters necessary for the specific kernel functor; stored in a `std::tuple`
+ * @param[in] target the target platform to run the kernel on
+ * @param[in] params the parameters used to determine the kernel function type
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <plssvm::target_platform, plssvm::kernel_function_type, typename...> typename KernelFunctor, typename... Args>
+void dispatch_target_platform(const plssvm::target_platform target, const plssvm::parameter &params, Args &&...args) {
+    switch (target) {
+        case plssvm::target_platform::automatic:
+            throw plssvm::dpcpp::backend_exception{ "Can't determine the target platform!" };
+        case plssvm::target_platform::gpu_nvidia:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::gpu_nvidia>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::gpu_amd>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::gpu_intel>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::cpu:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::cpu>(params, std::forward<Args>(args)...);
+            break;
+    }
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct target platform.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam Args the types of the parameters necessary for the specific kernel functor; stored in a `std::tuple`
+ * @param[in] target the target platform to run the kernel on
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <plssvm::target_platform> typename KernelFunctor, typename... Args>
+void dispatch_target_platform(const plssvm::target_platform target, Args &&...args) {
+    switch (target) {
+        case plssvm::target_platform::automatic:
+            throw plssvm::dpcpp::backend_exception{ "Can't determine the target platform!" };
+        case plssvm::target_platform::gpu_nvidia:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::gpu_nvidia>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::gpu_amd>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::gpu_intel>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::cpu:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::cpu>>(std::forward<Args>(args)...);
+            break;
+    }
+}
+
+}  // namespace
 
 namespace plssvm::dpcpp {
 
@@ -103,10 +229,10 @@ void csvm::init(const target_platform target) {
         throw backend_exception{ fmt::format("SYCL backend selected but no devices for the target {} were found!", target_) };
     }
 
-    // set correct kernel invocation type if "automatic" has been provided
-    if (invocation_type_ == sycl::kernel_invocation_type::automatic) {
+    // set the correct data parallel kernel if "automatic" has been provided
+    if (data_parallel_kernel_type_ == sycl::data_parallel_kernel::automatic) {
         // always use work_group for DPC++
-        invocation_type_ = sycl::kernel_invocation_type::work_group;
+        data_parallel_kernel_type_ = sycl::data_parallel_kernel::work_group;
     }
 
     std::vector<std::string> device_names{};
@@ -115,18 +241,18 @@ void csvm::init(const target_platform target) {
     if (comm_.size() > 1) {
         // use MPI rank specific command line output
         for (const queue_type &device : devices_) {
-            device_names.emplace_back(device.impl->sycl_queue.get_device().template get_info<::sycl::info::device::name>());
+            device_names.push_back(detail::get_device_name(device));
         }
 
-        mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::sycl, target_, device_names, fmt::format("{}", invocation_type_));
+        mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::sycl, target_, device_names, fmt::format("{}", data_parallel_kernel_type_));
     } else {
         // use more detailed single rank command line output
         plssvm::detail::log_untracked(verbosity_level::full,
                                       comm_,
-                                      "\nUsing DPC++ ({}; {}) as SYCL backend with the kernel invocation type \"{}\".\n",
+                                      "\nUsing DPC++ ({}; {}) as SYCL backend with the data parallel kernel \"{}\".\n",
                                       detail::get_dpcpp_version(),
                                       detail::get_dpcpp_timestamp_version(),
-                                      invocation_type_);
+                                      data_parallel_kernel_type_);
         if (target == target_platform::automatic) {
             plssvm::detail::log_untracked(verbosity_level::full,
                                           comm_,
@@ -140,14 +266,12 @@ void csvm::init(const target_platform target) {
                                       target_);
 
         for (typename std::vector<queue_type>::size_type device = 0; device < devices_.size(); ++device) {
-            const std::string device_name = devices_[device].impl->sycl_queue.get_device().template get_info<::sycl::info::device::name>();
-            const std::string_view trimmed_device_name = plssvm::detail::trim(device_name);
+            device_names.push_back(detail::get_device_name(devices_[device]));
             plssvm::detail::log_untracked(verbosity_level::full,
                                           comm_,
                                           "  [{}, {}]\n",
                                           device,
-                                          trimmed_device_name);
-            device_names.emplace_back(device_name);
+                                          device_names.back());
         }
     }
 
@@ -159,7 +283,7 @@ void csvm::init(const target_platform target) {
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "dpcpp_timestamp_version", detail::get_dpcpp_timestamp_version() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "backend", plssvm::backend_type::sycl }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "sycl_implementation_type", plssvm::sycl::implementation_type::dpcpp }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "sycl_kernel_invocation_type", invocation_type_ }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "sycl_data_parallel_kernel", data_parallel_kernel_type_ }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "target_platform", target_ }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", devices_.size() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names }));
@@ -193,6 +317,14 @@ std::vector<::plssvm::detail::memory_size> csvm::get_max_mem_alloc_size() const
     return res;
 }
 
+std::vector<std::optional<::plssvm::detail::memory_size>> csvm::get_local_memory() const {
+    std::vector<std::optional<::plssvm::detail::memory_size>> res(this->num_available_devices());
+    for (std::size_t device_id = 0; device_id < this->num_available_devices(); ++device_id) {
+        res[device_id] = ::plssvm::detail::memory_size{ static_cast<unsigned long long>(devices_[device_id].impl->sycl_queue.get_device().get_info<::sycl::info::device::local_mem_size>()) };
+    }
+    return res;
+}
+
 std::size_t csvm::get_max_work_group_size(const std::size_t device_id) const {
     PLSSVM_ASSERT(device_id < this->num_available_devices(), "Invalid device {} requested!", device_id);
     return devices_[device_id].impl->sycl_queue.get_device().get_info<::sycl::info::device::max_work_group_size>();
@@ -226,7 +358,7 @@ ::plssvm::detail::dim_type csvm::get_max_grid_size(const std::size_t device_id)
 auto csvm::run_assemble_kernel_matrix_explicit(const std::size_t device_id, const ::plssvm::detail::execution_range &exec, const parameter &params, const device_ptr_type &data_d, const device_ptr_type &q_red_d, real_type QA_cost) const -> device_ptr_type {
     const std::size_t num_rows_reduced = data_d.shape().x - 1;
     const std::size_t num_features = data_d.shape().y;
-    const queue_type &device = devices_[device_id];
+    const auto &device = devices_[device_id];
 
     // calculate the number of data points this device is responsible for
     const std::size_t device_specific_num_rows = data_distribution_->place_specific_num_rows(device_id);
@@ -243,220 +375,21 @@ auto csvm::run_assemble_kernel_matrix_explicit(const std::size_t device_id, cons
 
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (params.kernel_type) {
-            //***************************************************//
-            //               linear kernel function              //
-            //***************************************************//
-            case kernel_function_type::linear:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             sycl::detail::basic::device_kernel_assembly<kernel_function_type::linear>{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             sycl::detail::work_group::device_kernel_assembly<kernel_function_type::linear>{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::linear>{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
                 break;
-            //***************************************************//
-            //             polynomial kernel function            //
-            //***************************************************//
-            case kernel_function_type::polynomial:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
+            case sycl::data_parallel_kernel::basic:
+                dispatch_target_platform<sycl::detail::basic::device_kernel_assembly>(target_, params, device, partial_grid, exec.block, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets.y, offsets.x);
                 break;
-            //***************************************************//
-            //            radial-basis kernel function           //
-            //***************************************************//
-            case kernel_function_type::rbf:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::rbf, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
+            case sycl::data_parallel_kernel::work_group:
+                dispatch_target_platform<sycl::detail::work_group::device_kernel_assembly>(target_, params, device, partial_grid, exec.block, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets.y, offsets.x);
                 break;
-            //***************************************************//
-            //              sigmoid kernel function              //
-            //***************************************************//
-            case kernel_function_type::sigmoid:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
-                break;
-            //***************************************************//
-            //             laplacian kernel function             //
-            //***************************************************//
-            case kernel_function_type::laplacian:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::laplacian, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
-                break;
-            //***************************************************//
-            //            chi-squared kernel function            //
-            //***************************************************//
-            case kernel_function_type::chi_squared:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly<kernel_function_type::chi_squared, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
+            case sycl::data_parallel_kernel::hierarchical:
+                dispatch_target_platform<sycl::detail::hierarchical::device_kernel_assembly>(target_, params, device, partial_grid, exec.block, kernel_matrix_d.get(), data_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, q_red_d.get(), QA_cost, cost_factor, offsets.y, offsets.x);
                 break;
+            case sycl::data_parallel_kernel::scoped:
+                throw backend_exception{ "Can't use the sycl::data_parallel_kernel::scoped with DPC++!" };
         }
     }
     detail::device_synchronize(device);
@@ -479,33 +412,20 @@ void csvm::run_blas_level_3_kernel_explicit(const std::size_t device_id, const :
 
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (invocation_type_) {
-            case sycl::kernel_invocation_type::automatic:
-                throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-            case sycl::kernel_invocation_type::basic:
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                     sycl::detail::basic::device_kernel_symm{ num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                });
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+            case sycl::data_parallel_kernel::basic:
+                dispatch_target_platform<sycl::detail::basic::device_kernel_symm>(target_, device, partial_grid, exec.block, num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::work_group:
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                     sycl::detail::work_group::device_kernel_symm{ cgh, num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                });
+            case sycl::data_parallel_kernel::work_group:
+                dispatch_target_platform<sycl::detail::work_group::device_kernel_symm>(target_, device, partial_grid, exec.block, num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                    cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_symm{ num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                });
-#else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
+            case sycl::data_parallel_kernel::hierarchical:
+                dispatch_target_platform<sycl::detail::hierarchical::device_kernel_symm>(target_, device, partial_grid, exec.block, num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::scoped:
-                throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
+            case sycl::data_parallel_kernel::scoped:
+                throw backend_exception{ "Can't use the sycl::data_parallel_kernel::scoped with DPC++!" };
         }
     }
 
@@ -513,33 +433,20 @@ void csvm::run_blas_level_3_kernel_explicit(const std::size_t device_id, const :
         const unsigned long long num_mirror_rows = num_rows - row_offset - device_specific_num_rows;
 
         if (num_mirror_rows > 0) {
-            switch (invocation_type_) {
-                case sycl::kernel_invocation_type::automatic:
-                    throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                case sycl::kernel_invocation_type::basic:
-                    device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                        cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, mirror_exec.block),
-                                         sycl::detail::basic::device_kernel_symm_mirror{ num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                    });
+            switch (data_parallel_kernel_type_) {
+                case sycl::data_parallel_kernel::automatic:
+                    throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+                case sycl::data_parallel_kernel::basic:
+                    dispatch_target_platform<sycl::detail::basic::device_kernel_symm_mirror>(target_, device, partial_grid, exec.block, num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                     break;
-                case sycl::kernel_invocation_type::work_group:
-                    device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                        cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, mirror_exec.block),
-                                         sycl::detail::work_group::device_kernel_symm_mirror{ cgh, num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                    });
+                case sycl::data_parallel_kernel::work_group:
+                    dispatch_target_platform<sycl::detail::work_group::device_kernel_symm_mirror>(target_, device, partial_grid, exec.block, num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                     break;
-                case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                    device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                        const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, mirror_exec.block);
-                        cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_symm_mirror{ num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets_ref.y, offsets_ref.x });
-                    });
-#else
-                    throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
+                case sycl::data_parallel_kernel::hierarchical:
+                    dispatch_target_platform<sycl::detail::hierarchical::device_kernel_symm_mirror>(target_, device, partial_grid, exec.block, num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, A_d.get(), B_d.get(), beta, C_d.get(), offsets.y, offsets.x);
                     break;
-                case sycl::kernel_invocation_type::scoped:
-                    throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
+                case sycl::data_parallel_kernel::scoped:
+                    throw backend_exception{ "Can't use the sycl::data_parallel_kernel::scoped with DPC++!" };
             }
         }
     }
@@ -554,33 +461,33 @@ void csvm::run_inplace_matrix_addition(const std::size_t device_id, const ::plss
     const queue_type &device = devices_[device_id];
 
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (invocation_type_) {
-            case sycl::kernel_invocation_type::automatic:
-                throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-            case sycl::kernel_invocation_type::basic:
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+            case sycl::data_parallel_kernel::basic:
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
+                    cgh.parallel_for(detail::get_execution_range<sycl::data_parallel_kernel::basic>(partial_grid_ref, exec.block),
                                      sycl::detail::basic::device_kernel_inplace_matrix_add{ num_rhs, lhs_d.get(), rhs_d.get(), offsets_ref.y, offsets_ref.x });
                 });
                 break;
-            case sycl::kernel_invocation_type::work_group:
+            case sycl::data_parallel_kernel::work_group:
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
+                    cgh.parallel_for(detail::get_execution_range<sycl::data_parallel_kernel::work_group>(partial_grid_ref, exec.block),
                                      sycl::detail::work_group::device_kernel_inplace_matrix_add{ num_rhs, lhs_d.get(), rhs_d.get(), offsets_ref.y, offsets_ref.x });
                 });
                 break;
-            case sycl::kernel_invocation_type::hierarchical:
+            case sycl::data_parallel_kernel::hierarchical:
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
+                    const auto exec_range = detail::get_execution_range<sycl::data_parallel_kernel::hierarchical>(partial_grid_ref, exec.block);
                     cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_inplace_matrix_add{ num_rhs, lhs_d.get(), rhs_d.get(), offsets_ref.y, offsets_ref.x });
                 });
 #else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
+                throw backend_exception{ "Support for sycl::data_parallel_kernel::hierarchical was disabled!" };
 #endif
                 break;
-            case sycl::kernel_invocation_type::scoped:
-                throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
+            case sycl::data_parallel_kernel::scoped:
+                throw backend_exception{ "Can't use the sycl::data_parallel_kernel::scoped with DPC++!" };
         }
     }
     detail::device_synchronize(device);
@@ -591,33 +498,33 @@ void csvm::run_inplace_matrix_scale(const std::size_t device_id, const ::plssvm:
     const queue_type &device = devices_[device_id];
 
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (invocation_type_) {
-            case sycl::kernel_invocation_type::automatic:
-                throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-            case sycl::kernel_invocation_type::basic:
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+            case sycl::data_parallel_kernel::basic:
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
+                    cgh.parallel_for(detail::get_execution_range<sycl::data_parallel_kernel::basic>(partial_grid_ref, exec.block),
                                      sycl::detail::basic::device_kernel_inplace_matrix_scale{ num_rhs, lhs_d.get(), scale, offsets_ref.y, offsets_ref.x });
                 });
                 break;
-            case sycl::kernel_invocation_type::work_group:
+            case sycl::data_parallel_kernel::work_group:
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
+                    cgh.parallel_for(detail::get_execution_range<sycl::data_parallel_kernel::work_group>(partial_grid_ref, exec.block),
                                      sycl::detail::work_group::device_kernel_inplace_matrix_scale{ num_rhs, lhs_d.get(), scale, offsets_ref.y, offsets_ref.x });
                 });
                 break;
-            case sycl::kernel_invocation_type::hierarchical:
+            case sycl::data_parallel_kernel::hierarchical:
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
                 device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
+                    const auto exec_range = detail::get_execution_range<sycl::data_parallel_kernel::hierarchical>(partial_grid_ref, exec.block);
                     cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_inplace_matrix_scale{ num_rhs, lhs_d.get(), scale, offsets_ref.y, offsets_ref.x });
                 });
 #else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
+                throw backend_exception{ "Support for sycl::data_parallel_kernel::hierarchical was disabled!" };
 #endif
                 break;
-            case sycl::kernel_invocation_type::scoped:
-                throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
+            case sycl::data_parallel_kernel::scoped:
+                throw backend_exception{ "Can't use the sycl::data_parallel_kernel::scoped with DPC++!" };
         }
     }
     detail::device_synchronize(device);
@@ -638,220 +545,21 @@ void csvm::run_assemble_kernel_matrix_implicit_blas_level_3(const std::size_t de
 
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (params.kernel_type) {
-            //***************************************************//
-            //               linear kernel function              //
-            //***************************************************//
-            case kernel_function_type::linear:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::linear>{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::linear>{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::linear>{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
                 break;
-            //***************************************************//
-            //             polynomial kernel function            //
-            //***************************************************//
-            case kernel_function_type::polynomial:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
+            case sycl::data_parallel_kernel::basic:
+                dispatch_target_platform<sycl::detail::basic::device_kernel_assembly_symm>(target_, params, device, partial_grid, exec.block, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets.y, offsets.x);
                 break;
-            //***************************************************//
-            //            radial-basis kernel function           //
-            //***************************************************//
-            case kernel_function_type::rbf:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::rbf, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
+            case sycl::data_parallel_kernel::work_group:
+                dispatch_target_platform<sycl::detail::work_group::device_kernel_assembly_symm>(target_, params, device, partial_grid, exec.block, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets.y, offsets.x);
                 break;
-            //***************************************************//
-            //              sigmoid kernel function              //
-            //***************************************************//
-            case kernel_function_type::sigmoid:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
-                break;
-            //***************************************************//
-            //             laplacian kernel function             //
-            //***************************************************//
-            case kernel_function_type::laplacian:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::laplacian, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
-                break;
-            //***************************************************//
-            //            chi-squared kernel function            //
-            //***************************************************//
-            case kernel_function_type::chi_squared:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_assembly_symm<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_assembly_symm<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_assembly_symm<kernel_function_type::chi_squared, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
+            case sycl::data_parallel_kernel::hierarchical:
+                dispatch_target_platform<sycl::detail::hierarchical::device_kernel_assembly_symm>(target_, params, device, partial_grid, exec.block, alpha, q_red.get(), A_d.get(), num_rows_reduced, device_specific_num_rows, row_offset, num_features, QA_cost, cost_factor, B_d.get(), C_d.get(), num_classes, offsets.y, offsets.x);
                 break;
+            case sycl::data_parallel_kernel::scoped:
+                throw backend_exception{ "Can't use the sycl::data_parallel_kernel::scoped with DPC++!" };
         }
     }
     detail::device_synchronize(device);
@@ -878,33 +586,20 @@ auto csvm::run_w_kernel(const std::size_t device_id, const ::plssvm::detail::exe
 
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (invocation_type_) {
-            case sycl::kernel_invocation_type::automatic:
-                throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-            case sycl::kernel_invocation_type::basic:
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                     sycl::detail::basic::device_kernel_w_linear{ w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets_ref.y, offsets_ref.x });
-                });
+        switch (data_parallel_kernel_type_) {
+            case sycl::data_parallel_kernel::automatic:
+                throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+            case sycl::data_parallel_kernel::basic:
+                dispatch_target_platform<sycl::detail::basic::device_kernel_w_linear>(target_, device, partial_grid, exec.block, w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::work_group:
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                     sycl::detail::work_group::device_kernel_w_linear{ cgh, w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets_ref.y, offsets_ref.x });
-                });
+            case sycl::data_parallel_kernel::work_group:
+                dispatch_target_platform<sycl::detail::work_group::device_kernel_w_linear>(target_, device, partial_grid, exec.block, w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                    const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                    cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_w_linear{ w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets_ref.y, offsets_ref.x });
-                });
-#else
-                throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
+            case sycl::data_parallel_kernel::hierarchical:
+                dispatch_target_platform<sycl::detail::hierarchical::device_kernel_w_linear>(target_, device, partial_grid, exec.block, w_d.get(), alpha_d.get(), sv_d.get(), num_classes, num_sv, device_specific_num_sv, sv_offset, offsets.y, offsets.x);
                 break;
-            case sycl::kernel_invocation_type::scoped:
-                throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
+            case sycl::data_parallel_kernel::scoped:
+                throw backend_exception{ "Can't use the sycl::data_parallel_kernel::scoped with DPC++!" };
         }
     }
     detail::device_synchronize(device);
@@ -926,220 +621,38 @@ auto csvm::run_predict_kernel(const std::size_t device_id, const ::plssvm::detai
 
     const auto start = std::chrono::steady_clock::now();
     for (const auto &[partial_grid, offsets] : exec.grids) {
-        switch (params.kernel_type) {
-            //***************************************************//
-            //               linear kernel function              //
-            //***************************************************//
-            case kernel_function_type::linear:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             sycl::detail::basic::device_kernel_predict_linear{ out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             sycl::detail::work_group::device_kernel_predict_linear{ cgh, out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets_ref.y, offsets_ref.x });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), sycl::detail::hierarchical::device_kernel_predict_linear{ out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets_ref.y, offsets_ref.x });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
-                break;
-            //***************************************************//
-            //             polynomial kernel function            //
-            //***************************************************//
-            case kernel_function_type::polynomial:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_predict<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_predict<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_predict<kernel_function_type::polynomial, decltype(params.degree), real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, params.degree, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
-                break;
-            //***************************************************//
-            //            radial-basis kernel function           //
-            //***************************************************//
-            case kernel_function_type::rbf:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_predict<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_predict<kernel_function_type::rbf, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_predict<kernel_function_type::rbf, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
-                break;
-            //***************************************************//
-            //              sigmoid kernel function              //
-            //***************************************************//
-            case kernel_function_type::sigmoid:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_predict<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_predict<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_predict<kernel_function_type::sigmoid, real_type, decltype(params.coef0)>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma), params.coef0 });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
-                break;
-            //***************************************************//
-            //             laplacian kernel function             //
-            //***************************************************//
-            case kernel_function_type::laplacian:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_predict<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_predict<kernel_function_type::laplacian, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_predict<kernel_function_type::laplacian, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
-                break;
-            //***************************************************//
-            //            chi-squared kernel function            //
-            //***************************************************//
-            case kernel_function_type::chi_squared:
-                switch (invocation_type_) {
-                    case sycl::kernel_invocation_type::automatic:
-                        throw backend_exception{ "Can't determine the sycl::kernel_invocation_type!" };
-                    case sycl::kernel_invocation_type::basic:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::basic::device_kernel_predict<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::basic>(partial_grid_ref, exec.block),
-                                             functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::work_group:
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::work_group::device_kernel_predict<kernel_function_type::chi_squared, real_type>;
-                            cgh.parallel_for(detail::get_execution_range<sycl::kernel_invocation_type::work_group>(partial_grid_ref, exec.block),
-                                             functor_type{ cgh, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-                        break;
-                    case sycl::kernel_invocation_type::hierarchical:
-#if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-                        device.impl->sycl_queue.submit([&, &partial_grid_ref = partial_grid, &offsets_ref = offsets](::sycl::handler &cgh) {
-                            using functor_type = sycl::detail::hierarchical::device_kernel_predict<kernel_function_type::chi_squared, real_type>;
-                            const auto exec_range = detail::get_execution_range<sycl::kernel_invocation_type::hierarchical>(partial_grid_ref, exec.block);
-                            cgh.parallel_for_work_group(exec_range.get_global_range(), exec_range.get_local_range(), functor_type{ out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets_ref.y, offsets_ref.x, std::get<real_type>(params.gamma) });
-                        });
-#else
-                        throw backend_exception{ "Support for sycl::kernel_invocation_type::hierarchical was disabled!" };
-#endif
-                        break;
-                    case sycl::kernel_invocation_type::scoped:
-                        throw backend_exception{ "Can't use the sycl::kernel_invocation_type::scoped with DPC++!" };
-                }
-                break;
+        if (params.kernel_type == kernel_function_type::linear) {
+            switch (data_parallel_kernel_type_) {
+                case sycl::data_parallel_kernel::automatic:
+                    throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+                case sycl::data_parallel_kernel::basic:
+                    dispatch_target_platform<sycl::detail::basic::device_kernel_predict_linear>(target_, device, partial_grid, exec.block, out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::work_group:
+                    dispatch_target_platform<sycl::detail::work_group::device_kernel_predict_linear>(target_, device, partial_grid, exec.block, out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::hierarchical:
+                    dispatch_target_platform<sycl::detail::hierarchical::device_kernel_predict_linear>(target_, device, partial_grid, exec.block, out_d.get(), sv_or_w_d.get(), rho_d.get(), predict_points_d.get(), num_classes, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::scoped:
+                    throw backend_exception{ "Can't use the sycl::data_parallel_kernel::scoped with DPC++!" };
+            }
+        } else {
+            switch (data_parallel_kernel_type_) {
+                case sycl::data_parallel_kernel::automatic:
+                    throw backend_exception{ "Can't determine the sycl::data_parallel_kernel!" };
+                case sycl::data_parallel_kernel::basic:
+                    dispatch_target_platform<sycl::detail::basic::device_kernel_predict>(target_, params, device, partial_grid, exec.block, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::work_group:
+                    dispatch_target_platform<sycl::detail::work_group::device_kernel_predict>(target_, params, device, partial_grid, exec.block, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::hierarchical:
+                    dispatch_target_platform<sycl::detail::hierarchical::device_kernel_predict>(target_, params, device, partial_grid, exec.block, out_d.get(), alpha_d.get(), rho_d.get(), sv_or_w_d.get(), predict_points_d.get(), num_classes, num_sv, num_predict_points, num_features, offsets.y, offsets.x);
+                    break;
+                case sycl::data_parallel_kernel::scoped:
+                    throw backend_exception{ "Can't use the sycl::data_parallel_kernel::scoped with DPC++!" };
+            }
         }
     }
     detail::device_synchronize(device);
diff --git a/src/plssvm/backends/SYCL/DPCPP/detail/device_ptr.cpp b/src/plssvm/backends/SYCL/DPCPP/detail/device_ptr.cpp
index c24b84407..1a0bc05b4 100644
--- a/src/plssvm/backends/SYCL/DPCPP/detail/device_ptr.cpp
+++ b/src/plssvm/backends/SYCL/DPCPP/detail/device_ptr.cpp
@@ -12,14 +12,20 @@
 #include "plssvm/backends/SYCL/DPCPP/detail/queue_impl.hpp"  // plssvm::dpcpp::detail::queue (PImpl implementation)
 #include "plssvm/backends/SYCL/exceptions.hpp"               // plssvm::dpcpp::backend_exception
 #include "plssvm/detail/assert.hpp"                          // PLSSVM_ASSERT
+#include "plssvm/shape.hpp"                                  // plssvm::shape
 
 #include "sycl/sycl.hpp"  // ::sycl::malloc_device, ::sycl::free
 
 #include "fmt/format.h"  // fmt::format
 
 #include <algorithm>  // std::min
+#include <cstddef>    // std::size_t
 #include <vector>     // std::vector
 
+#if !defined(SYCL_EXT_ONEAPI_MEMCPY2D)
+    #include <cstring>  // std::memcpy
+#endif
+
 namespace plssvm::dpcpp::detail {
 
 template <typename T>
@@ -34,7 +40,11 @@ template <typename T>
 device_ptr<T>::device_ptr(const plssvm::shape shape, plssvm::shape padding, const queue &q) :
     base_type{ shape, padding, q } {
     data_ = ::sycl::malloc_device<value_type>(this->size_padded(), queue_.impl->sycl_queue);
-    this->memset(0);
+
+    // only non-empty pointers must be memset in the constructor
+    if (this->size_padded() != std::size_t{ 0 }) {
+        this->memset(0);
+    }
 }
 
 template <typename T>
diff --git a/src/plssvm/backends/SYCL/DPCPP/detail/utility.cpp b/src/plssvm/backends/SYCL/DPCPP/detail/utility.cpp
index 28742b23f..50f95f7f3 100644
--- a/src/plssvm/backends/SYCL/DPCPP/detail/utility.cpp
+++ b/src/plssvm/backends/SYCL/DPCPP/detail/utility.cpp
@@ -10,7 +10,8 @@
 
 #include "plssvm/backends/SYCL/DPCPP/detail/queue.hpp"       // plssvm::adaptivecpp::detail::queue
 #include "plssvm/backends/SYCL/DPCPP/detail/queue_impl.hpp"  // plssvm::dpcpp::detail::queue (PImpl implementation)
-#include "plssvm/detail/string_utility.hpp"                  // plssvm::detail::{as_lower_case, contains}
+#include "plssvm/detail/assert.hpp"                          // PLSSVM_ASSERT
+#include "plssvm/detail/string_utility.hpp"                  // plssvm::detail::{as_lower_case, contains, trim}
 #include "plssvm/detail/utility.hpp"                         // plssvm::detail::contains
 #include "plssvm/exceptions/exceptions.hpp"                  // plssvm::platform_devices_empty
 #include "plssvm/target_platforms.hpp"                       // plssvm::target_platform, plssvm::determine_default_target_platform
@@ -21,7 +22,6 @@
 
 #include <map>      // std::multimap
 #include <memory>   // std::make_shared
-#include <sstream>  // std::ostringstream
 #include <string>   // std::string
 #include <utility>  // std::pair, std::make_pair, std::move
 #include <vector>   // std::vector
@@ -101,9 +101,15 @@ void device_synchronize(const queue &q) {
 }
 
 queue get_default_queue() {
-    queue q;
-    q.impl = std::make_shared<queue::queue_impl>();
-    return q;
+    const auto &[devices, target] = detail::get_device_list(determine_default_target_platform());
+    // at least one platform must be present
+    PLSSVM_ASSERT(!devices.empty(), "At least one device must be available!");
+    // per default, use the first device for the tests
+    return devices.front();
+}
+
+std::string get_device_name(const queue &q) {
+    return std::string{ ::plssvm::detail::trim(q.impl->sycl_queue.get_device().get_info<::sycl::info::device::name>()) };
 }
 
 std::string get_dpcpp_version() {
diff --git a/src/plssvm/backends/SYCL/kernel_invocation_types.cpp b/src/plssvm/backends/SYCL/data_parallel_kernels.cpp
similarity index 52%
rename from src/plssvm/backends/SYCL/kernel_invocation_types.cpp
rename to src/plssvm/backends/SYCL/data_parallel_kernels.cpp
index 87ee18f26..ed098d335 100644
--- a/src/plssvm/backends/SYCL/kernel_invocation_types.cpp
+++ b/src/plssvm/backends/SYCL/data_parallel_kernels.cpp
@@ -6,7 +6,7 @@
  *          See the LICENSE.md file in the project root for full license information.
  */
 
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"
 
 #include "plssvm/detail/string_utility.hpp"  // plssvm::detail::to_lower_case
 
@@ -18,52 +18,52 @@
 
 namespace plssvm::sycl {
 
-std::vector<kernel_invocation_type> list_available_sycl_kernel_invocation_types() {
-    std::vector<kernel_invocation_type> available_sycl_kernel_invocation_types = {
-        kernel_invocation_type::automatic,
-        kernel_invocation_type::basic,
-        kernel_invocation_type::work_group
+std::vector<data_parallel_kernel> list_available_sycl_data_parallel_kernels() {
+    std::vector<data_parallel_kernel> available_sycl_data_parallel_kernels = {
+        data_parallel_kernel::automatic,
+        data_parallel_kernel::basic,
+        data_parallel_kernel::work_group
     };
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-    available_sycl_kernel_invocation_types.push_back(kernel_invocation_type::hierarchical);
+    available_sycl_data_parallel_kernels.push_back(data_parallel_kernel::hierarchical);
     #if defined(PLSSVM_SYCL_BACKEND_HAS_ADAPTIVECPP)
-    available_sycl_kernel_invocation_types.push_back(kernel_invocation_type::scoped);
+    available_sycl_data_parallel_kernels.push_back(data_parallel_kernel::scoped);
     #endif
 #endif
-    return available_sycl_kernel_invocation_types;
+    return available_sycl_data_parallel_kernels;
 }
 
-std::ostream &operator<<(std::ostream &out, const kernel_invocation_type invocation) {
-    switch (invocation) {
-        case kernel_invocation_type::automatic:
+std::ostream &operator<<(std::ostream &out, const data_parallel_kernel kernel_type) {
+    switch (kernel_type) {
+        case data_parallel_kernel::automatic:
             return out << "automatic";
-        case kernel_invocation_type::basic:
+        case data_parallel_kernel::basic:
             return out << "basic";
-        case kernel_invocation_type::work_group:
+        case data_parallel_kernel::work_group:
             return out << "work_group";
-        case kernel_invocation_type::hierarchical:
+        case data_parallel_kernel::hierarchical:
             return out << "hierarchical";
-        case kernel_invocation_type::scoped:
+        case data_parallel_kernel::scoped:
             return out << "scoped";
     }
     return out << "unknown";
 }
 
-std::istream &operator>>(std::istream &in, kernel_invocation_type &invocation) {
+std::istream &operator>>(std::istream &in, data_parallel_kernel &kernel_type) {
     std::string str;
     in >> str;
     detail::to_lower_case(str);
 
     if (str == "automatic" || str == "auto") {
-        invocation = kernel_invocation_type::automatic;
+        kernel_type = data_parallel_kernel::automatic;
     } else if (str == "basic") {
-        invocation = kernel_invocation_type::basic;
+        kernel_type = data_parallel_kernel::basic;
     } else if (str == "work_group" || str == "work-group" || str == "nd_range" || str == "nd-range") {
-        invocation = kernel_invocation_type::work_group;
+        kernel_type = data_parallel_kernel::work_group;
     } else if (str == "hierarchical") {
-        invocation = kernel_invocation_type::hierarchical;
+        kernel_type = data_parallel_kernel::hierarchical;
     } else if (str == "scoped") {
-        invocation = kernel_invocation_type::scoped;
+        kernel_type = data_parallel_kernel::scoped;
     } else {
         in.setstate(std::ios::failbit);
     }
diff --git a/src/plssvm/backends/execution_range.cpp b/src/plssvm/backends/execution_range.cpp
index fd72527d1..1287275f7 100644
--- a/src/plssvm/backends/execution_range.cpp
+++ b/src/plssvm/backends/execution_range.cpp
@@ -37,7 +37,8 @@ execution_range::execution_range(const dim_type block_p, const unsigned long lon
     // check whether the provided block size is valid
     if (this->num_threads_in_block() == 0) {
         throw kernel_launch_resources{ "At least one thread must be given per block! Maybe one dimension is zero?" };
-    } else if (max_allowed_block_size < this->num_threads_in_block()) {
+    }
+    if (max_allowed_block_size < this->num_threads_in_block()) {
         throw kernel_launch_resources{ fmt::format("Not enough work-items allowed for a work-groups of size {}x{}x{} (#threads: {}; max allowed: {})! Try reducing THREAD_BLOCK_SIZE.", block.x, block.y, block.z, this->num_threads_in_block(), max_allowed_block_size) };
     }
 
@@ -79,11 +80,10 @@ void swap(execution_range &lhs, execution_range &rhs) noexcept {
 std::ostream &operator<<(std::ostream &out, const execution_range &exec) {
     if (exec.grids.size() == 1) {
         return out << fmt::format("grid: {}; block: {}", exec.grids.front().first, exec.block);
-    } else {
-        std::vector<dim_type> transformed_vec(exec.grids.size());
-        std::transform(exec.grids.cbegin(), exec.grids.cend(), transformed_vec.begin(), [](const execution_range::grid_type &grid) { return grid.first; });
-        return out << fmt::format("grids: [{}]; block: {}", fmt::join(transformed_vec, ", "), exec.block);
     }
+    std::vector<dim_type> transformed_vec(exec.grids.size());
+    std::transform(exec.grids.cbegin(), exec.grids.cend(), transformed_vec.begin(), [](const execution_range::grid_type &grid) { return grid.first; });
+    return out << fmt::format("grids: [{}]; block: {}", fmt::join(transformed_vec, ", "), exec.block);
 }
 
 }  // namespace plssvm::detail
diff --git a/src/plssvm/backends/stdpar/.clang-tidy b/src/plssvm/backends/stdpar/.clang-tidy
new file mode 100644
index 000000000..cdf2ade2d
--- /dev/null
+++ b/src/plssvm/backends/stdpar/.clang-tidy
@@ -0,0 +1,6 @@
+---
+Checks: '
+-misc-include-cleaner,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/src/plssvm/backends/stdpar/AdaptiveCpp/.clang-tidy b/src/plssvm/backends/stdpar/AdaptiveCpp/.clang-tidy
new file mode 100644
index 000000000..d750bb334
--- /dev/null
+++ b/src/plssvm/backends/stdpar/AdaptiveCpp/.clang-tidy
@@ -0,0 +1,8 @@
+---
+Checks: '
+-clang-analyzer-core.CallAndMessage,
+
+-misc-include-cleaner,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/src/plssvm/backends/stdpar/AdaptiveCpp/csvm.cpp b/src/plssvm/backends/stdpar/AdaptiveCpp/csvm.cpp
index 8e15a2d18..6ef01bdc1 100644
--- a/src/plssvm/backends/stdpar/AdaptiveCpp/csvm.cpp
+++ b/src/plssvm/backends/stdpar/AdaptiveCpp/csvm.cpp
@@ -13,6 +13,7 @@
 #include "plssvm/backends/stdpar/exceptions.hpp"            // plssvm::stdpar::backend_exception
 #include "plssvm/backends/stdpar/implementation_types.hpp"  // plssvm::stdpar::implementation_type
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"      // plssvm::detail::log_untracked
+#include "plssvm/detail/string_utility.hpp"                 // plssvm::detail::trim
 #include "plssvm/detail/tracking/performance_tracker.hpp"   // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
 #include "plssvm/mpi/communicator.hpp"                      // plssvm::mpi::communicator
 #include "plssvm/mpi/detail/information.hpp"                // plssvm::mpi::detail::gather_and_print_csvm_information
@@ -23,6 +24,9 @@
 
 #include "fmt/format.h"  // fmt::format
 
+#include <string>  // std::string
+#include <vector>  // std::vector
+
 namespace plssvm::stdpar {
 
 csvm::csvm(const target_platform target) {
@@ -61,14 +65,15 @@ csvm::csvm(const target_platform target) {
 
     // AdaptiveCpp's stdpar per default uses the sycl default device
     const ::sycl::device default_device{};
+    const std::vector<std::string> device_names{ std::string{ ::plssvm::detail::trim(default_device.get_info<::sycl::info::device::name>()) } };
+
+    // check that the default device supports the requested target platform
     if (!detail::default_device_equals_target(default_device, target_)) {
         throw backend_exception{ fmt::format("The default device {} doesn't match the requested target platform {}! Please set the environment variable ACPP_VISIBILITY_MASK or change the target platform.",
-                                             default_device.get_info<::sycl::info::device::name>(),
+                                             device_names.front(),
                                              target_) };
     }
 
-    const std::vector<std::string> device_names{ default_device.get_info<::sycl::info::device::name>() };
-
     if (comm_.size() > 1) {
         mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::stdpar, target_, device_names, fmt::format("{}", this->get_implementation_type()));
     } else {
@@ -81,7 +86,7 @@ csvm::csvm(const target_platform target) {
                                       this->get_implementation_type(),
                                       detail::get_stdpar_version(),
                                       PLSSVM_ACPP_TARGETS,
-                                      this->num_available_devices(),
+                                      this->num_available_devices(),  // NOLINT: safe to call this virtual function in the constructor
                                       target_,
                                       device_names.front());
     }
@@ -90,12 +95,12 @@ csvm::csvm(const target_platform target) {
                                   comm_,
                                   "\n");
 
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "stdpar_implementation", this->get_implementation_type() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "stdpar_version", detail::get_stdpar_version() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "stdpar_implementation", this->get_implementation_type() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "backend", plssvm::backend_type::stdpar }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "target_platform", target_ }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names.front() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));  // NOLINT: safe to call this virtual function in the constructor
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "acpp_targets", PLSSVM_ACPP_TARGETS }));
 }
 
diff --git a/src/plssvm/backends/stdpar/GNU_TBB/csvm.cpp b/src/plssvm/backends/stdpar/GNU_TBB/csvm.cpp
index 35a3e7f58..f8719a230 100644
--- a/src/plssvm/backends/stdpar/GNU_TBB/csvm.cpp
+++ b/src/plssvm/backends/stdpar/GNU_TBB/csvm.cpp
@@ -12,9 +12,9 @@
 #include "plssvm/backends/stdpar/detail/utility.hpp"        // plssvm::stdpar::detail::{get_stdpar_version, default_device_equals_target}
 #include "plssvm/backends/stdpar/exceptions.hpp"            // plssvm::stdpar::backend_exception
 #include "plssvm/backends/stdpar/implementation_types.hpp"  // plssvm::stdpar::implementation_type
-#include "plssvm/detail/logging/log.hpp"                    // plssvm::detail::log
-#include "plssvm/detail/logging/log_untracked.hpp"          // plssvm::detail::log_untracked
+#include "plssvm/detail/logging/mpi_log_untracked.hpp"      // plssvm::detail::log_untracked
 #include "plssvm/detail/tracking/performance_tracker.hpp"   // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
+#include "plssvm/mpi/detail/information.hpp"                // plssvm::mpi::detail::gather_and_print_csvm_information
 #include "plssvm/target_platforms.hpp"                      // plssvm::target_platform
 #include "plssvm/verbosity_levels.hpp"                      // plssvm::verbosity_level
 
@@ -50,7 +50,7 @@ csvm::csvm(const target_platform target) {
                                       "Found {} stdpar device(s) for the target platform {}:\n",
                                       this->get_implementation_type(),
                                       detail::get_stdpar_version(),
-                                      this->num_available_devices(),
+                                      this->num_available_devices(),  // NOLINT: safe to call this virtual function in the constructor
                                       target_);
     }
 
@@ -58,11 +58,11 @@ csvm::csvm(const target_platform target) {
                                   comm_,
                                   "\n");
 
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "stdpar_implementation", this->get_implementation_type() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "stdpar_version", detail::get_stdpar_version() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "stdpar_implementation", this->get_implementation_type() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "backend", plssvm::backend_type::stdpar }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "target_platform", target_ }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));  // NOLINT: safe to call this virtual function in the constructor
 }
 
 implementation_type csvm::get_implementation_type() const noexcept {
diff --git a/src/plssvm/backends/stdpar/IntelLLVM/csvm.cpp b/src/plssvm/backends/stdpar/IntelLLVM/csvm.cpp
index 0ec757d8a..50aeee58e 100644
--- a/src/plssvm/backends/stdpar/IntelLLVM/csvm.cpp
+++ b/src/plssvm/backends/stdpar/IntelLLVM/csvm.cpp
@@ -12,9 +12,10 @@
 #include "plssvm/backends/stdpar/detail/utility.hpp"        // plssvm::stdpar::detail::{get_stdpar_version, default_device_equals_target}
 #include "plssvm/backends/stdpar/exceptions.hpp"            // plssvm::stdpar::backend_exception
 #include "plssvm/backends/stdpar/implementation_types.hpp"  // plssvm::stdpar::implementation_type
-#include "plssvm/detail/logging/log.hpp"                    // plssvm::detail::log
-#include "plssvm/detail/logging/log_untracked.hpp"          // plssvm::detail::log_untracked
+#include "plssvm/detail/logging/mpi_log_untracked.hpp"      // plssvm::detail::log_untracked
+#include "plssvm/detail/string_utility.hpp"                 // plssvm::detail::trim
 #include "plssvm/detail/tracking/performance_tracker.hpp"   // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
+#include "plssvm/mpi/detail/information.hpp"                // plssvm::mpi::detail::gather_and_print_csvm_information
 #include "plssvm/target_platforms.hpp"                      // plssvm::target_platform
 #include "plssvm/verbosity_levels.hpp"                      // plssvm::verbosity_level
 
@@ -22,6 +23,9 @@
 
 #include "fmt/format.h"  // fmt::format
 
+#include <string>  // std::string
+#include <vector>  // std::vector
+
 namespace plssvm::stdpar {
 
 csvm::csvm(const target_platform target) {
@@ -60,14 +64,15 @@ csvm::csvm(const target_platform target) {
 
     // IntelLLVM stdpar per default uses the sycl default device
     const ::sycl::device default_device{};
+    const std::vector<std::string> device_names{ std::string{ plssvm::detail::trim(default_device.get_info<::sycl::info::device::name>()) } };
+
+    // check that the default device supports the requested target platform
     if (!detail::default_device_equals_target(default_device, target_)) {
         throw backend_exception{ fmt::format("The default device {} doesn't match the requested target platform {}! Please set the environment variable ONEAPI_DEVICE_SELECTOR or change the target platform.",
-                                             default_device.get_info<::sycl::info::device::name>(),
+                                             device_names.front(),
                                              target_) };
     }
 
-    const std::vector<std::string> device_names{ default_device.get_info<::sycl::info::device::name>() };
-
     if (comm_.size() > 1) {
         mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::stdpar, target_, device_names, fmt::format("{}", this->get_implementation_type()));
     } else {
@@ -79,7 +84,7 @@ csvm::csvm(const target_platform target) {
                                       "  [0, {}]\n",
                                       this->get_implementation_type(),
                                       detail::get_stdpar_version(),
-                                      this->num_available_devices(),
+                                      this->num_available_devices(),  // NOLINT: safe to call this virtual function in the constructor
                                       target_,
                                       device_names.front());
     }
@@ -88,12 +93,12 @@ csvm::csvm(const target_platform target) {
                                   comm_,
                                   "\n");
 
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "stdpar_implementation", this->get_implementation_type() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "stdpar_version", detail::get_stdpar_version() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "stdpar_implementation", this->get_implementation_type() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "backend", plssvm::backend_type::stdpar }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "target_platform", target_ }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names.front() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));  // NOLINT: safe to call this virtual function in the constructor
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names }));
 }
 
 implementation_type csvm::get_implementation_type() const noexcept {
diff --git a/src/plssvm/backends/stdpar/NVHPC/csvm.cpp b/src/plssvm/backends/stdpar/NVHPC/csvm.cpp
index da8286d27..78ba50cc1 100644
--- a/src/plssvm/backends/stdpar/NVHPC/csvm.cpp
+++ b/src/plssvm/backends/stdpar/NVHPC/csvm.cpp
@@ -12,14 +12,24 @@
 #include "plssvm/backends/stdpar/detail/utility.hpp"        // plssvm::stdpar::detail::get_stdpar_version
 #include "plssvm/backends/stdpar/exceptions.hpp"            // plssvm::stdpar::backend_exception
 #include "plssvm/backends/stdpar/implementation_types.hpp"  // plssvm::stdpar::implementation_type
-#include "plssvm/detail/logging/log.hpp"                    // plssvm::detail::log
-#include "plssvm/detail/logging/log_untracked.hpp"          // plssvm::detail::log_untracked
+#include "plssvm/detail/logging/mpi_log_untracked.hpp"      // plssvm::detail::log_untracked
 #include "plssvm/detail/tracking/performance_tracker.hpp"   // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
+#include "plssvm/mpi/detail/information.hpp"                // plssvm::mpi::detail::gather_and_print_csvm_information
 #include "plssvm/target_platforms.hpp"                      // plssvm::target_platform
 #include "plssvm/verbosity_levels.hpp"                      // plssvm::verbosity_level
 
+#if defined(PLSSVM_STDPAR_BACKEND_NVHPC_GPU)
+    #include "plssvm/detail/string_utility.hpp"  // plssvm::detail::trim
+
+    #include "cuda_runtime_api.h"  // cudaGetDeviceProperties
+    #include "driver_types.h"      // cudaDeviceProp
+#endif
+
 #include "fmt/format.h"  // fmt::format
 
+#include <string>  // std::string
+#include <vector>  // std::vector
+
 namespace plssvm::stdpar {
 
 csvm::csvm(const target_platform target) {
@@ -58,33 +68,34 @@ csvm::csvm(const target_platform target) {
         target_ = target;
     }
 
-    std::vector<std::string> device_names{};
-
-    if (comm_.size() > 1) {
+    std::vector<std::string> device_names{};  // NOLINT(misc-const-correctness): cannot be const if the device is GPU
 #if defined(PLSSVM_STDPAR_BACKEND_NVHPC_GPU)
-        cudaDeviceProp prop{};
-        cudaGetDeviceProperties(&prop, 0);
-        device_names.emplace_back(prop.name);
+    cudaDeviceProp prop{};
+    cudaGetDeviceProperties(&prop, 0);
+    device_names.emplace_back(::plssvm::detail::trim(static_cast<const char *>(prop.name)));
 #endif
+
+    if (comm_.size() > 1) {
         mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::stdpar, target_, device_names, fmt::format("{}", this->get_implementation_type()));
     } else {
         // use more detailed single rank command line output
         plssvm::detail::log_untracked(verbosity_level::full,
                                       comm_,
                                       "\nUsing stdpar ({}; {}) as backend.\n"
+#if defined(PLSSVM_STDPAR_BACKEND_NVHPC_GPU)
                                       "Found {} stdpar device(s) for the target platform {}:\n",
+#else
+                                      "Found {} stdpar device(s) for the target platform {}.\n",
+#endif
                                       this->get_implementation_type(),
                                       detail::get_stdpar_version(),
-                                      this->num_available_devices(),
+                                      this->num_available_devices(),  // NOLINT: safe to call this virtual function in the constructor
                                       target_);
 #if defined(PLSSVM_STDPAR_BACKEND_NVHPC_GPU)
-        cudaDeviceProp prop{};
-        cudaGetDeviceProperties(&prop, 0);
-        device_names.emplace_back(prop.name);
         plssvm::detail::log_untracked(verbosity_level::full,
                                       comm_,
                                       "  [0, {}, {}.{}]\n",
-                                      prop.name,
+                                      device_names.back(),
                                       prop.major,
                                       prop.minor);
 #endif
@@ -94,13 +105,14 @@ csvm::csvm(const target_platform target) {
                                   comm_,
                                   "\n");
 
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "stdpar_implementation", this->get_implementation_type() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "stdpar_version", detail::get_stdpar_version() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "stdpar_implementation", this->get_implementation_type() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "backend", plssvm::backend_type::stdpar }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "target_platform", target_ }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));  // NOLINT: safe to call this virtual function in the constructor
     if (!device_names.empty()) {
-        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names.front() }));
+        // NVHPC does not provide us with a device name if compiled for CPUs
+        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names }));
     }
 }
 
diff --git a/src/plssvm/backends/stdpar/csvm.cpp b/src/plssvm/backends/stdpar/csvm.cpp
index aa7b32a0f..12707af71 100644
--- a/src/plssvm/backends/stdpar/csvm.cpp
+++ b/src/plssvm/backends/stdpar/csvm.cpp
@@ -8,15 +8,18 @@
 
 #include "plssvm/backends/stdpar/csvm.hpp"
 
+#include "plssvm/backends/stdpar/exceptions.hpp"                                      // plssvm::stdpar::backend_exception
 #include "plssvm/backends/stdpar/kernel/cg_explicit/blas.hpp"                         // plssvm::stdpar::detail::device_kernel_symm
 #include "plssvm/backends/stdpar/kernel/cg_explicit/kernel_matrix_assembly.hpp"       // plssvm::stdpar::detail::device_kernel_assembly
 #include "plssvm/backends/stdpar/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp"  // plssvm::stdpar::detail::device_kernel_assembly_symm
 #include "plssvm/backends/stdpar/kernel/predict_kernel.hpp"                           // plssvm::stdpar::detail::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
-#include "plssvm/constants.hpp"                                                       // plssvm::real_type
+#include "plssvm/constants.hpp"                                                       // plssvm::real_type, plssvm::PADDING_SIZE
 #include "plssvm/detail/assert.hpp"                                                   // PLSSVM_ASSERT
 #include "plssvm/detail/data_distribution.hpp"                                        // plssvm::detail::triangular_data_distribution
+#include "plssvm/detail/make_unique_for_overwrite.hpp"                                // plssvm::detail::{make_unique_for_overwrite, parallel_zero_memset}
 #include "plssvm/detail/memory_size.hpp"                                              // plssvm::detail::memory_size
 #include "plssvm/detail/move_only_any.hpp"                                            // plssvm::detail::{move_only_any, move_only_any_cast}
+#include "plssvm/detail/operators.hpp"                                                // NOLINT: operator overloads for std::vector (+ scalars)
 #include "plssvm/detail/tracking/performance_tracker.hpp"                             // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
 #include "plssvm/detail/utility.hpp"                                                  // plssvm::detail::{get_system_memory, unreachable}
 #include "plssvm/kernel_function_types.hpp"                                           // plssvm::kernel_function_type
@@ -24,27 +27,136 @@
 #include "plssvm/parameter.hpp"                                                       // plssvm::parameter
 #include "plssvm/shape.hpp"                                                           // plssvm::shape
 #include "plssvm/solver_types.hpp"                                                    // plssvm::solver_type
-#include "plssvm/svm/csvm.hpp"                                                        // plssvm::csvm
 #include "plssvm/target_platforms.hpp"                                                // plssvm::target_platform
 
-#include <chrono>   // std::chrono::{steady_clock, duration_cast}
-#include <cstddef>  // std::size_t
-#include <tuple>    // std::tuple, std::make_tuple
-#include <utility>  // std::move
-#include <vector>   // std::vector
+#include <chrono>      // std::chrono::{steady_clock, duration_cast}
+#include <cstddef>     // std::size_t
+#include <cstring>     // std::memcpy
+#include <functional>  // std::cref
+#include <memory>      // std::unique_ptr, std::make_unique
+#include <optional>    // std::optional, std::nullopt
+#include <tuple>       // std::tuple, std::make_tuple
+#include <utility>     // std::move, std::forward
+#include <vector>      // std::vector
+
+namespace {
+
+/**
+ * @brief Run the kernel functor on the given device.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam Args the types of the parameters necessary for the specific kernel functor
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <typename KernelFunctor, typename... Args>
+void run_kernel_functor(Args &&...args) {
+    KernelFunctor{}(std::forward<Args>(args)...);
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct kernel function type.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam target the target platform to run the kernel on
+ * @tparam Args the types of the parameters necessary for the specific kernel functor
+ * @param[in] params the parameters used to determine the kernel function type
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <plssvm::target_platform, plssvm::kernel_function_type, typename...> typename KernelFunctor, plssvm::target_platform target, typename... Args>
+void dispatch_kernel_function_type(const plssvm::parameter &params, Args &&...args) {
+    switch (params.kernel_type) {
+        case plssvm::kernel_function_type::linear:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::linear>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::kernel_function_type::polynomial:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::polynomial, int, plssvm::real_type, plssvm::real_type>>(std::forward<Args>(args)..., params.degree, std::get<plssvm::real_type>(params.gamma), params.coef0);
+            break;
+        case plssvm::kernel_function_type::rbf:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::rbf, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+        case plssvm::kernel_function_type::sigmoid:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::sigmoid, plssvm::real_type, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma), params.coef0);
+            break;
+        case plssvm::kernel_function_type::laplacian:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::laplacian, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+        case plssvm::kernel_function_type::chi_squared:
+            run_kernel_functor<KernelFunctor<target, plssvm::kernel_function_type::chi_squared, plssvm::real_type>>(std::forward<Args>(args)..., std::get<plssvm::real_type>(params.gamma));
+            break;
+    }
+}
+
+/**
+ * @brief Dispatch KernelFunctor kernel functor to the correct target platform and kernel function type.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam Args the types of the parameters necessary for the specific kernel functor
+ * @param[in] target the target platform to run the kernel on
+ * @param[in] params the parameters used to determine the kernel function type
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <plssvm::target_platform, plssvm::kernel_function_type, typename...> typename KernelFunctor, typename... Args>
+void dispatch_target_platform(const plssvm::target_platform target, const plssvm::parameter &params, Args &&...args) {
+    switch (target) {
+        case plssvm::target_platform::automatic:
+            throw plssvm::stdpar::backend_exception{ "Can't determine the target platform!" };
+        case plssvm::target_platform::gpu_nvidia:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::gpu_nvidia>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::gpu_amd>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::gpu_intel>(params, std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::cpu:
+            dispatch_kernel_function_type<KernelFunctor, plssvm::target_platform::cpu>(params, std::forward<Args>(args)...);
+            break;
+    }
+}
+
+/**
+ * @brief Dispatch the kernel functor to the correct target platform.
+ * @tparam KernelFunctor the type of the kernel functor to run
+ * @tparam Args the types of the parameters necessary for the specific kernel functor
+ * @param[in] target the target platform to run the kernel on
+ * @param[in] args the parameters necessary for the specific kernel functor
+ */
+template <template <plssvm::target_platform, typename...> typename KernelFunctor, typename... Args>
+void dispatch_target_platform(const plssvm::target_platform target, Args &&...args) {
+    switch (target) {
+        case plssvm::target_platform::automatic:
+            throw plssvm::stdpar::backend_exception{ "Can't determine the target platform!" };
+        case plssvm::target_platform::gpu_nvidia:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::gpu_nvidia>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::gpu_amd>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::gpu_intel>>(std::forward<Args>(args)...);
+            break;
+        case plssvm::target_platform::cpu:
+            run_kernel_functor<KernelFunctor<plssvm::target_platform::cpu>>(std::forward<Args>(args)...);
+            break;
+    }
+}
+
+}  // namespace
 
 namespace plssvm::stdpar {
 
 csvm::~csvm() = default;
 
 std::vector<::plssvm::detail::memory_size> csvm::get_device_memory() const {
-    return { ::plssvm::detail::get_system_memory() };
+    return std::vector<::plssvm::detail::memory_size>(this->num_available_devices(), ::plssvm::detail::get_system_memory());
 }
 
 std::vector<::plssvm::detail::memory_size> csvm::get_max_mem_alloc_size() const {
     return this->get_device_memory();
 }
 
+std::vector<std::optional<::plssvm::detail::memory_size>> csvm::get_local_memory() const {
+    return std::vector<std::optional<::plssvm::detail::memory_size>>(this->num_available_devices(), std::nullopt);
+}
+
 //***************************************************//
 //                        fit                        //
 //***************************************************//
@@ -78,28 +190,16 @@ std::vector<::plssvm::detail::move_only_any> csvm::assemble_kernel_matrix(const
                     // get the offset of the data points this device is responsible for
                     const std::size_t row_offset = dist.place_row_offset(0);
 
-                    std::vector<real_type> kernel_matrix(dist.calculate_explicit_kernel_matrix_num_entries_padded(0));  // only explicitly store the upper triangular matrix
+                    // get the number of kernel matrix entries
+                    const std::size_t num_entries = dist.calculate_explicit_kernel_matrix_num_entries_padded(0);
+
+                    // only explicitly store the upper triangular matrix
+                    auto kernel_matrix = ::plssvm::detail::make_unique_for_overwrite<real_type[]>(num_entries);  // NOLINT: C-style array must be used with make_unique_for_overwrite
+                    // initialize kernel matrix to all zeros in parallel
+                    ::plssvm::detail::parallel_zero_memset(kernel_matrix.get(), num_entries);
+
                     const auto start = std::chrono::steady_clock::now();
-                    switch (params.kernel_type) {
-                        case kernel_function_type::linear:
-                            detail::device_kernel_assembly<kernel_function_type::linear>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost);
-                            break;
-                        case kernel_function_type::polynomial:
-                            detail::device_kernel_assembly<kernel_function_type::polynomial>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, params.degree, std::get<real_type>(params.gamma), params.coef0);
-                            break;
-                        case kernel_function_type::rbf:
-                            detail::device_kernel_assembly<kernel_function_type::rbf>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
-                            break;
-                        case kernel_function_type::sigmoid:
-                            detail::device_kernel_assembly<kernel_function_type::sigmoid>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma), params.coef0);
-                            break;
-                        case kernel_function_type::laplacian:
-                            detail::device_kernel_assembly<kernel_function_type::laplacian>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
-                            break;
-                        case kernel_function_type::chi_squared:
-                            detail::device_kernel_assembly<kernel_function_type::chi_squared>(kernel_matrix, A, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<real_type>(params.gamma));
-                            break;
-                    }
+                    dispatch_target_platform<detail::device_kernel_assembly>(target_, params, kernel_matrix.get(), A, device_specific_num_rows, row_offset, q_red, QA_cost, cost);
                     const auto end = std::chrono::steady_clock::now();
                     [[maybe_unused]] const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
                     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "kernel_matrix", "kernel_matrix_assembly_kernel", duration }));
@@ -110,7 +210,7 @@ std::vector<::plssvm::detail::move_only_any> csvm::assemble_kernel_matrix(const
             case solver_type::cg_implicit:
                 {
                     // simply return data since in implicit we don't assembly the kernel matrix here!
-                    kernel_matrices_parts[0] = ::plssvm::detail::move_only_any{ std::make_tuple(std::move(A), params, std::move(q_red), QA_cost) };
+                    kernel_matrices_parts[0] = ::plssvm::detail::move_only_any{ std::make_tuple(std::cref(A), params, std::cref(q_red), QA_cost) };
                 }
                 break;
         }
@@ -129,7 +229,7 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
     PLSSVM_ASSERT(B.shape() == C.shape(), "The B ({}) and C ({}) matrices must have the same shape!", B.shape(), C.shape());
     PLSSVM_ASSERT(B.padding() == C.padding(), "The B ({}) and C ({}) matrices must have the same padding!", B.padding(), C.padding());
 
-    using namespace operators;
+    using namespace operators;  // NOLINT(google-build-using-namespace): only imports custom math operations on vectors (and scalars)
 
     // get the triangular data distribution
     const ::plssvm::detail::triangular_data_distribution &dist = dynamic_cast<::plssvm::detail::triangular_data_distribution &>(*data_distribution_);
@@ -155,16 +255,16 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
                 break;
             case solver_type::cg_explicit:
                 {
-                    const auto &explicit_A = ::plssvm::detail::move_only_any_cast<const std::vector<real_type> &>(A.front());
-                    PLSSVM_ASSERT(!explicit_A.empty(), "The A matrix must not be empty!");
+                    const auto &explicit_A = ::plssvm::detail::move_only_any_cast<const std::unique_ptr<real_type[]> &>(A.front());  // NOLINT: C-style array must be used
+                    PLSSVM_ASSERT(explicit_A != nullptr, "The A matrix must not be empty!");
 
                     const auto start = std::chrono::steady_clock::now();
 
-                    detail::device_kernel_symm(num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, explicit_A, B, beta, C);
+                    dispatch_target_platform<detail::device_kernel_symm>(target_, num_rows, num_rhs, device_specific_num_rows, row_offset, alpha, explicit_A.get(), B, beta, C);
 
                     const std::size_t num_mirror_rows = num_rows - row_offset - device_specific_num_rows;
                     if (num_mirror_rows > std::size_t{ 0 }) {
-                        detail::device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, explicit_A, B, beta, C);
+                        dispatch_target_platform<detail::device_kernel_symm_mirror>(target_, num_rows, num_rhs, num_mirror_rows, device_specific_num_rows, row_offset, alpha, explicit_A.get(), B, beta, C);
                     }
 
                     const auto end = std::chrono::steady_clock::now();
@@ -174,7 +274,7 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
                 break;
             case solver_type::cg_implicit:
                 {
-                    const auto &[matr_A, params, q_red, QA_cost] = ::plssvm::detail::move_only_any_cast<const std::tuple<soa_matrix<real_type>, parameter, std::vector<real_type>, real_type> &>(A.front());
+                    const auto &[matr_A, params, q_red, QA_cost] = ::plssvm::detail::move_only_any_cast<const std::tuple<const soa_matrix<real_type> &, parameter, const std::vector<real_type> &, real_type> &>(A.front());
                     PLSSVM_ASSERT(!matr_A.empty(), "The A matrix must not be empty!");
                     PLSSVM_ASSERT(!q_red.empty(), "The q_red vector must not be empty!");
                     const real_type cost = real_type{ 1.0 } / params.cost;
@@ -186,26 +286,7 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
                     }
 
                     const auto start = std::chrono::steady_clock::now();
-                    switch (params.kernel_type) {
-                        case kernel_function_type::linear:
-                            detail::device_kernel_assembly_symm<kernel_function_type::linear>(alpha, q_red, matr_A, device_specific_num_rows, row_offset, QA_cost, cost, B, C);
-                            break;
-                        case kernel_function_type::polynomial:
-                            detail::device_kernel_assembly_symm<kernel_function_type::polynomial>(alpha, q_red, matr_A, device_specific_num_rows, row_offset, QA_cost, cost, B, C, params.degree, std::get<real_type>(params.gamma), params.coef0);
-                            break;
-                        case kernel_function_type::rbf:
-                            detail::device_kernel_assembly_symm<kernel_function_type::rbf>(alpha, q_red, matr_A, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<real_type>(params.gamma));
-                            break;
-                        case kernel_function_type::sigmoid:
-                            detail::device_kernel_assembly_symm<kernel_function_type::sigmoid>(alpha, q_red, matr_A, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<real_type>(params.gamma), params.coef0);
-                            break;
-                        case kernel_function_type::laplacian:
-                            detail::device_kernel_assembly_symm<kernel_function_type::laplacian>(alpha, q_red, matr_A, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<real_type>(params.gamma));
-                            break;
-                        case kernel_function_type::chi_squared:
-                            detail::device_kernel_assembly_symm<kernel_function_type::chi_squared>(alpha, q_red, matr_A, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<real_type>(params.gamma));
-                            break;
-                    }
+                    dispatch_target_platform<detail::device_kernel_assembly_symm>(target_, params, alpha, q_red, matr_A, device_specific_num_rows, row_offset, QA_cost, cost, B, C);
                     const auto end = std::chrono::steady_clock::now();
                     [[maybe_unused]] const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
                     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "cg", "blas_level_3_times_kernel", duration }));
@@ -213,6 +294,8 @@ void csvm::blas_level_3(const solver_type solver, const real_type alpha, const s
                 break;
         }
     }
+    // restore padding entries by setting them to zero
+    C.restore_padding();
 }
 
 //***************************************************//
@@ -262,12 +345,14 @@ aos_matrix<real_type> csvm::predict_values(const parameter &params,
 
                 const auto start = std::chrono::steady_clock::now();
 
-                detail::device_kernel_w_linear(w, alpha, support_vectors, device_specific_num_sv, sv_offset);
+                dispatch_target_platform<detail::device_kernel_w_linear>(target_, w, alpha, support_vectors, device_specific_num_sv, sv_offset);
 
                 const auto end = std::chrono::steady_clock::now();
                 [[maybe_unused]] const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
                 PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "predict_values", "w_kernel", duration }));
             }
+            // restore padding entries by setting them to zero
+            w.restore_padding();
 
             // reduce w on all MPI ranks
             comm_.allreduce_inplace(w);
@@ -281,32 +366,19 @@ aos_matrix<real_type> csvm::predict_values(const parameter &params,
     if (data_distribution_->place_specific_num_rows(0) > std::size_t{ 0 }) {
         const auto start = std::chrono::steady_clock::now();
         // call the predict kernels
-        switch (params.kernel_type) {
-            case kernel_function_type::linear:
-                // predict the values using the w vector
-                detail::device_kernel_predict_linear(out, w, rho, predict_points, device_specific_num_predict_points, row_offset);
-                break;
-            case kernel_function_type::polynomial:
-                detail::device_kernel_predict<kernel_function_type::polynomial>(out, alpha, rho, support_vectors, predict_points, device_specific_num_predict_points, row_offset, params.degree, std::get<real_type>(params.gamma), params.coef0);
-                break;
-            case kernel_function_type::rbf:
-                detail::device_kernel_predict<kernel_function_type::rbf>(out, alpha, rho, support_vectors, predict_points, device_specific_num_predict_points, row_offset, std::get<real_type>(params.gamma));
-                break;
-            case kernel_function_type::sigmoid:
-                detail::device_kernel_predict<kernel_function_type::sigmoid>(out, alpha, rho, support_vectors, predict_points, device_specific_num_predict_points, row_offset, std::get<real_type>(params.gamma), params.coef0);
-                break;
-            case kernel_function_type::laplacian:
-                detail::device_kernel_predict<kernel_function_type::laplacian>(out, alpha, rho, support_vectors, predict_points, device_specific_num_predict_points, row_offset, std::get<real_type>(params.gamma));
-                break;
-            case kernel_function_type::chi_squared:
-                detail::device_kernel_predict<kernel_function_type::chi_squared>(out, alpha, rho, support_vectors, predict_points, device_specific_num_predict_points, row_offset, std::get<real_type>(params.gamma));
-                break;
+        if (params.kernel_type == kernel_function_type::linear) {
+            std::vector<real_type> rho_padded(rho.size() + PADDING_SIZE, real_type{ 0.0 });
+            std::memcpy(rho_padded.data(), rho.data(), rho.size() * sizeof(real_type));
+            dispatch_target_platform<detail::device_kernel_predict_linear>(target_, out, w, rho_padded, predict_points, device_specific_num_predict_points, row_offset);
+        } else {
+            dispatch_target_platform<detail::device_kernel_predict>(target_, params, out, alpha, rho, support_vectors, predict_points, device_specific_num_predict_points, row_offset);
         }
         const auto end = std::chrono::steady_clock::now();
         [[maybe_unused]] const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
         PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "predict_values", "predict_kernel", duration }));
     }
-
+    // restore padding entries by setting them to zero
+    out.restore_padding();
     return out;
 }
 
diff --git a/src/plssvm/backends/stdpar/detail/utility.cpp b/src/plssvm/backends/stdpar/detail/utility.cpp
index 236881ef2..fce015c69 100644
--- a/src/plssvm/backends/stdpar/detail/utility.cpp
+++ b/src/plssvm/backends/stdpar/detail/utility.cpp
@@ -8,11 +8,11 @@
 
 #include "plssvm/backends/stdpar/detail/utility.hpp"
 
-#include "plssvm/detail/string_utility.hpp"  // plssvm::detail::as_lower_case
-#include "plssvm/detail/utility.hpp"         // ::plssvm::detail::contains
-#include "plssvm/target_platforms.hpp"       // plssvm::target_platforms
-
 #if defined(PLSSVM_STDPAR_BACKEND_HAS_ACPP) || defined(PLSSVM_STDPAR_BACKEND_HAS_INTEL_LLVM)
+    #include "plssvm/detail/string_utility.hpp"  // plssvm::detail::as_lower_case
+    #include "plssvm/detail/utility.hpp"         // plssvm::detail::contains
+    #include "plssvm/target_platforms.hpp"       // plssvm::target_platform
+
     #include "sycl/sycl.hpp"  // sycl::device, sycl::info::device::vendor
 #endif
 
@@ -22,6 +22,10 @@
     #include "plssvm/backends/SYCL/DPCPP/detail/utility.hpp"  // plssvm::dpcpp::detail::{get_dpcpp_version, get_dpcpp_timestamp_version}
 #endif
 
+#if defined(PLSSVM_STDPAR_BACKEND_HAS_NVHPC) && defined(PLSSVM_STDPAR_BACKEND_NVHPC_GPU)
+    #include "cuda_runtime_api.h"  // cudaRuntimeGetVersion
+#endif
+
 #include "fmt/format.h"  // fmt::format
 
 #include <string>  // std::string
@@ -55,8 +59,10 @@ std::string get_stdpar_version() {
     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;
+    constexpr int major_version_mask = 1000;
+    constexpr int minor_version_mask = 10;
+    const int major_version = runtime_version / major_version_mask;
+    const int minor_version = runtime_version % major_version_mask / minor_version_mask;
     return fmt::format("{}.{}.{}; {}.{}", __NVCOMPILER_MAJOR__, __NVCOMPILER_MINOR__, __NVCOMPILER_PATCHLEVEL__, major_version, minor_version);
     #else
     return fmt::format("{}.{}.{}", __NVCOMPILER_MAJOR__, __NVCOMPILER_MINOR__, __NVCOMPILER_PATCHLEVEL__);
diff --git a/src/plssvm/backends/stdpar/roc-stdpar/csvm.cpp b/src/plssvm/backends/stdpar/roc-stdpar/csvm.cpp
index 5fcec2460..f63feebd3 100644
--- a/src/plssvm/backends/stdpar/roc-stdpar/csvm.cpp
+++ b/src/plssvm/backends/stdpar/roc-stdpar/csvm.cpp
@@ -12,14 +12,17 @@
 #include "plssvm/backends/stdpar/detail/utility.hpp"        // plssvm::stdpar::detail::get_stdpar_version
 #include "plssvm/backends/stdpar/exceptions.hpp"            // plssvm::stdpar::backend_exception
 #include "plssvm/backends/stdpar/implementation_types.hpp"  // plssvm::stdpar::implementation_type
-#include "plssvm/detail/logging/log.hpp"                    // plssvm::detail::log
-#include "plssvm/detail/logging/log_untracked.hpp"          // plssvm::detail::log_untracked
+#include "plssvm/detail/logging/mpi_log_untracked.hpp"      // plssvm::detail::log_untracked
+#include "plssvm/detail/string_utility.hpp"                 // plssvm::detail::trim
 #include "plssvm/detail/tracking/performance_tracker.hpp"   // plssvm::detail::tracking::tracking_entry, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY
+#include "plssvm/mpi/detail/information.hpp"                // plssvm::mpi::detail::gather_and_print_csvm_information
 #include "plssvm/target_platforms.hpp"                      // plssvm::target_platform
 #include "plssvm/verbosity_levels.hpp"                      // plssvm::verbosity_level
 
 #include "fmt/format.h"  // fmt::format
 
+#include <vector>  // std::vector
+
 namespace plssvm::stdpar {
 
 csvm::csvm(const target_platform target) {
@@ -41,17 +44,14 @@ csvm::csvm(const target_platform target) {
     }
 
     std::vector<std::string> device_names{};
+    hipDeviceProp_t prop{};
+    [[maybe_unused]] hipError_t err = hipGetDeviceProperties(&prop, 0);
+    device_names.emplace_back(::plssvm::detail::trim(prop.name));
 
     if (comm_.size() > 1) {
-        hipDeviceProp_t prop{};
-        [[maybe_unused]] hipError_t err = hipGetDeviceProperties(&prop, 0);
-        device_names.emplace_back(prop.name);
         mpi::detail::gather_and_print_csvm_information(comm_, plssvm::backend_type::stdpar, target_, device_names, fmt::format("{}", this->get_implementation_type()));
     } else {
         // use more detailed single rank command line output
-        hipDeviceProp_t prop{};
-        [[maybe_unused]] hipError_t err = hipGetDeviceProperties(&prop, 0);
-        device_names.emplace_back(prop.name);
         plssvm::detail::log_untracked(verbosity_level::full,
                                       comm_,
                                       "\nUsing stdpar ({}; {}) as backend.\n"
@@ -59,9 +59,9 @@ csvm::csvm(const target_platform target) {
                                       "  [0, {}, {}.{}]\n",
                                       this->get_implementation_type(),
                                       detail::get_stdpar_version(),
-                                      this->num_available_devices(),
+                                      this->num_available_devices(),  // NOLINT: safe to call this virtual function in the constructor
                                       target_,
-                                      prop.name,
+                                      device_names.back(),
                                       prop.major,
                                       prop.minor);
     }
@@ -70,14 +70,12 @@ csvm::csvm(const target_platform target) {
                                   comm_,
                                   "\n");
 
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "stdpar_implementation", this->get_implementation_type() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "dependencies", "stdpar_version", detail::get_stdpar_version() }));
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "stdpar_implementation", this->get_implementation_type() }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "backend", plssvm::backend_type::stdpar }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "target_platform", target_ }));
-    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));
-    if (!device_names.empty()) {
-        PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names.front() }));
-    }
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "num_devices", this->num_available_devices() }));  // NOLINT: safe to call this virtual function in the constructor
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "backend", "device", device_names }));
 }
 
 implementation_type csvm::get_implementation_type() const noexcept {
diff --git a/src/plssvm/classification_report.cpp b/src/plssvm/classification_report.cpp
index e1de07606..8f24ff362 100644
--- a/src/plssvm/classification_report.cpp
+++ b/src/plssvm/classification_report.cpp
@@ -54,7 +54,7 @@ double sanitize_nan(const double dividend, const double divisor, const classific
 
 std::ostream &operator<<(std::ostream &out, const classification_report &report) {
     // calculate the maximum size of the label for better table alignment
-    std::size_t max_label_string_size = 12;  // weighted avg = 12 characters
+    std::size_t max_label_string_size = std::string_view{ "weighted avg" }.size();
     for (const auto &[key, val] : report.metrics_) {
         max_label_string_size = std::max(max_label_string_size, key.size());
     }
@@ -132,7 +132,7 @@ std::ostream &operator<<(std::ostream &out, const classification_report::metric
 }
 
 std::ostream &operator<<(std::ostream &out, const classification_report::accuracy_metric &accuracy) {
-    return out << fmt::format("Accuracy = {:.2f}% ({}/{})", accuracy.achieved_accuracy * 100, accuracy.num_correct, accuracy.num_total);
+    return out << fmt::format("Accuracy = {:.2f}% ({}/{})", accuracy.achieved_accuracy * 100.0, accuracy.num_correct, accuracy.num_total);  // NOLINT: convert float to percent by multiplying it with 100
 }
 
 std::ostream &operator<<(std::ostream &out, const classification_report::zero_division_behavior zero_div) {
diff --git a/src/plssvm/data_set/min_max_scaler.cpp b/src/plssvm/data_set/min_max_scaler.cpp
index a7a897989..2f9b20d59 100644
--- a/src/plssvm/data_set/min_max_scaler.cpp
+++ b/src/plssvm/data_set/min_max_scaler.cpp
@@ -17,11 +17,12 @@
 #include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
 #include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity_level
 
+#include "fmt/format.h"  // fmt::format
+
 #include <chrono>   // std::chrono::{time_point, steady_clock, duration_cast, milliseconds}
 #include <string>   // std::string
 #include <tuple>    // std::tie
-#include <utility>  // std::move
-#include <utility>  // std::make_pair
+#include <utility>  // std::move, std::make_pair
 
 namespace plssvm {
 
diff --git a/src/plssvm/detail/cmd/parser_predict.cpp b/src/plssvm/detail/cmd/parser_predict.cpp
index ed4476e96..5b6d279c0 100644
--- a/src/plssvm/detail/cmd/parser_predict.cpp
+++ b/src/plssvm/detail/cmd/parser_predict.cpp
@@ -8,20 +8,21 @@
 
 #include "plssvm/detail/cmd/parser_predict.hpp"
 
-#include "plssvm/backend_types.hpp"                          // plssvm::list_available_backends
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::list_available_execution_spaces
-#include "plssvm/backends/SYCL/implementation_types.hpp"     // plssvm::sycl::list_available_sycl_implementations
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::{list_available_sycl_kernel_invocation_types, kernel_invocation_type}
-#include "plssvm/constants.hpp"                              // plssvm::real_type
-#include "plssvm/detail/assert.hpp"                          // PLSSVM_ASSERT
-#include "plssvm/detail/logging/mpi_log_untracked.hpp"       // plssvm::detail::log_untracked
-#include "plssvm/exceptions/exceptions.hpp"                  // plssvm::cmd_parser_exit
-#include "plssvm/mpi/communicator.hpp"                       // plssvm::mpi::communicator
-#include "plssvm/target_platforms.hpp"                       // plssvm::list_available_target_platforms
-#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 "plssvm/backend_types.hpp"                        // plssvm::list_available_backends
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"     // plssvm::kokkos::{list_available_execution_spaces, execution_space}
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::{list_available_sycl_data_parallel_kernels, data_parallel_kernels}
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::{list_available_sycl_implementations, implementation_type}
+#include "plssvm/constants.hpp"                            // plssvm::real_type
+#include "plssvm/detail/assert.hpp"                        // PLSSVM_ASSERT
+#include "plssvm/detail/cmd/utility.hpp"                   // plssvm::detail::cmd::{filter_argv, kernel_type_help_message, parse_and_check_sycl_options_if_available,
+                                                           // parse_and_check_kokkos_options_if_available, parse_and_check_mpi_options_if_available, parse_verbosity, max_cmd_width}
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::cmd_parser_exit
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform, plssvm::list_available_target_platforms
+#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, cxxopts::value, cxxopts::ParseResult
 #include "fmt/color.h"   // fmt::fg, fmt::color::orange
 #include "fmt/format.h"  // fmt::format
 #include "fmt/ranges.h"  // fmt::join
@@ -30,7 +31,9 @@
 #include <exception>    // std::exception
 #include <filesystem>   // std::filesystem::path
 #include <iostream>     // std::cout, std::cerr, std::endl
+#include <optional>     // std::optional
 #include <type_traits>  // std::is_same_v
+#include <utility>      // std::pair, std::move
 #include <vector>       // std::vector
 
 namespace plssvm::detail::cmd {
@@ -40,20 +43,23 @@ parser_predict::parser_predict(const mpi::communicator &comm, int argc, char **a
     PLSSVM_ASSERT(argc >= 1, fmt::format("At least one argument is always given (the executable name), but argc is {}!", argc));
     PLSSVM_ASSERT(argv != nullptr, "At least one argument is always given (the executable name), but argv is a nullptr!");
 
+    // filter the command line arguments removing third party options
+    std::vector<char *> filtered_args = filter_argv(argc, argv);
+
     // setup command line parser with all available options
     cxxopts::Options options("plssvm-predict", "LS-SVM with multiple (GPU-)backends");
     options
         .positional_help("test_file model_file [output_file]")
         .show_positional_help();
     options
-        .set_width(150)
+        .set_width(max_cmd_width)
         .set_tab_expansion()
         // clang-format off
         .add_options()
             ("b,backend", fmt::format("choose the backend: {}", fmt::join(list_available_backends(), "|")), cxxopts::value<backend_type>()->default_value(fmt::format("{}", backend)))
             ("p,target_platform", fmt::format("choose the target platform: {}", fmt::join(list_available_target_platforms(), "|")), cxxopts::value<target_platform>()->default_value(fmt::format("{}", target)))
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
-            ("sycl_kernel_invocation_type", fmt::format("choose the kernel invocation type when using SYCL as backend: {}", fmt::join(sycl::list_available_sycl_kernel_invocation_types(), "|")), cxxopts::value<decltype(sycl_kernel_invocation_type)>()->default_value(fmt::format("{}", sycl_kernel_invocation_type)))
+            ("sycl_data_parallel_kernel", fmt::format("choose the data parallel kernel when using SYCL as backend: {}", fmt::join(sycl::list_available_sycl_data_parallel_kernels(), "|")), cxxopts::value<decltype(sycl_data_parallel_kernel)>()->default_value(fmt::format("{}", sycl_data_parallel_kernel)))
             ("sycl_implementation_type", fmt::format("choose the SYCL implementation to be used in the SYCL backend: {}", fmt::join(sycl::list_available_sycl_implementations(), "|")), cxxopts::value<sycl::implementation_type>()->default_value(fmt::format("{}", sycl_implementation_type)))
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
@@ -79,7 +85,7 @@ parser_predict::parser_predict(const mpi::communicator &comm, int argc, char **a
     cxxopts::ParseResult result;
     try {
         options.parse_positional({ "test", "model", "output" });
-        result = options.parse(argc, argv);
+        result = options.parse(static_cast<int>(filtered_args.size()), filtered_args.data());
     } catch (const std::exception &e) {
         if (comm.is_main_rank()) {
             std::cerr << fmt::format(fmt::fg(fmt::color::red), "ERROR: {}\n", e.what()) << std::endl;
@@ -89,7 +95,7 @@ parser_predict::parser_predict(const mpi::communicator &comm, int argc, char **a
     }
 
     // print help message and exit
-    if (result.count("help")) {
+    if (result.contains("help")) {
         if (comm.is_main_rank()) {
             std::cout << options.help() << std::endl;
         }
@@ -97,7 +103,7 @@ parser_predict::parser_predict(const mpi::communicator &comm, int argc, char **a
     }
 
     // print version info
-    if (result.count("version")) {
+    if (result.contains("version")) {
         if (comm.is_main_rank()) {
             std::cout << version::detail::get_version_info("plssvm-predict") << std::endl;
         }
@@ -119,79 +125,30 @@ parser_predict::parser_predict(const mpi::communicator &comm, int argc, char **a
     // parse target_platform and cast the value to the respective enum
     target = result["target_platform"].as<decltype(target)>();
 
-#if defined(PLSSVM_HAS_SYCL_BACKEND)
-    {
-        // parse kernel invocation type when using SYCL as backend
-        sycl_kernel_invocation_type = result["sycl_kernel_invocation_type"].as<decltype(sycl_kernel_invocation_type)>();
-
-        // assemble warning condition
-        const std::vector<plssvm::target_platform> target_platforms = { target == target_platform::automatic ? determine_default_target_platform() : target };
-        const bool sycl_backend_is_used = backend == backend_type::sycl || (backend == backend_type::automatic && determine_default_backend(list_available_backends(), target_platforms) == backend_type::sycl);
-
-        // warn if kernel invocation type is explicitly set but SYCL isn't the current (automatic) backend
-        if (!sycl_backend_is_used && sycl_kernel_invocation_type != sycl::kernel_invocation_type::automatic) {
-            detail::log_untracked(verbosity_level::full | verbosity_level::warning,
-                                  comm,
-                                  "WARNING: explicitly set a SYCL kernel invocation type but the current backend isn't SYCL; ignoring --sycl_kernel_invocation_type={}\n",
-                                  sycl_kernel_invocation_type);
-        }
-
-        // parse SYCL implementation used in the SYCL backend
-        sycl_implementation_type = result["sycl_implementation_type"].as<decltype(sycl_implementation_type)>();
-
-        // warn if a SYCL implementation type is explicitly set but SYCL isn't the current (automatic) backend
-        if (!sycl_backend_is_used && sycl_implementation_type != sycl::implementation_type::automatic) {
-            detail::log_untracked(verbosity_level::full | verbosity_level::warning,
-                                  comm,
-                                  "WARNING: explicitly set a SYCL implementation type but the current backend isn't SYCL; ignoring --sycl_implementation_type={}\n",
-                                  sycl_implementation_type);
-        }
+    // parse the SYCL related options
+    const std::optional<std::pair<sycl::data_parallel_kernel, sycl::implementation_type>> sycl_options = parse_and_check_sycl_options_if_available(result, comm, backend, target);
+    if (sycl_options.has_value()) {
+        sycl_data_parallel_kernel = sycl_options->first;
+        sycl_implementation_type = sycl_options->second;
     }
-#endif
-
-#if defined(PLSSVM_HAS_KOKKOS_BACKEND)
-    {
-        // parse execution space when using Kokkos as backend
-        kokkos_execution_space = result["kokkos_execution_space"].as<decltype(kokkos_execution_space)>();
 
-        // assemble warning condition
-        const std::vector<plssvm::target_platform> target_platforms = { target == target_platform::automatic ? determine_default_target_platform() : target };
-        const bool kokkos_backend_is_used = backend == backend_type::kokkos || (backend == backend_type::automatic && determine_default_backend(list_available_backends(), target_platforms) == backend_type::kokkos);
-
-        // warn if the kokkos execution space is explicitly set but Kokkos isn't the current (automatic) backend
-        if (!kokkos_backend_is_used && kokkos_execution_space != kokkos::execution_space::automatic) {
-            detail::log_untracked(verbosity_level::full | verbosity_level::warning,
-                                  comm,
-                                  "WARNING: explicitly set a Kokkos execution space but the current backend isn't Kokkos; ignoring --kokkos_execution_space={}\n",
-                                  kokkos_execution_space);
-        }
+    // parse the Kokkos related options
+    const std::optional<kokkos::execution_space> kokkos_options = parse_and_check_kokkos_options_if_available(result, comm, backend, target);
+    if (kokkos_options.has_value()) {
+        kokkos_execution_space = kokkos_options.value();
     }
-#endif
 
     // parse whether strings should be used as labels
     strings_as_labels = result["use_strings_as_labels"].as<decltype(strings_as_labels)>();
 
-    // parse whether output is quiet or not
-    const bool quiet = result["quiet"].as<bool>();
-
     // -q/--quiet has precedence over --verbosity
-    if (result["verbosity"].count()) {
-        const verbosity_level verb = result["verbosity"].as<verbosity_level>();
-        if (quiet && verb != verbosity_level::quiet) {
-            detail::log_untracked(verbosity_level::full | verbosity_level::warning,
-                                  comm,
-                                  "WARNING: explicitly set the -q/--quiet flag, but the provided verbosity level isn't \"quiet\"; setting --verbosity={} to --verbosity=quiet\n",
-                                  verb);
-            verbosity = verbosity_level::quiet;
-        } else {
-            verbosity = verb;
-        }
-    } else if (quiet) {
-        verbosity = verbosity_level::quiet;
+    const std::optional<verbosity_level> verb = parse_verbosity(result, comm);
+    if (verb.has_value()) {
+        verbosity = verb.value();
     }
 
     // parse test data filename
-    if (!result.count("test")) {
+    if (!result.contains("test")) {
         if (comm.is_main_rank()) {
             std::cerr << fmt::format(fmt::fg(fmt::color::red), "ERROR: missing test file!\n") << std::endl;
             std::cout << options.help() << std::endl;
@@ -201,7 +158,7 @@ parser_predict::parser_predict(const mpi::communicator &comm, int argc, char **a
     input_filename = result["test"].as<decltype(input_filename)>();
 
     // parse model filename
-    if (!result.count("model")) {
+    if (!result.contains("model")) {
         if (comm.is_main_rank()) {
             std::cerr << fmt::format(fmt::fg(fmt::color::red), "ERROR: missing model file!\n") << std::endl;
             std::cout << options.help() << std::endl;
@@ -211,35 +168,23 @@ parser_predict::parser_predict(const mpi::communicator &comm, int argc, char **a
     model_filename = result["model"].as<decltype(model_filename)>();
 
     // parse output filename
-    if (result.count("output")) {
+    if (result.contains("output")) {
         predict_filename = result["output"].as<decltype(predict_filename)>();
     } else {
         const std::filesystem::path input_path{ input_filename };
         predict_filename = input_path.filename().string() + ".predict";
     }
 
-#if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
     // parse performance tracking filename
-    if (result.count("performance_tracking")) {
+    if (result.contains("performance_tracking")) {
         performance_tracking_filename = result["performance_tracking"].as<decltype(performance_tracking_filename)>();
     }
-#endif
-
-#if defined(PLSSVM_HAS_MPI_ENABLED)
-    // parse MPI load balancing factors
-    if (result.count("mpi_load_balancing_weights")) {
-        mpi_load_balancing_weights = result["mpi_load_balancing_weights"].as<decltype(mpi_load_balancing_weights)>();
 
-        // sanity check provided balance factors
-        if (mpi_load_balancing_weights.size() != comm.size()) {
-            if (comm.is_main_rank()) {
-                std::cerr << fmt::format(fmt::fg(fmt::color::red), "ERROR: the number of load balancing weights ({}) must match the number of MPI ranks ({})!\n", mpi_load_balancing_weights.size(), comm.size()) << std::endl;
-                std::cout << options.help() << std::endl;
-            }
-            throw cmd_parser_exit{ EXIT_FAILURE };
-        }
+    // parse the MPI related options
+    std::optional<std::vector<std::size_t>> mpi_options = parse_and_check_mpi_options_if_available(result, options, comm);
+    if (mpi_options.has_value()) {
+        mpi_load_balancing_weights = std::move(mpi_options.value());
     }
-#endif
 }
 
 std::ostream &operator<<(std::ostream &out, const parser_predict &params) {
@@ -252,9 +197,9 @@ std::ostream &operator<<(std::ostream &out, const parser_predict &params) {
     if (params.backend == backend_type::sycl || params.backend == backend_type::automatic) {
         out << fmt::format(
             "SYCL implementation type: {}\n"
-            "SYCL kernel invocation type: {}\n",
+            "SYCL data parallel kernel: {}\n",
             params.sycl_implementation_type,
-            params.sycl_kernel_invocation_type);
+            params.sycl_data_parallel_kernel);
     }
 
     if (params.backend == backend_type::kokkos || params.backend == backend_type::automatic) {
diff --git a/src/plssvm/detail/cmd/parser_scale.cpp b/src/plssvm/detail/cmd/parser_scale.cpp
index cd03fe5d6..a627958d0 100644
--- a/src/plssvm/detail/cmd/parser_scale.cpp
+++ b/src/plssvm/detail/cmd/parser_scale.cpp
@@ -8,11 +8,12 @@
 
 #include "plssvm/detail/cmd/parser_scale.hpp"
 
+#include "plssvm/constants.hpp"                         // plssvm::real_type
 #include "plssvm/detail/assert.hpp"                     // PLSSVM_ASSERT
+#include "plssvm/detail/cmd/utility.hpp"                // plssvm::detail::cmd::max_cmd_width
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"  // plssvm::detail::log_untracked
 #include "plssvm/exceptions/exceptions.hpp"             // plssvm::cmd_parser_exit
 #include "plssvm/mpi/communicator.hpp"                  // plssvm::mpi::communicator
-#include "plssvm/mpi/environment.hpp"                   // plssvm::mpi::{is_active, finalize}
 #include "plssvm/verbosity_levels.hpp"                  // plssvm::verbosity, plssvm::verbosity_level
 #include "plssvm/version/version.hpp"                   // plssvm::version::detail::get_version_info
 
@@ -39,7 +40,7 @@ parser_scale::parser_scale(const mpi::communicator &comm, int argc, char **argv)
         .positional_help("input_file [scaled_file]")
         .show_positional_help();
     options
-        .set_width(150)
+        .set_width(max_cmd_width)
         .set_tab_expansion()
         // clang-format off
        .add_options()
@@ -74,7 +75,7 @@ parser_scale::parser_scale(const mpi::communicator &comm, int argc, char **argv)
     }
 
     // print help message and exit
-    if (result.count("help")) {
+    if (result.contains("help")) {
         if (comm.is_main_rank()) {
             std::cout << options.help() << std::endl;
         }
@@ -82,7 +83,7 @@ parser_scale::parser_scale(const mpi::communicator &comm, int argc, char **argv)
     }
 
     // print version info
-    if (result.count("version")) {
+    if (result.contains("version")) {
         if (comm.is_main_rank()) {
             std::cout << version::detail::get_version_info("plssvm-scale", false) << std::endl;
         }
@@ -123,7 +124,7 @@ parser_scale::parser_scale(const mpi::communicator &comm, int argc, char **argv)
     const bool quiet = result["quiet"].as<bool>();
 
     // -q/--quiet has precedence over --verbosity
-    if (result["verbosity"].count()) {
+    if (result.contains("verbosity")) {
         const verbosity_level verb = result["verbosity"].as<verbosity_level>();
         if (quiet && verb != verbosity_level::quiet) {
             detail::log_untracked(verbosity_level::full | verbosity_level::warning,
@@ -139,7 +140,7 @@ parser_scale::parser_scale(const mpi::communicator &comm, int argc, char **argv)
     }
 
     // parse input data filename
-    if (!result.count("input")) {
+    if (!result.contains("input")) {
         if (comm.is_main_rank()) {
             std::cerr << fmt::format(fmt::fg(fmt::color::red), "ERROR: missing input file!\n") << std::endl;
             std::cout << options.help() << std::endl;
@@ -149,12 +150,12 @@ parser_scale::parser_scale(const mpi::communicator &comm, int argc, char **argv)
     input_filename = result["input"].as<decltype(input_filename)>();
 
     // parse output model filename
-    if (result.count("scaled")) {
+    if (result.contains("scaled")) {
         scaled_filename = result["scaled"].as<decltype(scaled_filename)>();
     }
 
     // can only use one of save_filename or restore_filename
-    if (result.count("save_filename") && result.count("restore_filename")) {
+    if (result.contains("save_filename") && result.contains("restore_filename")) {
         if (comm.is_main_rank()) {
             std::cerr << fmt::format(fmt::fg(fmt::color::red), "ERROR: cannot use -s (--save_filename) and -r (--restore_filename) simultaneously!\n") << std::endl;
             std::cout << options.help() << std::endl;
@@ -163,13 +164,13 @@ parser_scale::parser_scale(const mpi::communicator &comm, int argc, char **argv)
     }
 
     // parse the file name to save the calculated weights to
-    if (result.count("save_filename")) {
+    if (result.contains("save_filename")) {
         save_filename = result["save_filename"].as<decltype(save_filename)>();
     }
 
     // parse the file name to restore the previously saved weights from
-    if (result.count("restore_filename")) {
-        if (result.count("lower") || result.count("upper")) {
+    if (result.contains("restore_filename")) {
+        if (result.contains("lower") || result.contains("upper")) {
             detail::log_untracked(verbosity_level::full | verbosity_level::warning,
                                   comm,
                                   "WARNING: provided -l (--lower) and/or -u (--upper) together with -r (--restore_filename); ignoring -l/-u\n");
@@ -179,7 +180,7 @@ parser_scale::parser_scale(const mpi::communicator &comm, int argc, char **argv)
 
 #if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
     // parse performance tracking filename
-    if (result.count("performance_tracking")) {
+    if (result.contains("performance_tracking")) {
         performance_tracking_filename = result["performance_tracking"].as<decltype(performance_tracking_filename)>();
     }
 #endif
diff --git a/src/plssvm/detail/cmd/parser_train.cpp b/src/plssvm/detail/cmd/parser_train.cpp
index b47422a0f..4c1df7a0c 100644
--- a/src/plssvm/detail/cmd/parser_train.cpp
+++ b/src/plssvm/detail/cmd/parser_train.cpp
@@ -8,26 +8,27 @@
 
 #include "plssvm/detail/cmd/parser_train.hpp"
 
-#include "plssvm/backend_types.hpp"                          // plssvm::list_available_backends, plssvm::determine_default_backend
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::{list_available_execution_spaces, execution_space}
-#include "plssvm/backends/SYCL/implementation_types.hpp"     // plssvm::sycl::{list_available_sycl_implementations, implementation_type}
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::{list_available_sycl_kernel_invocation_types, kernel_invocation_type}
-#include "plssvm/classification_types.hpp"                   // plssvm::classification_type, plssvm::classification_type_to_full_string
-#include "plssvm/constants.hpp"                              // plssvm::real_type
-#include "plssvm/detail/assert.hpp"                          // PLSSVM_ASSERT
-#include "plssvm/detail/logging/mpi_log_untracked.hpp"       // plssvm::detail::log_untracked
-#include "plssvm/detail/utility.hpp"                         // plssvm::detail::to_underlying
-#include "plssvm/exceptions/exceptions.hpp"                  // plssvm::cmd_parser_exit
-#include "plssvm/gamma.hpp"                                  // plssvm::get_gamma_string
-#include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_type_to_math_string
-#include "plssvm/mpi/communicator.hpp"                       // plssvm::mpi::communicator
-#include "plssvm/mpi/environment.hpp"                        // plssvm::mpi::{is_active, finalize}
-#include "plssvm/svm_types.hpp"                              // plssvm::svm_type
-#include "plssvm/target_platforms.hpp"                       // plssvm::list_available_target_platforms
-#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, cxxopts::value,cxxopts::ParseResult
+#include "plssvm/backend_types.hpp"                        // plssvm::list_available_backends
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"     // plssvm::kokkos::{list_available_execution_spaces, execution_space}
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::{list_available_sycl_data_parallel_kernels, data_parallel_kernels}
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::{list_available_sycl_implementations, implementation_type}
+#include "plssvm/classification_types.hpp"                 // plssvm::classification_type, plssvm::classification_type_to_full_string
+#include "plssvm/constants.hpp"                            // plssvm::real_type
+#include "plssvm/detail/assert.hpp"                        // PLSSVM_ASSERT
+#include "plssvm/detail/cmd/utility.hpp"                   // plssvm::detail::cmd::{filter_argv, kernel_type_help_message, parse_and_check_sycl_options_if_available,
+                                                           // parse_and_check_kokkos_options_if_available, parse_and_check_mpi_options_if_available, parse_verbosity, max_cmd_width}
+#include "plssvm/detail/logging/mpi_log_untracked.hpp"     // plssvm::detail::log_untracked
+#include "plssvm/detail/utility.hpp"                       // plssvm::detail::to_underlying
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::cmd_parser_exit
+#include "plssvm/gamma.hpp"                                // plssvm::get_gamma_string
+#include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type, plssvm::kernel_function_type_to_math_string
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/svm_types.hpp"                            // plssvm::svm_type
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform, plssvm::list_available_target_platforms
+#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, cxxopts::value, cxxopts::ParseResult
 #include "fmt/color.h"   // fmt::fg, fmt::color::red
 #include "fmt/format.h"  // fmt::format
 #include "fmt/ranges.h"  // fmt::join
@@ -36,8 +37,10 @@
 #include <exception>    // std::exception
 #include <filesystem>   // std::filesystem::path
 #include <iostream>     // std::cout, std::cerr, std::endl
+#include <optional>     // std::optional
 #include <string>       // std::string
 #include <type_traits>  // std::is_same_v
+#include <utility>      // std::pair, std::move
 #include <variant>      // std::holds_alternative, std::get
 #include <vector>       // std::vector
 
@@ -48,22 +51,18 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
     PLSSVM_ASSERT(argc >= 1, fmt::format("At least one argument is always given (the executable name), but argc is {}!", argc));
     PLSSVM_ASSERT(argv != nullptr, "At least one argument is always given (the executable name), but argv is a nullptr!");
 
+    // filter the command line arguments removing third party options
+    std::vector<char *> filtered_args = filter_argv(argc, argv);
+
     // create the help message for the kernel function type
-    const auto kernel_type_to_help_entry = [](const kernel_function_type kernel) {
-        return fmt::format("\t {} -- {}: {}\n", detail::to_underlying(kernel), kernel, kernel_function_type_to_math_string(kernel));
-    };
-    std::string kernel_type_help{ "set type of kernel function. \n" };
-    for (const kernel_function_type kernel : { kernel_function_type::linear, kernel_function_type::polynomial, kernel_function_type::rbf, kernel_function_type::sigmoid, kernel_function_type::laplacian, kernel_function_type::chi_squared }) {
-        kernel_type_help += kernel_type_to_help_entry(kernel);
-    }
-    kernel_type_help.pop_back();  // remove last newline character
+    const std::string kernel_type_help = kernel_type_help_message();
 
     cxxopts::Options options("plssvm-train", "LS-SVM with multiple (GPU-)backends");
     options
         .positional_help("training_set_file [model_file]")
         .show_positional_help();
     options
-        .set_width(150)
+        .set_width(max_cmd_width)
         .set_tab_expansion()
         // clang-format off
        .add_options()
@@ -80,7 +79,7 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
            ("b,backend", fmt::format("choose the backend: {}", fmt::join(list_available_backends(), "|")), cxxopts::value<decltype(backend)>()->default_value(fmt::format("{}", backend)))
            ("p,target_platform", fmt::format("choose the target platform: {}", fmt::join(list_available_target_platforms(), "|")), cxxopts::value<decltype(target)>()->default_value(fmt::format("{}", target)))
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
-           ("sycl_kernel_invocation_type", fmt::format("choose the kernel invocation type when using SYCL as backend: {}", fmt::join(sycl::list_available_sycl_kernel_invocation_types(), "|")), cxxopts::value<decltype(sycl_kernel_invocation_type)>()->default_value(fmt::format("{}", sycl_kernel_invocation_type)))
+           ("sycl_data_parallel_kernel", fmt::format("choose the data parallel kernel when using SYCL as backend: {}", fmt::join(sycl::list_available_sycl_data_parallel_kernels(), "|")), cxxopts::value<decltype(sycl_data_parallel_kernel)>()->default_value(fmt::format("{}", sycl_data_parallel_kernel)))
            ("sycl_implementation_type", fmt::format("choose the SYCL implementation to be used in the SYCL backend: {}", fmt::join(sycl::list_available_sycl_implementations(), "|")), cxxopts::value<decltype(sycl_implementation_type)>()->default_value(fmt::format("{}", sycl_implementation_type)))
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
@@ -105,7 +104,7 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
     cxxopts::ParseResult result;
     try {
         options.parse_positional({ "input", "model" });
-        result = options.parse(argc, argv);
+        result = options.parse(static_cast<int>(filtered_args.size()), filtered_args.data());
     } catch (const std::exception &e) {
         if (comm.is_main_rank()) {
             std::cerr << fmt::format(fmt::fg(fmt::color::red), "ERROR: {}\n", e.what()) << std::endl;
@@ -115,7 +114,7 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
     }
 
     // print help message and exit
-    if (result.count("help")) {
+    if (result.contains("help")) {
         if (comm.is_main_rank()) {
             std::cout << options.help() << std::endl;
         }
@@ -123,7 +122,7 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
     }
 
     // print version info
-    if (result.count("version")) {
+    if (result.contains("version")) {
         if (comm.is_main_rank()) {
             std::cout << version::detail::get_version_info("plssvm-train") << std::endl;
         }
@@ -140,22 +139,22 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
     }
 
     // parse svm_type and cast the value to the respective enum
-    if (result.count("svm_type")) {
+    if (result.contains("svm_type")) {
         svm = result["svm_type"].as<decltype(svm)>();
     }
 
     // parse kernel_type and cast the value to the respective enum
-    if (result.count("kernel_type")) {
+    if (result.contains("kernel_type")) {
         csvm_params.kernel_type = result["kernel_type"].as<decltype(csvm_params.kernel_type)>();
     }
 
     // parse degree
-    if (result.count("degree")) {
+    if (result.contains("degree")) {
         csvm_params.degree = result["degree"].as<decltype(csvm_params.degree)>();
     }
 
     // parse gamma
-    if (result.count("gamma")) {
+    if (result.contains("gamma")) {
         const decltype(csvm_params.gamma) gamma_input = result["gamma"].as<decltype(csvm_params.gamma)>();
         // check if the provided gamma is legal iff a real_type has been provided
         if (std::holds_alternative<real_type>(gamma_input) && std::get<real_type>(gamma_input) <= real_type{ 0.0 }) {
@@ -170,22 +169,22 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
     }
 
     // parse coef0
-    if (result.count("coef0")) {
+    if (result.contains("coef0")) {
         csvm_params.coef0 = result["coef0"].as<decltype(csvm_params.coef0)>();
     }
 
     // parse cost
-    if (result.count("cost")) {
+    if (result.contains("cost")) {
         csvm_params.cost = result["cost"].as<decltype(csvm_params.cost)>();
     }
 
     // parse epsilon
-    if (result.count("epsilon")) {
+    if (result.contains("epsilon")) {
         epsilon = result["epsilon"].as<decltype(epsilon)>();
     }
 
     // parse max_iter
-    if (result.count("max_iter")) {
+    if (result.contains("max_iter")) {
         const auto max_iter_input = result["max_iter"].as<long long int>();
         // check if the provided max_iter is legal
         if (max_iter_input <= decltype(max_iter_input){ 0 }) {
@@ -200,7 +199,7 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
     }
 
     // parse the classification type
-    if (result.count("classification")) {
+    if (result.contains("classification")) {
         classification = result["classification"].as<decltype(classification)>();
 
         // warn if a classification type has been provided, but the SVM type is a C-SVR (regression)
@@ -221,54 +220,18 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
     // parse the solver_type and cast the value to the respective enum
     solver = result["solver"].as<decltype(solver)>();
 
-#if defined(PLSSVM_HAS_SYCL_BACKEND)
-    {
-        // parse kernel invocation type when using SYCL as backend
-        sycl_kernel_invocation_type = result["sycl_kernel_invocation_type"].as<decltype(sycl_kernel_invocation_type)>();
-
-        // assemble warning condition
-        const std::vector<plssvm::target_platform> target_platforms = { target == target_platform::automatic ? determine_default_target_platform() : target };
-        const bool sycl_backend_is_used = backend == backend_type::sycl || (backend == backend_type::automatic && determine_default_backend(list_available_backends(), target_platforms) == backend_type::sycl);
-
-        // warn if kernel invocation type is explicitly set but SYCL isn't the current (automatic) backend
-        if (!sycl_backend_is_used && sycl_kernel_invocation_type != sycl::kernel_invocation_type::automatic) {
-            detail::log_untracked(verbosity_level::full | verbosity_level::warning,
-                                  comm,
-                                  "WARNING: explicitly set a SYCL kernel invocation type but the current backend isn't SYCL; ignoring --sycl_kernel_invocation_type={}\n",
-                                  sycl_kernel_invocation_type);
-        }
-
-        // parse SYCL implementation used in the SYCL backend
-        sycl_implementation_type = result["sycl_implementation_type"].as<decltype(sycl_implementation_type)>();
-
-        // warn if a SYCL implementation type is explicitly set but SYCL isn't the current (automatic) backend
-        if (!sycl_backend_is_used && sycl_implementation_type != sycl::implementation_type::automatic) {
-            detail::log_untracked(verbosity_level::full | verbosity_level::warning,
-                                  comm,
-                                  "WARNING: explicitly set a SYCL implementation type but the current backend isn't SYCL; ignoring --sycl_implementation_type={}\n",
-                                  sycl_implementation_type);
-        }
+    // parse the SYCL related options
+    const std::optional<std::pair<sycl::data_parallel_kernel, sycl::implementation_type>> sycl_options = parse_and_check_sycl_options_if_available(result, comm, backend, target);
+    if (sycl_options.has_value()) {
+        sycl_data_parallel_kernel = sycl_options->first;
+        sycl_implementation_type = sycl_options->second;
     }
-#endif
 
-#if defined(PLSSVM_HAS_KOKKOS_BACKEND)
-    {
-        // parse execution space when using Kokkos as backend
-        kokkos_execution_space = result["kokkos_execution_space"].as<decltype(kokkos_execution_space)>();
-
-        // assemble warning condition
-        const std::vector<plssvm::target_platform> target_platforms = { target == target_platform::automatic ? determine_default_target_platform() : target };
-        const bool kokkos_backend_is_used = backend == backend_type::kokkos || (backend == backend_type::automatic && determine_default_backend(list_available_backends(), target_platforms) == backend_type::kokkos);
-
-        // warn if the kokkos execution space is explicitly set but Kokkos isn't the current (automatic) backend
-        if (!kokkos_backend_is_used && kokkos_execution_space != kokkos::execution_space::automatic) {
-            detail::log_untracked(verbosity_level::full | verbosity_level::warning,
-                                  comm,
-                                  "WARNING: explicitly set a Kokkos execution space but the current backend isn't Kokkos; ignoring --kokkos_execution_space={}\n",
-                                  kokkos_execution_space);
-        }
+    // parse the Kokkos related options
+    const std::optional<kokkos::execution_space> kokkos_options = parse_and_check_kokkos_options_if_available(result, comm, backend, target);
+    if (kokkos_options.has_value()) {
+        kokkos_execution_space = kokkos_options.value();
     }
-#endif
 
     // parse whether strings should be used as labels for the classification task
     strings_as_labels = result["use_strings_as_labels"].as<decltype(strings_as_labels)>();
@@ -278,27 +241,14 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
                               "WARNING: explicitly requested string labels for the regression task; ignoring --use_strings_as_labels\n");
     }
 
-    // parse whether output is quiet or not
-    const bool quiet = result["quiet"].as<bool>();
-
     // -q/--quiet has precedence over --verbosity
-    if (result["verbosity"].count()) {
-        const verbosity_level verb = result["verbosity"].as<verbosity_level>();
-        if (quiet && verb != verbosity_level::quiet) {
-            detail::log_untracked(verbosity_level::full | verbosity_level::warning,
-                                  comm,
-                                  "WARNING: explicitly set the -q/--quiet flag, but the provided verbosity level isn't \"quiet\"; setting --verbosity={} to --verbosity=quiet\n",
-                                  verb);
-            verbosity = verbosity_level::quiet;
-        } else {
-            verbosity = verb;
-        }
-    } else if (quiet) {
-        verbosity = verbosity_level::quiet;
+    const std::optional<verbosity_level> verb = parse_verbosity(result, comm);
+    if (verb.has_value()) {
+        verbosity = verb.value();
     }
 
     // parse input data filename
-    if (!result.count("input")) {
+    if (!result.contains("input")) {
         if (comm.is_main_rank()) {
             std::cerr << fmt::format(fmt::fg(fmt::color::red), "ERROR: missing input file!\n") << std::endl;
             std::cout << options.help() << std::endl;
@@ -308,35 +258,23 @@ parser_train::parser_train(const mpi::communicator &comm, int argc, char **argv)
     input_filename = result["input"].as<decltype(input_filename)>();
 
     // parse output model filename
-    if (result.count("model")) {
+    if (result.contains("model")) {
         model_filename = result["model"].as<decltype(model_filename)>();
     } else {
         const std::filesystem::path input_path{ input_filename };
         model_filename = input_path.filename().string() + ".model";
     }
 
-#if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
     // parse performance tracking filename
-    if (result.count("performance_tracking")) {
+    if (result.contains("performance_tracking")) {
         performance_tracking_filename = result["performance_tracking"].as<decltype(performance_tracking_filename)>();
     }
-#endif
 
-#if defined(PLSSVM_HAS_MPI_ENABLED)
-    // parse MPI load balancing factors
-    if (result.count("mpi_load_balancing_weights")) {
-        mpi_load_balancing_weights = result["mpi_load_balancing_weights"].as<decltype(mpi_load_balancing_weights)>();
-
-        // sanity check provided balance factors
-        if (mpi_load_balancing_weights.size() != comm.size()) {
-            if (comm.is_main_rank()) {
-                std::cerr << fmt::format(fmt::fg(fmt::color::red), "ERROR: the number of load balancing weights ({}) must match the number of MPI ranks ({})!\n", mpi_load_balancing_weights.size(), comm.size()) << std::endl;
-                std::cout << options.help() << std::endl;
-            }
-            throw cmd_parser_exit{ EXIT_FAILURE };
-        }
+    // parse the MPI related options
+    std::optional<std::vector<std::size_t>> mpi_options = parse_and_check_mpi_options_if_available(result, options, comm);
+    if (mpi_options.has_value()) {
+        mpi_load_balancing_weights = std::move(mpi_options.value());
     }
-#endif
 }
 
 std::ostream &operator<<(std::ostream &out, const parser_train &params) {
@@ -387,9 +325,9 @@ std::ostream &operator<<(std::ostream &out, const parser_train &params) {
     if (params.backend == backend_type::sycl || params.backend == backend_type::automatic) {
         out << fmt::format(
             "SYCL implementation type: {}\n"
-            "SYCL kernel invocation type: {}\n",
+            "SYCL data parallel kernel: {}\n",
             params.sycl_implementation_type,
-            params.sycl_kernel_invocation_type);
+            params.sycl_data_parallel_kernel);
     }
 
     if (params.backend == backend_type::kokkos || params.backend == backend_type::automatic) {
diff --git a/src/plssvm/detail/cmd/utility.cpp b/src/plssvm/detail/cmd/utility.cpp
new file mode 100644
index 000000000..babaaa813
--- /dev/null
+++ b/src/plssvm/detail/cmd/utility.cpp
@@ -0,0 +1,185 @@
+/**
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ */
+
+#include "plssvm/detail/cmd/utility.hpp"
+
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type, plssvm::list_available_backends, plssvm::determine_default_backend
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"     // plssvm::kokkos::execution_space
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernels
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::implementation_type
+#include "plssvm/detail/logging/mpi_log_untracked.hpp"     // plssvm::detail::log_untracked
+#include "plssvm/detail/string_utility.hpp"                // plssvm::detail::starts_with
+#include "plssvm/detail/utility.hpp"                       // plssvm::detail::to_underlying
+#include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
+#include "plssvm/mpi/communicator.hpp"                     // plssvm::mpi::communicator
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform, plssvm::determine_default_target_platform
+#include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity_level
+
+#include "cxxopts.hpp"   // cxxopts::ParseResult, cxxopts::Options
+#include "fmt/format.h"  // fmt::format
+
+#include <cstddef>   // std::size_t
+#include <cstdlib>   // EXIT_FAILURE
+#include <optional>  // std::optional, std::nullopt
+#include <string>    // std::string
+#include <utility>   // std::pair, std::make_pair
+#include <vector>    // std::vector
+
+#if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/exceptions/exceptions.hpp"  // plssvm::cmd_parser_exit
+
+    #include "fmt/color.h"  // fmt::fg, fmt::color::red
+
+    #include <iostream>  // std::cout, std::cerr, std::endl
+#endif
+
+namespace plssvm::detail::cmd {
+
+// NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic): pointer arithmetic necessary due to char** from the main function
+
+std::vector<char *> filter_argv(int argc, char **argv, const std::vector<std::string> &prefix_filter) {
+    // We ignore all command line options starting with --hpx: like --hpx:threads=42.
+    // We also ignore all command line options starting with --kokkos-.
+    // NOTE: this does not include OUR command line option --kokkos_execution_space.
+    std::vector<char *> filtered_argv{ argv[0] };
+    for (std::size_t i = 1; i < static_cast<std::size_t>(argc); ++i) {
+        bool remove_option = false;
+
+        // check whether the current command line option starts with any of the provided prefixes
+        for (const std::string &prefix : prefix_filter) {
+            if (detail::starts_with(argv[i], prefix)) {
+                remove_option = true;
+            }
+        }
+
+        // only add the command line options that should not be removed
+        if (!remove_option) {
+            filtered_argv.push_back(argv[i]);
+        }
+    }
+
+    return filtered_argv;
+}
+
+// NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+
+std::string kernel_type_help_message() {
+    // create the help message for the kernel function type
+    const auto kernel_type_to_help_entry = [](const kernel_function_type kernel) {
+        return fmt::format("\t {} -- {}: {}\n", detail::to_underlying(kernel), kernel, kernel_function_type_to_math_string(kernel));
+    };
+    std::string kernel_type_help{ "set type of kernel function. \n" };
+    for (const kernel_function_type kernel : { kernel_function_type::linear, kernel_function_type::polynomial, kernel_function_type::rbf, kernel_function_type::sigmoid, kernel_function_type::laplacian, kernel_function_type::chi_squared }) {
+        kernel_type_help += kernel_type_to_help_entry(kernel);
+    }
+    kernel_type_help.pop_back();  // remove last newline character
+
+    return kernel_type_help;
+}
+
+std::optional<std::pair<sycl::data_parallel_kernel, sycl::implementation_type>> parse_and_check_sycl_options_if_available([[maybe_unused]] const cxxopts::ParseResult &result, [[maybe_unused]] const mpi::communicator &comm, [[maybe_unused]] const backend_type backend, [[maybe_unused]] const target_platform target) {
+#if defined(PLSSVM_HAS_SYCL_BACKEND)
+    // parse the data parallel kernel when using SYCL as backend
+    const sycl::data_parallel_kernel data_parallel_kernel = result["sycl_data_parallel_kernel"].as<sycl::data_parallel_kernel>();
+
+    // assemble warning condition
+    const std::vector<target_platform> target_platforms = { target == target_platform::automatic ? determine_default_target_platform() : target };
+    const bool sycl_backend_is_used = backend == backend_type::sycl || (backend == backend_type::automatic && determine_default_backend(list_available_backends(), target_platforms) == backend_type::sycl);
+
+    // warn if the data parallel kernel is explicitly set but SYCL isn't the current (automatic) backend
+    if (!sycl_backend_is_used && data_parallel_kernel != sycl::data_parallel_kernel::automatic) {
+        detail::log_untracked(verbosity_level::full | verbosity_level::warning,
+                              comm,
+                              "WARNING: explicitly set a SYCL data parallel kernel but the current backend isn't SYCL; ignoring --sycl_data_parallel_kernel={}\n",
+                              data_parallel_kernel);
+    }
+
+    // parse the SYCL implementation used in the SYCL backend
+    const sycl::implementation_type implementation_type = result["sycl_implementation_type"].as<sycl::implementation_type>();
+
+    // warn if a SYCL implementation type is explicitly set but SYCL isn't the current (automatic) backend
+    if (!sycl_backend_is_used && implementation_type != sycl::implementation_type::automatic) {
+        detail::log_untracked(verbosity_level::full | verbosity_level::warning,
+                              comm,
+                              "WARNING: explicitly set a SYCL implementation type but the current backend isn't SYCL; ignoring --sycl_implementation_type={}\n",
+                              implementation_type);
+    }
+
+    return std::make_pair(data_parallel_kernel, implementation_type);
+#else
+    return std::nullopt;
+#endif
+}
+
+[[nodiscard]] std::optional<kokkos::execution_space> parse_and_check_kokkos_options_if_available([[maybe_unused]] const cxxopts::ParseResult &result, [[maybe_unused]] const mpi::communicator &comm, [[maybe_unused]] const backend_type backend, [[maybe_unused]] const target_platform target) {
+#if defined(PLSSVM_HAS_KOKKOS_BACKEND)
+    // parse execution space when using Kokkos as backend
+    const kokkos::execution_space execution_space = result["kokkos_execution_space"].as<kokkos::execution_space>();
+
+    // assemble warning condition
+    const std::vector<target_platform> target_platforms = { target == target_platform::automatic ? determine_default_target_platform() : target };
+    const bool kokkos_backend_is_used = backend == backend_type::kokkos || (backend == backend_type::automatic && determine_default_backend(list_available_backends(), target_platforms) == backend_type::kokkos);
+
+    // warn if the kokkos execution space is explicitly set but Kokkos isn't the current (automatic) backend
+    if (!kokkos_backend_is_used && execution_space != kokkos::execution_space::automatic) {
+        detail::log_untracked(verbosity_level::full | verbosity_level::warning,
+                              comm,
+                              "WARNING: explicitly set a Kokkos execution space but the current backend isn't Kokkos; ignoring --kokkos_execution_space={}\n",
+                              execution_space);
+    }
+
+    return execution_space;
+#else
+    return std::nullopt;
+#endif
+}
+
+std::optional<std::vector<std::size_t>> parse_and_check_mpi_options_if_available([[maybe_unused]] const cxxopts::ParseResult &result, [[maybe_unused]] const cxxopts::Options &options, [[maybe_unused]] const mpi::communicator &comm) {
+#if defined(PLSSVM_HAS_MPI_ENABLED)
+    // parse MPI load balancing factors
+    if (result.contains("mpi_load_balancing_weights")) {
+        std::vector<std::size_t> mpi_load_balancing_weights = result["mpi_load_balancing_weights"].as<std::vector<std::size_t>>();
+
+        // sanity-check provided balance factors
+        if (mpi_load_balancing_weights.size() != comm.size()) {
+            if (comm.is_main_rank()) {
+                std::cerr << fmt::format(fmt::fg(fmt::color::red), "ERROR: the number of load balancing weights ({}) must match the number of MPI ranks ({})!\n", mpi_load_balancing_weights.size(), comm.size()) << std::endl;
+                std::cout << options.help() << std::endl;
+            }
+            throw cmd_parser_exit{ EXIT_FAILURE };
+        }
+        return std::make_optional(std::move(mpi_load_balancing_weights));
+    }
+    return std::nullopt;
+#else
+    return std::nullopt;
+#endif
+}
+
+std::optional<verbosity_level> parse_verbosity(const cxxopts::ParseResult &result, const mpi::communicator &comm) {
+    // parse whether output is quiet or not
+    const bool quiet = result["quiet"].as<bool>();
+
+    if (result.contains("verbosity")) {
+        const verbosity_level verb = result["verbosity"].as<verbosity_level>();
+        if (quiet && verb != verbosity_level::quiet) {
+            detail::log_untracked(verbosity_level::full | verbosity_level::warning,
+                                  comm,
+                                  "WARNING: explicitly set the -q/--quiet flag, but the provided verbosity level isn't \"quiet\"; setting --verbosity={} to --verbosity=quiet\n",
+                                  verb);
+            return verbosity_level::quiet;
+        }
+        return verb;
+    }
+    if (quiet) {
+        return verbosity_level::quiet;
+    }
+    return std::nullopt;
+}
+
+}  // namespace plssvm::detail::cmd
diff --git a/src/plssvm/detail/data_distribution.cpp b/src/plssvm/detail/data_distribution.cpp
index 3f3e42678..7b738eb52 100644
--- a/src/plssvm/detail/data_distribution.cpp
+++ b/src/plssvm/detail/data_distribution.cpp
@@ -25,6 +25,8 @@
 #include <utility>    // std::move
 #include <vector>     // std::vector
 
+namespace {
+
 [[nodiscard]] std::size_t calculate_data_set_num_entries(const std::size_t num_data_points, const std::size_t num_features) noexcept {
     return (num_data_points + plssvm::PADDING_SIZE) * (num_features + plssvm::PADDING_SIZE);
 }
@@ -37,6 +39,8 @@
     return (num_data_points - 1 + plssvm::PADDING_SIZE) * (num_classes + plssvm::PADDING_SIZE);
 }
 
+}  // namespace
+
 namespace plssvm::detail {
 
 data_distribution::data_distribution(mpi::communicator comm, const std::size_t num_rows, const std::size_t num_places) :
@@ -111,7 +115,7 @@ std::ostream &operator<<(std::ostream &out, const data_distribution &dist) {
 //*************************************************************************************************************************************//
 //                                                     specific data distributions                                                     //
 //*************************************************************************************************************************************//
-using namespace literals;
+using namespace literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
 
 triangular_data_distribution::triangular_data_distribution(mpi::communicator comm, const std::size_t num_rows, const std::size_t num_places) :
     data_distribution{ std::move(comm), num_rows, num_places } {
diff --git a/src/plssvm/detail/fast_float_wrapper.cpp b/src/plssvm/detail/fast_float_wrapper.cpp
index a771b5f50..f09c39457 100644
--- a/src/plssvm/detail/fast_float_wrapper.cpp
+++ b/src/plssvm/detail/fast_float_wrapper.cpp
@@ -8,7 +8,8 @@
 
 #include "plssvm/detail/fast_float_wrapper.hpp"
 
-#include "fast_float/fast_float.h"  // fast_float::from_chars_result, fast_float::from_chars
+#include "fast_float/fast_float.h"    // fast_float::from_chars
+#include "fast_float/float_common.h"  // fast_float::from_chars_result
 
 #include <algorithm>     // std::min
 #include <string>        // std::stold, std::string
diff --git a/src/plssvm/detail/io/file_reader.cpp b/src/plssvm/detail/io/file_reader.cpp
index 1973b1c36..695419a4d 100644
--- a/src/plssvm/detail/io/file_reader.cpp
+++ b/src/plssvm/detail/io/file_reader.cpp
@@ -28,14 +28,15 @@
 
 #ifdef _OPENMP
     #include "omp.h"
+
+    #include <cstddef>  // std::size_t
+    #include <deque>    // std::deque
 #endif
 
 #include <algorithm>    // std::min
 #include <climits>      // INT32_MAX
 #include <cmath>        // std::ceil
-#include <cstddef>      // std::size_t
 #include <cstdint>      // INT_MAX
-#include <deque>        // std::deque
 #include <filesystem>   // std::filesystem::path
 #include <fstream>      // std::ifstream
 #include <ios>          // std::ios, std::streamsize
@@ -296,12 +297,12 @@ const char *file_reader::buffer() const noexcept {
 #if defined(PLSSVM_HAS_MEMORY_MAPPING_UNIX)
 void file_reader::open_memory_mapped_file_unix([[maybe_unused]] const char *filename) {
     // open the file
-    file_descriptor_ = ::open(filename, O_RDONLY);
+    file_descriptor_ = ::open(filename, O_RDONLY);  // NOLINT: only way to get a file descriptor to later call mmap
 
     struct stat attr { };
 
     // check if file could be opened
-    if (fstat(file_descriptor_, &attr) == -1) {
+    if (fstat(file_descriptor_, &attr) == -1) {  // NOLINT(clang-analyzer-unix.StdCLibraryFunctions)
         ::close(file_descriptor_);
         throw file_not_found_exception{ fmt::format("Couldn't find file: '{}'!", filename) };
     }
@@ -399,7 +400,7 @@ void file_reader::open_file(const char *filename) {
         fallback_file_content_.resize(num_bytes_);
         for (std::streamsize i = 0; i < static_cast<std::streamsize>(std::ceil(static_cast<double>(num_bytes_) / INT32_MAX)); ++i) {
             // read the whole file in chunks of up to INT32_MAX bytes at once
-            if (!f.read(fallback_file_content_.data() + i * INT32_MAX, std::min<std::streamsize>(INT32_MAX, num_bytes_ - i * INT32_MAX))) {
+            if (!f.read(&fallback_file_content_[i * INT32_MAX], std::min<std::streamsize>(INT32_MAX, num_bytes_ - i * INT32_MAX))) {
                 throw invalid_file_format_exception{ fmt::format("Error while reading file: '{}'!", filename) };
             }
         }
diff --git a/src/plssvm/detail/memory_size.cpp b/src/plssvm/detail/memory_size.cpp
index b7211956c..d21ff8955 100644
--- a/src/plssvm/detail/memory_size.cpp
+++ b/src/plssvm/detail/memory_size.cpp
@@ -21,18 +21,26 @@ namespace plssvm::detail {
 
 std::ostream &operator<<(std::ostream &out, const memory_size mem) {
     // make custom memory size literals available
-    using namespace literals;
+    using namespace literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
+
+    // named constants
+    constexpr double ratio_base2 = 1024.0;
+    constexpr memory_size one_kibi_byte = 1.0_KiB;
+    constexpr memory_size one_mibi_byte = 1.0_MiB;
+    constexpr memory_size one_gibi_byte = 1.0_GiB;
+    constexpr memory_size one_tibi_byte = 1.0_TiB;
+
     // get the number of bytes as decimal value
     const auto val = static_cast<double>(mem.num_bytes());
     // output the value together with the correct binary memory unit suffix
-    if (mem >= 1.0_TiB) {
-        out << fmt::format("{:.2f} TiB", val / 1024.0 / 1024.0 / 1024.0 / 1024.0);
-    } else if (mem >= 1.0_GiB) {
-        out << fmt::format("{:.2f} GiB", val / 1024.0 / 1024.0 / 1024.0);
-    } else if (mem >= 1.0_MiB) {
-        out << fmt::format("{:.2f} MiB", val / 1024.0 / 1024.0);
-    } else if (mem >= 1.0_KiB) {
-        out << fmt::format("{:.2f} KiB", val / 1024.0);
+    if (mem >= one_tibi_byte) {
+        out << fmt::format("{:.2f} TiB", val / ratio_base2 / ratio_base2 / ratio_base2 / ratio_base2);
+    } else if (mem >= one_gibi_byte) {
+        out << fmt::format("{:.2f} GiB", val / ratio_base2 / ratio_base2 / ratio_base2);
+    } else if (mem >= one_mibi_byte) {
+        out << fmt::format("{:.2f} MiB", val / ratio_base2 / ratio_base2);
+    } else if (mem >= one_kibi_byte) {
+        out << fmt::format("{:.2f} KiB", val / ratio_base2);
     } else {
         out << fmt::format("{} B", mem.num_bytes());
     }
@@ -49,29 +57,32 @@ std::istream &operator>>(std::istream &in, memory_size &mem) {
     in >> unit;
     unit = detail::trim(unit);
 
+    constexpr long double ratio_base2 = 1024L;
+    constexpr long double ratio_base10 = 1000L;
+
     // convert size to bytes according to the provided unit
     if (unit == "B") {
         // noting to do, size already given in byte
     } else if (unit == "KiB") {
-        size *= 1024L;
+        size *= ratio_base2;
     } else if (unit == "KB") {
-        size *= 1000L;
+        size *= ratio_base10;
     } else if (unit == "MiB") {
-        size *= 1024L * 1024L;
+        size *= ratio_base2 * ratio_base2;
     } else if (unit == "MB") {
-        size *= 1000L * 1000L;
+        size *= ratio_base10 * ratio_base10;
     } else if (unit == "GiB") {
-        size *= 1024L * 1024L;
-        size *= 1024L;
+        size *= ratio_base2 * ratio_base2;
+        size *= ratio_base2;
     } else if (unit == "GB") {
-        size *= 1000L * 1000L;
-        size *= 1000L;
+        size *= ratio_base10 * ratio_base10;
+        size *= ratio_base10;
     } else if (unit == "TiB") {
-        size *= 1024L * 1024L;
-        size *= 1024L * 1024L;
+        size *= ratio_base2 * ratio_base2;
+        size *= ratio_base2 * ratio_base2;
     } else if (unit == "TB") {
-        size *= 1000L * 1000L;
-        size *= 1000L * 1000L;
+        size *= ratio_base10 * ratio_base10;
+        size *= ratio_base10 * ratio_base10;
     } else {
         // provided memory unit not recognized
         in.setstate(std::ios::failbit);
diff --git a/src/plssvm/detail/sha256.cpp b/src/plssvm/detail/sha256.cpp
index a2a023041..bb77a7039 100644
--- a/src/plssvm/detail/sha256.cpp
+++ b/src/plssvm/detail/sha256.cpp
@@ -18,6 +18,7 @@
 
 namespace plssvm::detail {
 
+// NOLINTBEGIN
 std::string sha256::operator()(std::string input) const {
     // Initialize hash values: (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
     std::array<std::uint32_t, 8> hash_values = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 };
@@ -35,7 +36,6 @@ std::string sha256::operator()(std::string input) const {
     const std::uint32_t K = CHUNK_SIZE - (L + 1 + 8) % CHUNK_SIZE;
     input.resize(L + 1 + K + 8);
 
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast): cast necessary to use the correct character type for the sha256 algorithm
     auto *input_unsigned_ptr = reinterpret_cast<unsigned char *>(input.data());
 
     // append L as an 8-byte big-endian integer, making the total post-processed length a multiple of 64 byte
@@ -121,4 +121,6 @@ std::uint32_t sha256::rotr32(const std::uint32_t value, int count) {
     return (value >> count) | (value << (-count & mask));
 }
 
+// NOLINTEND
+
 }  // namespace plssvm::detail
diff --git a/src/plssvm/detail/tracking/CMakeLists.txt b/src/plssvm/detail/tracking/CMakeLists.txt
index 90f8a2451..32e6566a0 100644
--- a/src/plssvm/detail/tracking/CMakeLists.txt
+++ b/src/plssvm/detail/tracking/CMakeLists.txt
@@ -71,6 +71,7 @@ if (PLSSVM_ENABLE_HARDWARE_SAMPLING)
             QUIET
         )
         FetchContent_MakeAvailable(hws)
+        set_target_properties(hws PROPERTIES CXX_CLANG_TIDY "")
         add_dependencies(${PLSSVM_BASE_LIBRARY_NAME} hws)
     endif ()
     target_link_libraries(${PLSSVM_BASE_LIBRARY_NAME} PUBLIC hws::hws)
diff --git a/src/plssvm/detail/tracking/events.cpp b/src/plssvm/detail/tracking/events.cpp
index 086199913..db6470976 100644
--- a/src/plssvm/detail/tracking/events.cpp
+++ b/src/plssvm/detail/tracking/events.cpp
@@ -12,7 +12,7 @@
 #include "plssvm/detail/tracking/utility.hpp"  // plssvm::detail::tracking::{durations_from_reference_time, time_points_to_epoch}
 #include "plssvm/exceptions/exceptions.hpp"    // plssvm::exception
 
-#include "fmt/chrono.h"  // format std::chrono types
+#include "fmt/chrono.h"  // NOLINT(misc-include-cleaner): false positive, header is used to format std::chrono types
 #include "fmt/format.h"  // fmt::format
 #include "fmt/ranges.h"  // fmt::join
 
@@ -26,7 +26,7 @@
 namespace plssvm::detail::tracking {
 
 void events::add_event(event e) {
-    this->time_points_.push_back(std::move(e.time_point));
+    this->time_points_.push_back(e.time_point);
     this->names_.push_back(fmt::format("{}", std::move(e.name)));
 
     PLSSVM_ASSERT(this->num_events() == this->time_points_.size(), "Error: number of event members mismatch!");
@@ -34,7 +34,7 @@ void events::add_event(event e) {
 }
 
 void events::add_event(decltype(event::time_point) time_point, decltype(event::name) name) {
-    this->time_points_.push_back(std::move(time_point));
+    this->time_points_.push_back(time_point);
     this->names_.push_back(fmt::format("{}", std::move(name)));
 
     PLSSVM_ASSERT(this->num_events() == this->time_points_.size(), "Error: number of event members mismatch!");
@@ -58,18 +58,17 @@ std::string events::generate_yaml_string(const std::chrono::steady_clock::time_p
     if (this->empty()) {
         // no events -> return empty string
         return std::string{};
-    } else {
-        std::vector<std::string> quoted_names(this->num_events());
+    }
+    std::vector<std::string> quoted_names(this->num_events());
 #pragma omp parallel for
-        for (std::size_t i = 0; i < this->num_events(); ++i) {
-            quoted_names[i] = fmt::format("\"{}\"", names_[i]);
-        }
-        // assemble string
-        return fmt::format("    time_points: [{}]\n"
-                           "    names: [{}]",
-                           fmt::join(durations_from_reference_time(time_points_, start_time_point), ", "),
-                           fmt::join(quoted_names, ", "));
+    for (std::size_t i = 0; i < this->num_events(); ++i) {
+        quoted_names[i] = fmt::format("\"{}\"", names_[i]);
     }
+    // assemble string
+    return fmt::format("    time_points: [{}]\n"
+                       "    names: [{}]",
+                       fmt::join(durations_from_reference_time(time_points_, start_time_point), ", "),
+                       fmt::join(quoted_names, ", "));
 }
 
 std::ostream &operator<<(std::ostream &out, const events::event &e) {
diff --git a/src/plssvm/detail/tracking/performance_tracker.cpp b/src/plssvm/detail/tracking/performance_tracker.cpp
index 58b4e975a..4d2f0a732 100644
--- a/src/plssvm/detail/tracking/performance_tracker.cpp
+++ b/src/plssvm/detail/tracking/performance_tracker.cpp
@@ -8,40 +8,44 @@
 
 #include "plssvm/detail/tracking/performance_tracker.hpp"
 
-#include "plssvm/constants.hpp"                          // plssvm::real_type, plssvm::THREAD_BLOCK_SIZE, plssvm::INTERNAL_BLOCK_SIZE, plssvm::FEATURE_BLOCK_SIZE, plssvm::PADDING_SIZE
+#include "plssvm/constants.hpp"                          // plssvm::real_type, plssvm::THREAD_BLOCK_SIZE, plssvm::INTERNAL_BLOCK_SIZE, plssvm::PADDING_SIZE
 #include "plssvm/detail/arithmetic_type_name.hpp"        // plssvm::detail::arithmetic_type_name
 #include "plssvm/detail/assert.hpp"                      // PLSSVM_ASSERT, PLSSVM_ASSERT_ENABLED
 #include "plssvm/detail/cmd/parser_predict.hpp"          // plssvm::detail::cmd::parser_predict
 #include "plssvm/detail/cmd/parser_scale.hpp"            // plssvm::detail::cmd::parser_scale
 #include "plssvm/detail/cmd/parser_train.hpp"            // plssvm::detail::cmd::parser_train
-#include "plssvm/detail/string_utility.hpp"              // plssvm::detail::replace_all
 #include "plssvm/detail/utility.hpp"                     // plssvm::detail::current_date_time, PLSSVM_IS_DEFINED
 #include "plssvm/gamma.hpp"                              // plssvm::get_gamma_string
 #include "plssvm/mpi/communicator.hpp"                   // plssvm::mpi::communicator
-#include "plssvm/mpi/detail/utility.hpp"                 // plssvm::mpi::detail::node_name
-#include "plssvm/mpi/detail/version.hpp"                 // plssvm::mpi::detail::{mpi_library_version, mpi_version}
 #include "plssvm/parameter.hpp"                          // plssvm::parameter
 #include "plssvm/version/git_metadata/git_metadata.hpp"  // plssvm::version::git_metadata::commit_sha1
 #include "plssvm/version/version.hpp"                    // plssvm::version::{version, detail::target_platforms}
 
+#if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/mpi/detail/utility.hpp"  // plssvm::mpi::detail::node_name
+    #include "plssvm/mpi/detail/version.hpp"  // plssvm::mpi::detail::{mpi_library_version, mpi_version}
+#endif
+
 #if defined(PLSSVM_HARDWARE_SAMPLING_ENABLED)
+    #include "plssvm/detail/string_utility.hpp"  // plssvm::detail::replace_all
     #include "plssvm/detail/tracking/utility.hpp"
 
     #include "hws/hardware_sampler.hpp"         // hws::hardware_sampler
     #include "hws/system_hardware_sampler.hpp"  // hws::system_hardware_sampler
     #include "hws/version.hpp"                  // hws::version::version
+    #include <memory>                           // std::unique_ptr
 #endif
 
 #include "cxxopts.hpp"                // CXXOPTS__VERSION_MAJOR, CXXOPTS__VERSION_MINOR, CXXOPTS__VERSION_MINOR
 #include "fast_float/float_common.h"  // FASTFLOAT_VERSION_MAJOR, FASTFLOAT_VERSION_MINOR, FASTFLOAT_VERSION_PATCH
 #include "fmt/base.h"                 // FMT_VERSION
-#include "fmt/chrono.h"               // format std::chrono types
+#include "fmt/chrono.h"               // NOLINT(misc-include-cleaner): false positive, header is used to format std::chrono types
 #include "fmt/format.h"               // fmt::format
 #include "fmt/ranges.h"               // fmt::join
 
 #if __has_include(<unistd.h>)
     #include <unistd.h>  // gethostname, getlogin_r, sysconf, _SC_HOST_NAME_MAX, _SC_LOGIN_NAME_MAX
-    #define PLSSVM_UNISTD_AVAILABLE
+    #define PLSSVM_HAS_POSIX_INCLUDES
 #endif
 
 #if defined(PLSSVM_STDPAR_BACKEND_HAS_GNU_TBB)
@@ -64,18 +68,69 @@
     #endif
 #endif
 
-#include <algorithm>    // std::max
+#include <algorithm>    // std::max, std::find
 #include <chrono>       // std::chrono::steady_clock::time_point
 #include <cstddef>      // std::size_t
 #include <fstream>      // std::ofstream
 #include <iostream>     // std::ios_base::app, std::ostream, std::clog, std::endl
 #include <map>          // std::map
-#include <memory>       // std::unique_ptr
 #include <string>       // std::string
 #include <string_view>  // std::string_view
 #include <utility>      // std::move
 #include <vector>       // std::vector
 
+namespace {
+
+/**
+ * @brief Get the hostname from the current machine. Returns `"not available"` if this is not possible.
+ * @return the hostname of the current machine (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::string get_hostname() {
+#if defined(PLSSVM_HAS_POSIX_INCLUDES)
+    const auto host_name_max = static_cast<std::size_t>(sysconf(_SC_HOST_NAME_MAX));
+    std::string hostname(host_name_max, '\0');
+    if (gethostname(hostname.data(), host_name_max) != 0) {
+        hostname = "not available";
+    }
+    // resize to actual string length (truncate trailing '\0's)
+    if (const auto it = std::find(hostname.cbegin(), hostname.cend(), '\0'); it != hostname.cend()) {
+        hostname.erase(it, hostname.cend());
+    }
+    if (hostname.empty()) {
+        hostname = "not available";
+    }
+    return hostname;
+#else
+    return "not available";
+#endif
+}
+
+/**
+ * @brief Get the username of the current user. Returns `"not available"` if this is not possible.
+ * @return the username of the current user (`[[nodiscard]]`)
+ */
+[[nodiscard]] std::string get_username() {
+#if defined(PLSSVM_HAS_POSIX_INCLUDES)
+    const auto login_name_max = static_cast<std::size_t>(sysconf(_SC_LOGIN_NAME_MAX));
+    std::string username(login_name_max, '\0');
+    if (getlogin_r(username.data(), login_name_max) != 0) {
+        username = "not available";
+    }
+    // resize to actual string length (truncate trailing '\0's)
+    if (const auto it = std::find(username.cbegin(), username.cend(), '\0'); it != username.cend()) {
+        username.erase(it, username.cend());
+    }
+    if (username.empty()) {
+        username = "not available";
+    }
+    return username;
+#else
+    return "not available";
+#endif
+}
+
+}  // namespace
+
 namespace plssvm::detail::tracking {
 
 // Must be explicitly defaulted in the cpp file to prevent linker errors!
@@ -136,7 +191,7 @@ void performance_tracker::add_tracking_entry(const tracking_entry<cmd::parser_tr
         tracking_entries_[entry.entry_category].emplace("classification_type", std::vector<std::string>{ fmt::format("{}", entry.entry_value.classification) });
         tracking_entries_[entry.entry_category].emplace("backend", std::vector<std::string>{ fmt::format("{}", entry.entry_value.backend) });
         tracking_entries_[entry.entry_category].emplace("target", std::vector<std::string>{ fmt::format("{}", entry.entry_value.target) });
-        tracking_entries_[entry.entry_category].emplace("sycl_kernel_invocation_type", std::vector<std::string>{ fmt::format("{}", entry.entry_value.sycl_kernel_invocation_type) });
+        tracking_entries_[entry.entry_category].emplace("sycl_data_parallel_kernel", std::vector<std::string>{ fmt::format("{}", entry.entry_value.sycl_data_parallel_kernel) });
         tracking_entries_[entry.entry_category].emplace("sycl_implementation_type", std::vector<std::string>{ fmt::format("{}", entry.entry_value.sycl_implementation_type) });
         tracking_entries_[entry.entry_category].emplace("kokkos_execution_space", std::vector<std::string>{ fmt::format("{}", entry.entry_value.kokkos_execution_space) });
         tracking_entries_[entry.entry_category].emplace("strings_as_labels", std::vector<std::string>{ fmt::format("{}", entry.entry_value.strings_as_labels) });
@@ -155,6 +210,7 @@ void performance_tracker::add_tracking_entry(const tracking_entry<cmd::parser_pr
         tracking_entries_[entry.entry_category].emplace("task", std::vector<std::string>{ "predict" });
         tracking_entries_[entry.entry_category].emplace("backend", std::vector<std::string>{ fmt::format("{}", entry.entry_value.backend) });
         tracking_entries_[entry.entry_category].emplace("target", std::vector<std::string>{ fmt::format("{}", entry.entry_value.target) });
+        tracking_entries_[entry.entry_category].emplace("sycl_data_parallel_kernel", std::vector<std::string>{ fmt::format("{}", entry.entry_value.sycl_data_parallel_kernel) });
         tracking_entries_[entry.entry_category].emplace("sycl_implementation_type", std::vector<std::string>{ fmt::format("{}", entry.entry_value.sycl_implementation_type) });
         tracking_entries_[entry.entry_category].emplace("kokkos_execution_space", std::vector<std::string>{ fmt::format("{}", entry.entry_value.kokkos_execution_space) });
         tracking_entries_[entry.entry_category].emplace("strings_as_labels", std::vector<std::string>{ fmt::format("{}", entry.entry_value.strings_as_labels) });
@@ -209,7 +265,7 @@ void performance_tracker::add_hws_entry(const hws::system_hardware_sampler &entr
 }
 #endif
 
-void performance_tracker::add_event(const std::string name) {
+void performance_tracker::add_event(std::string name) {
     events_.add_event(std::chrono::steady_clock::now(), std::move(name));
 }
 
@@ -242,27 +298,18 @@ void performance_tracker::save(std::ostream &out) {
     //                                                              meta-data                                                              //
     //*************************************************************************************************************************************//
     // get the current host- and username
-#if defined(PLSSVM_UNISTD_AVAILABLE)
-    const auto host_name_max = static_cast<std::size_t>(sysconf(_SC_HOST_NAME_MAX));
-    std::string hostname(host_name_max, '\0');
-    gethostname(hostname.data(), host_name_max);
-    const auto login_name_max = static_cast<std::size_t>(sysconf(_SC_LOGIN_NAME_MAX));
-    std::string username(login_name_max, '\0');
-    getlogin_r(username.data(), login_name_max);
-#else
-    constexpr std::string_view hostname{ "not available" };
-    constexpr std::string_view username{ "not available" };
-#endif
-    // check whether asserts are enabled
+    const std::string hostname = get_hostname();
+    const std::string username = get_username();
+    // check if asserts are enabled
     constexpr bool assert_enabled = PLSSVM_IS_DEFINED(PLSSVM_ENABLE_ASSERTS);
-    // check whether LTO has been enabled
+    // check if LTO has been enabled
     constexpr bool lto_enabled = PLSSVM_IS_DEFINED(PLSSVM_LTO_SUPPORTED);
-    // check whether fast-math has been enabled
+    // check if fast-math has been enabled
     constexpr bool fast_math_enabled = PLSSVM_IS_DEFINED(PLSSVM_USE_FAST_MATH);
-    // check whether the maximum allocatable memory size should be enforced
+    // check if the maximum allocatable memory size should be enforced
     constexpr bool enforce_max_mem_alloc_size = PLSSVM_IS_DEFINED(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE);
 
-    // begin a new YAML document (only with "---" multiple YAML docments in a single file are allowed)
+    // begin a new YAML document (only with "---" multiple YAML documents in a single file are allowed)
     out << "---\n";
 
     // output metadata information
@@ -270,38 +317,36 @@ void performance_tracker::save(std::ostream &out) {
         "meta_data:\n"
         "  date:                              \"{}\"\n"
         "  PLSSVM_TARGET_PLATFORMS:           \"{}\"\n"
-        "  commit:                            {}\n"
+        "  commit:                            \"{}\"\n"
         "  version:                           {}\n"
-        "  hostname:                          {}\n"
-        "  user:                              {}\n"
-        "  build_type:                        {}\n"
+        "  hostname:                          \"{}\"\n"
+        "  user:                              \"{}\"\n"
+        "  build_type:                        \"{}\"\n"
         "  LTO:                               {}\n"
         "  fast-math:                         {}\n"
         "  asserts:                           {}\n"
         "  enforce_max_mem_alloc_size:        {}\n"
         "  THREAD_BLOCK_SIZE:                 {}\n"
-        "  FEATURE_BLOCK_SIZE:                {}\n"
         "  INTERNAL_BLOCK_SIZE:               {}\n"
         "  PADDING_SIZE:                      {}\n",
         plssvm::detail::current_date_time(),
         version::detail::target_platforms,
         version::git_metadata::commit_sha1().empty() ? "unknown" : version::git_metadata::commit_sha1(),
         version::version,
-        hostname.data(),
-        username.data(),
+        hostname,
+        username,
         PLSSVM_BUILD_TYPE,
         lto_enabled,
         fast_math_enabled,
         assert_enabled,
         enforce_max_mem_alloc_size,
         THREAD_BLOCK_SIZE,
-        FEATURE_BLOCK_SIZE,
         INTERNAL_BLOCK_SIZE,
         PADDING_SIZE);
 
 #if defined(PLSSVM_SYCL_BACKEND_HAS_DPCPP)
     out << fmt::format(
-        "  DPCPP_backend_type:                {}\n",
+        "  DPCPP_backend_type:                \"{}\"\n",
         PLSSVM_SYCL_BACKEND_DPCPP_BACKEND_TYPE);
 #endif
 #if defined(PLSSVM_SYCL_BACKEND_HAS_ADAPTIVECPP)
@@ -363,8 +408,8 @@ void performance_tracker::save(std::ostream &out) {
 
     out << "dependencies:\n";
 
-    // calculate the number of padding whitespaces for the dependencies category
-    std::size_t max_dependency_entry_name_length = 18;  // fast_float_version
+    // calculate the number of padding whitespaces for the "dependencies" category
+    std::size_t max_dependency_entry_name_length = std::string_view{ "fast_float_version" }.size();
     if (detail::contains(tracking_entries_, "dependencies")) {
         for (const auto &[entry_name, entry_value] : tracking_entries_["dependencies"]) {
             max_dependency_entry_name_length = std::max(max_dependency_entry_name_length, entry_name.size());
@@ -393,14 +438,14 @@ void performance_tracker::save(std::ostream &out) {
         "  oneDPL_version: {}\n"
         "  tbb_version: {}\n"
         "  hws_version: {}\n\n",
-        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - 15, cxxopts_version),
-        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - 11, fmt_version),
-        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - 18, fast_float_version),
-        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - 12, igor_version),
-        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - 13, boost_version),
-        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - 14, oneDPL_version),
-        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - 11, tbb_version),
-        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - 11, hws_version));
+        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - std::string_view{ "cxxopts_version" }.size(), cxxopts_version),
+        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - std::string_view{ "fmt_version" }.size(), fmt_version),
+        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - std::string_view{ "fast_float_version" }.size(), fast_float_version),
+        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - std::string_view{ "igor_version" }.size(), igor_version),
+        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - std::string_view{ "boost_version" }.size(), boost_version),
+        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - std::string_view{ "oneDPL_version" }.size(), oneDPL_version),
+        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - std::string_view{ "tbb_version" }.size(), tbb_version),
+        fmt::format("{:<{}}\"{}\"", "", max_dependency_entry_name_length - std::string_view{ "hws_version" }.size(), hws_version));
 
     //*************************************************************************************************************************************//
     //                                                          events, if present                                                         //
@@ -467,4 +512,4 @@ performance_tracker &global_performance_tracker() {
 
 }  // namespace plssvm::detail::tracking
 
-#undef PLSSVM_UNISTD_AVAILABLE
+#undef PLSSVM_HAS_POSIX_INCLUDES
diff --git a/src/plssvm/detail/utility.cpp b/src/plssvm/detail/utility.cpp
index ace6a5f73..7569aa812 100644
--- a/src/plssvm/detail/utility.cpp
+++ b/src/plssvm/detail/utility.cpp
@@ -8,9 +8,13 @@
 
 #include "plssvm/detail/utility.hpp"
 
-#include "plssvm/detail/memory_size.hpp"  // plssvm::detail::memory_size
+#include "plssvm/constants.hpp"                            // plssvm::THREAD_BLOCK_SIZE, plssvm::INTERNAL_BLOCK_SIZE
+#include "plssvm/detail/assert.hpp"                        // PLSSVM_ASSERT
+#include "plssvm/detail/data_distribution.hpp"             // plssvm::detail::data_distribution::maximum_local_memory_needed
+#include "plssvm/detail/memory_size.hpp"                   // plssvm::detail::memory_size, custom memory size literals
+#include "plssvm/detail/tracking/performance_tracker.hpp"  // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY, plssvm::detail::tracking::tracking_entry
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::kernel_launch_resources
 
-#include "fmt/chrono.h"  // fmt::localtime
 #include "fmt/format.h"  // fmt::format
 
 #if __has_include(<unistd.h>)
@@ -21,13 +25,49 @@
     #define PLSSVM_WINDOWS_AVAILABLE_MEMORY
 #endif
 
-#include <ctime>   // std::time
-#include <string>  // std::string
+#if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
+    #include <cstddef>  // std::size_t
+#endif
+
+#include <cstdlib>   // std::getenv
+#include <ctime>     // std::time_t, std::time, std:tm, std::localtime
+#include <optional>  // std::optional, std::make_optional, std::nullopt
+#include <string>    // std::string
+#include <vector>    // std::vector
 
 namespace plssvm::detail {
 
+void check_local_memory_usage(const std::vector<std::optional<memory_size>> &local_memory) {
+    PLSSVM_ASSERT(!local_memory.empty(), "At least one local memory value must be available since at least one place must always be present!");
+
+    // determine the used local memory and check whether it exceeds the maximum necessary value!
+    constexpr detail::memory_size required_local_memory_per_device = detail::data_distribution::maximum_local_memory_needed();
+    for (const std::optional<detail::memory_size> &available_local_memory : local_memory) {
+        if (available_local_memory.has_value() && required_local_memory_per_device > available_local_memory.value()) {
+            // we need more local memory than available -> throw an exception
+            throw kernel_launch_resources{ fmt::format("At least {} of local memory must be available for the hyperparameter combination THREAD_BLOCK_SIZE={} and INTERNAL_BLOCK_SIZE={}, but available are only {}!",
+                                                       required_local_memory_per_device,
+                                                       THREAD_BLOCK_SIZE,
+                                                       INTERNAL_BLOCK_SIZE,
+                                                       available_local_memory.value()) };
+        }
+    }
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "resource_constraints", "needed_local_memory", required_local_memory_per_device }));
+#if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
+    using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
+    // post-process the local_memory vector for a better performance tracker output
+    std::vector<memory_size> processed_local_memory(local_memory.size());
+    for (std::size_t i = 0; i < processed_local_memory.size(); ++i) {
+        processed_local_memory[i] = local_memory[i].value_or(0_B);
+    }
+    PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((detail::tracking::tracking_entry{ "resource_constraints", "available_local_memory_per_place", processed_local_memory }));
+#endif
+}
+
 std::string current_date_time() {
-    return fmt::format("{:%Y-%m-%d %H:%M:%S}", fmt::localtime(std::time(nullptr)));
+    const std::time_t t = std::time(nullptr);
+    const std::tm tm = *std::localtime(&t);
+    return fmt::format("{:%Y-%m-%d %H:%M:%S}", tm);
 }
 
 memory_size get_system_memory() {
@@ -45,6 +85,13 @@ memory_size get_system_memory() {
 #endif
 }
 
+std::optional<std::string> get_env_variable(const std::string &env_variable) {
+    if (const char *env_value = std::getenv(env_variable.c_str()); env_value != nullptr) {
+        return std::make_optional(env_value);
+    }
+    return std::nullopt;
+}
+
 #undef PLSSVM_UNIX_AVAILABLE_MEMORY
 #undef PLSSVM_WINDOWS_AVAILABLE_MEMORY
 
diff --git a/src/plssvm/exceptions/source_location.cpp b/src/plssvm/exceptions/source_location.cpp
index 5b75dba27..d8e63aaec 100644
--- a/src/plssvm/exceptions/source_location.cpp
+++ b/src/plssvm/exceptions/source_location.cpp
@@ -8,13 +8,16 @@
 
 #include "plssvm/exceptions/source_location.hpp"
 
+#include "plssvm/exceptions/exceptions.hpp"  // plssvm::mpi_exception
+#include "plssvm/mpi/environment.hpp"        // plssvm::mpi::is_active
+
 #if defined(PLSSVM_HAS_MPI_ENABLED)
     #include "mpi.h"  // MPI_Comm_rank, MPI_COMM_WORLD
+
+    #include <optional>  // std::make_optional
 #endif
-#include "plssvm/mpi/environment.hpp"  // plssvm::mpi::is_active
 
-#include <cstdint>   // std::uint_least32_t
-#include <optional>  // std::make_optional
+#include <cstdint>  // std::uint_least32_t
 
 namespace plssvm {
 
@@ -31,13 +34,14 @@ source_location source_location::current(const char *file_name, const char *func
         if (mpi::is_active()) {
             // prevent excessive mpi::communicator constructor calls
 #if defined(PLSSVM_HAS_MPI_ENABLED)
-            int rank;
+            int rank{};
             MPI_Comm_rank(MPI_COMM_WORLD, &rank);
             loc.world_rank_ = std::make_optional(rank);
 #endif
         }
-    } catch (...) {
-        // std::nullopt
+    } catch (const plssvm::mpi_exception &) {
+        // no MPI information available
+        loc.world_rank_ = std::nullopt;
     }
 
     return loc;
diff --git a/src/plssvm/gamma.cpp b/src/plssvm/gamma.cpp
index 0834d1736..539b2bc39 100644
--- a/src/plssvm/gamma.cpp
+++ b/src/plssvm/gamma.cpp
@@ -10,7 +10,7 @@
 
 #include "plssvm/constants.hpp"              // plssvm::real_type
 #include "plssvm/detail/string_utility.hpp"  // plssvm::detail::to_lower_case
-#include "plssvm/exceptions/exceptions.hpp"  // plssvm::exception
+#include "plssvm/detail/utility.hpp"         // plssvm::detail::overloaded
 
 #include "fmt/format.h"  // fmt::format
 
diff --git a/src/plssvm/kernel_function_types.cpp b/src/plssvm/kernel_function_types.cpp
index 266919526..5d9513034 100644
--- a/src/plssvm/kernel_function_types.cpp
+++ b/src/plssvm/kernel_function_types.cpp
@@ -10,8 +10,6 @@
 
 #include "plssvm/detail/string_utility.hpp"  // plssvm::detail::to_lower_case
 
-#include "fmt/format.h"  // fmt::format
-
 #include <ios>          // std::ios::failbit
 #include <istream>      // std::istream
 #include <ostream>      // std::ostream
diff --git a/src/plssvm/mpi/communicator.cpp b/src/plssvm/mpi/communicator.cpp
index d1f92addb..9904a8d10 100644
--- a/src/plssvm/mpi/communicator.cpp
+++ b/src/plssvm/mpi/communicator.cpp
@@ -8,25 +8,30 @@
 
 #include "plssvm/mpi/communicator.hpp"
 
-#include "plssvm/detail/assert.hpp"            // PLSSVM_ASSERT
-#include "plssvm/exceptions/exceptions.hpp"    // plssvm::mpi_exception
-#include "plssvm/mpi/detail/mpi_datatype.hpp"  // plssvm::mpi::detail::mpi_datatype
-#include "plssvm/mpi/detail/utility.hpp"       // PLSSVM_MPI_ERROR_CHECK
+#include "plssvm/exceptions/exceptions.hpp"  // plssvm::mpi_exception
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/mpi/detail/mpi_datatype.hpp"  // plssvm::mpi::detail::mpi_datatype
+    #include "plssvm/mpi/detail/utility.hpp"       // PLSSVM_MPI_ERROR_CHECK
+
     #include "mpi.h"  // MPI_Comm, MPI_Comm_size, MPI_Comm_rank, MPI_Barrier, MPI_Gatherv, MPI_Gather, MPI_Bcast, MPI_Comm_compare, MPI_IDENT
+
+    #include <algorithm>  // std::transform
+    #include <cstdint>    // std::int64_t
+#endif
+
+#if defined(PLSSVM_ENABLE_ASSERTS) && defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/detail/assert.hpp"  // PLSSVM_ASSERT
 #endif
 
 #include "fmt/format.h"  // fmt::format
 
-#include <algorithm>  // std::transform
-#include <chrono>     // std::chrono::milliseconds
-#include <cstddef>    // std::size_t
-#include <cstdint>    // std::int64_t
-#include <optional>   // std::optional, std::nullopt
-#include <string>     // std::string
-#include <utility>    // std::move
-#include <vector>     // std::vector
+#include <chrono>    // std::chrono::milliseconds
+#include <cstddef>   // std::size_t
+#include <optional>  // std::optional, std::nullopt
+#include <string>    // std::string
+#include <utility>   // std::move
+#include <vector>    // std::vector
 
 namespace plssvm::mpi {
 
@@ -154,7 +159,7 @@ const std::optional<std::vector<std::size_t>> &communicator::get_load_balancing_
     PLSSVM_ASSERT(and_result == or_result, "Some MPI ranks have load balancing weights and some don't!");
 
     // if all MPI ranks have load balancing weights, check that they are the same
-    if (and_result) {
+    if (and_result && load_balancing_weights_.has_value()) {
         // check that the balancing weights are the same for all MPI ranks
         std::vector<std::size_t> reference_weights(load_balancing_weights_->size());
         if (this->is_main_rank()) {
diff --git a/src/plssvm/mpi/detail/information.cpp b/src/plssvm/mpi/detail/information.cpp
index 3e30cdb70..9e79f2ac4 100644
--- a/src/plssvm/mpi/detail/information.cpp
+++ b/src/plssvm/mpi/detail/information.cpp
@@ -67,6 +67,7 @@ void gather_and_print_csvm_information(const communicator &comm, backend_type ra
     }
     // assemble one device name string
     std::vector<std::string> rank_str{};
+    rank_str.reserve(devices_for_rank.size());
     for (const auto &[device, count] : devices_for_rank) {
         rank_str.emplace_back(fmt::format("{}x {}", count, device));
     }
diff --git a/src/plssvm/mpi/detail/utility.cpp b/src/plssvm/mpi/detail/utility.cpp
index d61991d76..fb30a557e 100644
--- a/src/plssvm/mpi/detail/utility.cpp
+++ b/src/plssvm/mpi/detail/utility.cpp
@@ -8,12 +8,11 @@
 
 #include "plssvm/mpi/detail/utility.hpp"
 
-#include "plssvm/exceptions/exceptions.hpp"  // plssvm::mpi_exception
-
-#include "fmt/format.h"  // fmt::format
-
 #if defined(PLSSVM_HAS_MPI_ENABLED)
-    #include "mpi.h"  // MPI_Get_processor_name
+    #include "plssvm/exceptions/exceptions.hpp"  // plssvm::mpi_exception
+
+    #include "fmt/format.h"  // fmt::format
+    #include "mpi.h"         // MPI_Get_processor_name
 #endif
 
 #include <string>  // std::string
@@ -28,9 +27,8 @@ void mpi_error_check([[maybe_unused]] const int err) {
         const int res = MPI_Error_string(err, err_str.data(), &err_str_len);
         if (res == MPI_SUCCESS) {
             throw plssvm::mpi_exception{ fmt::format("MPI error {}: {}", err, err_str.substr(0, err_str.find_first_of('\0'))) };
-        } else {
-            throw plssvm::mpi_exception{ fmt::format("MPI error {}", err) };
         }
+        throw plssvm::mpi_exception{ fmt::format("MPI error {}", err) };
     }
 #endif
 }
@@ -38,8 +36,8 @@ void mpi_error_check([[maybe_unused]] const int err) {
 std::string node_name() {
 #if defined(PLSSVM_HAS_MPI_ENABLED)
     std::string name(MPI_MAX_PROCESSOR_NAME, '\0');
-    int resultlen{};
-    PLSSVM_MPI_ERROR_CHECK(MPI_Get_processor_name(name.data(), &resultlen));
+    int result_len{};
+    PLSSVM_MPI_ERROR_CHECK(MPI_Get_processor_name(name.data(), &result_len));
     return name.substr(0, name.find_first_of('\0'));
 #else
     return std::string{ "unknown/unused" };
diff --git a/src/plssvm/mpi/detail/version.cpp b/src/plssvm/mpi/detail/version.cpp
index 3e9cb0124..bd62a4f74 100644
--- a/src/plssvm/mpi/detail/version.cpp
+++ b/src/plssvm/mpi/detail/version.cpp
@@ -8,13 +8,12 @@
 
 #include "plssvm/mpi/detail/version.hpp"
 
-#include "plssvm/mpi/detail/utility.hpp"  // PLSSVM_MPI_ERROR_CHECK
-
 #if defined(PLSSVM_HAS_MPI_ENABLED)
-    #include "mpi.h"  // MPI_Get_library_version, MPI_Get_version
-#endif
+    #include "plssvm/mpi/detail/utility.hpp"  // PLSSVM_MPI_ERROR_CHECK
 
-#include "fmt/format.h"  // fmt::format
+    #include "fmt/format.h"  // fmt::format
+    #include "mpi.h"         // MPI_Get_library_version, MPI_Get_version
+#endif
 
 #include <string>  // std::string
 
@@ -23,8 +22,8 @@ namespace plssvm::mpi::detail {
 std::string mpi_library_version() {
 #if defined(PLSSVM_HAS_MPI_ENABLED)
     std::string version(MPI_MAX_LIBRARY_VERSION_STRING, '\0');
-    int resultlen{};
-    PLSSVM_MPI_ERROR_CHECK(MPI_Get_library_version(version.data(), &resultlen));
+    int result_len{};
+    PLSSVM_MPI_ERROR_CHECK(MPI_Get_library_version(version.data(), &result_len));
     return version.substr(0, version.find_first_of('\0'));
 #else
     return std::string{ "unknown/unused" };
diff --git a/src/plssvm/mpi/environment.cpp b/src/plssvm/mpi/environment.cpp
index 205d22f2a..5cc41d159 100644
--- a/src/plssvm/mpi/environment.cpp
+++ b/src/plssvm/mpi/environment.cpp
@@ -8,13 +8,12 @@
 
 #include "plssvm/mpi/environment.hpp"
 
-#include "plssvm/exceptions/exceptions.hpp"  // plssvm::mpi_exception
-#include "plssvm/mpi/detail/utility.hpp"     // PLSSVM_MPI_ERROR_CHECK
-
-#include "fmt/format.h"  // fmt::format
-
 #if defined(PLSSVM_HAS_MPI_ENABLED)
-    #include "mpi.h"  // MPI_THREAD_FUNNELED, MPI_Init_thread, MPI_Finalize, MPI_Initialized, MPI_Finalized
+    #include "plssvm/exceptions/exceptions.hpp"  // plssvm::mpi_exception
+    #include "plssvm/mpi/detail/utility.hpp"     // PLSSVM_MPI_ERROR_CHECK
+
+    #include "fmt/format.h"  // fmt::format
+    #include "mpi.h"         // MPI_THREAD_FUNNELED, MPI_Init_thread, MPI_Finalize, MPI_Initialized, MPI_Finalized
 #endif
 
 #include <cstdlib>  // EXIT_FAILURE, std::getenv, std::abort
diff --git a/src/plssvm/svm/csvm.cpp b/src/plssvm/svm/csvm.cpp
index 3f750e088..b5f126f38 100644
--- a/src/plssvm/svm/csvm.cpp
+++ b/src/plssvm/svm/csvm.cpp
@@ -8,14 +8,13 @@
 
 #include "plssvm/svm/csvm.hpp"
 
-#include "plssvm/constants.hpp"                            // plssvm::real_type, plssvm::PADDING_SIZE
+#include "plssvm/constants.hpp"                            // plssvm::real_type, plssvm::PADDING_SIZE, plssvm::NUM_ITER_BEFORE_EXPLICIT_CG_RESIDUAL_RECALCULATION
 #include "plssvm/detail/assert.hpp"                        // PLSSVM_ASSERT
 #include "plssvm/detail/logging/mpi_log.hpp"               // plssvm::detail::log
 #include "plssvm/detail/logging/mpi_log_untracked.hpp"     // plssvm::detail::log_untracked
 #include "plssvm/detail/move_only_any.hpp"                 // plssvm::detail::move_only_any
-#include "plssvm/detail/operators.hpp"                     // plssvm operator overloads for vectors
+#include "plssvm/detail/operators.hpp"                     // operator overloads for std::vector (+ scalars)
 #include "plssvm/detail/tracking/performance_tracker.hpp"  // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT, plssvm::detail::tracking::tracking_entry
-#include "plssvm/gamma.hpp"                                // plssvm::gamma_type
 #include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
 #include "plssvm/kernel_functions.hpp"                     // plssvm::kernel_function
 #include "plssvm/matrix.hpp"                               // plssvm::soa_matrix
@@ -24,22 +23,21 @@
 #include "plssvm/solver_types.hpp"                         // plssvm::solver_type
 #include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity_level
 
-#include "fmt/format.h"  // fmt::format
+#if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
+    #include "fmt/format.h"  // fmt::format
+#endif
 
-#include <algorithm>   // std::count
-#include <chrono>      // std::chrono::{steady_clock, duration_cast, milliseconds}
-#include <cstddef>     // std::size_t
-#include <functional>  // std::plus
-#include <numeric>     // std::inner_product
-#include <utility>     // std::move
-#include <utility>     // std::pair, std::make_pair
-#include <variant>     // std::get
-#include <vector>      // std::vector
+#include <algorithm>  // std::count
+#include <chrono>     // std::chrono::{steady_clock, duration_cast, milliseconds}
+#include <cstddef>    // std::size_t
+#include <ratio>      // std::milli
+#include <utility>    // std::move, std::pair, std::make_pair, std::get
+#include <vector>     // std::vector
 
 namespace plssvm {
 
 std::pair<soa_matrix<real_type>, std::vector<unsigned long long>> csvm::conjugate_gradients(const std::vector<detail::move_only_any> &A, const soa_matrix<real_type> &B, const real_type eps, const unsigned long long max_cg_iter, const solver_type cg_solver) const {
-    using namespace plssvm::operators;
+    using namespace plssvm::operators;  // NOLINT(google-build-using-namespace): only imports custom math operations on vectors (and scalars)
 
     PLSSVM_ASSERT(!B.empty(), "The right-hand sides must not be empty!");
     PLSSVM_ASSERT(eps > real_type{ 0.0 }, "The epsilon value must be greater than 0.0!");
@@ -155,7 +153,7 @@ std::pair<soa_matrix<real_type>, std::vector<unsigned long long>> csvm::conjugat
         // X = X + alpha * D
         X += masked_rowwise_scale(mask, alpha, D);
 
-        if (iter % 50 == 49) {
+        if (iter % NUM_ITER_BEFORE_EXPLICIT_CG_RESIDUAL_RECALCULATION == NUM_ITER_BEFORE_EXPLICIT_CG_RESIDUAL_RECALCULATION - 1) {
             // explicitly recalculate residual to remove accumulating floating point errors
             // R = B - A * X
             R = soa_matrix<real_type>{ B, shape{ PADDING_SIZE, PADDING_SIZE } };
diff --git a/src/plssvm/svm_types.cpp b/src/plssvm/svm_types.cpp
index b2104033e..6d9207696 100644
--- a/src/plssvm/svm_types.cpp
+++ b/src/plssvm/svm_types.cpp
@@ -73,7 +73,8 @@ svm_type svm_type_from_model_file(const std::string &filename) {
             svm_type svm{};
             iss >> svm;
             return svm;
-        } else if (detail::starts_with(line, "sv")) {
+        }
+        if (detail::starts_with(line, "sv")) {
             // read the last line of the header section but didn't find the SVM type yet -> throw an exception
             throw invalid_file_format_exception{ R"(The provided model file is not a valid LIBSVM model file since "svm_type" is missing!)" };
         }
diff --git a/src/plssvm/target_platforms.cpp b/src/plssvm/target_platforms.cpp
index 8fc47e223..3b2b664e7 100644
--- a/src/plssvm/target_platforms.cpp
+++ b/src/plssvm/target_platforms.cpp
@@ -45,9 +45,11 @@ target_platform determine_default_target_platform(const std::vector<target_platf
     // check for devices in order gpu_nvidia -> gpu_amd -> gpu_intel -> cpu
     if (detail::contains(platform_device_list, target_platform::gpu_nvidia)) {
         return target_platform::gpu_nvidia;
-    } else if (detail::contains(platform_device_list, target_platform::gpu_amd)) {
+    }
+    if (detail::contains(platform_device_list, target_platform::gpu_amd)) {
         return target_platform::gpu_amd;
-    } else if (detail::contains(platform_device_list, target_platform::gpu_intel)) {
+    }
+    if (detail::contains(platform_device_list, target_platform::gpu_intel)) {
         return target_platform::gpu_intel;
     }
     return target_platform::cpu;
diff --git a/src/plssvm/verbosity_levels.cpp b/src/plssvm/verbosity_levels.cpp
index d22ab3962..30c18d292 100644
--- a/src/plssvm/verbosity_levels.cpp
+++ b/src/plssvm/verbosity_levels.cpp
@@ -23,7 +23,7 @@
 
 namespace plssvm {
 
-verbosity_level verbosity = verbosity_level::full;
+verbosity_level verbosity = verbosity_level::full;  // NOLINT: variable must be global or too many interfaces would change
 
 std::ostream &operator<<(std::ostream &out, const verbosity_level verb) {
     if (verb == verbosity_level::quiet) {
@@ -48,9 +48,8 @@ std::ostream &operator<<(std::ostream &out, const verbosity_level verb) {
 
     if (level_names.empty()) {
         return out << "unknown";
-    } else {
-        return out << fmt::format("{}", fmt::join(level_names, " | "));
     }
+    return out << fmt::format("{}", fmt::join(level_names, " | "));
 }
 
 std::istream &operator>>(std::istream &in, verbosity_level &verb) {
@@ -85,7 +84,7 @@ std::istream &operator>>(std::istream &in, verbosity_level &verb) {
 }
 
 verbosity_level operator|(const verbosity_level lhs, const verbosity_level rhs) {
-    return static_cast<verbosity_level>(detail::to_underlying(lhs) | detail::to_underlying(rhs));
+    return static_cast<verbosity_level>(detail::to_underlying(lhs) | detail::to_underlying(rhs));  // NOLINT: allow combination of different enum values
 }
 
 verbosity_level operator|=(verbosity_level &lhs, const verbosity_level rhs) {
@@ -94,7 +93,7 @@ verbosity_level operator|=(verbosity_level &lhs, const verbosity_level rhs) {
 }
 
 verbosity_level operator&(const verbosity_level lhs, const verbosity_level rhs) {
-    return static_cast<verbosity_level>(detail::to_underlying(lhs) & detail::to_underlying(rhs));
+    return static_cast<verbosity_level>(detail::to_underlying(lhs) & detail::to_underlying(rhs));  // NOLINT: allow combination of different enum values
 }
 
 verbosity_level operator&=(verbosity_level &lhs, const verbosity_level rhs) {
diff --git a/src/plssvm/version/version.cpp b/src/plssvm/version/version.cpp
index 031a21629..89225b2b8 100644
--- a/src/plssvm/version/version.cpp
+++ b/src/plssvm/version/version.cpp
@@ -33,10 +33,9 @@ std::optional<std::string> get_git_info() {
         std::string_view date = git_metadata::commit_date();
         date.remove_suffix(date.size() - date.find_last_of(' '));
         return std::make_optional(fmt::format("({} {} {} ({}))", git_metadata::remote_url(), git_metadata::branch(), git_metadata::commit_sha1(), date));
-    } else {
-        // no git information available
-        return std::nullopt;
     }
+    // no git information available
+    return std::nullopt;
 }
 
 std::string get_version_info(const std::string_view executable_name, const bool with_backend_info) {
diff --git a/tests/.clang-tidy b/tests/.clang-tidy
new file mode 100644
index 000000000..7a803f6d5
--- /dev/null
+++ b/tests/.clang-tidy
@@ -0,0 +1,8 @@
+---
+Checks: '
+-cppcoreguidelines-avoid-magic-numbers,
+
+-readability-magic-numbers,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index e7be2758e..549432496 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -39,6 +39,9 @@ else ()
         QUIET
     )
     FetchContent_MakeAvailable(googletest)
+    set_target_properties(gtest PROPERTIES CXX_CLANG_TIDY "")
+    set_target_properties(gtest_main PROPERTIES CXX_CLANG_TIDY "")
+    set_target_properties(gmock PROPERTIES CXX_CLANG_TIDY "")
     # For Windows: Prevent overriding the parent project's compiler/linker settings
     set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_OLD}")
@@ -162,10 +165,10 @@ set(PLSSVM_BASE_TEST_SOURCES
     ${CMAKE_CURRENT_LIST_DIR}/backends/execution_range.cpp
     # since the Kokkos execution_space enumeration is used even if no Kokkos backend is available this is also tested in the base library
     ${CMAKE_CURRENT_LIST_DIR}/backends/Kokkos/execution_space.cpp
-    # since the SYCL implementation_type and kernel_invocation_type enumerations are used even if no SYCL backend is available these are also tested in the base
+    # since the SYCL implementation_type and data_parallel_kernel enumerations are used even if no SYCL backend is available these are also tested in the base
     # library
+    ${CMAKE_CURRENT_LIST_DIR}/backends/SYCL/data_parallel_kernels.cpp
     ${CMAKE_CURRENT_LIST_DIR}/backends/SYCL/implementation_types.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/backends/SYCL/kernel_invocation_types.cpp
     # since the stdpar implementation_type enumeration is used even if no stdpar backend is available this is also tested in the base library
     ${CMAKE_CURRENT_LIST_DIR}/backends/stdpar/implementation_types.cpp
     ${CMAKE_CURRENT_LIST_DIR}/data_set/classification/constructors.cpp
@@ -215,6 +218,10 @@ set(PLSSVM_BASE_TEST_SOURCES
     ${CMAKE_CURRENT_LIST_DIR}/detail/utility.cpp
     ${CMAKE_CURRENT_LIST_DIR}/exceptions/exceptions.cpp
     ${CMAKE_CURRENT_LIST_DIR}/exceptions/source_location.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/matrix/constructors.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/matrix/layout_type.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/matrix/member_and_free_functions.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/matrix/operators.cpp
     ${CMAKE_CURRENT_LIST_DIR}/model/classification_model.cpp
     ${CMAKE_CURRENT_LIST_DIR}/model/regression_model.cpp
     ${CMAKE_CURRENT_LIST_DIR}/mpi/detail/information.cpp
@@ -238,7 +245,6 @@ set(PLSSVM_BASE_TEST_SOURCES
     ${CMAKE_CURRENT_LIST_DIR}/gamma.cpp
     ${CMAKE_CURRENT_LIST_DIR}/kernel_function_types.cpp
     ${CMAKE_CURRENT_LIST_DIR}/kernel_functions.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/matrix.cpp
     ${CMAKE_CURRENT_LIST_DIR}/parameter.cpp
     ${CMAKE_CURRENT_LIST_DIR}/regression_report.cpp
     ${CMAKE_CURRENT_LIST_DIR}/shape.cpp
@@ -267,47 +273,52 @@ else ()
     set(PLSSVM_ENABLE_DEATH_TESTS OFF)
 endif ()
 
+# This define is used such that the environment header does not include <hpx/hpx_main.hpp> which would result in a linker error when tests are enabled. Without
+# the <hpx/hpx_main.hpp> include, HPX's short command line arguments can be used which doesn't matter in the tests. This is necessary for the HPX backend and
+# Kokkos backend using the HPX execution space, but it doesn't hurt to always set the env variable here.
+target_compile_definitions(${PLSSVM_BASE_TEST_LIBRARY_NAME} PUBLIC PLSSVM_HPX_DO_NOT_INCLUDE_HPX_MAIN)
+
 # add tests to google test
 include(GoogleTest)
 include(${PROJECT_SOURCE_DIR}/cmake/discover_tests_with_death_test_filter.cmake)
 discover_tests_with_death_test_filter(${PLSSVM_BASE_TEST_NAME})
 
 # add test for help messages
-add_test(NAME MainTrain/executable_help COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} --help)
-add_test(NAME MainPredict/executable_help COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} --help)
-add_test(NAME MainScale/executable_help COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} --help)
+add_test(NAME MainTrain/ExecutableHelp COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} --help)
+add_test(NAME MainPredict/ExecutableHelp COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} --help)
+add_test(NAME MainScale/ExecutableHelp COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} --help)
 
 # add test for version messages
-add_test(NAME MainTrain/executable_version COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} --version)
-add_test(NAME MainPredict/executable_version COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} --version)
-add_test(NAME MainScale/executable_version COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} --version)
+add_test(NAME MainTrain/ExecutableVersion COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} --version)
+add_test(NAME MainPredict/ExecutableVersion COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} --version)
+add_test(NAME MainScale/ExecutableVersion COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} --version)
 
 # add minimal run test for scaling
-add_test(NAME MainScale/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} "${PLSSVM_CLASSIFICATION_TEST_FILE}"
-                                                   "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.scaled"
+add_test(NAME MainScale/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} "${PLSSVM_CLASSIFICATION_TEST_FILE}"
+                                                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.scaled"
 )
-add_test(NAME MainScale/executable_minimal_cmd_output COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} "${PLSSVM_CLASSIFICATION_TEST_FILE}")
-add_test(NAME MainScale/executable_save_scaling_factors
+add_test(NAME MainScale/ExecutableMinimalCmdOutput COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} "${PLSSVM_CLASSIFICATION_TEST_FILE}")
+add_test(NAME MainScale/ExecutableSaveScalingFactors
          COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} -s "${CMAKE_CURRENT_BINARY_DIR}/scaling_parameter.txt" # the file the scaling parameters are saved to
                  "${PLSSVM_CLASSIFICATION_TEST_FILE}" # the file to scale
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.scaled" # the scaled file (result)
 )
 
 # add minimal run test for the classification task
-add_test(NAME MainTrainClassification/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -i 10 "${PLSSVM_CLASSIFICATION_TEST_FILE}"
-                                                                 "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
+add_test(NAME MainTrainClassification/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -i 10 "${PLSSVM_CLASSIFICATION_TEST_FILE}"
+                                                                "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
 )
-add_test(NAME MainPredictClassification/executable_minimal
+add_test(NAME MainPredictClassification/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} "${CMAKE_CURRENT_LIST_DIR}/data/libsvm/classification/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/data/model/classification/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.predict" # predict file (result)
 )
 
 # add minimal run test for the regression task
-add_test(NAME MainTrainRegression/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -i 10 "${PLSSVM_REGRESSION_TEST_FILE}"
-                                                             "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
+add_test(NAME MainTrainRegression/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -i 10 "${PLSSVM_REGRESSION_TEST_FILE}"
+                                                            "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
 )
-add_test(NAME MainPredictRegression/executable_minimal
+add_test(NAME MainPredictRegression/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} "${CMAKE_CURRENT_LIST_DIR}/data/libsvm/regression/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/data/model/regression/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.predict" # predict file (result)
@@ -315,12 +326,12 @@ add_test(NAME MainPredictRegression/executable_minimal
 
 # if performance tracking is enabled, also add minimal run tests
 if (PLSSVM_ENABLE_PERFORMANCE_TRACKING)
-    add_test(NAME MainTrainPerformanceTracking/executable_minimal
+    add_test(NAME MainTrainPerformanceTracking/ExecutableMinimal
              COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 --performance_tracking "${CMAKE_CURRENT_BINARY_DIR}/track.yaml" "${PLSSVM_CLASSIFICATION_TEST_FILE}"
                      "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
     )
     add_test(
-        NAME MainPredictPerformanceTracking/executable_minimal
+        NAME MainPredictPerformanceTracking/ExecutableMinimal
         COMMAND
             ${PLSSVM_EXECUTABLE_PREDICT_NAME} --performance_tracking "${CMAKE_CURRENT_BINARY_DIR}/track.yaml"
             "${CMAKE_CURRENT_LIST_DIR}/data/libsvm/classification/5x4.libsvm" # test file
@@ -330,12 +341,12 @@ if (PLSSVM_ENABLE_PERFORMANCE_TRACKING)
 endif ()
 
 # add failing test (must return with a non-zero exit code)
-add_test(NAME MainTrain/executable_fail COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} " ")
-set_tests_properties(MainTrain/executable_fail PROPERTIES WILL_FAIL TRUE)
-add_test(NAME MainPredict/executable_fail COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} " " " ")
-set_tests_properties(MainPredict/executable_fail PROPERTIES WILL_FAIL TRUE)
-add_test(NAME MainScale/executable_fail COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} " ")
-set_tests_properties(MainScale/executable_fail PROPERTIES WILL_FAIL TRUE)
+add_test(NAME MainTrain/ExecutableFail COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} " ")
+set_tests_properties(MainTrain/ExecutableFail PROPERTIES WILL_FAIL TRUE)
+add_test(NAME MainPredict/ExecutableFail COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} " " " ")
+set_tests_properties(MainPredict/ExecutableFail PROPERTIES WILL_FAIL TRUE)
+add_test(NAME MainScale/ExecutableFail COMMAND ${PLSSVM_EXECUTABLE_SCALE_NAME} " ")
+set_tests_properties(MainScale/ExecutableFail PROPERTIES WILL_FAIL TRUE)
 
 # add test as coverage dependency
 if (TARGET coverage)
diff --git a/tests/backend_types.cpp b/tests/backend_types.cpp
index 8a735a26b..a6d6764e8 100644
--- a/tests/backend_types.cpp
+++ b/tests/backend_types.cpp
@@ -11,7 +11,7 @@
 
 #include "plssvm/backend_types.hpp"
 
-#include "plssvm/backends/SYCL/detail/constants.hpp"      // namespace plssvm::sycl
+#include "plssvm/backends/SYCL/detail/constants.hpp"      // NOLINT: namespace plssvm::sycl
 #include "plssvm/backends/SYCL/implementation_types.hpp"  // plssvm::sycl::implementation_type
 #include "plssvm/exceptions/exceptions.hpp"               // plssvm::unsupported_backend_exception
 #include "plssvm/target_platforms.hpp"                    // plssvm::target_platform
@@ -30,7 +30,7 @@
 #include <vector>   // std::vector
 
 // check whether the plssvm::backend_type -> std::string conversions are correct
-TEST(BackendType, to_string) {
+TEST(BackendType, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::backend_type::automatic, "automatic");
     EXPECT_CONVERSION_TO_STRING(plssvm::backend_type::openmp, "openmp");
@@ -43,13 +43,13 @@ TEST(BackendType, to_string) {
     EXPECT_CONVERSION_TO_STRING(plssvm::backend_type::kokkos, "kokkos");
 }
 
-TEST(BackendType, to_string_unknown) {
+TEST(BackendType, ToStringUnknown) {
     // check conversions to std::string from unknown backend_type
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::backend_type>(9), "unknown");
 }
 
 // check whether the std::string -> plssvm::backend_type conversions are correct
-TEST(BackendType, from_string) {
+TEST(BackendType, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("automatic", plssvm::backend_type::automatic);
     EXPECT_CONVERSION_FROM_STRING("AUTOmatic", plssvm::backend_type::automatic);
@@ -73,7 +73,7 @@ TEST(BackendType, from_string) {
     EXPECT_CONVERSION_FROM_STRING("KOKKOS", plssvm::backend_type::kokkos);
 }
 
-TEST(BackendType, from_string_unknown) {
+TEST(BackendType, FromStringUnknown) {
     // foo isn't a valid backend_type
     std::istringstream input{ "foo" };
     plssvm::backend_type backend{};
@@ -81,7 +81,7 @@ TEST(BackendType, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(BackendType, minimal_available_backend) {
+TEST(BackendType, MinimalAvailableBackend) {
     const std::vector<plssvm::backend_type> backends = plssvm::list_available_backends();
 
     // at least two backends must be available (automatic + one user provided)!
@@ -91,7 +91,7 @@ TEST(BackendType, minimal_available_backend) {
     EXPECT_THAT(backends, ::testing::Contains(plssvm::backend_type::automatic));
 }
 
-TEST(BackendType, determine_default_backend_type) {
+TEST(BackendType, DetermineDefaultBackendType) {
     // the determined default backend must not be backend_type::automatic
     const plssvm::backend_type backend = plssvm::determine_default_backend();
     EXPECT_NE(backend, plssvm::backend_type::automatic);
@@ -101,7 +101,7 @@ using unsupported_combination_type = std::pair<std::vector<plssvm::backend_type>
 
 class BackendTypeUnsupportedCombination : public ::testing::TestWithParam<unsupported_combination_type> { };
 
-TEST_P(BackendTypeUnsupportedCombination, unsupported_backend_target_platform_combinations) {
+TEST_P(BackendTypeUnsupportedCombination, UnsupportedBackendTargetPlatformCombinations) {
     const auto &[available_backends, available_target_platforms] = GetParam();
     EXPECT_THROW_WHAT(std::ignore = plssvm::determine_default_backend(available_backends, available_target_platforms),
                       plssvm::unsupported_backend_exception,
@@ -122,7 +122,7 @@ using supported_combination_type = std::tuple<std::vector<plssvm::backend_type>,
 
 class BackendTypeSupportedCombination : public ::testing::TestWithParam<supported_combination_type> { };
 
-TEST_P(BackendTypeSupportedCombination, supported_backend_target_platform_combinations) {
+TEST_P(BackendTypeSupportedCombination, SupportedBackendTargetPlatformCombinations) {
     const auto &[available_backends, available_target_platforms, result_backend] = GetParam();
     EXPECT_EQ(plssvm::determine_default_backend(available_backends, available_target_platforms), result_backend);
 }
@@ -144,7 +144,7 @@ INSTANTIATE_TEST_SUITE_P(BackendType, BackendTypeSupportedCombination, ::testing
          naming::pretty_print_supported_backend_combination<BackendTypeSupportedCombination>);
 // clang-format on
 
-TEST(BackendType, csvm_to_backend_type) {
+TEST(BackendType, CsvmToBackendType) {
     // test the type_trait
     EXPECT_EQ(plssvm::csvm_to_backend_type<plssvm::openmp::csvm>::value, plssvm::backend_type::openmp);
     EXPECT_EQ(plssvm::csvm_to_backend_type<plssvm::hpx::csvm>::value, plssvm::backend_type::hpx);
@@ -161,7 +161,7 @@ TEST(BackendType, csvm_to_backend_type) {
     EXPECT_EQ(plssvm::csvm_to_backend_type<plssvm::dpcpp::csvm>::impl, plssvm::sycl::implementation_type::dpcpp);
 }
 
-TEST(BackendType, csvm_to_backend_type_v) {
+TEST(BackendType, CsvmToBackendTypeV) {
     // test the type_trait
     EXPECT_EQ(plssvm::csvm_to_backend_type_v<plssvm::openmp::csvm>, plssvm::backend_type::openmp);
     EXPECT_EQ(plssvm::csvm_to_backend_type_v<plssvm::hpx::csvm>, plssvm::backend_type::hpx);
diff --git a/tests/backends/CUDA/CMakeLists.txt b/tests/backends/CUDA/CMakeLists.txt
index ee4dcea66..c12fbfad2 100644
--- a/tests/backends/CUDA/CMakeLists.txt
+++ b/tests/backends/CUDA/CMakeLists.txt
@@ -31,20 +31,20 @@ include(${PROJECT_SOURCE_DIR}/cmake/discover_tests_with_death_test_filter.cmake)
 discover_tests_with_death_test_filter(${PLSSVM_CUDA_TEST_NAME})
 
 # add minimal run test for the classification task with the CUDA backend
-add_test(NAME MainTrainClassificationCUDA/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b cuda "${PLSSVM_CLASSIFICATION_TEST_FILE}"
-                                                                     "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
+add_test(NAME MainTrainClassificationCUDA/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b cuda "${PLSSVM_CLASSIFICATION_TEST_FILE}"
+                                                                    "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
 )
-add_test(NAME MainPredictClassificationCUDA/executable_minimal
+add_test(NAME MainPredictClassificationCUDA/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b cuda "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/classification/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/classification/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.predict" # predict file (result)
 )
 
 # add minimal run test for the regression task with the CUDA backend
-add_test(NAME MainTrainRegressionCUDA/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b cuda "${PLSSVM_REGRESSION_TEST_FILE}"
-                                                                 "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
+add_test(NAME MainTrainRegressionCUDA/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b cuda "${PLSSVM_REGRESSION_TEST_FILE}"
+                                                                "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
 )
-add_test(NAME MainPredictRegressionCUDA/executable_minimal
+add_test(NAME MainPredictRegressionCUDA/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b cuda "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/regression/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/regression/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.predict" # predict file (result)
diff --git a/tests/backends/CUDA/cuda_csvm.cpp b/tests/backends/CUDA/cuda_csvm.cpp
index 26725f642..1fcd1d96b 100644
--- a/tests/backends/CUDA/cuda_csvm.cpp
+++ b/tests/backends/CUDA/cuda_csvm.cpp
@@ -10,7 +10,6 @@
 
 #include "plssvm/backends/CUDA/csvm.hpp"        // plssvm::cuda::{csvm, csvc, csvr}
 #include "plssvm/backends/CUDA/exceptions.hpp"  // plssvm::cuda::backend_exception
-#include "plssvm/detail/type_list.hpp"          // plssvm::detail::label_type_list
 #include "plssvm/kernel_function_types.hpp"     // plssvm::kernel_function_type
 #include "plssvm/parameter.hpp"                 // plssvm::parameter
 #include "plssvm/target_platforms.hpp"          // plssvm::target_platform
@@ -42,7 +41,7 @@ class CUDACSVMConstructor : public ::testing::Test,
 TYPED_TEST_SUITE(CUDACSVMConstructor, cuda_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(CUDACSVMConstructor, default_construct) {
+TYPED_TEST(CUDACSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_NVIDIA_TARGET)
@@ -55,7 +54,7 @@ TYPED_TEST(CUDACSVMConstructor, default_construct) {
 #endif
 }
 
-TYPED_TEST(CUDACSVMConstructor, construct_parameter) {
+TYPED_TEST(CUDACSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_NVIDIA_TARGET)
@@ -68,7 +67,7 @@ TYPED_TEST(CUDACSVMConstructor, construct_parameter) {
 #endif
 }
 
-TYPED_TEST(CUDACSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(CUDACSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -99,7 +98,7 @@ TYPED_TEST(CUDACSVMConstructor, construct_target_and_parameter) {
                       "Invalid target platform 'gpu_intel' for the CUDA backend!");
 }
 
-TYPED_TEST(CUDACSVMConstructor, construct_named_args) {
+TYPED_TEST(CUDACSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_NVIDIA_TARGET)
@@ -116,7 +115,7 @@ TYPED_TEST(CUDACSVMConstructor, construct_named_args) {
 #endif
 }
 
-TYPED_TEST(CUDACSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(CUDACSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_NVIDIA_TARGET)
diff --git a/tests/backends/CUDA/detail/device_ptr.cpp b/tests/backends/CUDA/detail/device_ptr.cpp
index 53b746fcb..c74478c01 100644
--- a/tests/backends/CUDA/detail/device_ptr.cpp
+++ b/tests/backends/CUDA/detail/device_ptr.cpp
@@ -15,20 +15,23 @@
 #include "plssvm/shape.hpp"                     // plssvm::shape
 
 #include "tests/backends/generic_device_ptr_tests.hpp"  // generic device pointer tests to instantiate
+#include "tests/custom_test_macros.hpp"                 // EXPECT_THROW_WHAT_MATCHER
 #include "tests/naming.hpp"                             // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"                      // util::{combine_test_parameters_gtest_t, cartesian_type_product_t, layout_type_list, real_type_gtest}
 
+#include "fmt/format.h"   // fmt::format
 #include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
 #include "gtest/gtest.h"  // INSTANTIATE_TYPED_TEST_SUITE_P
 
-#include <tuple>  // std::tuple
+#include <cstddef>  // std::size_t
+#include <tuple>    // std::tuple
 
 template <typename T>
 class CUDADevicePtrConstruct : public ::testing::Test { };
 
 TYPED_TEST_SUITE(CUDADevicePtrConstruct, util::real_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(CUDADevicePtrConstruct, construct_invalid_queue) {
+TYPED_TEST(CUDADevicePtrConstruct, ConstructInvalidQueue) {
     using real_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // the number of devices
diff --git a/tests/backends/CUDA/detail/utility.cu b/tests/backends/CUDA/detail/utility.cu
index d120fbed9..31ac1ca57 100644
--- a/tests/backends/CUDA/detail/utility.cu
+++ b/tests/backends/CUDA/detail/utility.cu
@@ -13,15 +13,19 @@
 #include "plssvm/backends/CUDA/exceptions.hpp"  // plssvm::cuda::backend_exception
 #include "plssvm/backends/execution_range.hpp"  // plssvm::detail::dim_type
 
+#include "driver_types.h"  // cudaSuccess, cudaErrorInvalidValue
+#include "vector_types.h"  // dim3
+
 #include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT, EXPECT_THROW_WHAT_MATCHER
 
 #include "fmt/format.h"   // fmt::format
 #include "gmock/gmock.h"  // ::testing::StartsWith
 #include "gtest/gtest.h"  // TEST, EXPECT_GE, EXPECT_NO_THROW
 
-#include <regex>  // std::regex, std::regex::extended, std::regex_match
+#include <regex>   // std::regex, std::regex::extended, std::regex_match
+#include <string>  // std::string
 
-TEST(CUDAUtility, error_check) {
+TEST(CUDAUtility, ErrorCheck) {
     // cudaSuccess must not throw
     EXPECT_NO_THROW(PLSSVM_CUDA_ERROR_CHECK(cudaSuccess));
 
@@ -31,7 +35,7 @@ TEST(CUDAUtility, error_check) {
                               ::testing::StartsWith("CUDA assert 'cudaErrorInvalidValue' (1):"));
 }
 
-TEST(CUDAUtility, dim_type_to_native) {
+TEST(CUDAUtility, DimTypeToNative) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -44,26 +48,35 @@ TEST(CUDAUtility, dim_type_to_native) {
     EXPECT_EQ(native_dim.z, dim.z);
 }
 
-TEST(CUDAUtility, get_device_count) {
+TEST(CUDAUtility, GetDeviceCount) {
     // must not return a negative number
     EXPECT_GE(plssvm::cuda::detail::get_device_count(), 0);
 }
 
-TEST(CUDAUtility, set_device) {
+TEST(CUDAUtility, SetDevice) {
     // exception must be thrown if an illegal device ID has been provided
     EXPECT_THROW_WHAT(plssvm::cuda::detail::set_device(plssvm::cuda::detail::get_device_count()),
                       plssvm::cuda::backend_exception,
                       fmt::format("Illegal device ID! Must be in range: [0, {}) but is {}!", plssvm::cuda::detail::get_device_count(), plssvm::cuda::detail::get_device_count()));
 }
 
-TEST(CUDAUtility, device_synchronize) {
+TEST(CUDAUtility, DeviceSynchronize) {
     // exception must be thrown if an illegal device ID has been provided
     EXPECT_THROW_WHAT(plssvm::cuda::detail::device_synchronize(plssvm::cuda::detail::get_device_count()),
                       plssvm::cuda::backend_exception,
                       fmt::format("Illegal device ID! Must be in range: [0, {}) but is {}!", plssvm::cuda::detail::get_device_count(), plssvm::cuda::detail::get_device_count()));
 }
 
-TEST(CUDAUtility, get_runtime_version) {
+TEST(CUDAUtility, GetDeviceName) {
+    const std::string device_name = plssvm::cuda::detail::get_device_name(0);
+    // must not be empty
+    EXPECT_FALSE(device_name.empty());
+    // must not start or end with whitespace
+    const std::regex reg{ R"([^\s](?:.*[^\s])?)" };
+    EXPECT_TRUE(std::regex_match(device_name, reg));
+}
+
+TEST(CUDAUtility, GetRuntimeVersion) {
     const std::regex reg{ "[0-9]+\\.[0-9]+", std::regex::extended };
     EXPECT_TRUE(std::regex_match(plssvm::cuda::detail::get_runtime_version(), reg));
 }
diff --git a/tests/backends/CUDA/kernel/detail/fill_kernel.cu b/tests/backends/CUDA/kernel/detail/fill_kernel.cu
index 1ff7ace62..e53d518d3 100644
--- a/tests/backends/CUDA/kernel/detail/fill_kernel.cu
+++ b/tests/backends/CUDA/kernel/detail/fill_kernel.cu
@@ -10,6 +10,10 @@
 
 #include "plssvm/backends/CUDA/kernel/detail/fill_kernel.cuh"
 
+#include "cuda_runtime_api.h"  // cudaDeviceSynchronize
+#include "driver_types.h"      // cudaMemcpyDeviceToHost
+#include "vector_types.h"      // dim3
+
 #include "tests/naming.hpp"         // util::test_parameter_to_name
 #include "tests/types_to_test.hpp"  // util::{real_type_gtest, test_parameter_type_at_t}
 
@@ -28,7 +32,7 @@ class CUDAFillUtility : public ::testing::Test {
 
 TYPED_TEST_SUITE(CUDAFillUtility, util::real_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(CUDAFillUtility, fill_kernel) {
+TYPED_TEST(CUDAFillUtility, FillKernel) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // allocate array on the host
@@ -36,7 +40,7 @@ TYPED_TEST(CUDAFillUtility, fill_kernel) {
 
     // allocate array on the device
     real_type *vec_d{};
-    cudaMalloc((void **) &vec_d, vec.size() * sizeof(real_type));
+    cudaMalloc(&vec_d, vec.size() * sizeof(real_type));
 
     // create the block and grid partition
     const dim3 block{ 512 };
@@ -54,7 +58,7 @@ TYPED_TEST(CUDAFillUtility, fill_kernel) {
     EXPECT_TRUE(std::all_of(vec.cbegin(), vec.cend(), [](const real_type val) { return val == real_type{ 42.0 }; }));
 }
 
-TYPED_TEST(CUDAFillUtility, fill_kernel_partial) {
+TYPED_TEST(CUDAFillUtility, FillKernelPartial) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // allocate array on the host
@@ -62,7 +66,7 @@ TYPED_TEST(CUDAFillUtility, fill_kernel_partial) {
 
     // allocate array on the device
     real_type *vec_d{};
-    cudaMalloc((void **) &vec_d, vec.size() * sizeof(real_type));
+    cudaMalloc(&vec_d, vec.size() * sizeof(real_type));
     cudaMemset(vec_d, 0, vec.size() * sizeof(real_type));
 
     // create the block and grid partition
diff --git a/tests/backends/CUDA/mock_cuda_csvm.hpp b/tests/backends/CUDA/mock_cuda_csvm.hpp
index 5a0c4187f..e233f12ce 100644
--- a/tests/backends/CUDA/mock_cuda_csvm.hpp
+++ b/tests/backends/CUDA/mock_cuda_csvm.hpp
@@ -47,6 +47,7 @@ class mock_cuda_csvm final : public plssvm::cuda::csvm {
     using base_type::assemble_kernel_matrix;
     using base_type::blas_level_3;
     using base_type::get_device_memory;
+    using base_type::get_local_memory;
     using base_type::get_max_work_group_size;
     using base_type::num_available_devices;
 
diff --git a/tests/backends/HIP/CMakeLists.txt b/tests/backends/HIP/CMakeLists.txt
index 2d86c5990..2a9212a6a 100644
--- a/tests/backends/HIP/CMakeLists.txt
+++ b/tests/backends/HIP/CMakeLists.txt
@@ -59,20 +59,20 @@ include(${PROJECT_SOURCE_DIR}/cmake/discover_tests_with_death_test_filter.cmake)
 discover_tests_with_death_test_filter(${PLSSVM_HIP_TEST_NAME})
 
 # add minimal run test for the classification task with the HIP backend
-add_test(NAME MainTrainClassificationHIP/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b hip "${PLSSVM_CLASSIFICATION_TEST_FILE}"
-                                                                    "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
+add_test(NAME MainTrainClassificationHIP/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b hip "${PLSSVM_CLASSIFICATION_TEST_FILE}"
+                                                                   "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
 )
-add_test(NAME MainPredictClassificationHIP/executable_minimal
+add_test(NAME MainPredictClassificationHIP/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b hip "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/classification/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/classification/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.predict" # predict file (result)
 )
 
 # add minimal run test for the regression task with the HIP backend
-add_test(NAME MainTrainRegressionHIP/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b hip "${PLSSVM_REGRESSION_TEST_FILE}"
-                                                                "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
+add_test(NAME MainTrainRegressionHIP/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b hip "${PLSSVM_REGRESSION_TEST_FILE}"
+                                                               "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
 )
-add_test(NAME MainPredictRegressionHIP/executable_minimal
+add_test(NAME MainPredictRegressionHIP/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b hip "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/regression/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/regression/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.predict" # predict file (result)
diff --git a/tests/backends/HIP/detail/device_ptr.hip b/tests/backends/HIP/detail/device_ptr.hip
index b72d3f83c..64fb940b6 100644
--- a/tests/backends/HIP/detail/device_ptr.hip
+++ b/tests/backends/HIP/detail/device_ptr.hip
@@ -14,20 +14,23 @@
 #include "plssvm/shape.hpp"                               // plssvm::shape
 
 #include "tests/backends/generic_device_ptr_tests.hpp"  // generic device pointer tests to instantiate
+#include "tests/custom_test_macros.hpp"                 // EXPECT_THROW_WHAT_MATCHER
 #include "tests/naming.hpp"                             // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"                      // util::{combine_test_parameters_gtest_t, cartesian_type_product_t, layout_type_list, real_type_gtest}
 
+#include "fmt/format.h"   // fmt::format
 #include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
 #include "gtest/gtest.h"  // INSTANTIATE_TYPED_TEST_SUITE_P
 
-#include <tuple>  // std::tuple
+#include <cstddef>  // std::size_t
+#include <tuple>    // std::tuple
 
 template <typename T>
 class HIPDevicePtrConstruct : public ::testing::Test { };
 
 TYPED_TEST_SUITE(HIPDevicePtrConstruct, util::real_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(HIPDevicePtrConstruct, construct_invalid_queue) {
+TYPED_TEST(HIPDevicePtrConstruct, ConstructInvalidQueue) {
     using real_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // the number of devices
diff --git a/tests/backends/HIP/detail/utility.hip b/tests/backends/HIP/detail/utility.hip
index caaa35049..06281b703 100644
--- a/tests/backends/HIP/detail/utility.hip
+++ b/tests/backends/HIP/detail/utility.hip
@@ -23,9 +23,10 @@
 #include "gmock/gmock.h"  // ::testing::StartsWith
 #include "gtest/gtest.h"  // TEST, EXPECT_GE, EXPECT_NO_THROW
 
-#include <regex>  // std::regex, std::regex::extended, std::regex_match
+#include <regex>   // std::regex, std::regex::extended, std::regex_match
+#include <string>  // std::string
 
-TEST(HIPUtility, error_check) {
+TEST(HIPUtility, ErrorCheck) {
     // hipSuccess must not throw
     EXPECT_NO_THROW(PLSSVM_HIP_ERROR_CHECK(hipSuccess));
 
@@ -41,7 +42,7 @@ TEST(HIPUtility, error_check) {
 #endif
 }
 
-TEST(HIPUtility, dim_type_to_native) {
+TEST(HIPUtility, DimTypeToNative) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -54,31 +55,40 @@ TEST(HIPUtility, dim_type_to_native) {
     EXPECT_EQ(native_dim.z, dim.z);
 }
 
-TEST(HIPUtility, get_device_count) {
+TEST(HIPUtility, GetDeviceCount) {
     // must not return a negative number
     EXPECT_GE(plssvm::hip::detail::get_device_count(), 0);
 }
 
-TEST(HIPUtility, set_device) {
+TEST(HIPUtility, SetDevice) {
     // exception must be thrown if an illegal device ID has been provided
     EXPECT_THROW_WHAT(plssvm::hip::detail::set_device(plssvm::hip::detail::get_device_count()),
                       plssvm::hip::backend_exception,
                       fmt::format("Illegal device ID! Must be in range: [0, {}) but is {}!", plssvm::hip::detail::get_device_count(), plssvm::hip::detail::get_device_count()));
 }
 
-TEST(HIPUtility, device_synchronize) {
+TEST(HIPUtility, DeviceSynchronize) {
     // exception must be thrown if an illegal device ID has been provided
     EXPECT_THROW_WHAT(plssvm::hip::detail::device_synchronize(plssvm::hip::detail::get_device_count()),
                       plssvm::hip::backend_exception,
                       fmt::format("Illegal device ID! Must be in range: [0, {}) but is {}!", plssvm::hip::detail::get_device_count(), plssvm::hip::detail::get_device_count()));
 }
 
-TEST(HIPUtility, get_runtime_version) {
+TEST(HIPUtility, GetDeviceName) {
+    const std::string device_name = plssvm::hip::detail::get_device_name(0);
+    // must not be empty
+    EXPECT_FALSE(device_name.empty());
+    // must not start or end with whitespace
+    const std::regex reg{ R"([^\s](?:.*[^\s])?)" };
+    EXPECT_TRUE(std::regex_match(device_name, reg));
+}
+
+TEST(HIPUtility, GetRuntimeVersion) {
     const std::regex reg{ "[0-9]+\\.[0-9]+", std::regex::extended };
     EXPECT_TRUE(std::regex_match(plssvm::hip::detail::get_runtime_version(), reg));
 }
 
-TEST(HIPUtility, get_runtime) {
+TEST(HIPUtility, GetRuntime) {
     const std::regex reg{ "HIP|CUDA", std::regex::extended };
     EXPECT_TRUE(std::regex_match(plssvm::hip::detail::get_runtime(), reg));
 }
diff --git a/tests/backends/HIP/hip_csvm.hip b/tests/backends/HIP/hip_csvm.hip
index dd40dfba1..b84cec3f2 100644
--- a/tests/backends/HIP/hip_csvm.hip
+++ b/tests/backends/HIP/hip_csvm.hip
@@ -42,7 +42,7 @@ class HIPCSVMConstructor : public ::testing::Test,
 TYPED_TEST_SUITE(HIPCSVMConstructor, hip_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(HIPCSVMConstructor, default_construct) {
+TYPED_TEST(HIPCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HIP_BACKEND_USE_HIP_RUNTIME)
@@ -66,7 +66,7 @@ TYPED_TEST(HIPCSVMConstructor, default_construct) {
 #endif
 }
 
-TYPED_TEST(HIPCSVMConstructor, construct_parameter) {
+TYPED_TEST(HIPCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HIP_BACKEND_USE_HIP_RUNTIME)
@@ -90,7 +90,7 @@ TYPED_TEST(HIPCSVMConstructor, construct_parameter) {
 #endif
 }
 
-TYPED_TEST(HIPCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(HIPCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -137,17 +137,17 @@ TYPED_TEST(HIPCSVMConstructor, construct_target_and_parameter) {
     // all other target platforms must throw
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::cpu, params }),
                       plssvm::hip::backend_exception,
-                      "Invalid target platform 'cpu' for the HIP backend using the HIP runtime!");
+                      "Invalid target platform 'cpu' for the HIP backend using the CUDA runtime!");
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_amd, params }),
                       plssvm::hip::backend_exception,
-                      "Invalid target platform 'gpu_amd' for the HIP backend using the HIP runtime!");
+                      "Invalid target platform 'gpu_amd' for the HIP backend using the CUDA runtime!");
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_intel, params }),
                       plssvm::hip::backend_exception,
-                      "Invalid target platform 'gpu_intel' for the HIP backend using the HIP runtime!");
+                      "Invalid target platform 'gpu_intel' for the HIP backend using the CUDA runtime!");
 #endif
 }
 
-TYPED_TEST(HIPCSVMConstructor, construct_named_args) {
+TYPED_TEST(HIPCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HIP_BACKEND_USE_HIP_RUNTIME)
@@ -179,7 +179,7 @@ TYPED_TEST(HIPCSVMConstructor, construct_named_args) {
 #endif
 }
 
-TYPED_TEST(HIPCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(HIPCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HIP_BACKEND_USE_HIP_RUNTIME)
@@ -223,13 +223,13 @@ TYPED_TEST(HIPCSVMConstructor, construct_target_and_named_args) {
     // all other target platforms must throw
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::cpu, plssvm::cost = 2.0 }),
                       plssvm::hip::backend_exception,
-                      "Invalid target platform 'cpu' for the HIP backend using the HIP runtime!");
+                      "Invalid target platform 'cpu' for the HIP backend using the CUDA runtime!");
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_amd, plssvm::cost = 2.0 }),
                       plssvm::hip::backend_exception,
-                      "Invalid target platform 'gpu_amd' for the HIP backend using the HIP runtime!");
+                      "Invalid target platform 'gpu_amd' for the HIP backend using the CUDA runtime!");
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_intel, plssvm::cost = 2.0 }),
                       plssvm::hip::backend_exception,
-                      "Invalid target platform 'gpu_intel' for the HIP backend using the HIP runtime!");
+                      "Invalid target platform 'gpu_intel' for the HIP backend using the CUDA runtime!");
 #endif
 }
 
diff --git a/tests/backends/HIP/kernel/detail/fill_kernel.hip b/tests/backends/HIP/kernel/detail/fill_kernel.hip
index 13abfbe29..bc700015c 100644
--- a/tests/backends/HIP/kernel/detail/fill_kernel.hip
+++ b/tests/backends/HIP/kernel/detail/fill_kernel.hip
@@ -32,7 +32,7 @@ class HIPFillUtility : public ::testing::Test {
 
 TYPED_TEST_SUITE(HIPFillUtility, util::real_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(HIPFillUtility, fill_kernel) {
+TYPED_TEST(HIPFillUtility, FillKernel) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // allocate array on the host
@@ -58,7 +58,7 @@ TYPED_TEST(HIPFillUtility, fill_kernel) {
     EXPECT_TRUE(std::all_of(vec.cbegin(), vec.cend(), [](const real_type val) { return val == real_type{ 42.0 }; }));
 }
 
-TYPED_TEST(HIPFillUtility, fill_kernel_partial) {
+TYPED_TEST(HIPFillUtility, FillKernelPartial) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // allocate array on the host
diff --git a/tests/backends/HIP/mock_hip_csvm.hpp b/tests/backends/HIP/mock_hip_csvm.hpp
index 0f19c730a..74f4846a1 100644
--- a/tests/backends/HIP/mock_hip_csvm.hpp
+++ b/tests/backends/HIP/mock_hip_csvm.hpp
@@ -9,8 +9,8 @@
  * @brief MOCK class for the C-SVM class using the HIP backend.
  */
 
-#ifndef PLSSVM_TESTS_BACKENDS_CUDA_MOCK_HIP_CSVM_HPP_
-#define PLSSVM_TESTS_BACKENDS_CUDA_MOCK_HIP_CSVM_HPP_
+#ifndef PLSSVM_TESTS_BACKENDS_HIP_MOCK_HIP_CSVM_HPP_
+#define PLSSVM_TESTS_BACKENDS_HIP_MOCK_HIP_CSVM_HPP_
 #pragma once
 
 #include "plssvm/backends/execution_range.hpp"  // plssvm::detail::dim_type
@@ -47,6 +47,7 @@ class mock_hip_csvm final : public plssvm::hip::csvm {
     using base_type::assemble_kernel_matrix;
     using base_type::blas_level_3;
     using base_type::get_device_memory;
+    using base_type::get_local_memory;
     using base_type::get_max_work_group_size;
     using base_type::num_available_devices;
 
@@ -85,4 +86,4 @@ class mock_hip_csvm final : public plssvm::hip::csvm {
     }
 };
 
-#endif  // PLSSVM_TESTS_BACKENDS_CUDA_MOCK_HIP_CSVM_HPP_
+#endif  // PLSSVM_TESTS_BACKENDS_HIP_MOCK_HIP_CSVM_HPP_
diff --git a/tests/backends/HPX/CMakeLists.txt b/tests/backends/HPX/CMakeLists.txt
index 0b9cc116e..12c51ec00 100644
--- a/tests/backends/HPX/CMakeLists.txt
+++ b/tests/backends/HPX/CMakeLists.txt
@@ -16,7 +16,7 @@ set(PLSSVM_HPX_TEST_SOURCES ${CMAKE_CURRENT_LIST_DIR}/detail/utility.cpp ${CMAKE
 add_executable(${PLSSVM_HPX_TEST_NAME} ${CMAKE_CURRENT_LIST_DIR}/../../hpx_main.cpp ${PLSSVM_HPX_TEST_SOURCES})
 
 # link against test library
-target_link_libraries(${PLSSVM_HPX_TEST_NAME} PRIVATE ${PLSSVM_BASE_TEST_LIBRARY_NAME} HPX::hpx HPX::wrap_main)
+target_link_libraries(${PLSSVM_HPX_TEST_NAME} PRIVATE ${PLSSVM_BASE_TEST_LIBRARY_NAME} HPX::hpx)
 
 # add tests to google test
 include(GoogleTest)
@@ -24,20 +24,20 @@ include(${PROJECT_SOURCE_DIR}/cmake/discover_tests_with_death_test_filter.cmake)
 discover_tests_with_death_test_filter(${PLSSVM_HPX_TEST_NAME})
 
 # add minimal run test for the classification task with the HPX backend
-add_test(NAME MainTrainClassificationHPX/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b hpx "${PLSSVM_CLASSIFICATION_TEST_FILE}"
-                                                                    "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
+add_test(NAME MainTrainClassificationHPX/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b hpx "${PLSSVM_CLASSIFICATION_TEST_FILE}"
+                                                                   "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
 )
-add_test(NAME MainPredictClassificationHPX/executable_minimal
+add_test(NAME MainPredictClassificationHPX/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b hpx "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/classification/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/classification/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.predict" # predict file (result)
 )
 
 # add minimal run test for the regression task with the HPX backend
-add_test(NAME MainTrainRegressionHPX/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b hpx "${PLSSVM_REGRESSION_TEST_FILE}"
-                                                                "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
+add_test(NAME MainTrainRegressionHPX/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b hpx "${PLSSVM_REGRESSION_TEST_FILE}"
+                                                               "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
 )
-add_test(NAME MainPredictRegressionHPX/executable_minimal
+add_test(NAME MainPredictRegressionHPX/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b hpx "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/regression/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/regression/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.predict" # predict file (result)
diff --git a/tests/backends/HPX/detail/utility.cpp b/tests/backends/HPX/detail/utility.cpp
index 16647745a..c1f7fc36a 100644
--- a/tests/backends/HPX/detail/utility.cpp
+++ b/tests/backends/HPX/detail/utility.cpp
@@ -15,10 +15,10 @@
 
 #include <string>  // std::string
 
-TEST(HPXUtility, get_num_threads) {
+TEST(HPXUtility, GetNumThreads) {
     EXPECT_GT(plssvm::hpx::detail::get_num_threads(), 0);
 }
 
-TEST(HPXUtility, get_hpx_version) {
+TEST(HPXUtility, GetHpxVersion) {
     EXPECT_FALSE(plssvm::hpx::detail::get_hpx_version().empty());
 }
diff --git a/tests/backends/HPX/hpx_csvm.cpp b/tests/backends/HPX/hpx_csvm.cpp
index 0d5d9003e..b1f9cc9d2 100644
--- a/tests/backends/HPX/hpx_csvm.cpp
+++ b/tests/backends/HPX/hpx_csvm.cpp
@@ -17,33 +17,23 @@
 #include "plssvm/backends/HPX/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp"  // plssvm::hpx::device_kernel_assembly_symm
 #include "plssvm/backends/HPX/kernel/predict_kernel.hpp"                           // plssvm::hpx::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
 #include "plssvm/constants.hpp"                                                    // plssvm::PADDING_SIZE
-#include "plssvm/data_set/classification_data_set.hpp"                             // plssvm::classification_data_set
-#include "plssvm/detail/arithmetic_type_name.hpp"                                  // plssvm::detail::arithmetic_type_name
-#include "plssvm/detail/data_distribution.hpp"                                     // plssvm::detail::triangular_data_distribution
-#include "plssvm/detail/type_list.hpp"                                             // plssvm::detail::supported_label_types
 #include "plssvm/kernel_function_types.hpp"                                        // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                                                       // plssvm::soa_matrix
 #include "plssvm/parameter.hpp"                                                    // plssvm::parameter, plssvm::detail::parameter, plssvm::kernel_type, plssvm::cost
-#include "plssvm/shape.hpp"                                                        // plssvm::shape
 #include "plssvm/target_platforms.hpp"                                             // plssvm::target_platform
 
 #include "tests/backends/generic_base_csvc_tests.hpp"  // generic C-SVC tests to instantiate
 #include "tests/backends/generic_base_csvm_tests.hpp"  // generic C-SVM tests to instantiate
 #include "tests/backends/generic_base_csvr_tests.hpp"  // generic C-SVR tests to instantiate
-#include "tests/backends/ground_truth.hpp"             // ground_truth::{perform_dimensional_reduction, assemble_device_specific_kernel_matrix, assemble_full_kernel_matrix, gemm, calculate_w}
 #include "tests/backends/HPX/mock_hpx_csvm.hpp"        // mock_hpx_csvm
 #include "tests/custom_test_macros.hpp"                // EXPECT_THROW_WHAT
 #include "tests/naming.hpp"                            // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"                     // util::{cartesian_type_product_t, combine_test_parameters_gtest_t}
 #include "tests/utility.hpp"                           // util::redirect_output
 
-#include "fmt/format.h"   // fmt::format
 #include "gtest/gtest.h"  // TYPED_TEST, TYPED_TEST_SUITE, TEST_F, EXPECT_NO_THROW, INSTANTIATE_TYPED_TEST_SUITE_P, ::testing::Test
 
-#include <algorithm>  // std::min
-#include <cstddef>    // std::size_t
-#include <tuple>      // std::make_tuple, std::tuple
-#include <vector>     // std::vector
+#include <tuple>  // std::make_tuple, std::tuple
 
 using hpx_csvm_types_list = std::tuple<plssvm::hpx::csvc, plssvm::hpx::csvr>;
 using hpx_csvm_types_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<hpx_csvm_types_list>>;
@@ -58,7 +48,7 @@ class HPXCSVMConstructor : public ::testing::Test,
 TYPED_TEST_SUITE(HPXCSVMConstructor, hpx_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(HPXCSVMConstructor, default_construct) {
+TYPED_TEST(HPXCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -71,7 +61,7 @@ TYPED_TEST(HPXCSVMConstructor, default_construct) {
 #endif
 }
 
-TYPED_TEST(HPXCSVMConstructor, construct_parameter) {
+TYPED_TEST(HPXCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -84,7 +74,7 @@ TYPED_TEST(HPXCSVMConstructor, construct_parameter) {
 #endif
 }
 
-TYPED_TEST(HPXCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(HPXCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -115,7 +105,7 @@ TYPED_TEST(HPXCSVMConstructor, construct_target_and_parameter) {
                       "Invalid target platform 'gpu_intel' for the HPX backend!");
 }
 
-TYPED_TEST(HPXCSVMConstructor, construct_named_args) {
+TYPED_TEST(HPXCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -129,7 +119,7 @@ TYPED_TEST(HPXCSVMConstructor, construct_named_args) {
 #endif
 }
 
-TYPED_TEST(HPXCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(HPXCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -163,7 +153,7 @@ struct hpx_csvm_test_type {
     using csvc_type = plssvm::hpx::csvc;
     using csvr_type = plssvm::hpx::csvr;
     using device_ptr_type = const plssvm::soa_matrix<plssvm::real_type> *;
-    inline constexpr static auto additional_arguments = std::make_tuple();
+    constexpr static auto additional_arguments = std::make_tuple();
 };
 
 // a tuple containing the test structs
diff --git a/tests/backends/HPX/mock_hpx_csvm.hpp b/tests/backends/HPX/mock_hpx_csvm.hpp
index 697eac2b5..2eafb01cb 100644
--- a/tests/backends/HPX/mock_hpx_csvm.hpp
+++ b/tests/backends/HPX/mock_hpx_csvm.hpp
@@ -34,6 +34,7 @@ class mock_hpx_csvm final : public plssvm::hpx::csvm {
     using base_type::assemble_kernel_matrix;
     using base_type::blas_level_3;
     using base_type::get_device_memory;
+    using base_type::get_local_memory;
     using base_type::num_available_devices;
 
     using base_type::predict_values;
diff --git a/tests/backends/Kokkos/.clang-tidy b/tests/backends/Kokkos/.clang-tidy
new file mode 100644
index 000000000..cdf2ade2d
--- /dev/null
+++ b/tests/backends/Kokkos/.clang-tidy
@@ -0,0 +1,6 @@
+---
+Checks: '
+-misc-include-cleaner,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/tests/backends/Kokkos/CMakeLists.txt b/tests/backends/Kokkos/CMakeLists.txt
index d1f12507c..64acfc44a 100644
--- a/tests/backends/Kokkos/CMakeLists.txt
+++ b/tests/backends/Kokkos/CMakeLists.txt
@@ -48,20 +48,20 @@ include(${PROJECT_SOURCE_DIR}/cmake/discover_tests_with_death_test_filter.cmake)
 discover_tests_with_death_test_filter(${PLSSVM_KOKKOS_TEST_NAME})
 
 # add minimal run test for the classification task with the Kokkos backend
-add_test(NAME MainTrainClassificationKokkos/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b kokkos "${PLSSVM_CLASSIFICATION_TEST_FILE}"
-                                                                       "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
+add_test(NAME MainTrainClassificationKokkos/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b kokkos "${PLSSVM_CLASSIFICATION_TEST_FILE}"
+                                                                      "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
 )
-add_test(NAME MainPredictClassificationKokkos/executable_minimal
+add_test(NAME MainPredictClassificationKokkos/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b kokkos "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/classification/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/classification/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.predict" # predict file (result)
 )
 
 # add minimal run test for the regression task with the Kokkos backend
-add_test(NAME MainTrainRegressionKokkos/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b kokkos "${PLSSVM_REGRESSION_TEST_FILE}"
-                                                                   "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
+add_test(NAME MainTrainRegressionKokkos/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b kokkos "${PLSSVM_REGRESSION_TEST_FILE}"
+                                                                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
 )
-add_test(NAME MainPredictRegressionKokkos/executable_minimal
+add_test(NAME MainPredictRegressionKokkos/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b kokkos "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/regression/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/regression/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.predict" # predict file (result)
diff --git a/tests/backends/Kokkos/detail/constexpr_available_execution_spaces.cpp b/tests/backends/Kokkos/detail/constexpr_available_execution_spaces.cpp
index 2e8f064e7..76a2e9cb3 100644
--- a/tests/backends/Kokkos/detail/constexpr_available_execution_spaces.cpp
+++ b/tests/backends/Kokkos/detail/constexpr_available_execution_spaces.cpp
@@ -12,7 +12,8 @@
 
 #include "gtest/gtest.h"  // TEST, EXPECT_TRUE, EXPECT_FALSE
 
-TEST(KokkosConstexprAvailableExecutionSpaces, constexpr_available_execution_spaces) {
+TEST(KokkosConstexprAvailableExecutionSpaces, ConstexprAvailableExecutionSpaces) {
     // at least one execution space must always be available
     EXPECT_FALSE(plssvm::kokkos::detail::constexpr_available_execution_spaces().empty());
+    EXPECT_EQ(plssvm::kokkos::detail::constexpr_available_execution_spaces().size(), PLSSVM_KOKKOS_BACKEND_NUM_AVAILABLE_EXECUTION_SPACES);
 }
diff --git a/tests/backends/Kokkos/detail/device_ptr.cpp b/tests/backends/Kokkos/detail/device_ptr.cpp
index ec525dad5..b3d2d99ae 100644
--- a/tests/backends/Kokkos/detail/device_ptr.cpp
+++ b/tests/backends/Kokkos/detail/device_ptr.cpp
@@ -11,8 +11,8 @@
 #include "plssvm/backends/Kokkos/detail/device_ptr.hpp"  // plssvm::kokkos::detail::device_ptr
 
 #include "plssvm/backends/Kokkos/detail/device_wrapper.hpp"        // plssvm::kokkos::detail::device_wrapper
-#include "plssvm/backends/Kokkos/execution_space.hpp"              // plssvm::kokkos::execution_space
 #include "plssvm/backends/Kokkos/execution_space_type_traits.hpp"  // plssvm::kokkos::execution_space_to_kokkos_type_t
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"             // plssvm::kokkos::execution_space
 
 #include "tests/backends/generic_device_ptr_tests.hpp"  // generic device pointer tests to instantiate
 #include "tests/backends/Kokkos/utility.hpp"            // util::create_kokkos_test_tuple_impl
@@ -22,8 +22,6 @@
 
 #include "gtest/gtest.h"  // INSTANTIATE_TYPED_TEST_SUITE_P
 
-#include <tuple>  // std::tuple
-
 template <typename T, plssvm::kokkos::execution_space exec_space>
 struct kokkos_device_ptr_test_type {
     using device_ptr_type = plssvm::kokkos::detail::device_ptr<T>;
diff --git a/tests/backends/Kokkos/detail/device_view_wrapper.cpp b/tests/backends/Kokkos/detail/device_view_wrapper.cpp
index 28dc97cba..c6e125e0c 100644
--- a/tests/backends/Kokkos/detail/device_view_wrapper.cpp
+++ b/tests/backends/Kokkos/detail/device_view_wrapper.cpp
@@ -10,8 +10,10 @@
 
 #include "plssvm/backends/Kokkos/detail/device_view_wrapper.hpp"
 
-#include "plssvm/backends/Kokkos/detail/device_wrapper.hpp"  // plssvm::kokkos::detail::device_wrapper
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::{execution_space, kokkos_type_to_execution_space_v}
+#include "plssvm/backends/Kokkos/detail/constexpr_available_execution_spaces.hpp"  // plssvm::kokkos::detail::constexpr_available_execution_spaces
+#include "plssvm/backends/Kokkos/detail/device_wrapper.hpp"                        // plssvm::kokkos::detail::device_wrapper
+#include "plssvm/backends/Kokkos/execution_space_type_traits.hpp"                  // plssvm::kokkos::kokkos_type_to_execution_space_v
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"                             // plssvm::kokkos::execution_space
 
 #include "Kokkos_Core.hpp"  // Kokkos::DefaultExecutionSpace, Kokkos::View
 
@@ -19,7 +21,7 @@
 
 #include <cstddef>  // std::size_t
 
-TEST(KokkosDeviceViewWrapper, default_construct) {
+TEST(KokkosDeviceViewWrapper, DefaultConstruct) {
     // default construct a device view wrapper
     const plssvm::kokkos::detail::device_view_wrapper<double *> view{};
 
@@ -29,7 +31,7 @@ TEST(KokkosDeviceViewWrapper, default_construct) {
     EXPECT_EQ(view.get_execution_space(), spaces.front());
 }
 
-TEST(KokkosDeviceViewWrapper, construct) {
+TEST(KokkosDeviceViewWrapper, Construct) {
     // construct a device view wrapper using the current Kokkos::DefaultExecutionSpace
     const plssvm::kokkos::detail::device_view_wrapper view{ Kokkos::View<double *, Kokkos::DefaultExecutionSpace>{} };
 
@@ -37,16 +39,16 @@ TEST(KokkosDeviceViewWrapper, construct) {
     EXPECT_EQ(view.get_execution_space(), plssvm::kokkos::kokkos_type_to_execution_space_v<Kokkos::DefaultExecutionSpace>);
 }
 
-TEST(KokkosDeviceViewWrapper, get) {
+TEST(KokkosDeviceViewWrapper, Get) {
     // construct a device view wrapper using the current Kokkos::DefaultExecutionSpace
-    plssvm::kokkos::detail::device_view_wrapper view{ Kokkos::View<double *, Kokkos::DefaultExecutionSpace>{} };
+    plssvm::kokkos::detail::device_view_wrapper view{ Kokkos::View<double *, Kokkos::DefaultExecutionSpace>{} };  // NOLINT(misc-const-correctness): want to test the non-const overload
 
     // check that the returned Kokkos::View has the correct type
     constexpr plssvm::kokkos::execution_space space = plssvm::kokkos::kokkos_type_to_execution_space_v<Kokkos::DefaultExecutionSpace>;
     ::testing::StaticAssertTypeEq<decltype(view.get<space>()), Kokkos::View<double *, Kokkos::DefaultExecutionSpace> &>();
 }
 
-TEST(KokkosDeviceViewWrapper, get_const) {
+TEST(KokkosDeviceViewWrapper, GetConst) {
     // construct a device view wrapper using the current Kokkos::DefaultExecutionSpace
     const plssvm::kokkos::detail::device_view_wrapper view{ Kokkos::View<int **, Kokkos::DefaultExecutionSpace>{} };
 
@@ -55,7 +57,7 @@ TEST(KokkosDeviceViewWrapper, get_const) {
     ::testing::StaticAssertTypeEq<decltype(view.get<space>()), const Kokkos::View<int **, Kokkos::DefaultExecutionSpace> &>();
 }
 
-TEST(KokkosDeviceViewWrapper, get_execution_space) {
+TEST(KokkosDeviceViewWrapper, GetExecutionSpace) {
     // construct a device wrapper using the current Kokkos::DefaultExecutionSpace
     const plssvm::kokkos::detail::device_view_wrapper view{ Kokkos::View<double *, Kokkos::DefaultExecutionSpace>{} };
 
@@ -63,7 +65,7 @@ TEST(KokkosDeviceViewWrapper, get_execution_space) {
     EXPECT_EQ(view.get_execution_space(), plssvm::kokkos::kokkos_type_to_execution_space_v<Kokkos::DefaultExecutionSpace>);
 }
 
-TEST(KokkosDeviceViewWrapper, equality) {
+TEST(KokkosDeviceViewWrapper, Equality) {
     const plssvm::kokkos::detail::device_view_wrapper view1{ Kokkos::View<double *, Kokkos::DefaultExecutionSpace>{} };
     const plssvm::kokkos::detail::device_view_wrapper view2{ Kokkos::View<double *, Kokkos::DefaultExecutionSpace>{} };
 
@@ -71,7 +73,7 @@ TEST(KokkosDeviceViewWrapper, equality) {
     EXPECT_TRUE(view1 == view2);
 }
 
-TEST(KokkosDeviceViewWrapper, inequality) {
+TEST(KokkosDeviceViewWrapper, Inequality) {
     const plssvm::kokkos::detail::device_view_wrapper view1{ Kokkos::View<double *, Kokkos::DefaultExecutionSpace>{} };
     const plssvm::kokkos::detail::device_view_wrapper view2{ Kokkos::View<double *, Kokkos::DefaultExecutionSpace>{} };
 
@@ -79,7 +81,7 @@ TEST(KokkosDeviceViewWrapper, inequality) {
     EXPECT_FALSE(view1 != view2);
 }
 
-TEST(KokkosDeviceViewWrapper, make_device_view_wrapper) {
+TEST(KokkosDeviceViewWrapper, MakeDeviceViewWrapper) {
     // create a device wrapper for the Kokkos::DefaultExecutionSpace
     const plssvm::kokkos::detail::device_wrapper device{ Kokkos::DefaultExecutionSpace{} };
 
diff --git a/tests/backends/Kokkos/detail/device_wrapper.cpp b/tests/backends/Kokkos/detail/device_wrapper.cpp
index 64af4fe4d..aeacea5a5 100644
--- a/tests/backends/Kokkos/detail/device_wrapper.cpp
+++ b/tests/backends/Kokkos/detail/device_wrapper.cpp
@@ -10,11 +10,13 @@
 
 #include "plssvm/backends/Kokkos/detail/device_wrapper.hpp"
 
-#include "plssvm/backends/Kokkos/detail/utility.hpp"   // plssvm::kokkos::detail::available_target_platform_to_execution_space_mapping
-#include "plssvm/backends/Kokkos/execution_space.hpp"  // plssvm::kokkos::{execution_space, kokkos_type_to_execution_space_v}
-#include "plssvm/detail/utility.hpp"                   // plssvm::detail::contains
-#include "plssvm/mpi/communicator.hpp"                 // plssvm::mpi::communicator
-#include "plssvm/target_platforms.hpp"                 // plssvm::target_platform
+#include "plssvm/backends/Kokkos/detail/constexpr_available_execution_spaces.hpp"  // plssvm::kokkos::detail::constexpr_available_execution_spaces
+#include "plssvm/backends/Kokkos/detail/utility.hpp"                               // plssvm::kokkos::detail::available_target_platform_to_execution_space_mapping
+#include "plssvm/backends/Kokkos/execution_space_type_traits.hpp"                  // plssvm::kokkos::kokkos_type_to_execution_space_v
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"                             // plssvm::kokkos::execution_space
+#include "plssvm/detail/utility.hpp"                                               // plssvm::detail::contains
+#include "plssvm/mpi/communicator.hpp"                                             // plssvm::mpi::communicator
+#include "plssvm/target_platforms.hpp"                                             // plssvm::target_platform
 
 #include "Kokkos_Core.hpp"  // Kokkos::DefaultExecutionSpace
 
@@ -24,7 +26,7 @@
 
 #include <vector>  // std::vector
 
-TEST(KokkosDeviceWrapper, default_construct) {
+TEST(KokkosDeviceWrapper, DefaultConstruct) {
     // default construct a device wrapper
     const plssvm::kokkos::detail::device_wrapper device{};
 
@@ -34,7 +36,7 @@ TEST(KokkosDeviceWrapper, default_construct) {
     EXPECT_EQ(device.get_execution_space(), spaces.front());
 }
 
-TEST(KokkosDeviceWrapper, construct) {
+TEST(KokkosDeviceWrapper, Construct) {
     // construct a device wrapper using the current Kokkos::DefaultExecutionSpace
     const plssvm::kokkos::detail::device_wrapper device{ Kokkos::DefaultExecutionSpace{} };
 
@@ -42,16 +44,16 @@ TEST(KokkosDeviceWrapper, construct) {
     EXPECT_EQ(device.get_execution_space(), plssvm::kokkos::kokkos_type_to_execution_space_v<Kokkos::DefaultExecutionSpace>);
 }
 
-TEST(KokkosDeviceWrapper, get) {
+TEST(KokkosDeviceWrapper, Get) {
     // construct a device wrapper using the current Kokkos::DefaultExecutionSpace
-    plssvm::kokkos::detail::device_wrapper device{ Kokkos::DefaultExecutionSpace{} };
+    plssvm::kokkos::detail::device_wrapper device{ Kokkos::DefaultExecutionSpace{} };  // NOLINT(misc-const-correctness): want to test the non-const overload
 
     // check that the returned Kokkos::ExecutionSpace has the correct type
     constexpr plssvm::kokkos::execution_space space = plssvm::kokkos::kokkos_type_to_execution_space_v<Kokkos::DefaultExecutionSpace>;
     ::testing::StaticAssertTypeEq<decltype(device.get<space>()), Kokkos::DefaultExecutionSpace &>();
 }
 
-TEST(KokkosDeviceWrapper, get_const) {
+TEST(KokkosDeviceWrapper, GetConst) {
     // construct a device wrapper using the current Kokkos::DefaultExecutionSpace
     const plssvm::kokkos::detail::device_wrapper device{ Kokkos::DefaultExecutionSpace{} };
 
@@ -60,7 +62,7 @@ TEST(KokkosDeviceWrapper, get_const) {
     ::testing::StaticAssertTypeEq<decltype(device.get<space>()), const Kokkos::DefaultExecutionSpace &>();
 }
 
-TEST(KokkosDeviceWrapper, get_execution_space) {
+TEST(KokkosDeviceWrapper, GetExecutionSpace) {
     // construct a device wrapper using the current Kokkos::DefaultExecutionSpace
     const plssvm::kokkos::detail::device_wrapper device{ Kokkos::DefaultExecutionSpace{} };
 
@@ -68,7 +70,7 @@ TEST(KokkosDeviceWrapper, get_execution_space) {
     EXPECT_EQ(device.get_execution_space(), plssvm::kokkos::kokkos_type_to_execution_space_v<Kokkos::DefaultExecutionSpace>);
 }
 
-TEST(KokkosDeviceWrapper, equality) {
+TEST(KokkosDeviceWrapper, Equality) {
     const plssvm::kokkos::detail::device_wrapper device1{ Kokkos::DefaultExecutionSpace{} };
     const plssvm::kokkos::detail::device_wrapper device2{ Kokkos::DefaultExecutionSpace{} };
 
@@ -76,7 +78,7 @@ TEST(KokkosDeviceWrapper, equality) {
     EXPECT_TRUE(device1 == device2);
 }
 
-TEST(KokkosDeviceWrapper, inequality) {
+TEST(KokkosDeviceWrapper, Inequality) {
     const plssvm::kokkos::detail::device_wrapper device1{ Kokkos::DefaultExecutionSpace{} };
     const plssvm::kokkos::detail::device_wrapper device2{ Kokkos::DefaultExecutionSpace{} };
 
@@ -110,7 +112,7 @@ struct device_list_test {
     }
 };
 
-TEST(KokkosDeviceWrapper, get_device_list) {
+TEST(KokkosDeviceWrapper, GetDeviceList) {
     using variant_type = typename plssvm::kokkos::detail::impl::create_device_variant_type::type;
     util::for_each_variant_type<variant_type>(device_list_test{});
 }
diff --git a/tests/backends/Kokkos/detail/standard_layout_tuple.cpp b/tests/backends/Kokkos/detail/standard_layout_tuple.cpp
index 7b4fb6cd8..e921079cf 100644
--- a/tests/backends/Kokkos/detail/standard_layout_tuple.cpp
+++ b/tests/backends/Kokkos/detail/standard_layout_tuple.cpp
@@ -14,7 +14,7 @@
 
 #include <type_traits>  // std::remove_const_t
 
-TEST(KokkosStandardLayoutTuple, make_standard_layout_tuple) {
+TEST(KokkosStandardLayoutTuple, MakeStandardLayoutTuple) {
     // create a new standard layout tuple
     [[maybe_unused]] const auto tuple = plssvm::kokkos::detail::make_standard_layout_tuple(true, 42, 3.1415);
 
@@ -22,7 +22,7 @@ TEST(KokkosStandardLayoutTuple, make_standard_layout_tuple) {
     ::testing::StaticAssertTypeEq<plssvm::kokkos::detail::standard_layout_tuple<bool, int, double>, std::remove_const_t<decltype(tuple)>>();
 }
 
-TEST(KokkosStandardLayoutTuple, get) {
+TEST(KokkosStandardLayoutTuple, Get) {
     // create a new standard layout tuple
     const auto tuple = plssvm::kokkos::detail::make_standard_layout_tuple(true, 42, 3.1415);
 
diff --git a/tests/backends/Kokkos/detail/utility.cpp b/tests/backends/Kokkos/detail/utility.cpp
index ec18a977b..c05b10472 100644
--- a/tests/backends/Kokkos/detail/utility.cpp
+++ b/tests/backends/Kokkos/detail/utility.cpp
@@ -12,19 +12,12 @@
 
 #include "plssvm/backends/execution_range.hpp"               // plssvm::detail::dim_type
 #include "plssvm/backends/Kokkos/detail/device_wrapper.hpp"  // plssvm::kokkos::detail::device_wrapper
-#include "plssvm/backends/Kokkos/exceptions.hpp"             // plssvm::kokkos::backend_exception
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::{execution_space, kokkos_type_to_execution_space_v}
-#include "plssvm/detail/utility.hpp"                         // plssvm::detail::contains
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"       // plssvm::kokkos::execution_space
 #include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
 
-#include "Kokkos_Core.hpp"  // Kokkos::ExecutionSpace
+#include "tests/utility.hpp"  // util::for_each_variant_type
 
-#include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT
-#include "tests/utility.hpp"             // util::for_each_variant_type
-
-#include "fmt/core.h"     // fmt::format
-#include "gmock/gmock.h"  // EXPECT_THAT; ::testing::AnyOf
-#include "gtest/gtest.h"  // TEST, EXPECT_NE
+#include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, EXPECT_FALSE, EXPECT_GE, SCOPED_TRACE
 
 #include <map>      // std::map
 #include <regex>    // std::regex, std::regex::extended, std::regex_match
@@ -32,7 +25,7 @@
 #include <variant>  // std::variant
 #include <vector>   // std::vector
 
-TEST(KokkosUtility, is_type_in_variant) {
+TEST(KokkosUtility, IsTypeInVariant) {
     // check type trait that determines if a type is contained in a type trait
     using variant_type = std::variant<int, double, bool, std::string>;
 
@@ -44,7 +37,7 @@ TEST(KokkosUtility, is_type_in_variant) {
     EXPECT_FALSE((plssvm::kokkos::detail::impl::is_type_in_variant_v<float, variant_type>) );
 }
 
-TEST(KokkosUtility, dim_type_to_native) {
+TEST(KokkosUtility, DimTypeToNative) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -55,7 +48,7 @@ TEST(KokkosUtility, dim_type_to_native) {
     EXPECT_EQ(native_dim, 262'144);  // = 128 * 64 * 32
 }
 
-TEST(KokkosUtility, available_target_platform_to_execution_space_mapping) {
+TEST(KokkosUtility, AvailableTargetPlatformToExecutionSpaceMapping) {
     // get the target_platform <-> execution_space mappings
     const std::map<plssvm::target_platform, std::vector<plssvm::kokkos::execution_space>> mapping = plssvm::kokkos::detail::available_target_platform_to_execution_space_mapping();
 
@@ -72,22 +65,24 @@ TEST(KokkosUtility, available_target_platform_to_execution_space_mapping) {
 struct device_name_test {
     template <typename ExecutionSpace>
     void operator()() const {
-        // get the device name of the default Kokkos execution space
-        const std::string name = plssvm::kokkos::detail::get_device_name(plssvm::kokkos::detail::device_wrapper{ ExecutionSpace{} });
-        SCOPED_TRACE(name);
-
-        // the returned device name may not be empty or unknown
-        EXPECT_FALSE(name.empty());
-        EXPECT_NE(name, std::string{ "unknown" });
+        // get the device name of the specified Kokkos execution space
+        const std::string device_name = plssvm::kokkos::detail::get_device_name(plssvm::kokkos::detail::device_wrapper{ ExecutionSpace{} });
+        SCOPED_TRACE(device_name);
+
+        // must not be empty
+        EXPECT_FALSE(device_name.empty());
+        // must not start or end with whitespace
+        const std::regex reg{ R"([^\s](?:.*[^\s])?)" };
+        EXPECT_TRUE(std::regex_match(device_name, reg));
     }
 };
 
-TEST(KokkosUtility, get_device_name) {
+TEST(KokkosUtility, GetDeviceName) {
     using variant_type = typename plssvm::kokkos::detail::impl::create_device_variant_type::type;
     util::for_each_variant_type<variant_type>(device_name_test{});
 }
 
-TEST(KokkosUtility, get_kokkos_version) {
+TEST(KokkosUtility, GetKokkosVersion) {
     const std::regex reg{ "[0-9]+\\.[0-9]+\\.[0-9]+", std::regex::extended };
     EXPECT_TRUE(std::regex_match(plssvm::kokkos::detail::get_kokkos_version(), reg));
 }
diff --git a/tests/backends/Kokkos/execution_space.cpp b/tests/backends/Kokkos/execution_space.cpp
index 3e54f3be5..458cd4337 100644
--- a/tests/backends/Kokkos/execution_space.cpp
+++ b/tests/backends/Kokkos/execution_space.cpp
@@ -8,16 +8,18 @@
  * @brief Tests for functions related to the different Kokkos execution spaces.
  */
 
-#include "plssvm/backends/Kokkos/execution_space.hpp"
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING
 
+#include "gmock/gmock.h"  // EXPECT_THAT, testing::contains
 #include "gtest/gtest.h"  // TEST, EXPECT_TRUE, EXPECT_FALSE
 
 #include <sstream>  // std::istringstream
+#include <vector>   // std::vector
 
 // check whether the plssvm::kokkos::execution_space -> std::string conversions are correct
-TEST(KokkosExecutionSpace, to_string) {
+TEST(KokkosExecutionSpace, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::kokkos::execution_space::automatic, "automatic");
     EXPECT_CONVERSION_TO_STRING(plssvm::kokkos::execution_space::cuda, "Cuda");
@@ -31,13 +33,13 @@ TEST(KokkosExecutionSpace, to_string) {
     EXPECT_CONVERSION_TO_STRING(plssvm::kokkos::execution_space::serial, "Serial");
 }
 
-TEST(KokkosExecutionSpace, to_string_unknown) {
+TEST(KokkosExecutionSpace, ToStringUnknown) {
     // check conversions to std::string from unknown execution_space
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::kokkos::execution_space>(10), "unknown");
 }
 
 // check whether the std::string -> plssvm::kokkos::execution_space conversions are correct
-TEST(KokkosExecutionSpace, from_string) {
+TEST(KokkosExecutionSpace, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("Automatic", plssvm::kokkos::execution_space::automatic);
     EXPECT_CONVERSION_FROM_STRING("AUTO", plssvm::kokkos::execution_space::automatic);
@@ -62,7 +64,7 @@ TEST(KokkosExecutionSpace, from_string) {
     EXPECT_CONVERSION_FROM_STRING("SERIAL", plssvm::kokkos::execution_space::serial);
 }
 
-TEST(KokkosExecutionSpace, from_string_unknown) {
+TEST(KokkosExecutionSpace, FromStringUnknown) {
     // foo isn't a valid execution_space
     std::istringstream input{ "foo" };
     plssvm::kokkos::execution_space space{};
@@ -70,7 +72,7 @@ TEST(KokkosExecutionSpace, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(KokkosExecutionSpace, list_available_execution_spaces) {
+TEST(KokkosExecutionSpace, ListAvailableExecutionSpaces) {
     const std::vector<plssvm::kokkos::execution_space> execution_spaces = plssvm::kokkos::list_available_execution_spaces();
 
     // at least one must be available (automatic)!
diff --git a/tests/backends/Kokkos/execution_space_type_traits.cpp b/tests/backends/Kokkos/execution_space_type_traits.cpp
index f813fa836..a41ad27e3 100644
--- a/tests/backends/Kokkos/execution_space_type_traits.cpp
+++ b/tests/backends/Kokkos/execution_space_type_traits.cpp
@@ -10,9 +10,13 @@
 
 #include "plssvm/backends/Kokkos/execution_space_type_traits.hpp"
 
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"  // plssvm::kokkos::execution_space
+
+#include "Kokkos_Core.hpp"  // Kokkos ExecutionSpace types
+
 #include "gtest/gtest.h"  // TEST, EXPECT_EQ, ::testing::StaticAssertTypeEq
 
-TEST(KokkosExecutionSpaceTypeTraits, execution_space_to_kokkos_type) {
+TEST(KokkosExecutionSpaceTypeTraits, ExecutionSpaceToKokkosType) {
     // check conversions
 #if defined(KOKKOS_ENABLE_CUDA)
     ::testing::StaticAssertTypeEq<plssvm::kokkos::execution_space_to_kokkos_type_t<plssvm::kokkos::execution_space::cuda>, Kokkos::Cuda>();
@@ -43,7 +47,7 @@ TEST(KokkosExecutionSpaceTypeTraits, execution_space_to_kokkos_type) {
 #endif
 }
 
-TEST(KokkosExecutionSpaceTypeTraits, kokkos_type_to_execution_space) {
+TEST(KokkosExecutionSpaceTypeTraits, KokkosTypeToExecutionSpace) {
     // check conversions
 #if defined(KOKKOS_ENABLE_CUDA)
     EXPECT_EQ(plssvm::kokkos::kokkos_type_to_execution_space_v<Kokkos::Cuda>, plssvm::kokkos::execution_space::cuda);
diff --git a/tests/backends/Kokkos/kokkos_csvm.cpp b/tests/backends/Kokkos/kokkos_csvm.cpp
index 9e9b4d83f..3137c623d 100644
--- a/tests/backends/Kokkos/kokkos_csvm.cpp
+++ b/tests/backends/Kokkos/kokkos_csvm.cpp
@@ -8,14 +8,14 @@
  * @brief Tests for the functionality related to the Kokkos backend.
  */
 
-#include "plssvm/backends/Kokkos/csvm.hpp"             // plssvm::kokkos::{csvm, csvc, csvr}
-#include "plssvm/backends/Kokkos/detail/utility.hpp"   // plssvm::kokkos::detail::available_target_platform_to_execution_space_mapping
-#include "plssvm/backends/Kokkos/exceptions.hpp"       // plssvm::kokkos::backend_exception
-#include "plssvm/backends/Kokkos/execution_space.hpp"  // plssvm::kokkos::execution_space
-#include "plssvm/detail/type_list.hpp"                 // plssvm::detail::label_type_list
-#include "plssvm/kernel_function_types.hpp"            // plssvm::kernel_function_type
-#include "plssvm/parameter.hpp"                        // plssvm::parameter
-#include "plssvm/target_platforms.hpp"                 // plssvm::target_platform, plssvm::list_available_target_platforms
+#include "plssvm/backends/Kokkos/csvm.hpp"              // plssvm::kokkos::{csvm, csvc, csvr}
+#include "plssvm/backends/Kokkos/detail/utility.hpp"    // plssvm::kokkos::detail::available_target_platform_to_execution_space_mapping
+#include "plssvm/backends/Kokkos/exceptions.hpp"        // plssvm::kokkos::backend_exception
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"  // plssvm::kokkos::execution_space
+#include "plssvm/detail/utility.hpp"                    // plssvm::detail::contains
+#include "plssvm/kernel_function_types.hpp"             // plssvm::kernel_function_type
+#include "plssvm/parameter.hpp"                         // plssvm::parameter
+#include "plssvm/target_platforms.hpp"                  // plssvm::target_platform, plssvm::list_available_target_platforms
 
 #include "tests/backends/generic_base_csvc_tests.hpp"  // generic C-SVC tests to instantiate
 #include "tests/backends/generic_base_csvm_tests.hpp"  // generic C-SVM tests to instantiate
@@ -28,12 +28,13 @@
 #include "tests/types_to_test.hpp"                     // util::{cartesian_type_product_t, combine_test_parameters_gtest_t}
 #include "tests/utility.hpp"                           // util::redirect_output
 
+#include "fmt/format.h"   // fmt::format
+#include "fmt/ranges.h"   // fmt::join
 #include "gtest/gtest.h"  // TEST_F, EXPECT_NO_THROW, INSTANTIATE_TYPED_TEST_SUITE_P, ::testing::Test
 
-#include <array>    // std::array
-#include <cstddef>  // std::size_t
 #include <map>      // std::map
 #include <tuple>    // std::make_tuple, std::tuple
+#include <utility>  // std::make_pair
 #include <vector>   // std::vector
 
 using kokkos_csvm_types_list = std::tuple<plssvm::kokkos::csvc, plssvm::kokkos::csvr>;
@@ -48,7 +49,7 @@ class KokkosCSVMConstructor : public ::testing::Test,
 
 TYPED_TEST_SUITE(KokkosCSVMConstructor, kokkos_csvm_types_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(KokkosCSVMConstructor, default_construct) {  // execution_space automatic, target_platform automatic
+TYPED_TEST(KokkosCSVMConstructor, DefaultConstruct) {  // execution_space automatic, target_platform automatic
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // check whether the execution space would be automatically determined as either OpenMPTarget or OpenACC
@@ -71,7 +72,7 @@ TYPED_TEST(KokkosCSVMConstructor, default_construct) {  // execution_space autom
     }
 }
 
-TYPED_TEST(KokkosCSVMConstructor, construct_parameter) {  // execution_space automatic, target_platform automatic
+TYPED_TEST(KokkosCSVMConstructor, ConstructParameter) {  // execution_space automatic, target_platform automatic
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // check whether the execution space would be automatically determined as either OpenMPTarget or OpenACC
@@ -94,7 +95,7 @@ TYPED_TEST(KokkosCSVMConstructor, construct_parameter) {  // execution_space aut
     }
 }
 
-TYPED_TEST(KokkosCSVMConstructor, construct_target_and_parameter) {  // execution_space automatic, target_platform explicit
+TYPED_TEST(KokkosCSVMConstructor, ConstructTargetAndParameter) {  // execution_space automatic, target_platform explicit
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -165,7 +166,7 @@ TYPED_TEST(KokkosCSVMConstructor, construct_target_and_parameter) {  // executio
 #endif
 }
 
-TYPED_TEST(KokkosCSVMConstructor, construct_execution_space_and_parameter) {  // execution_space explicit, target_platform automatic
+TYPED_TEST(KokkosCSVMConstructor, ConstructExecutionSpaceAndParameter) {  // execution_space explicit, target_platform automatic
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -306,14 +307,14 @@ TYPED_TEST(KokkosCSVMConstructor, construct_execution_space_and_parameter) {  //
 #endif
 }
 
-TYPED_TEST(KokkosCSVMConstructor, construct_target_and_execution_space_and_parameter) {  // execution_space explicit, target_platform explicit
+TYPED_TEST(KokkosCSVMConstructor, ConstructTargetAndExecutionSpaceAndParameter) {  // execution_space explicit, target_platform explicit
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
     const plssvm::parameter params{};
 
     // list all possible execution spaces
-    std::vector<plssvm::kokkos::execution_space> all_execution_spaces{
+    const std::vector<plssvm::kokkos::execution_space> all_execution_spaces{
         plssvm::kokkos::execution_space::cuda,
         plssvm::kokkos::execution_space::hip,
         plssvm::kokkos::execution_space::sycl,
@@ -421,7 +422,7 @@ TYPED_TEST(KokkosCSVMConstructor, construct_target_and_execution_space_and_param
 #endif
 }
 
-TYPED_TEST(KokkosCSVMConstructor, construct_named_args) {  // execution_space automatic, target_platform automatic
+TYPED_TEST(KokkosCSVMConstructor, ConstructNamedArgs) {  // execution_space automatic, target_platform automatic
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // check whether the execution space would be automatically determined as either OpenMPTarget or OpenACC
@@ -445,7 +446,7 @@ TYPED_TEST(KokkosCSVMConstructor, construct_named_args) {  // execution_space au
     }
 }
 
-TYPED_TEST(KokkosCSVMConstructor, construct_target_and_named_args) {  // execution_space automatic, target_platform explicit
+TYPED_TEST(KokkosCSVMConstructor, ConstructTargetAndNamedArgs) {  // execution_space automatic, target_platform explicit
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // automatic should always work
@@ -513,7 +514,7 @@ TYPED_TEST(KokkosCSVMConstructor, construct_target_and_named_args) {  // executi
 #endif
 }
 
-TYPED_TEST(KokkosCSVMConstructor, construct_execution_space_and_named_args) {  // execution_space explicit, target_platform automatic
+TYPED_TEST(KokkosCSVMConstructor, ConstructExecutionSpaceAndNamedArgs) {  // execution_space explicit, target_platform automatic
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // automatic should always work
@@ -651,11 +652,11 @@ TYPED_TEST(KokkosCSVMConstructor, construct_execution_space_and_named_args) {  /
 #endif
 }
 
-TYPED_TEST(KokkosCSVMConstructor, construct_target_and_execution_space_and_named_args) {  // execution_space explicit, target_platform explicit
+TYPED_TEST(KokkosCSVMConstructor, ConstructTargetAndExecutionSpaceAndNamedArgs) {  // execution_space explicit, target_platform explicit
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // list all possible execution spaces
-    std::vector<plssvm::kokkos::execution_space> all_execution_spaces{
+    const std::vector<plssvm::kokkos::execution_space> all_execution_spaces{
         plssvm::kokkos::execution_space::cuda,
         plssvm::kokkos::execution_space::hip,
         plssvm::kokkos::execution_space::sycl,
@@ -763,7 +764,7 @@ TYPED_TEST(KokkosCSVMConstructor, construct_target_and_execution_space_and_named
 #endif
 }
 
-TYPED_TEST(KokkosCSVMConstructor, get_execution_space) {
+TYPED_TEST(KokkosCSVMConstructor, GetExecutionSpace) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // construct default C-SVM
@@ -780,7 +781,7 @@ struct kokkos_csvm_test_type {
     using csvc_type = plssvm::kokkos::csvc;
     using csvr_type = plssvm::kokkos::csvr;
     using device_ptr_type = typename csvm_type::device_ptr_type;
-    inline static auto additional_arguments = std::make_tuple(std::make_pair(plssvm::kokkos_execution_space, space));
+    inline static auto additional_arguments = std::make_tuple(std::make_pair(plssvm::kokkos_execution_space, space));  // NOLINT(cert-err58-cpp): won't throw an exception
 };
 
 // a tuple containing the test structs
diff --git a/tests/backends/Kokkos/mock_kokkos_csvm.hpp b/tests/backends/Kokkos/mock_kokkos_csvm.hpp
index e39bb6cc8..a2cb1f517 100644
--- a/tests/backends/Kokkos/mock_kokkos_csvm.hpp
+++ b/tests/backends/Kokkos/mock_kokkos_csvm.hpp
@@ -48,6 +48,7 @@ class mock_kokkos_csvm final : public plssvm::kokkos::csvm {
     using base_type::assemble_kernel_matrix;
     using base_type::blas_level_3;
     using base_type::get_device_memory;
+    using base_type::get_local_memory;
     using base_type::get_max_work_group_size;
     using base_type::num_available_devices;
 
@@ -59,6 +60,7 @@ class mock_kokkos_csvm final : public plssvm::kokkos::csvm {
     using base_type::run_blas_level_3;
     using base_type::solve_lssvm_system_of_linear_equations;
 
+    using base_type::get_execution_space;
     using base_type::get_max_mem_alloc_size;
 
     using base_type::run_assemble_kernel_matrix_explicit;
diff --git a/tests/backends/OpenCL/CMakeLists.txt b/tests/backends/OpenCL/CMakeLists.txt
index 5f4e8b006..899884c7a 100644
--- a/tests/backends/OpenCL/CMakeLists.txt
+++ b/tests/backends/OpenCL/CMakeLists.txt
@@ -30,20 +30,20 @@ include(${PROJECT_SOURCE_DIR}/cmake/discover_tests_with_death_test_filter.cmake)
 discover_tests_with_death_test_filter(${PLSSVM_OPENCL_TEST_NAME})
 
 # add minimal run test for the classification task with the OpenCL backend
-add_test(NAME MainTrainClassificationOpenCL/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b opencl "${PLSSVM_CLASSIFICATION_TEST_FILE}"
-                                                                       "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
+add_test(NAME MainTrainClassificationOpenCL/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b opencl "${PLSSVM_CLASSIFICATION_TEST_FILE}"
+                                                                      "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
 )
-add_test(NAME MainPredictClassificationOpenCL/executable_minimal
+add_test(NAME MainPredictClassificationOpenCL/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b opencl "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/classification/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/classification/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.predict" # predict file (result)
 )
 
 # add minimal run test for the regression task with the OpenCL backend
-add_test(NAME MainTrainRegressionOpenCL/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b opencl "${PLSSVM_REGRESSION_TEST_FILE}"
-                                                                   "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
+add_test(NAME MainTrainRegressionOpenCL/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b opencl "${PLSSVM_REGRESSION_TEST_FILE}"
+                                                                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
 )
-add_test(NAME MainPredictRegressionOpenCL/executable_minimal
+add_test(NAME MainPredictRegressionOpenCL/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b opencl "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/regression/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/regression/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.predict" # predict file (result)
diff --git a/tests/backends/OpenCL/detail/device_ptr.cpp b/tests/backends/OpenCL/detail/device_ptr.cpp
index aa5f678c6..d641213b0 100644
--- a/tests/backends/OpenCL/detail/device_ptr.cpp
+++ b/tests/backends/OpenCL/detail/device_ptr.cpp
@@ -12,7 +12,9 @@
 
 #include "plssvm/backends/OpenCL/detail/command_queue.hpp"  // plssvm::opencl::detail::command_queue
 #include "plssvm/backends/OpenCL/detail/context.hpp"        // plssvm::opencl::detail::context
-#include "plssvm/backends/OpenCL/detail/utility.hpp"        // plssvm::opencl::detail::get_contexts
+#include "plssvm/backends/OpenCL/detail/utility.hpp"        // plssvm::opencl::detail::{get_contexts, create_command_queues}
+#include "plssvm/kernel_function_types.hpp"                 // plssvm::kernel_function_type
+#include "plssvm/target_platforms.hpp"                      // plssvm::determine_default_target_platform
 
 #include "tests/backends/generic_device_ptr_tests.hpp"  // generic device pointer tests to instantiate
 #include "tests/naming.hpp"                             // naming::test_parameter_to_name
@@ -29,8 +31,10 @@ struct opencl_device_ptr_test_type {
     using queue_type = plssvm::opencl::detail::command_queue;
 
     static const queue_type &default_queue() {
-        static const std::vector<plssvm::opencl::detail::context> contexts{ plssvm::opencl::detail::get_contexts(plssvm::target_platform::automatic).first };
-        static const plssvm::opencl::detail::command_queue queue{ contexts[0], contexts[0].device };
+        static const std::vector<plssvm::opencl::detail::context> contexts{ plssvm::opencl::detail::get_contexts(plssvm::determine_default_target_platform()).first };
+        // note: the kernel_function_type doesn't matter for the device_ptr tests!
+        static const auto command_queues{ plssvm::opencl::detail::create_command_queues({}, contexts, plssvm::determine_default_target_platform(), plssvm::kernel_function_type::linear) };
+        static const plssvm::opencl::detail::command_queue &queue{ command_queues.first.front() };
         return queue;
     }
 };
diff --git a/tests/backends/OpenCL/detail/error_code.cpp b/tests/backends/OpenCL/detail/error_code.cpp
index c6b2b134e..0a877449b 100644
--- a/tests/backends/OpenCL/detail/error_code.cpp
+++ b/tests/backends/OpenCL/detail/error_code.cpp
@@ -10,25 +10,27 @@
 
 #include "plssvm/backends/OpenCL/detail/error_code.hpp"  // plssvm::opencl::detail::error_code
 
-#include "CL/cl.h"  // CL_SUCCESS, CL_DEVICE_NOT_FOUND, cl_int
+#include "CL/cl.h"           // CL_SUCCESS, CL_DEVICE_NOT_FOUND
+#include "CL/cl_platform.h"  // cl_int
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING
 
+#include "fmt/format.h"   // fmt::format
 #include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, EXPECT_FALSE
 
 #include <string>  // std::string
 
-TEST(OpenCLErrorCode, default_construct) {
+TEST(OpenCLErrorCode, DefaultConstruct) {
     // the default error code should signal success
     EXPECT_EQ(plssvm::opencl::detail::error_code{}.value(), CL_SUCCESS);
 }
 
-TEST(OpenCLErrorCode, construct) {
+TEST(OpenCLErrorCode, Construct) {
     // construct from an OpenCL error code
     EXPECT_EQ(plssvm::opencl::detail::error_code{ CL_DEVICE_NOT_FOUND }.value(), CL_DEVICE_NOT_FOUND);
 }
 
-TEST(OpenCLErrorCode, operator_assign) {
+TEST(OpenCLErrorCode, OperatorAssign) {
     // default construct the error code
     plssvm::opencl::detail::error_code errc{};
     EXPECT_EQ(errc.value(), CL_SUCCESS);
@@ -37,7 +39,7 @@ TEST(OpenCLErrorCode, operator_assign) {
     EXPECT_EQ(errc.value(), CL_DEVICE_NOT_FOUND);
 }
 
-TEST(OpenCLErrorCode, assign) {
+TEST(OpenCLErrorCode, Assign) {
     // default construct the error code
     plssvm::opencl::detail::error_code errc{};
     EXPECT_EQ(errc.value(), CL_SUCCESS);
@@ -46,7 +48,7 @@ TEST(OpenCLErrorCode, assign) {
     EXPECT_EQ(errc.value(), CL_DEVICE_NOT_FOUND);
 }
 
-TEST(OpenCLErrorCode, clear) {
+TEST(OpenCLErrorCode, Clear) {
     // construct from an OpenCL error code
     plssvm::opencl::detail::error_code errc{ CL_DEVICE_NOT_FOUND };
     EXPECT_EQ(errc.value(), CL_DEVICE_NOT_FOUND);
@@ -55,21 +57,21 @@ TEST(OpenCLErrorCode, clear) {
     EXPECT_EQ(errc.value(), CL_SUCCESS);
 }
 
-TEST(OpenCLErrorCode, value) {
+TEST(OpenCLErrorCode, Value) {
     // default construct the error code
     const plssvm::opencl::detail::error_code errc{};
     // get the value
     EXPECT_EQ(errc.value(), CL_SUCCESS);
 }
 
-TEST(OpenCLErrorCode, message) {
+TEST(OpenCLErrorCode, Message) {
     // default construct the error code
     const plssvm::opencl::detail::error_code errc{};
     // get the value as a string
     EXPECT_EQ(errc.message(), "CL_SUCCESS");
 }
 
-TEST(OpenCLErrorCode, possible_message_error_codes) {
+TEST(OpenCLErrorCode, PossibleMessageErrorCodes) {
     // any error code greater than zero is unknown
     std::string msg = std::string{ plssvm::opencl::detail::error_code{ 1 }.message() };
     EXPECT_EQ(msg, "UNKNOWN ERROR_CODE");
@@ -87,19 +89,19 @@ TEST(OpenCLErrorCode, possible_message_error_codes) {
     }
 }
 
-TEST(OpenCLErrorCode, operator_bool) {
+TEST(OpenCLErrorCode, OperatorBool) {
     // conversion to bool must be true if the error code is CL_SUCCESS
     EXPECT_TRUE(static_cast<bool>(plssvm::opencl::detail::error_code{}));
     // must return false otherwise
     EXPECT_FALSE(static_cast<bool>(plssvm::opencl::detail::error_code{ CL_DEVICE_NOT_FOUND }));
 }
 
-TEST(OpenCLErrorCode, operator_ostream) {
+TEST(OpenCLErrorCode, OperatorOstream) {
     EXPECT_CONVERSION_TO_STRING(plssvm::opencl::detail::error_code{ CL_SUCCESS }, "0: CL_SUCCESS");
     EXPECT_CONVERSION_TO_STRING(plssvm::opencl::detail::error_code{ CL_DEVICE_NOT_FOUND }, "-1: CL_DEVICE_NOT_FOUND");
 }
 
-TEST(OpenCLErrorCode, operator_equal) {
+TEST(OpenCLErrorCode, OperatorEqual) {
     // test two error codes for equality
     const plssvm::opencl::detail::error_code errc1{};
     const plssvm::opencl::detail::error_code errc2{ CL_SUCCESS };
@@ -111,7 +113,7 @@ TEST(OpenCLErrorCode, operator_equal) {
     EXPECT_FALSE(errc2 == errc3);
 }
 
-TEST(OpenCLErrorCode, operator_unequal) {
+TEST(OpenCLErrorCode, OperatorUnequal) {
     // test two error codes for equality
     const plssvm::opencl::detail::error_code errc1{};
     const plssvm::opencl::detail::error_code errc2{ CL_SUCCESS };
diff --git a/tests/backends/OpenCL/detail/jit_info.cpp b/tests/backends/OpenCL/detail/jit_info.cpp
index 675146acf..858b4d29c 100644
--- a/tests/backends/OpenCL/detail/jit_info.cpp
+++ b/tests/backends/OpenCL/detail/jit_info.cpp
@@ -19,19 +19,19 @@
 #include <string>  // std::string
 
 // check whether the plssvm::opencl::detail::jit_info::caching_status -> std::string conversions are correct
-TEST(OpenCLJITInfoCachingStatus, to_string) {
+TEST(OpenCLJITInfoCachingStatus, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::opencl::detail::jit_info::caching_status::success, "success");
     EXPECT_CONVERSION_TO_STRING(plssvm::opencl::detail::jit_info::caching_status::error_no_cached_files, "no cached files exist (checksum missmatch)");
     EXPECT_CONVERSION_TO_STRING(plssvm::opencl::detail::jit_info::caching_status::error_invalid_number_of_cached_files, "invalid number of cached files");
 }
 
-TEST(OpenCLJITInfoCachingStatus, to_string_unknown) {
+TEST(OpenCLJITInfoCachingStatus, ToStringUnknown) {
     // check conversions to std::string from unknown caching_status
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::opencl::detail::jit_info::caching_status>(3), "unknown");
 }
 
-TEST(OpenCLJITInfo, default_construct) {
+TEST(OpenCLJITInfo, DefaultConstruct) {
     // default construct a JIT info struct
     const plssvm::opencl::detail::jit_info info{};
 
@@ -41,7 +41,7 @@ TEST(OpenCLJITInfo, default_construct) {
     EXPECT_EQ(info.duration, std::chrono::milliseconds{});
 }
 
-TEST(OpenCLJITInfo, construct) {
+TEST(OpenCLJITInfo, Construct) {
     using namespace std::chrono_literals;
 
     // construct a JIT info struct
@@ -49,7 +49,7 @@ TEST(OpenCLJITInfo, construct) {
         true,
         plssvm::opencl::detail::jit_info::caching_status::error_no_cached_files,
         "jit/file/path",
-        250ms
+        250ms  // NOLINT(misc-include-cleaner): included via <chrono>
     };
 
     EXPECT_TRUE(info.use_ptx_inline);
@@ -58,7 +58,7 @@ TEST(OpenCLJITInfo, construct) {
     EXPECT_EQ(info.duration, 250ms);
 }
 
-TEST(OpenCLJITInfo, create_jit_report) {
+TEST(OpenCLJITInfo, CreateJitReport) {
     using namespace std::chrono_literals;
 
     // construct a JIT info struct
@@ -66,7 +66,7 @@ TEST(OpenCLJITInfo, create_jit_report) {
         true,
         plssvm::opencl::detail::jit_info::caching_status::error_invalid_number_of_cached_files,
         "jit/file/path",
-        250ms
+        250ms  // NOLINT(misc-include-cleaner): included via <chrono>
     };
 
     EXPECT_THAT(plssvm::opencl::detail::create_jit_report(info), ::testing::HasSubstr("250ms; PTX inline; cache: invalid number of cached files (jit/file/path)"));
diff --git a/tests/backends/OpenCL/detail/utility.cpp b/tests/backends/OpenCL/detail/utility.cpp
index fe24e594a..d6b7759a9 100644
--- a/tests/backends/OpenCL/detail/utility.cpp
+++ b/tests/backends/OpenCL/detail/utility.cpp
@@ -14,19 +14,20 @@
 #include "plssvm/backends/OpenCL/detail/command_queue.hpp"  // plssvm::opencl::detail::command_queue
 #include "plssvm/backends/OpenCL/detail/context.hpp"        // plssvm::opencl::detail::context
 #include "plssvm/backends/OpenCL/exceptions.hpp"            // plssvm::opencl::backend_exception
+#include "plssvm/target_platforms.hpp"                      // plssvm::target_platform
 
 #include "CL/cl.h"  // CL_SUCCESS, CL_DEVICE_NOT_FOUND
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT
 
-#include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_NE, EXPECT_NO_THROW, EXPECT_FALSE
+#include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_NE, EXPECT_GE, EXPECT_NO_THROW, EXPECT_FALSE
 
 #include <cstddef>  // std::size_t
 #include <regex>    // std::regex, std::regex::extended, std::regex_match
 #include <string>   // std::string
 #include <vector>   // std::vector
 
-TEST(OpenCLUtility, error_check) {
+TEST(OpenCLUtility, ErrorCheck) {
     // CL_SUCCESS must not throw
     EXPECT_NO_THROW(PLSSVM_OPENCL_ERROR_CHECK(CL_SUCCESS, "success!"));
 
@@ -36,7 +37,7 @@ TEST(OpenCLUtility, error_check) {
                       "OpenCL assert 'CL_DEVICE_NOT_FOUND' (-1): error!");
 }
 
-TEST(OpenCLUtility, dim_type_to_native_1) {
+TEST(OpenCLUtility, DimTypeToNativeOneDimensional) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -48,7 +49,7 @@ TEST(OpenCLUtility, dim_type_to_native_1) {
     EXPECT_EQ(native_dim[0], dim.x);
 }
 
-TEST(OpenCLUtility, dim_type_to_native_2) {
+TEST(OpenCLUtility, DimTypeToNativeTwoDimensional) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -61,7 +62,7 @@ TEST(OpenCLUtility, dim_type_to_native_2) {
     EXPECT_EQ(native_dim[1], dim.y);
 }
 
-TEST(OpenCLUtility, dim_type_to_native_3) {
+TEST(OpenCLUtility, DimTypeToNativeThreeDimensional) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -75,20 +76,20 @@ TEST(OpenCLUtility, dim_type_to_native_3) {
     EXPECT_EQ(native_dim[2], dim.z);
 }
 
-TEST(OpenCLUtility, get_contexts) {
+TEST(OpenCLUtility, GetContexts) {
     const auto &[contexts, actual_target] = plssvm::opencl::detail::get_contexts(plssvm::target_platform::automatic);
     // exactly one context must be provided
-    EXPECT_EQ(contexts.size(), 1);
+    EXPECT_GE(contexts.size(), 1);
     // the returned target must not be the automatic one
     EXPECT_NE(actual_target, plssvm::target_platform::automatic);
 }
 
-TEST(OpenCLUtility, get_opencl_target_version) {
+TEST(OpenCLUtility, GetOpenCLTargetVersion) {
     const std::regex reg{ "[0-9]+\\.[0-9]+", std::regex::extended };
     EXPECT_TRUE(std::regex_match(plssvm::opencl::detail::get_opencl_target_version(), reg));
 }
 
-TEST(OpenCLUtility, get_driver_version) {
+TEST(OpenCLUtility, GetDriverVersion) {
     // create a valid command queue
     const std::vector<plssvm::opencl::detail::context> contexts{ plssvm::opencl::detail::get_contexts(plssvm::target_platform::automatic).first };
     const plssvm::opencl::detail::command_queue queue{ contexts[0], contexts[0].device };
@@ -97,16 +98,22 @@ TEST(OpenCLUtility, get_driver_version) {
     EXPECT_FALSE(driver_version.empty());
 }
 
-TEST(OpenCLUtility, get_device_name) {
+TEST(OpenCLUtility, GetDeviceName) {
     // create a valid command queue
     const std::vector<plssvm::opencl::detail::context> contexts{ plssvm::opencl::detail::get_contexts(plssvm::target_platform::automatic).first };
+    // at least one context must be available
+    EXPECT_FALSE(contexts.empty());
     const plssvm::opencl::detail::command_queue queue{ contexts[0], contexts[0].device };
-    // the device name should not be empty
-    const std::string name = plssvm::opencl::detail::get_device_name(queue);
-    EXPECT_FALSE(name.empty());
+
+    const std::string device_name = plssvm::opencl::detail::get_device_name(queue);
+    // must not be empty
+    EXPECT_FALSE(device_name.empty());
+    // must not start or end with whitespace
+    const std::regex reg{ R"([^\s](?:.*[^\s])?)" };
+    EXPECT_TRUE(std::regex_match(device_name, reg));
 }
 
-TEST(OpenCLUtility, kernel_type_to_function_names) {
+TEST(OpenCLUtility, KernelTypeToFunctionNames) {
     // retrieve the function names
     const auto function_name_map = plssvm::opencl::detail::kernel_type_to_function_names();
     // the map must not be empty!
diff --git a/tests/backends/OpenCL/mock_opencl_csvm.hpp b/tests/backends/OpenCL/mock_opencl_csvm.hpp
index f0ae913d6..78c4df969 100644
--- a/tests/backends/OpenCL/mock_opencl_csvm.hpp
+++ b/tests/backends/OpenCL/mock_opencl_csvm.hpp
@@ -47,6 +47,7 @@ class mock_opencl_csvm : public plssvm::opencl::csvm {
     using base_type::assemble_kernel_matrix;
     using base_type::blas_level_3;
     using base_type::get_device_memory;
+    using base_type::get_local_memory;
     using base_type::get_max_work_group_size;
     using base_type::num_available_devices;
 
diff --git a/tests/backends/OpenCL/opencl_csvm.cpp b/tests/backends/OpenCL/opencl_csvm.cpp
index 4a8929a76..a39268763 100644
--- a/tests/backends/OpenCL/opencl_csvm.cpp
+++ b/tests/backends/OpenCL/opencl_csvm.cpp
@@ -6,14 +6,12 @@
  *          See the LICENSE.md file in the project root for full license information.
  */
 
-#include "plssvm/backend_types.hpp"                // plssvm::csvm_to_backend_type_v
-#include "plssvm/backends/OpenCL/csvm.hpp"         // plssvm::opencl::{csvm, csvc, csvr}
-#include "plssvm/backends/OpenCL/exceptions.hpp"   // plssvm::opencl::backend_exception
-#include "plssvm/detail/arithmetic_type_name.hpp"  // plssvm::detail::arithmetic_type_name
-#include "plssvm/detail/type_list.hpp"             // plssvm::detail::label_type_list
-#include "plssvm/kernel_function_types.hpp"        // plssvm::kernel_function_type
-#include "plssvm/parameter.hpp"                    // plssvm::parameter, plssvm::kernel_type, plssvm::cost
-#include "plssvm/target_platforms.hpp"             // plssvm::target_platform
+#include "plssvm/backend_types.hpp"               // plssvm::csvm_to_backend_type_v
+#include "plssvm/backends/OpenCL/csvm.hpp"        // plssvm::opencl::{csvm, csvc, csvr}
+#include "plssvm/backends/OpenCL/exceptions.hpp"  // plssvm::opencl::backend_exception
+#include "plssvm/kernel_function_types.hpp"       // plssvm::kernel_function_type
+#include "plssvm/parameter.hpp"                   // plssvm::parameter, plssvm::kernel_type, plssvm::cost
+#include "plssvm/target_platforms.hpp"            // plssvm::target_platform
 
 #include "tests/backends/generic_base_csvc_tests.hpp"  // generic C-SVC tests to instantiate
 #include "tests/backends/generic_base_csvm_tests.hpp"  // generic C-SVM tests to instantiate
@@ -42,21 +40,21 @@ class OpenCLCSVMConstructor : public ::testing::Test,
 TYPED_TEST_SUITE(OpenCLCSVMConstructor, opencl_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(OpenCLCSVMConstructor, default_construct) {
+TYPED_TEST(OpenCLCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // default constructor must always work
     EXPECT_NO_THROW(csvm_type{});
 }
 
-TYPED_TEST(OpenCLCSVMConstructor, construct_parameter) {
+TYPED_TEST(OpenCLCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // the automatic target platform must always be available
     EXPECT_NO_THROW(csvm_type{ plssvm::parameter{} });
 }
 
-TYPED_TEST(OpenCLCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(OpenCLCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -93,7 +91,7 @@ TYPED_TEST(OpenCLCSVMConstructor, construct_target_and_parameter) {
 #endif
 }
 
-TYPED_TEST(OpenCLCSVMConstructor, construct_named_args) {
+TYPED_TEST(OpenCLCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // every target is allowed for OpenCL
@@ -101,7 +99,7 @@ TYPED_TEST(OpenCLCSVMConstructor, construct_named_args) {
     EXPECT_NO_THROW((csvm_type{ plssvm::cost = 2.0 }));
 }
 
-TYPED_TEST(OpenCLCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(OpenCLCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // every target is allowed for OpenCL
@@ -146,7 +144,7 @@ struct opencl_csvm_test_type {
     using csvc_type = plssvm::opencl::csvc;
     using csvr_type = plssvm::opencl::csvr;
     using device_ptr_type = typename csvm_type::device_ptr_type;
-    inline constexpr static auto additional_arguments = std::make_tuple();
+    constexpr static auto additional_arguments = std::make_tuple();
 };
 
 // a tuple containing the test structs
diff --git a/tests/backends/OpenMP/CMakeLists.txt b/tests/backends/OpenMP/CMakeLists.txt
index bfc76436d..5cfab2a5d 100644
--- a/tests/backends/OpenMP/CMakeLists.txt
+++ b/tests/backends/OpenMP/CMakeLists.txt
@@ -22,20 +22,20 @@ include(${PROJECT_SOURCE_DIR}/cmake/discover_tests_with_death_test_filter.cmake)
 discover_tests_with_death_test_filter(${PLSSVM_OPENMP_TEST_NAME})
 
 # add minimal run test for the classification task with the OpenMP backend
-add_test(NAME MainTrainClassificationOpenMP/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b openmp "${PLSSVM_CLASSIFICATION_TEST_FILE}"
-                                                                       "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
+add_test(NAME MainTrainClassificationOpenMP/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b openmp "${PLSSVM_CLASSIFICATION_TEST_FILE}"
+                                                                      "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
 )
-add_test(NAME MainPredictClassificationOpenMP/executable_minimal
+add_test(NAME MainPredictClassificationOpenMP/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b openmp "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/classification/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/classification/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.predict" # predict file (result)
 )
 
 # add minimal run test for the regression task with the OpenMP backend
-add_test(NAME MainTrainRegressionOpenMP/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b openmp "${PLSSVM_REGRESSION_TEST_FILE}"
-                                                                   "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
+add_test(NAME MainTrainRegressionOpenMP/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b openmp "${PLSSVM_REGRESSION_TEST_FILE}"
+                                                                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
 )
-add_test(NAME MainPredictRegressionOpenMP/executable_minimal
+add_test(NAME MainPredictRegressionOpenMP/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b openmp "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/regression/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/regression/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.predict" # predict file (result)
diff --git a/tests/backends/OpenMP/detail/utility.cpp b/tests/backends/OpenMP/detail/utility.cpp
index 416820b8c..2d4ced8df 100644
--- a/tests/backends/OpenMP/detail/utility.cpp
+++ b/tests/backends/OpenMP/detail/utility.cpp
@@ -10,15 +10,14 @@
 
 #include "plssvm/backends/OpenMP/detail/utility.hpp"
 
-#include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_NE, EXPECT_NO_THROW, EXPECT_FALSE
+#include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_FALSE
 
-#include <regex>   // std::regex, std::regex::extended, std::regex_match
 #include <string>  // std::string
 
-TEST(OpenMPUtility, get_num_threads) {
+TEST(OpenMPUtility, GetNumThreads) {
     EXPECT_GT(plssvm::openmp::detail::get_num_threads(), 0);
 }
 
-TEST(OpenMPUtility, get_openmp_version) {
+TEST(OpenMPUtility, GetOpenMPVersion) {
     EXPECT_FALSE(plssvm::openmp::detail::get_openmp_version().empty());
 }
diff --git a/tests/backends/OpenMP/mock_openmp_csvm.hpp b/tests/backends/OpenMP/mock_openmp_csvm.hpp
index c09b3b765..1ecef2021 100644
--- a/tests/backends/OpenMP/mock_openmp_csvm.hpp
+++ b/tests/backends/OpenMP/mock_openmp_csvm.hpp
@@ -33,6 +33,7 @@ class mock_openmp_csvm final : public plssvm::openmp::csvm {
     using base_type::assemble_kernel_matrix;
     using base_type::blas_level_3;
     using base_type::get_device_memory;
+    using base_type::get_local_memory;
     using base_type::num_available_devices;
 
     using base_type::predict_values;
diff --git a/tests/backends/OpenMP/openmp_csvm.cpp b/tests/backends/OpenMP/openmp_csvm.cpp
index f4d87e7b6..b37dc0011 100644
--- a/tests/backends/OpenMP/openmp_csvm.cpp
+++ b/tests/backends/OpenMP/openmp_csvm.cpp
@@ -15,34 +15,24 @@
 #include "plssvm/backends/OpenMP/kernel/cg_explicit/kernel_matrix_assembly.hpp"       // plssvm::openmp::device_kernel_assembly
 #include "plssvm/backends/OpenMP/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp"  // plssvm::openmp::device_kernel_assembly_symm
 #include "plssvm/backends/OpenMP/kernel/predict_kernel.hpp"                           // plssvm::openmp::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
-#include "plssvm/constants.hpp"                                                       // plssvm::PADDING_SIZE
-#include "plssvm/data_set/classification_data_set.hpp"                                // plssvm::classification_data_set
-#include "plssvm/detail/arithmetic_type_name.hpp"                                     // plssvm::detail::arithmetic_type_name
-#include "plssvm/detail/data_distribution.hpp"                                        // plssvm::detail::triangular_data_distribution
-#include "plssvm/detail/type_list.hpp"                                                // plssvm::detail::supported_label_types
+#include "plssvm/constants.hpp"                                                       // plssvm::real_type
 #include "plssvm/kernel_function_types.hpp"                                           // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                                                          // plssvm::soa_matrix
 #include "plssvm/parameter.hpp"                                                       // plssvm::parameter, plssvm::detail::parameter, plssvm::kernel_type, plssvm::cost
-#include "plssvm/shape.hpp"                                                           // plssvm::shape
 #include "plssvm/target_platforms.hpp"                                                // plssvm::target_platform
 
-#include "tests/backends/generic_base_csvc_tests.hpp"  // generic C-SVC tests to instantiate
-#include "tests/backends/generic_base_csvm_tests.hpp"  // generic C-SVM tests to instantiate
-#include "tests/backends/generic_base_csvr_tests.hpp"  // generic C-SVR tests to instantiate
-#include "tests/backends/ground_truth.hpp"             // ground_truth::{perform_dimensional_reduction, assemble_device_specific_kernel_matrix, assemble_full_kernel_matrix, gemm, calculate_w}
+#include "tests/backends/generic_base_csvc_tests.hpp"  // NOLINT: generic C-SVC tests to instantiate
+#include "tests/backends/generic_base_csvm_tests.hpp"  // NOLINT: generic C-SVM tests to instantiate
+#include "tests/backends/generic_base_csvr_tests.hpp"  // NOLINT: generic C-SVR tests to instantiate
 #include "tests/backends/OpenMP/mock_openmp_csvm.hpp"  // mock_openmp_csvm
 #include "tests/custom_test_macros.hpp"                // EXPECT_THROW_WHAT
-#include "tests/naming.hpp"                            // naming::test_parameter_to_name
-#include "tests/types_to_test.hpp"                     // util::{cartesian_type_product_t, combine_test_parameters_gtest_t}
-#include "tests/utility.hpp"                           // util::redirect_output
+#include "tests/naming.hpp"                            // NOLINT: naming::test_parameter_to_name
+#include "tests/types_to_test.hpp"                     // NOLINT: util::{cartesian_type_product_t, combine_test_parameters_gtest_t}
+#include "tests/utility.hpp"                           // NOLINT: util::redirect_output
 
-#include "fmt/format.h"   // fmt::format
-#include "gtest/gtest.h"  // TYPED_TEST, TYPED_TEST_SUITE, TEST_F, EXPECT_NO_THROW, INSTANTIATE_TYPED_TEST_SUITE_P, ::testing::Test
+#include "gtest/gtest.h"  // TYPED_TEST, TYPED_TEST_SUITE, EXPECT_NO_THROW, INSTANTIATE_TYPED_TEST_SUITE_P, ::testing::Test
 
-#include <algorithm>  // std::min
-#include <cstddef>    // std::size_t
-#include <tuple>      // std::make_tuple, std::tuple
-#include <vector>     // std::vector
+#include <tuple>  // std::make_tuple, std::tuple
 
 using openmp_csvm_types_list = std::tuple<plssvm::openmp::csvc, plssvm::openmp::csvr>;
 using openmp_csvm_types_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<openmp_csvm_types_list>>;
@@ -57,7 +47,7 @@ class OpenMPCSVMConstructor : public ::testing::Test,
 TYPED_TEST_SUITE(OpenMPCSVMConstructor, openmp_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(OpenMPCSVMConstructor, default_construct) {
+TYPED_TEST(OpenMPCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -70,7 +60,7 @@ TYPED_TEST(OpenMPCSVMConstructor, default_construct) {
 #endif
 }
 
-TYPED_TEST(OpenMPCSVMConstructor, construct_parameter) {
+TYPED_TEST(OpenMPCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -83,7 +73,7 @@ TYPED_TEST(OpenMPCSVMConstructor, construct_parameter) {
 #endif
 }
 
-TYPED_TEST(OpenMPCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(OpenMPCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -114,7 +104,7 @@ TYPED_TEST(OpenMPCSVMConstructor, construct_target_and_parameter) {
                       "Invalid target platform 'gpu_intel' for the OpenMP backend!");
 }
 
-TYPED_TEST(OpenMPCSVMConstructor, construct_named_args) {
+TYPED_TEST(OpenMPCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -131,7 +121,7 @@ TYPED_TEST(OpenMPCSVMConstructor, construct_named_args) {
 #endif
 }
 
-TYPED_TEST(OpenMPCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(OpenMPCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -165,7 +155,7 @@ struct openmp_csvm_test_type {
     using csvc_type = plssvm::openmp::csvc;
     using csvr_type = plssvm::openmp::csvr;
     using device_ptr_type = const plssvm::soa_matrix<plssvm::real_type> *;
-    inline constexpr static auto additional_arguments = std::make_tuple();
+    constexpr static auto additional_arguments = std::make_tuple();
 };
 
 // a tuple containing the test structs
diff --git a/tests/backends/SYCL/AdaptiveCpp/.clang-tidy b/tests/backends/SYCL/AdaptiveCpp/.clang-tidy
new file mode 100644
index 000000000..cdf2ade2d
--- /dev/null
+++ b/tests/backends/SYCL/AdaptiveCpp/.clang-tidy
@@ -0,0 +1,6 @@
+---
+Checks: '
+-misc-include-cleaner,
+'
+
+InheritParentConfig: true
\ No newline at end of file
diff --git a/tests/backends/SYCL/AdaptiveCpp/CMakeLists.txt b/tests/backends/SYCL/AdaptiveCpp/CMakeLists.txt
index 31967bce4..8016395cd 100644
--- a/tests/backends/SYCL/AdaptiveCpp/CMakeLists.txt
+++ b/tests/backends/SYCL/AdaptiveCpp/CMakeLists.txt
@@ -15,10 +15,10 @@ set(PLSSVM_SYCL_ADAPTIVECPP_TEST_SOURCES
     ${CMAKE_CURRENT_LIST_DIR}/detail/utility.cpp
     ${CMAKE_CURRENT_LIST_DIR}/adaptivecpp_csvm.cpp
     # ~~~
-    # since the SYCL implementation_type and kernel_invocation_type enumerations are used even if no SYCL backend
+    # since the SYCL implementation_type and data_parallel_kernel enumerations are used even if no SYCL backend
     # is available these are also tested in the base library
     # ${CMAKE_CURRENT_LIST_DIR}/../implementation_types.cpp
-    # ${CMAKE_CURRENT_LIST_DIR}/../kernel_invocation_types.cpp
+    # ${CMAKE_CURRENT_LIST_DIR}/../data_parallel_kernels.cpp
     # ~~~
 )
 
@@ -38,12 +38,12 @@ include(${PROJECT_SOURCE_DIR}/cmake/discover_tests_with_death_test_filter.cmake)
 discover_tests_with_death_test_filter(${PLSSVM_SYCL_ADAPTIVECPP_TEST_NAME})
 
 # add minimal run test for the classification task with the AdaptiveCpp SYCL backend
-add_test(NAME MainTrainClassificationSYCLAdaptiveCpp/executable_minimal
+add_test(NAME MainTrainClassificationSYCLAdaptiveCpp/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b sycl --sycl_implementation_type acpp "${PLSSVM_CLASSIFICATION_TEST_FILE}"
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
 )
 add_test(
-    NAME MainPredictClassificationSYCLAdaptiveCpp/executable_minimal
+    NAME MainPredictClassificationSYCLAdaptiveCpp/ExecutableMinimal
     COMMAND
         ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b sycl --sycl_implementation_type acpp
         "${CMAKE_CURRENT_LIST_DIR}/../../../data/libsvm/classification/5x4.libsvm" # test file
@@ -52,12 +52,12 @@ add_test(
 )
 
 # add minimal run test for the regression task with the AdaptiveCpp SYCL backend
-add_test(NAME MainTrainRegressionSYCLAdaptiveCpp/executable_minimal
+add_test(NAME MainTrainRegressionSYCLAdaptiveCpp/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b sycl --sycl_implementation_type acpp "${PLSSVM_REGRESSION_TEST_FILE}"
                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
 )
 add_test(
-    NAME MainPredictRegressionSYCLAdaptiveCpp/executable_minimal
+    NAME MainPredictRegressionSYCLAdaptiveCpp/ExecutableMinimal
     COMMAND
         ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b sycl --sycl_implementation_type acpp
         "${CMAKE_CURRENT_LIST_DIR}/../../../data/libsvm/regression/5x4.libsvm" # test file
diff --git a/tests/backends/SYCL/AdaptiveCpp/adaptivecpp_csvm.cpp b/tests/backends/SYCL/AdaptiveCpp/adaptivecpp_csvm.cpp
index 446374ef6..788c7087b 100644
--- a/tests/backends/SYCL/AdaptiveCpp/adaptivecpp_csvm.cpp
+++ b/tests/backends/SYCL/AdaptiveCpp/adaptivecpp_csvm.cpp
@@ -8,14 +8,13 @@
  * @brief Tests for the functionality related to the SYCL backend using AdaptiveCpp as SYCL implementation.
  */
 
-#include "plssvm/backend_types.hpp"                          // plssvm::csvm_to_backend_type_v
-#include "plssvm/backends/SYCL/AdaptiveCpp/csvm.hpp"         // plssvm::adaptivecpp::{csvm, csvc, csvr}
-#include "plssvm/backends/SYCL/exceptions.hpp"               // plssvm::adaptivecpp::backend_exception
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/detail/arithmetic_type_name.hpp"            // plssvm::detail::arithmetic_type_name
-#include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
-#include "plssvm/parameter.hpp"                              // plssvm::parameter, plssvm::kernel_type, plssvm::cost, plssvm::sycl_kernel_invocation_type
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
+#include "plssvm/backend_types.hpp"                        // plssvm::csvm_to_backend_type_v
+#include "plssvm/backends/SYCL/AdaptiveCpp/csvm.hpp"       // plssvm::adaptivecpp::{csvm, csvc, csvr}
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/exceptions.hpp"             // plssvm::adaptivecpp::backend_exception
+#include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
+#include "plssvm/parameter.hpp"                            // plssvm::parameter, plssvm::kernel_type, plssvm::cost, plssvm::sycl_data_parallel_kernel
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "tests/backends/generic_base_csvc_tests.hpp"                 // generic C-SVC tests to instantiate
 #include "tests/backends/generic_base_csvm_tests.hpp"                 // generic C-SVM tests to instantiate
@@ -29,7 +28,8 @@
 
 #include "gtest/gtest.h"  // TYPED_TEST, EXPECT_NO_THROW, INSTANTIATE_TYPED_TEST_SUITE_P, ::testing::Test
 
-#include <tuple>  // std::make_tuple, std::tuple
+#include <tuple>    // std::make_tuple, std::tuple
+#include <utility>  // std::make_pair
 
 using adaptivecpp_csvm_types_list = std::tuple<plssvm::adaptivecpp::csvc, plssvm::adaptivecpp::csvr>;
 using adaptivecpp_csvm_types_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<adaptivecpp_csvm_types_list>>;
@@ -44,23 +44,23 @@ class AdaptiveCppCSVMConstructor : public ::testing::Test,
 TYPED_TEST_SUITE(AdaptiveCppCSVMConstructor, adaptivecpp_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(AdaptiveCppCSVMConstructor, default_construct) {
+TYPED_TEST(AdaptiveCppCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // default constructor must always work
     EXPECT_NO_THROW(csvm_type{});
-    EXPECT_NO_THROW((csvm_type{ plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 }
 
-TYPED_TEST(AdaptiveCppCSVMConstructor, construct_parameter) {
+TYPED_TEST(AdaptiveCppCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // the automatic target platform must always be available
     EXPECT_NO_THROW(csvm_type{ plssvm::parameter{} });
-    EXPECT_NO_THROW((csvm_type{ plssvm::parameter{}, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::parameter{}, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 }
 
-TYPED_TEST(AdaptiveCppCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(AdaptiveCppCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -69,129 +69,129 @@ TYPED_TEST(AdaptiveCppCSVMConstructor, construct_target_and_parameter) {
     // every target is allowed for SYCL
 #if defined(PLSSVM_HAS_CPU_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, params }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
-    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::cpu, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::cpu, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::adaptivecpp::backend_exception,
                       "Requested target platform 'cpu' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_NVIDIA_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, params }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
-    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_nvidia, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_nvidia, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::adaptivecpp::backend_exception,
                       "Requested target platform 'gpu_nvidia' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_AMD_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, params }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
-    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_amd, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_amd, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::adaptivecpp::backend_exception,
                       "Requested target platform 'gpu_amd' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_INTEL_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, params }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
-    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_intel, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_intel, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::adaptivecpp::backend_exception,
                       "Requested target platform 'gpu_intel' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 }
 
-TYPED_TEST(AdaptiveCppCSVMConstructor, construct_named_args) {
+TYPED_TEST(AdaptiveCppCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // every target is allowed for SYCL
     EXPECT_NO_THROW((csvm_type{ plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::cost = 2.0 }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 }
 
-TYPED_TEST(AdaptiveCppCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(AdaptiveCppCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // every target is allowed for SYCL
 #if defined(PLSSVM_HAS_CPU_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, plssvm::cost = 2.0 }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::cpu,
                                   plssvm::kernel_type = plssvm::kernel_function_type::linear,
                                   plssvm::cost = 2.0,
-                                  plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+                                  plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::adaptivecpp::backend_exception,
                       "Requested target platform 'cpu' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_NVIDIA_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, plssvm::cost = 2.0 }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_nvidia,
                                   plssvm::kernel_type = plssvm::kernel_function_type::linear,
                                   plssvm::cost = 2.0,
-                                  plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+                                  plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::adaptivecpp::backend_exception,
                       "Requested target platform 'gpu_nvidia' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_AMD_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, plssvm::cost = 2.0 }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_amd,
                                   plssvm::kernel_type = plssvm::kernel_function_type::linear,
                                   plssvm::cost = 2.0,
-                                  plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+                                  plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::adaptivecpp::backend_exception,
                       "Requested target platform 'gpu_amd' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_INTEL_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, plssvm::cost = 2.0 }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_intel,
                                   plssvm::kernel_type = plssvm::kernel_function_type::linear,
                                   plssvm::cost = 2.0,
-                                  plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+                                  plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::adaptivecpp::backend_exception,
                       "Requested target platform 'gpu_intel' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 }
 
-TYPED_TEST(AdaptiveCppCSVMConstructor, get_kernel_invocation_type) {
+TYPED_TEST(AdaptiveCppCSVMConstructor, GetDataParallelKernel) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // construct default C-SVM
     const csvm_type svm{ plssvm::parameter{} };
 
-    // after construction: get_kernel_invocation_type must refer to a plssvm::sycl::kernel_invocation_type that is not automatic
-    EXPECT_NE(svm.get_kernel_invocation_type(), plssvm::sycl::kernel_invocation_type::automatic);
+    // after construction: get_data_parallel_kernel must refer to a plssvm::sycl::data_parallel_kernel that is not automatic
+    EXPECT_NE(svm.get_data_parallel_kernel(), plssvm::sycl::data_parallel_kernel::automatic);
 }
 
-template <bool mock_grid_size, plssvm::sycl::kernel_invocation_type invocation_type>
+template <bool mock_grid_size, plssvm::sycl::data_parallel_kernel data_parallel_kernel_type>
 struct adaptivecpp_csvm_test_type {
     using mock_csvm_type = mock_adaptivecpp_csvm<mock_grid_size>;
     using csvm_type = plssvm::adaptivecpp::csvm;
     using csvc_type = plssvm::adaptivecpp::csvc;
     using csvr_type = plssvm::adaptivecpp::csvr;
     using device_ptr_type = typename csvm_type::device_ptr_type;
-    inline static auto additional_arguments = std::make_tuple(std::make_pair(plssvm::sycl_kernel_invocation_type, invocation_type));
+    inline static auto additional_arguments = std::make_tuple(std::make_pair(plssvm::sycl_data_parallel_kernel, data_parallel_kernel_type));  // NOLINT(cert-err58-cpp): won't throw an exception
 };
 
 // a tuple containing the test structs
 using adaptivecpp_csvm_test_tuple = std::tuple<
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-    adaptivecpp_csvm_test_type<false, plssvm::sycl::kernel_invocation_type::hierarchical>,
-    adaptivecpp_csvm_test_type<false, plssvm::sycl::kernel_invocation_type::scoped>,
+    adaptivecpp_csvm_test_type<false, plssvm::sycl::data_parallel_kernel::hierarchical>,
+    adaptivecpp_csvm_test_type<false, plssvm::sycl::data_parallel_kernel::scoped>,
 #endif
-    adaptivecpp_csvm_test_type<false, plssvm::sycl::kernel_invocation_type::basic>,
-    adaptivecpp_csvm_test_type<false, plssvm::sycl::kernel_invocation_type::work_group>>;
+    adaptivecpp_csvm_test_type<false, plssvm::sycl::data_parallel_kernel::basic>,
+    adaptivecpp_csvm_test_type<false, plssvm::sycl::data_parallel_kernel::work_group>>;
 
 // the tests used in the instantiated GTest test suites
 // general test types
@@ -239,11 +239,11 @@ INSTANTIATE_TYPED_TEST_SUITE_P(AdaptiveCppCSVMDeathTest, GenericGPUCSVMDeathTest
 
 using adaptivecpp_mock_csvm_test_tuple = std::tuple<
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-    adaptivecpp_csvm_test_type<true, plssvm::sycl::kernel_invocation_type::hierarchical>,
-    adaptivecpp_csvm_test_type<true, plssvm::sycl::kernel_invocation_type::scoped>,
+    adaptivecpp_csvm_test_type<true, plssvm::sycl::data_parallel_kernel::hierarchical>,
+    adaptivecpp_csvm_test_type<true, plssvm::sycl::data_parallel_kernel::scoped>,
 #endif
-    adaptivecpp_csvm_test_type<true, plssvm::sycl::kernel_invocation_type::basic>,
-    adaptivecpp_csvm_test_type<true, plssvm::sycl::kernel_invocation_type::work_group>>;
+    adaptivecpp_csvm_test_type<true, plssvm::sycl::data_parallel_kernel::basic>,
+    adaptivecpp_csvm_test_type<true, plssvm::sycl::data_parallel_kernel::work_group>>;
 
 using adaptivecpp_mock_csvm_test_type_list = util::cartesian_type_product_t<adaptivecpp_mock_csvm_test_tuple>;
 
diff --git a/tests/backends/SYCL/AdaptiveCpp/detail/utility.cpp b/tests/backends/SYCL/AdaptiveCpp/detail/utility.cpp
index e909fa2a9..a4ed73d70 100644
--- a/tests/backends/SYCL/AdaptiveCpp/detail/utility.cpp
+++ b/tests/backends/SYCL/AdaptiveCpp/detail/utility.cpp
@@ -10,9 +10,9 @@
 
 #include "plssvm/backends/SYCL/AdaptiveCpp/detail/utility.hpp"
 
-#include "plssvm/backends/execution_range.hpp"               // plssvm::detail::dim_type
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
+#include "plssvm/backends/execution_range.hpp"             // plssvm::detail::dim_type
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::range, sycl::nd_range
 
@@ -22,7 +22,7 @@
 #include <string>       // std::string
 #include <type_traits>  // std::remove_const_t
 
-TEST(AdaptiveCppUtility, dim_type_to_native_1) {
+TEST(AdaptiveCppUtility, DimTypeToNativeOneDimensional) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -34,7 +34,7 @@ TEST(AdaptiveCppUtility, dim_type_to_native_1) {
     EXPECT_EQ(native_dim[0], dim.x);
 }
 
-TEST(AdaptiveCppUtility, dim_type_to_native_2) {
+TEST(AdaptiveCppUtility, DimTypeToNativeTwoDimensional) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -47,7 +47,7 @@ TEST(AdaptiveCppUtility, dim_type_to_native_2) {
     EXPECT_EQ(native_dim[1], dim.x);
 }
 
-TEST(AdaptiveCppUtility, dim_type_to_native_3) {
+TEST(AdaptiveCppUtility, DimTypeToNativeThreeDimensional) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -61,51 +61,51 @@ TEST(AdaptiveCppUtility, dim_type_to_native_3) {
     EXPECT_EQ(native_dim[2], dim.x);
 }
 
-TEST(AdaptiveCppUtility, get_execution_range_basic) {
+TEST(AdaptiveCppUtility, GetExecutionRangeBasic) {
     // create a grid
     const plssvm::detail::dim_type grid{ 64ull, 64ull };
     const plssvm::detail::dim_type block{ 8ull, 8ull };
 
     // calculate the SYCL execution range
-    const ::sycl::range exec = plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::kernel_invocation_type::basic>(grid, block);
+    const ::sycl::range exec = plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::basic>(grid, block);
 
     EXPECT_EQ(exec, (sycl::range<2>{ 512ull, 512ull }));
 }
 
-TEST(AdaptiveCppUtility, get_execution_range_work_group) {
+TEST(AdaptiveCppUtility, GetExecutionRangeWorkGroup) {
     // create a grid
     const plssvm::detail::dim_type grid{ 64ull, 64ull };
     const plssvm::detail::dim_type block{ 8ull, 8ull };
 
     // calculate the SYCL execution range
-    const ::sycl::nd_range exec = plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::kernel_invocation_type::work_group>(grid, block);
+    const ::sycl::nd_range exec = plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::work_group>(grid, block);
 
     EXPECT_EQ(exec, (::sycl::nd_range<2>{ ::sycl::range<2>{ 512ull, 512ull }, ::sycl::range<2>{ 8ull, 8ull } }));
 }
 
-TEST(AdaptiveCppUtility, get_execution_range_hierarchical) {
+TEST(AdaptiveCppUtility, GetExecutionRangeHierarchical) {
     // create a grid
     const plssvm::detail::dim_type grid{ 64ull, 64ull };
     const plssvm::detail::dim_type block{ 8ull, 8ull };
 
     // calculate the SYCL execution range
-    const ::sycl::nd_range exec = plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::kernel_invocation_type::hierarchical>(grid, block);
+    const ::sycl::nd_range exec = plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::hierarchical>(grid, block);
 
     EXPECT_EQ(exec, (::sycl::nd_range<2>{ ::sycl::range<2>{ 64ull, 64ull }, ::sycl::range<2>{ 8ull, 8ull } }));
 }
 
-TEST(AdaptiveCppUtility, get_execution_range_scoped) {
+TEST(AdaptiveCppUtility, GetExecutionRangeScoped) {
     // create a grid
     const plssvm::detail::dim_type grid{ 64ull, 64ull };
     const plssvm::detail::dim_type block{ 8ull, 8ull };
 
     // calculate the SYCL execution range
-    const ::sycl::nd_range exec = plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::kernel_invocation_type::scoped>(grid, block);
+    const ::sycl::nd_range exec = plssvm::adaptivecpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::scoped>(grid, block);
 
     EXPECT_EQ(exec, (::sycl::nd_range<2>{ ::sycl::range<2>{ 64ull, 64ull }, ::sycl::range<2>{ 8ull, 8ull } }));
 }
 
-TEST(AdaptiveCppUtility, get_device_list) {
+TEST(AdaptiveCppUtility, GetDeviceList) {
     const auto &[queues, actual_target] = plssvm::adaptivecpp::detail::get_device_list(plssvm::target_platform::automatic);
     // at least one queue must be provided
     EXPECT_FALSE(queues.empty());
@@ -113,12 +113,25 @@ TEST(AdaptiveCppUtility, get_device_list) {
     EXPECT_NE(actual_target, plssvm::target_platform::automatic);
 }
 
-TEST(AdaptiveCppUtility, get_adaptivecpp_version_short) {
+TEST(AdaptiveCppUtility, GetDeviceName) {
+    const auto &[queues, actual_target] = plssvm::adaptivecpp::detail::get_device_list(plssvm::target_platform::automatic);
+    // at least one queue must be available
+    EXPECT_FALSE(queues.empty());
+
+    const std::string device_name = plssvm::adaptivecpp::detail::get_device_name(queues.front());
+    // must not be empty
+    EXPECT_FALSE(device_name.empty());
+    // must not start or end with whitespace
+    const std::regex reg{ R"([^\s](?:.*[^\s])?)" };
+    EXPECT_TRUE(std::regex_match(device_name, reg));
+}
+
+TEST(AdaptiveCppUtility, GetAdaptiveCppVersionShort) {
     const std::regex reg{ "[0-9]+\\.[0-9]+\\.[0-9]+", std::regex::extended };
     EXPECT_TRUE(std::regex_match(plssvm::adaptivecpp::detail::get_adaptivecpp_version_short(), reg));
 }
 
-TEST(AdaptiveCppUtility, get_adaptivecpp_version) {
+TEST(AdaptiveCppUtility, GetAdaptiveCppVersion) {
     const std::string version = plssvm::adaptivecpp::detail::get_adaptivecpp_version();
     EXPECT_FALSE(version.empty());
 }
diff --git a/tests/backends/SYCL/AdaptiveCpp/mock_adaptivecpp_csvm.hpp b/tests/backends/SYCL/AdaptiveCpp/mock_adaptivecpp_csvm.hpp
index 18f31cb34..b3a9baf54 100644
--- a/tests/backends/SYCL/AdaptiveCpp/mock_adaptivecpp_csvm.hpp
+++ b/tests/backends/SYCL/AdaptiveCpp/mock_adaptivecpp_csvm.hpp
@@ -48,6 +48,7 @@ class mock_adaptivecpp_csvm final : public plssvm::adaptivecpp::csvm {
     using base_type::assemble_kernel_matrix;
     using base_type::blas_level_3;
     using base_type::get_device_memory;
+    using base_type::get_local_memory;
     using base_type::get_max_work_group_size;
     using base_type::num_available_devices;
 
diff --git a/tests/backends/SYCL/DPCPP/CMakeLists.txt b/tests/backends/SYCL/DPCPP/CMakeLists.txt
index e36545f08..086b721f4 100644
--- a/tests/backends/SYCL/DPCPP/CMakeLists.txt
+++ b/tests/backends/SYCL/DPCPP/CMakeLists.txt
@@ -15,10 +15,10 @@ set(PLSSVM_SYCL_DPCPP_TEST_SOURCES
     ${CMAKE_CURRENT_LIST_DIR}/detail/utility.cpp
     ${CMAKE_CURRENT_LIST_DIR}/dpcpp_csvm.cpp
     # ~~~
-    # since the SYCL implementation_type and kernel_invocation_type enumerations are used even if no SYCL backend
+    # since the SYCL implementation_type and data_parallel_kernel enumerations are used even if no SYCL backend
     # is available these are also tested in the base library
     # ${CMAKE_CURRENT_LIST_DIR}/../implementation_types.cpp
-    # ${CMAKE_CURRENT_LIST_DIR}/../kernel_invocation_types.cpp
+    # ${CMAKE_CURRENT_LIST_DIR}/../data_parallel_kernels.cpp
     # ~~~
 )
 
@@ -38,12 +38,12 @@ include(${PROJECT_SOURCE_DIR}/cmake/discover_tests_with_death_test_filter.cmake)
 discover_tests_with_death_test_filter(${PLSSVM_SYCL_DPCPP_TEST_NAME})
 
 # add minimal run test for the classification task with the DPC++ SYCL backend
-add_test(NAME MainTrainClassificationSYCLDPCPP/executable_minimal
+add_test(NAME MainTrainClassificationSYCLDPCPP/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b sycl --sycl_implementation_type dpcpp "${PLSSVM_CLASSIFICATION_TEST_FILE}"
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
 )
 add_test(
-    NAME MainPredictClassificationSYCLDPCPP/executable_minimal
+    NAME MainPredictClassificationSYCLDPCPP/ExecutableMinimal
     COMMAND
         ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b sycl --sycl_implementation_type dpcpp
         "${CMAKE_CURRENT_LIST_DIR}/../../../data/libsvm/classification/5x4.libsvm" # test file
@@ -52,12 +52,12 @@ add_test(
 )
 
 # add minimal run test for the regression task with the DPC++ SYCL backend
-add_test(NAME MainTrainRegressionSYCLDPCPP/executable_minimal
+add_test(NAME MainTrainRegressionSYCLDPCPP/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b sycl --sycl_implementation_type dpcpp "${PLSSVM_REGRESSION_TEST_FILE}"
                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
 )
 add_test(
-    NAME MainPredictRegressionSYCLDPCPP/executable_minimal
+    NAME MainPredictRegressionSYCLDPCPP/ExecutableMinimal
     COMMAND
         ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b sycl --sycl_implementation_type dpcpp
         "${CMAKE_CURRENT_LIST_DIR}/../../../data/libsvm/regression/5x4.libsvm" # test file
diff --git a/tests/backends/SYCL/DPCPP/detail/utility.cpp b/tests/backends/SYCL/DPCPP/detail/utility.cpp
index 84b2d60f9..ccd269caa 100644
--- a/tests/backends/SYCL/DPCPP/detail/utility.cpp
+++ b/tests/backends/SYCL/DPCPP/detail/utility.cpp
@@ -10,9 +10,9 @@
 
 #include "plssvm/backends/SYCL/DPCPP/detail/utility.hpp"
 
-#include "plssvm/backends/execution_range.hpp"               // plssvm::detail::dim_type
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
+#include "plssvm/backends/execution_range.hpp"             // plssvm::detail::dim_type
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "sycl/sycl.hpp"  // sycl::range, sycl::nd_range
 
@@ -21,7 +21,7 @@
 #include <regex>   // std::regex, std::regex::extended, std::regex_match
 #include <string>  // std::string
 
-TEST(DPCPPUtility, dim_type_to_native_1) {
+TEST(DPCPPUtility, DimTypeToNativeOneDimensional) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -33,7 +33,7 @@ TEST(DPCPPUtility, dim_type_to_native_1) {
     EXPECT_EQ(native_dim[0], dim.x);
 }
 
-TEST(DPCPPUtility, dim_type_to_native_2) {
+TEST(DPCPPUtility, DimTypeToNativeTwoDimensional) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -46,7 +46,7 @@ TEST(DPCPPUtility, dim_type_to_native_2) {
     EXPECT_EQ(native_dim[1], dim.x);
 }
 
-TEST(DPCPPUtility, dim_type_to_native_3) {
+TEST(DPCPPUtility, DimTypeToNativeThreeDimensional) {
     // create a dim_type
     constexpr plssvm::detail::dim_type dim{ 128ull, 64ull, 32ull };
 
@@ -60,40 +60,40 @@ TEST(DPCPPUtility, dim_type_to_native_3) {
     EXPECT_EQ(native_dim[2], dim.x);
 }
 
-TEST(DPCPPUtility, get_execution_range_basic) {
+TEST(DPCPPUtility, GetExecutionRangeBasic) {
     // create a grid
     const plssvm::detail::dim_type grid{ 64ull, 64ull };
     const plssvm::detail::dim_type block{ 8ull, 8ull };
 
     // calculate the SYCL execution range
-    const ::sycl::range exec = plssvm::dpcpp::detail::get_execution_range<plssvm::sycl::kernel_invocation_type::basic>(grid, block);
+    const ::sycl::range exec = plssvm::dpcpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::basic>(grid, block);
 
     EXPECT_EQ(exec, (sycl::range<2>{ 512ull, 512ull }));
 }
 
-TEST(DPCPPUtility, get_execution_range_work_group) {
+TEST(DPCPPUtility, GetExecutionRangeWorkGroup) {
     // create a grid
     const plssvm::detail::dim_type grid{ 64ull, 64ull };
     const plssvm::detail::dim_type block{ 8ull, 8ull };
 
     // calculate the SYCL execution range
-    const ::sycl::nd_range exec = plssvm::dpcpp::detail::get_execution_range<plssvm::sycl::kernel_invocation_type::work_group>(grid, block);
+    const ::sycl::nd_range exec = plssvm::dpcpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::work_group>(grid, block);
 
     EXPECT_EQ(exec, (::sycl::nd_range<2>{ ::sycl::range<2>{ 512ull, 512ull }, ::sycl::range<2>{ 8ull, 8ull } }));
 }
 
-TEST(DPCPPUtility, get_execution_range_hierarchical) {
+TEST(DPCPPUtility, GetExecutionRangeHierarchical) {
     // create a grid
     const plssvm::detail::dim_type grid{ 64ull, 64ull };
     const plssvm::detail::dim_type block{ 8ull, 8ull };
 
     // calculate the SYCL execution range
-    const ::sycl::nd_range exec = plssvm::dpcpp::detail::get_execution_range<plssvm::sycl::kernel_invocation_type::hierarchical>(grid, block);
+    const ::sycl::nd_range exec = plssvm::dpcpp::detail::get_execution_range<plssvm::sycl::data_parallel_kernel::hierarchical>(grid, block);
 
     EXPECT_EQ(exec, (::sycl::nd_range<2>{ ::sycl::range<2>{ 64ull, 64ull }, ::sycl::range<2>{ 8ull, 8ull } }));
 }
 
-TEST(DPCPPUtility, get_device_list) {
+TEST(DPCPPUtility, GetDeviceList) {
     const auto &[queues, actual_target] = plssvm::dpcpp::detail::get_device_list(plssvm::target_platform::automatic);
     // at least one queue must be provided
     EXPECT_FALSE(queues.empty());
@@ -101,12 +101,25 @@ TEST(DPCPPUtility, get_device_list) {
     EXPECT_NE(actual_target, plssvm::target_platform::automatic);
 }
 
-TEST(DPCPPUtility, get_dpcpp_version) {
+TEST(DPCPPUtility, GetDeviceName) {
+    const auto &[queues, actual_target] = plssvm::dpcpp::detail::get_device_list(plssvm::target_platform::automatic);
+    // at least one queue must be available
+    EXPECT_FALSE(queues.empty());
+
+    const std::string device_name = plssvm::dpcpp::detail::get_device_name(queues.front());
+    // must not be empty
+    EXPECT_FALSE(device_name.empty());
+    // must not start or end with whitespace
+    const std::regex reg{ R"([^\s](?:.*[^\s])?)" };
+    EXPECT_TRUE(std::regex_match(device_name, reg));
+}
+
+TEST(DPCPPUtility, GetDPCPPVersion) {
     const std::regex reg{ "[0-9]+\\.[0-9]+\\.[0-9]+", std::regex::extended };
     EXPECT_TRUE(std::regex_match(plssvm::dpcpp::detail::get_dpcpp_version(), reg));
 }
 
-TEST(DPCPPUtility, get_dpcpp_timestamp_version) {
+TEST(DPCPPUtility, GetDPCPPTimestampVersion) {
     const std::string version = plssvm::dpcpp::detail::get_dpcpp_timestamp_version();
     EXPECT_FALSE(version.empty());
 }
diff --git a/tests/backends/SYCL/DPCPP/dpcpp_csvm.cpp b/tests/backends/SYCL/DPCPP/dpcpp_csvm.cpp
index ada2f4b56..15359969c 100644
--- a/tests/backends/SYCL/DPCPP/dpcpp_csvm.cpp
+++ b/tests/backends/SYCL/DPCPP/dpcpp_csvm.cpp
@@ -8,14 +8,13 @@
  * @brief Tests for the functionality related to the SYCL backend using DPC++ as SYCL implementation.
  */
 
-#include "plssvm/backend_types.hpp"                          // plssvm::csvm_to_backend_type_v
-#include "plssvm/backends/SYCL/DPCPP/csvm.hpp"               // plssvm::dpcpp::{csvm, csvc, csvr}
-#include "plssvm/backends/SYCL/exceptions.hpp"               // plssvm::dpcpp::backend_exception
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/detail/arithmetic_type_name.hpp"            // plssvm::detail::arithmetic_type_name
-#include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
-#include "plssvm/parameter.hpp"                              // plssvm::parameter, plssvm::kernel_type, plssvm::cost, plssvm::sycl_kernel_invocation_type
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
+#include "plssvm/backend_types.hpp"                        // plssvm::csvm_to_backend_type_v
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/DPCPP/csvm.hpp"             // plssvm::dpcpp::{csvm, csvc, csvr}
+#include "plssvm/backends/SYCL/exceptions.hpp"             // plssvm::dpcpp::backend_exception
+#include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
+#include "plssvm/parameter.hpp"                            // plssvm::parameter, plssvm::kernel_type, plssvm::cost, plssvm::sycl_data_parallel_kernel
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
 
 #include "tests/backends/generic_base_csvc_tests.hpp"     // generic C-SVC tests to instantiate
 #include "tests/backends/generic_base_csvm_tests.hpp"     // generic C-SVM tests to instantiate
@@ -29,7 +28,8 @@
 
 #include "gtest/gtest.h"  // TYPED_TEST, EXPECT_NO_THROW, INSTANTIATE_TYPED_TEST_SUITE_P, ::testing::Test
 
-#include <tuple>  // std::make_tuple, std::tuple
+#include <tuple>    // std::make_tuple, std::tuple
+#include <utility>  // std::make_pair
 
 using dpcpp_csvm_types_list = std::tuple<plssvm::dpcpp::csvc, plssvm::dpcpp::csvr>;
 using dpcpp_csvm_types_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<dpcpp_csvm_types_list>>;
@@ -44,23 +44,23 @@ class DPCPPCSVMConstructor : public ::testing::Test,
 TYPED_TEST_SUITE(DPCPPCSVMConstructor, dpcpp_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(DPCPPCSVMConstructor, default_construct) {
+TYPED_TEST(DPCPPCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // default constructor must always work
     EXPECT_NO_THROW(csvm_type{});
-    EXPECT_NO_THROW((csvm_type{ plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 }
 
-TYPED_TEST(DPCPPCSVMConstructor, construct_parameter) {
+TYPED_TEST(DPCPPCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // the automatic target platform must always be available
     EXPECT_NO_THROW(csvm_type{ plssvm::parameter{} });
-    EXPECT_NO_THROW((csvm_type{ plssvm::parameter{}, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::parameter{}, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 }
 
-TYPED_TEST(DPCPPCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(DPCPPCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -69,128 +69,128 @@ TYPED_TEST(DPCPPCSVMConstructor, construct_target_and_parameter) {
     // every target is allowed for SYCL
 #if defined(PLSSVM_HAS_CPU_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, params }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
-    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::cpu, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::cpu, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::dpcpp::backend_exception,
                       "Requested target platform 'cpu' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_NVIDIA_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, params }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
-    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_nvidia, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_nvidia, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::dpcpp::backend_exception,
                       "Requested target platform 'gpu_nvidia' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_AMD_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, params }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
-    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_amd, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_amd, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::dpcpp::backend_exception,
                       "Requested target platform 'gpu_amd' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_INTEL_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, params }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
-    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_intel, params, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+    EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_intel, params, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::dpcpp::backend_exception,
                       "Requested target platform 'gpu_intel' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 }
 
-TYPED_TEST(DPCPPCSVMConstructor, construct_named_args) {
+TYPED_TEST(DPCPPCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // every target is allowed for SYCL
     EXPECT_NO_THROW((csvm_type{ plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::cost = 2.0 }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 }
 
-TYPED_TEST(DPCPPCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(DPCPPCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // every target is allowed for SYCL
 #if defined(PLSSVM_HAS_CPU_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, plssvm::cost = 2.0 }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::cpu, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::cpu,
                                   plssvm::kernel_type = plssvm::kernel_function_type::linear,
                                   plssvm::cost = 2.0,
-                                  plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+                                  plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::dpcpp::backend_exception,
                       "Requested target platform 'cpu' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_NVIDIA_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, plssvm::cost = 2.0 }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_nvidia, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_nvidia,
                                   plssvm::kernel_type = plssvm::kernel_function_type::linear,
                                   plssvm::cost = 2.0,
-                                  plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+                                  plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::dpcpp::backend_exception,
                       "Requested target platform 'gpu_nvidia' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_AMD_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, plssvm::cost = 2.0 }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_amd,
                                   plssvm::kernel_type = plssvm::kernel_function_type::linear,
                                   plssvm::cost = 2.0,
-                                  plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+                                  plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::dpcpp::backend_exception,
                       "Requested target platform 'gpu_amd' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 #if defined(PLSSVM_HAS_INTEL_TARGET)
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, plssvm::cost = 2.0 }));
-    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }));
+    EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_intel, plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }));
 #else
     EXPECT_THROW_WHAT((csvm_type{ plssvm::target_platform::gpu_intel,
                                   plssvm::kernel_type = plssvm::kernel_function_type::linear,
                                   plssvm::cost = 2.0,
-                                  plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group }),
+                                  plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group }),
                       plssvm::dpcpp::backend_exception,
                       "Requested target platform 'gpu_intel' that hasn't been enabled using PLSSVM_TARGET_PLATFORMS!");
 #endif
 }
 
-TYPED_TEST(DPCPPCSVMConstructor, get_kernel_invocation_type) {
+TYPED_TEST(DPCPPCSVMConstructor, GetDataParallelKernel) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // construct default C-SVM
     const csvm_type svm{ plssvm::parameter{} };
 
-    // after construction: get_kernel_invocation_type must refer to a plssvm::sycl::kernel_invocation_type that is not automatic
-    EXPECT_NE(svm.get_kernel_invocation_type(), plssvm::sycl::kernel_invocation_type::automatic);
+    // after construction: get_data_parallel_kernel must refer to a plssvm::sycl::data_parallel_kernel that is not automatic
+    EXPECT_NE(svm.get_data_parallel_kernel(), plssvm::sycl::data_parallel_kernel::automatic);
 }
 
-template <bool mock_grid_size, plssvm::sycl::kernel_invocation_type invocation_type>
+template <bool mock_grid_size, plssvm::sycl::data_parallel_kernel data_parallel_kernel_type>
 struct dpcpp_csvm_test_type {
     using mock_csvm_type = mock_dpcpp_csvm<mock_grid_size>;
     using csvm_type = plssvm::dpcpp::csvm;
     using csvc_type = plssvm::dpcpp::csvc;
     using csvr_type = plssvm::dpcpp::csvr;
     using device_ptr_type = typename csvm_type::device_ptr_type;
-    inline static auto additional_arguments = std::make_tuple(std::make_pair(plssvm::sycl_kernel_invocation_type, invocation_type));
+    inline static auto additional_arguments = std::make_tuple(std::make_pair(plssvm::sycl_data_parallel_kernel, data_parallel_kernel_type));  // NOLINT(cert-err58-cpp): won't throw an exception
 };
 
 // a tuple containing the test structs
 using dpcpp_csvm_test_tuple = std::tuple<
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-    dpcpp_csvm_test_type<false, plssvm::sycl::kernel_invocation_type::hierarchical>,
+    dpcpp_csvm_test_type<false, plssvm::sycl::data_parallel_kernel::hierarchical>,
 #endif
-    dpcpp_csvm_test_type<false, plssvm::sycl::kernel_invocation_type::basic>,
-    dpcpp_csvm_test_type<false, plssvm::sycl::kernel_invocation_type::work_group>>;
+    dpcpp_csvm_test_type<false, plssvm::sycl::data_parallel_kernel::basic>,
+    dpcpp_csvm_test_type<false, plssvm::sycl::data_parallel_kernel::work_group>>;
 
 // the tests used in the instantiated GTest test suites
 // general test types
@@ -238,10 +238,10 @@ INSTANTIATE_TYPED_TEST_SUITE_P(DPCPPCSVMDeathTest, GenericGPUCSVMDeathTest, dpcp
 
 using dpcpp_mock_csvm_test_tuple = std::tuple<
 #if defined(PLSSVM_SYCL_HIERARCHICAL_AND_SCOPED_KERNELS_ENABLED)
-    dpcpp_csvm_test_type<true, plssvm::sycl::kernel_invocation_type::hierarchical>,
+    dpcpp_csvm_test_type<true, plssvm::sycl::data_parallel_kernel::hierarchical>,
 #endif
-    dpcpp_csvm_test_type<true, plssvm::sycl::kernel_invocation_type::basic>,
-    dpcpp_csvm_test_type<true, plssvm::sycl::kernel_invocation_type::work_group>>;
+    dpcpp_csvm_test_type<true, plssvm::sycl::data_parallel_kernel::basic>,
+    dpcpp_csvm_test_type<true, plssvm::sycl::data_parallel_kernel::work_group>>;
 
 using dpcpp_mock_csvm_test_type_list = util::cartesian_type_product_t<dpcpp_mock_csvm_test_tuple>;
 
diff --git a/tests/backends/SYCL/DPCPP/mock_dpcpp_csvm.hpp b/tests/backends/SYCL/DPCPP/mock_dpcpp_csvm.hpp
index 49e45936a..7f8b605d5 100644
--- a/tests/backends/SYCL/DPCPP/mock_dpcpp_csvm.hpp
+++ b/tests/backends/SYCL/DPCPP/mock_dpcpp_csvm.hpp
@@ -48,6 +48,7 @@ class mock_dpcpp_csvm final : public plssvm::dpcpp::csvm {
     using base_type::assemble_kernel_matrix;
     using base_type::blas_level_3;
     using base_type::get_device_memory;
+    using base_type::get_local_memory;
     using base_type::get_max_work_group_size;
     using base_type::num_available_devices;
 
diff --git a/tests/backends/SYCL/data_parallel_kernels.cpp b/tests/backends/SYCL/data_parallel_kernels.cpp
new file mode 100644
index 000000000..4c967c79b
--- /dev/null
+++ b/tests/backends/SYCL/data_parallel_kernels.cpp
@@ -0,0 +1,73 @@
+/**
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Tests for functions related to the different SYCL data parallel kernels.
+ */
+
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::{data_parallel_kernel, list_available_sycl_data_parallel_kernels}
+
+#include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING
+
+#include "gmock/gmock.h"  // EXPECT_THAT; ::testing::Contains
+#include "gtest/gtest.h"  // TEST, EXPECT_TRUE, EXPECT_GE
+
+#include <sstream>  // std::istringstream
+#include <vector>   // std::vector
+
+// check whether the plssvm::sycl::data_parallel_kernel -> std::string conversions are correct
+TEST(SYCLDataParallelKernel, ToString) {
+    // check conversions to std::string
+    EXPECT_CONVERSION_TO_STRING(plssvm::sycl::data_parallel_kernel::automatic, "automatic");
+    EXPECT_CONVERSION_TO_STRING(plssvm::sycl::data_parallel_kernel::basic, "basic");
+    EXPECT_CONVERSION_TO_STRING(plssvm::sycl::data_parallel_kernel::work_group, "work_group");
+    EXPECT_CONVERSION_TO_STRING(plssvm::sycl::data_parallel_kernel::hierarchical, "hierarchical");
+    EXPECT_CONVERSION_TO_STRING(plssvm::sycl::data_parallel_kernel::scoped, "scoped");
+}
+
+TEST(SYCLDataParallelKernel, ToStringUnknown) {
+    // check conversions to std::string from unknown file_format_type
+    EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::sycl::data_parallel_kernel>(5), "unknown");
+}
+
+// check whether the std::string -> plssvm::sycl::data_parallel_kernel conversions are correct
+TEST(SYCLDataParallelKernel, FromString) {
+    // check conversion from std::string
+    EXPECT_CONVERSION_FROM_STRING("automatic", plssvm::sycl::data_parallel_kernel::automatic);
+    EXPECT_CONVERSION_FROM_STRING("AUTOMATIC", plssvm::sycl::data_parallel_kernel::automatic);
+    EXPECT_CONVERSION_FROM_STRING("auto", plssvm::sycl::data_parallel_kernel::automatic);
+    EXPECT_CONVERSION_FROM_STRING("AUTO", plssvm::sycl::data_parallel_kernel::automatic);
+    EXPECT_CONVERSION_FROM_STRING("basic", plssvm::sycl::data_parallel_kernel::basic);
+    EXPECT_CONVERSION_FROM_STRING("BASIC", plssvm::sycl::data_parallel_kernel::basic);
+    EXPECT_CONVERSION_FROM_STRING("work_group", plssvm::sycl::data_parallel_kernel::work_group);
+    EXPECT_CONVERSION_FROM_STRING("WORK-GROUP", plssvm::sycl::data_parallel_kernel::work_group);
+    EXPECT_CONVERSION_FROM_STRING("nd_range", plssvm::sycl::data_parallel_kernel::work_group);
+    EXPECT_CONVERSION_FROM_STRING("ND-RANGE", plssvm::sycl::data_parallel_kernel::work_group);
+    EXPECT_CONVERSION_FROM_STRING("hierarchical", plssvm::sycl::data_parallel_kernel::hierarchical);
+    EXPECT_CONVERSION_FROM_STRING("HIERARCHICAL", plssvm::sycl::data_parallel_kernel::hierarchical);
+    EXPECT_CONVERSION_FROM_STRING("scoped", plssvm::sycl::data_parallel_kernel::scoped);
+    EXPECT_CONVERSION_FROM_STRING("SCOPED", plssvm::sycl::data_parallel_kernel::scoped);
+}
+
+TEST(SYCLDataParallelKernel, FromStringUnknown) {
+    // foo isn't a valid file_format_type
+    std::istringstream input{ "foo" };
+    plssvm::sycl::data_parallel_kernel data_parallel_kernel_type{};
+    input >> data_parallel_kernel_type;
+    EXPECT_TRUE(input.fail());
+}
+
+TEST(SYCLDataParallelKernel, MinimalAvailableSYCLDataParallelKernels) {
+    const std::vector<plssvm::sycl::data_parallel_kernel> data_parallel_kernel_types = plssvm::sycl::list_available_sycl_data_parallel_kernels();
+
+    // at least three must be available (automatic, basic, and work_group)!
+    EXPECT_GE(data_parallel_kernel_types.size(), 3);
+
+    // check for the data parallel kernels that must always be present
+    EXPECT_THAT(data_parallel_kernel_types, ::testing::Contains(plssvm::sycl::data_parallel_kernel::automatic));
+    EXPECT_THAT(data_parallel_kernel_types, ::testing::Contains(plssvm::sycl::data_parallel_kernel::basic));
+    EXPECT_THAT(data_parallel_kernel_types, ::testing::Contains(plssvm::sycl::data_parallel_kernel::work_group));
+}
diff --git a/tests/backends/SYCL/implementation_types.cpp b/tests/backends/SYCL/implementation_types.cpp
index f7f31b45d..65dcce834 100644
--- a/tests/backends/SYCL/implementation_types.cpp
+++ b/tests/backends/SYCL/implementation_types.cpp
@@ -16,22 +16,23 @@
 #include "gtest/gtest.h"  // TEST, EXPECT_TRUE, EXPECT_GE
 
 #include <sstream>  // std::istringstream
+#include <vector>   // std::vector
 
 // check whether the plssvm::sycl::implementation_type -> std::string conversions are correct
-TEST(SYCLImplementationType, to_string) {
+TEST(SYCLImplementationType, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::sycl::implementation_type::automatic, "automatic");
     EXPECT_CONVERSION_TO_STRING(plssvm::sycl::implementation_type::adaptivecpp, "adaptivecpp");
     EXPECT_CONVERSION_TO_STRING(plssvm::sycl::implementation_type::dpcpp, "dpcpp");
 }
 
-TEST(SYCLImplementationType, to_string_unknown) {
+TEST(SYCLImplementationType, ToStringUnknown) {
     // check conversions to std::string from unknown implementation_type
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::sycl::implementation_type>(3), "unknown");
 }
 
 // check whether the std::string -> plssvm::sycl::implementation_type conversions are correct
-TEST(SYCLImplementationType, from_string) {
+TEST(SYCLImplementationType, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("automatic", plssvm::sycl::implementation_type::automatic);
     EXPECT_CONVERSION_FROM_STRING("AUTOMATIC", plssvm::sycl::implementation_type::automatic);
@@ -48,7 +49,7 @@ TEST(SYCLImplementationType, from_string) {
     EXPECT_CONVERSION_FROM_STRING("ICPX", plssvm::sycl::implementation_type::dpcpp);
 }
 
-TEST(SYCLImplementationType, from_string_unknown) {
+TEST(SYCLImplementationType, FromStringUnknown) {
     // foo isn't a valid implementation_type
     std::istringstream input{ "foo" };
     plssvm::sycl::implementation_type impl{};
@@ -56,7 +57,7 @@ TEST(SYCLImplementationType, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(SYCLImplementationType, minimal_available_sycl_implementation_type) {
+TEST(SYCLImplementationType, MinimalAvailableSYCLImplementationType) {
     const std::vector<plssvm::sycl::implementation_type> implementation_type = plssvm::sycl::list_available_sycl_implementations();
 
     // at least one must be available (automatic)!
diff --git a/tests/backends/SYCL/kernel_invocation_types.cpp b/tests/backends/SYCL/kernel_invocation_types.cpp
deleted file mode 100644
index 3227cb077..000000000
--- a/tests/backends/SYCL/kernel_invocation_types.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/**
- * @author Alexander Van Craen
- * @author Marcel Breyer
- * @copyright 2018-today The PLSSVM project - All Rights Reserved
- * @license This file is part of the PLSSVM project which is released under the MIT license.
- *          See the LICENSE.md file in the project root for full license information.
- *
- * @brief Tests for functions related to the different SYCL kernel invocation types.
- */
-
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-
-#include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING
-
-#include "gmock/gmock.h"  // EXPECT_THAT; ::testing::Contains
-#include "gtest/gtest.h"  // TEST, EXPECT_TRUE, EXPECT_GE
-
-#include <sstream>  // std::istringstream
-
-// check whether the plssvm::sycl::kernel_invocation_type -> std::string conversions are correct
-TEST(SYCLKernelInvocationType, to_string) {
-    // check conversions to std::string
-    EXPECT_CONVERSION_TO_STRING(plssvm::sycl::kernel_invocation_type::automatic, "automatic");
-    EXPECT_CONVERSION_TO_STRING(plssvm::sycl::kernel_invocation_type::basic, "basic");
-    EXPECT_CONVERSION_TO_STRING(plssvm::sycl::kernel_invocation_type::work_group, "work_group");
-    EXPECT_CONVERSION_TO_STRING(plssvm::sycl::kernel_invocation_type::hierarchical, "hierarchical");
-    EXPECT_CONVERSION_TO_STRING(plssvm::sycl::kernel_invocation_type::scoped, "scoped");
-}
-
-TEST(SYCLKernelInvocationType, to_string_unknown) {
-    // check conversions to std::string from unknown file_format_type
-    EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::sycl::kernel_invocation_type>(5), "unknown");
-}
-
-// check whether the std::string -> plssvm::sycl::kernel_invocation_type conversions are correct
-TEST(SYCLKernelInvocationType, from_string) {
-    // check conversion from std::string
-    EXPECT_CONVERSION_FROM_STRING("automatic", plssvm::sycl::kernel_invocation_type::automatic);
-    EXPECT_CONVERSION_FROM_STRING("AUTOMATIC", plssvm::sycl::kernel_invocation_type::automatic);
-    EXPECT_CONVERSION_FROM_STRING("auto", plssvm::sycl::kernel_invocation_type::automatic);
-    EXPECT_CONVERSION_FROM_STRING("AUTO", plssvm::sycl::kernel_invocation_type::automatic);
-    EXPECT_CONVERSION_FROM_STRING("basic", plssvm::sycl::kernel_invocation_type::basic);
-    EXPECT_CONVERSION_FROM_STRING("BASIC", plssvm::sycl::kernel_invocation_type::basic);
-    EXPECT_CONVERSION_FROM_STRING("work_group", plssvm::sycl::kernel_invocation_type::work_group);
-    EXPECT_CONVERSION_FROM_STRING("WORK-GROUP", plssvm::sycl::kernel_invocation_type::work_group);
-    EXPECT_CONVERSION_FROM_STRING("nd_range", plssvm::sycl::kernel_invocation_type::work_group);
-    EXPECT_CONVERSION_FROM_STRING("ND-RANGE", plssvm::sycl::kernel_invocation_type::work_group);
-    EXPECT_CONVERSION_FROM_STRING("hierarchical", plssvm::sycl::kernel_invocation_type::hierarchical);
-    EXPECT_CONVERSION_FROM_STRING("HIERARCHICAL", plssvm::sycl::kernel_invocation_type::hierarchical);
-    EXPECT_CONVERSION_FROM_STRING("scoped", plssvm::sycl::kernel_invocation_type::scoped);
-    EXPECT_CONVERSION_FROM_STRING("SCOPED", plssvm::sycl::kernel_invocation_type::scoped);
-}
-
-TEST(SYCLKernelInvocationType, from_string_unknown) {
-    // foo isn't a valid file_format_type
-    std::istringstream input{ "foo" };
-    plssvm::sycl::kernel_invocation_type invocation_type{};
-    input >> invocation_type;
-    EXPECT_TRUE(input.fail());
-}
-
-TEST(SYCLKernelInvocationType, minimal_available_sycl_kernel_invocation_types) {
-    const std::vector<plssvm::sycl::kernel_invocation_type> invocation_type = plssvm::sycl::list_available_sycl_kernel_invocation_types();
-
-    // at least three must be available (automatic, basic, and work_group)!
-    EXPECT_GE(invocation_type.size(), 3);
-
-    // check for the kernel invocation types that must always be present
-    EXPECT_THAT(invocation_type, ::testing::Contains(plssvm::sycl::kernel_invocation_type::automatic));
-    EXPECT_THAT(invocation_type, ::testing::Contains(plssvm::sycl::kernel_invocation_type::basic));
-    EXPECT_THAT(invocation_type, ::testing::Contains(plssvm::sycl::kernel_invocation_type::work_group));
-}
diff --git a/tests/backends/execution_range.cpp b/tests/backends/execution_range.cpp
index 371c5fa94..bb090a6a0 100644
--- a/tests/backends/execution_range.cpp
+++ b/tests/backends/execution_range.cpp
@@ -23,7 +23,7 @@
 //                                                              dim_type                                                               //
 //*************************************************************************************************************************************//
 
-TEST(DimType, default_construct) {
+TEST(DimType, DefaultConstruct) {
     // a default constructed dim_type should be all ones
     constexpr plssvm::detail::dim_type dim{};
 
@@ -32,7 +32,7 @@ TEST(DimType, default_construct) {
     EXPECT_EQ(dim.z, 1ull);
 }
 
-TEST(DimType, one_argument) {
+TEST(DimType, OneArgument) {
     // a default constructed dim_type should be all ones
     constexpr plssvm::detail::dim_type dim{ 64ull };
 
@@ -41,7 +41,7 @@ TEST(DimType, one_argument) {
     EXPECT_EQ(dim.z, 1ull);
 }
 
-TEST(DimType, two_arguments) {
+TEST(DimType, TwoArguments) {
     // a default constructed dim_type should be all ones
     constexpr plssvm::detail::dim_type dim{ 64ull, 32ull };
 
@@ -50,7 +50,7 @@ TEST(DimType, two_arguments) {
     EXPECT_EQ(dim.z, 1ull);
 }
 
-TEST(DimType, three_arguments) {
+TEST(DimType, ThreeArguments) {
     // a default constructed dim_type should be all ones
     constexpr plssvm::detail::dim_type dim{ 64ull, 32ull, 16ull };
 
@@ -59,7 +59,7 @@ TEST(DimType, three_arguments) {
     EXPECT_EQ(dim.z, 16ull);
 }
 
-TEST(DimType, swap_member_function) {
+TEST(DimType, SwapMemberFunction) {
     plssvm::detail::dim_type dim1{ 64ull };
     plssvm::detail::dim_type dim2{ 32ull, 16ull };
 
@@ -76,7 +76,7 @@ TEST(DimType, swap_member_function) {
     EXPECT_EQ(dim2.z, 1ull);
 }
 
-TEST(DimType, swap_free_function) {
+TEST(DimType, SwapFreeFunction) {
     plssvm::detail::dim_type dim1{ 64ull };
     plssvm::detail::dim_type dim2{ 32ull, 16ull };
 
@@ -94,7 +94,7 @@ TEST(DimType, swap_free_function) {
     EXPECT_EQ(dim2.z, 1ull);
 }
 
-TEST(DimType, equality) {
+TEST(DimType, Equality) {
     // create dim types
     constexpr plssvm::detail::dim_type dim_1{};
     constexpr plssvm::detail::dim_type dim_2{ 64ull };
@@ -117,7 +117,7 @@ TEST(DimType, equality) {
     EXPECT_FALSE(dim_4 == dim_7);
 }
 
-TEST(DimType, inequality) {
+TEST(DimType, Inequality) {
     // create dim types
     constexpr plssvm::detail::dim_type dim_1{};
     constexpr plssvm::detail::dim_type dim_2{ 64ull };
@@ -140,7 +140,7 @@ TEST(DimType, inequality) {
     EXPECT_TRUE(dim_4 != dim_7);
 }
 
-TEST(DimType, to_string) {
+TEST(DimType, ToString) {
     constexpr plssvm::detail::dim_type dim{ 64ull, 32ull, 16ull };
 
     // convert it to a string
@@ -154,7 +154,7 @@ TEST(DimType, to_string) {
 //                                                           execution_range                                                           //
 //*************************************************************************************************************************************//
 
-TEST(ExecutionRange, construct_single_grid) {
+TEST(ExecutionRange, ConstructSingleGrid) {
     // create execution range
     const plssvm::detail::execution_range exec{ plssvm::detail::dim_type{ 16ull, 16ull, 2ull }, 1024ull, plssvm::detail::dim_type{ 64ull, 64ull, 64ull }, plssvm::detail::dim_type{ 1024ull, 1024ull, 1024ull } };
 
@@ -167,7 +167,7 @@ TEST(ExecutionRange, construct_single_grid) {
     EXPECT_EQ(exec.grids.front().second, (plssvm::detail::dim_type{ 0ull, 0ull, 0ull }));
 }
 
-TEST(ExecutionRange, construct_multiple_grids) {
+TEST(ExecutionRange, ConstructMultipleGrids) {
     // create execution range
     const plssvm::detail::execution_range exec{ plssvm::detail::dim_type{ 16ull, 16ull, 4ull }, 1024ull, plssvm::detail::dim_type{ 128ull, 127ull, 126ull }, plssvm::detail::dim_type{ 64ull, 64ull, 64ull } };
 
@@ -175,7 +175,7 @@ TEST(ExecutionRange, construct_multiple_grids) {
     EXPECT_EQ(exec.block, (plssvm::detail::dim_type{ 16ull, 16ull, 4ull }));
 
     // check the grids
-    EXPECT_EQ(exec.grids.size(), 8);
+    ASSERT_EQ(exec.grids.size(), 8);
     EXPECT_EQ(exec.grids[0].first, (plssvm::detail::dim_type{ 64ull, 64ull, 64ull }));
     EXPECT_EQ(exec.grids[0].second, (plssvm::detail::dim_type{ 0ull, 0ull, 0ull }));
     EXPECT_EQ(exec.grids[1].first, (plssvm::detail::dim_type{ 64ull, 64ull, 62ull }));
@@ -197,28 +197,28 @@ TEST(ExecutionRange, construct_multiple_grids) {
     EXPECT_EQ(exec.grids[7].second, (plssvm::detail::dim_type{ 64ull, 64ull, 64ull }));
 }
 
-TEST(ExecutionRange, construct_block_zero_threads) {
+TEST(ExecutionRange, ConstructBlockZeroThreads) {
     // at least one thread must be present!
     EXPECT_THROW_WHAT((plssvm::detail::execution_range{ plssvm::detail::dim_type{ 0ull, 0ull, 0ull }, 16ull, plssvm::detail::dim_type{ 64ull, 64ull, 64ull }, plssvm::detail::dim_type{ 1024ull, 1024ull, 1024ull } }),
                       plssvm::kernel_launch_resources,
                       "At least one thread must be given per block! Maybe one dimension is zero?");
 }
 
-TEST(ExecutionRange, construct_block_zero_threads_in_single_dimension) {
+TEST(ExecutionRange, ConstructBlockZeroThreadsInSingleDimension) {
     // EACH dimension must at least consist of a single thread!
     EXPECT_THROW_WHAT((plssvm::detail::execution_range{ plssvm::detail::dim_type{ 4ull, 4ull, 0ull }, 16ull, plssvm::detail::dim_type{ 64ull, 64ull, 64ull }, plssvm::detail::dim_type{ 1024ull, 1024ull, 1024ull } }),
                       plssvm::kernel_launch_resources,
                       "At least one thread must be given per block! Maybe one dimension is zero?");
 }
 
-TEST(ExecutionRange, construct_block_too_many_threads) {
+TEST(ExecutionRange, ConstructBlockTooManyThreads) {
     // the product of the block dimensions may not exceed to total number of threads allowed in a block
     EXPECT_THROW_WHAT((plssvm::detail::execution_range{ plssvm::detail::dim_type{ 16ull, 16ull, 4ull }, 16ull, plssvm::detail::dim_type{ 64ull, 64ull, 64ull }, plssvm::detail::dim_type{ 1024ull, 1024ull, 1024ull } }),
                       plssvm::kernel_launch_resources,
                       "Not enough work-items allowed for a work-groups of size 16x16x4 (#threads: 1024; max allowed: 16)! Try reducing THREAD_BLOCK_SIZE.");
 }
 
-TEST(ExecutionRange, swap_member_function) {
+TEST(ExecutionRange, SwapMemberFunction) {
     plssvm::detail::execution_range exec1{ plssvm::detail::dim_type{ 16ull, 16ull, 4ull }, 1024ull, plssvm::detail::dim_type{ 64ull, 64ull, 64ull }, plssvm::detail::dim_type{ 1024ull, 1024ull, 1024ull } };
     plssvm::detail::execution_range exec2{ plssvm::detail::dim_type{ 4ull, 4ull, 4ull }, 1024ull, plssvm::detail::dim_type{ 128ull, 128ull, 128ull }, plssvm::detail::dim_type{ 64ull, 64ull, 64ull } };
 
@@ -234,7 +234,7 @@ TEST(ExecutionRange, swap_member_function) {
     EXPECT_EQ(exec2.grids.front().first, (plssvm::detail::dim_type{ 64ull, 64ull, 64ull }));
 }
 
-TEST(ExecutionRange, swap_free_function) {
+TEST(ExecutionRange, SwapFreeFunction) {
     plssvm::detail::execution_range exec1{ plssvm::detail::dim_type{ 16ull, 16ull, 4ull }, 1024ull, plssvm::detail::dim_type{ 64ull, 64ull, 64ull }, plssvm::detail::dim_type{ 1024ull, 1024ull, 1024ull } };
     plssvm::detail::execution_range exec2{ plssvm::detail::dim_type{ 4ull, 4ull, 4ull }, 1024ull, plssvm::detail::dim_type{ 128ull, 128ull, 128ull }, plssvm::detail::dim_type{ 64ull, 64ull, 64ull } };
 
@@ -251,7 +251,7 @@ TEST(ExecutionRange, swap_free_function) {
     EXPECT_EQ(exec2.grids.front().first, (plssvm::detail::dim_type{ 64ull, 64ull, 64ull }));
 }
 
-TEST(ExecutionRange, equality) {
+TEST(ExecutionRange, Equality) {
     // create execution ranges
     const plssvm::detail::execution_range exec1{ plssvm::detail::dim_type{ 16ull, 16ull }, 1024ull, plssvm::detail::dim_type{ 64ull, 64ull }, plssvm::detail::dim_type{ 1024ull, 1024ull } };
     const plssvm::detail::execution_range exec2{ plssvm::detail::dim_type{ 16ull, 16ull }, 1024ull, plssvm::detail::dim_type{ 64ull, 64ull }, plssvm::detail::dim_type{ 64ull, 64ull } };
@@ -267,7 +267,7 @@ TEST(ExecutionRange, equality) {
     EXPECT_TRUE(exec4 == exec4);
 }
 
-TEST(ExecutionRange, inequality) {
+TEST(ExecutionRange, Inequality) {
     // create execution ranges
     const plssvm::detail::execution_range exec1{ plssvm::detail::dim_type{ 16ull, 16ull }, 1024ull, plssvm::detail::dim_type{ 64ull, 64ull }, plssvm::detail::dim_type{ 1024ull, 1024ull } };
     const plssvm::detail::execution_range exec2{ plssvm::detail::dim_type{ 16ull, 16ull }, 1024ull, plssvm::detail::dim_type{ 64ull, 64ull }, plssvm::detail::dim_type{ 64ull, 64ull } };
@@ -283,7 +283,7 @@ TEST(ExecutionRange, inequality) {
     EXPECT_FALSE(exec4 != exec4);
 }
 
-TEST(ExecutionRange, to_string_single_grid) {
+TEST(ExecutionRange, ToStringSingleGrid) {
     const plssvm::detail::execution_range exec{ plssvm::detail::dim_type{ 16ull, 16ull }, 1024ull, plssvm::detail::dim_type{ 64ull, 64ull }, plssvm::detail::dim_type{ 1024ull, 1024ull } };
 
     // convert it to a string
@@ -293,7 +293,7 @@ TEST(ExecutionRange, to_string_single_grid) {
     EXPECT_EQ(str, std::string{ "grid: [64, 64, 1]; block: [16, 16, 1]" });
 }
 
-TEST(ExecutionRange, to_string_multiple_grids) {
+TEST(ExecutionRange, ToStringMultipleGrids) {
     const plssvm::detail::execution_range exec{ plssvm::detail::dim_type{ 32ull, 32ull }, 1024ull, plssvm::detail::dim_type{ 128ull, 128ull }, plssvm::detail::dim_type{ 64ull, 64ull } };
 
     // convert it to a string
diff --git a/tests/backends/generic_base_csvc_tests.hpp b/tests/backends/generic_base_csvc_tests.hpp
index b110978a0..d5112ccf5 100644
--- a/tests/backends/generic_base_csvc_tests.hpp
+++ b/tests/backends/generic_base_csvc_tests.hpp
@@ -15,7 +15,7 @@
 #pragma once
 
 #include "plssvm/classification_types.hpp"              // plssvm::classification_type
-#include "plssvm/constants.hpp"                         // plssvm::real_type, plssvm::PADDING_SIZE
+#include "plssvm/constants.hpp"                         // plssvm::real_type
 #include "plssvm/data_set/classification_data_set.hpp"  // plssvm::classification_data_set
 #include "plssvm/kernel_function_types.hpp"             // plssvm::kernel_function_type
 #include "plssvm/model/classification_model.hpp"        // plssvm::classification_model
@@ -23,15 +23,15 @@
 #include "plssvm/solver_types.hpp"                      // plssvm::solver_type
 #include "plssvm/target_platforms.hpp"                  // plssvm::target_platform
 
-#include "tests/types_to_test.hpp"  // util::{test_parameter_type_at_t, test_parameter_value_at_v}
-#include "tests/utility.hpp"        // util::{redirect_output, construct_from_tuple, temporary_file, instantiate_template_file}
+#include "tests/custom_test_macros.hpp"  // EXPECT_OPTIONAL_EQ
+#include "tests/types_to_test.hpp"       // util::{test_parameter_type_at_t, test_parameter_value_at_v}
+#include "tests/utility.hpp"             // util::{redirect_output, construct_from_tuple, temporary_file, instantiate_template_file}
 
-#include "fmt/format.h"   // fmt::format
 #include "gtest/gtest.h"  // TYPED_TEST_SUITE_P, TYPED_TEST_P, REGISTER_TYPED_TEST_SUITE_P, EXPECT_EQ, EXPECT_TRUE, ::testing::Test
 
-#include <string>   // std::string
-#include <utility>  // std::move
-#include <vector>   // std::vector
+#include <iostream>  // std::iostream
+#include <utility>   // std::move
+#include <vector>    // std::vector
 
 template <typename T>
 class GenericCSVC : public ::testing::Test,
@@ -39,7 +39,7 @@ class GenericCSVC : public ::testing::Test,
 
 TYPED_TEST_SUITE_P(GenericCSVC);
 
-TYPED_TEST_P(GenericCSVC, move_constructor) {
+TYPED_TEST_P(GenericCSVC, MoveConstructor) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvc_type = typename csvm_test_type::csvc_type;
 
@@ -58,7 +58,7 @@ TYPED_TEST_P(GenericCSVC, move_constructor) {
     EXPECT_EQ(new_svc.get_target_platform(), target);
 }
 
-TYPED_TEST_P(GenericCSVC, move_assignment) {
+TYPED_TEST_P(GenericCSVC, MoveAssignment) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvc_type = typename csvm_test_type::csvc_type;
 
@@ -81,8 +81,8 @@ TYPED_TEST_P(GenericCSVC, move_assignment) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVC,
-                            move_constructor,
-                            move_assignment);
+                            MoveConstructor,
+                            MoveAssignment);
 
 //*************************************************************************************************************************************//
 //                                C-SVC tests depending on the kernel function and classification type                                 //
@@ -93,7 +93,7 @@ class GenericCSVCKernelFunctionClassification : public GenericCSVC<T> { };
 
 TYPED_TEST_SUITE_P(GenericCSVCKernelFunctionClassification);
 
-TYPED_TEST_P(GenericCSVCKernelFunctionClassification, predict) {
+TYPED_TEST_P(GenericCSVCKernelFunctionClassification, Predict) {
     using label_type = util::test_parameter_type_at_t<1, TypeParam>;
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvc_type = typename csvm_test_type::csvc_type;
@@ -101,22 +101,23 @@ TYPED_TEST_P(GenericCSVCKernelFunctionClassification, predict) {
     constexpr plssvm::classification_type classification = util::test_parameter_value_at_v<1, TypeParam>;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
 
     // create data set that is always classifiable
-    plssvm::classification_data_set<label_type> test_data = util::generate_trivially_solvable_classification_data_set<label_type>();
+    plssvm::classification_data_set<label_type> test_data = util::generate_trivially_solvable_classification_data_set<label_type>();  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (test_data.labels().has_value()) {
-            test_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(test_data.data()), *test_data.labels() };
+        const auto &labels_opt = test_data.labels();
+        if (labels_opt.has_value()) {
+            test_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(test_data.data()), labels_opt.value() };
         }
     }
 
     // create normal C-SVC
-    const csvc_type svc = util::construct_from_tuple<csvc_type>(params, csvm_test_type::additional_arguments);
+    const auto svc = util::construct_from_tuple<csvc_type>(params, csvm_test_type::additional_arguments);
 
     // fitting the test data will ALWAYS score 100% accuracy
     const plssvm::classification_model<label_type> model = svc.fit(test_data, plssvm::epsilon = 1e-16, plssvm::classification = classification);
@@ -125,16 +126,16 @@ TYPED_TEST_P(GenericCSVCKernelFunctionClassification, predict) {
     const std::vector<label_type> calculated = svc.predict(model, test_data);
 
     // check the calculated result for correctness
-    EXPECT_EQ(calculated, test_data.labels().value().get());
+    EXPECT_OPTIONAL_EQ(calculated, test_data.labels());
 
     // for the linear kernel, predict again to check whether reusing the w vector works as intended
     if (kernel == plssvm::kernel_function_type::linear) {
         const std::vector<label_type> calculated_second = svc.predict(model, test_data);
-        EXPECT_EQ(calculated_second, test_data.labels().value().get());
+        EXPECT_OPTIONAL_EQ(calculated_second, test_data.labels());
     }
 }
 
-TYPED_TEST_P(GenericCSVCKernelFunctionClassification, score_model) {
+TYPED_TEST_P(GenericCSVCKernelFunctionClassification, ScoreModel) {
     using label_type = util::test_parameter_type_at_t<1, TypeParam>;
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvc_type = typename csvm_test_type::csvc_type;
@@ -142,22 +143,23 @@ TYPED_TEST_P(GenericCSVCKernelFunctionClassification, score_model) {
     constexpr plssvm::classification_type classification = util::test_parameter_value_at_v<1, TypeParam>;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
 
     // create data set that is always classifiable
-    plssvm::classification_data_set<label_type> test_data = util::generate_trivially_solvable_classification_data_set<label_type>();
+    plssvm::classification_data_set<label_type> test_data = util::generate_trivially_solvable_classification_data_set<label_type>();  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (test_data.labels().has_value()) {
-            test_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(test_data.data()), *test_data.labels() };
+        const auto &labels_opt = test_data.labels();
+        if (labels_opt.has_value()) {
+            test_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(test_data.data()), labels_opt.value() };
         }
     }
 
     // create normal C-SVC
-    const csvc_type svc = util::construct_from_tuple<csvc_type>(params, csvm_test_type::additional_arguments);
+    const auto svc = util::construct_from_tuple<csvc_type>(params, csvm_test_type::additional_arguments);
 
     // fitting the test data will ALWAYS score 100% accuracy
     const plssvm::classification_model<label_type> model = svc.fit(test_data, plssvm::epsilon = 1e-16, plssvm::classification = classification);
@@ -169,7 +171,7 @@ TYPED_TEST_P(GenericCSVCKernelFunctionClassification, score_model) {
     EXPECT_EQ(calculated, plssvm::real_type{ 1.0 });
 }
 
-TYPED_TEST_P(GenericCSVCKernelFunctionClassification, score) {
+TYPED_TEST_P(GenericCSVCKernelFunctionClassification, Score) {
     using label_type = util::test_parameter_type_at_t<1, TypeParam>;
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvc_type = typename csvm_test_type::csvc_type;
@@ -177,22 +179,23 @@ TYPED_TEST_P(GenericCSVCKernelFunctionClassification, score) {
     constexpr plssvm::classification_type classification = util::test_parameter_value_at_v<1, TypeParam>;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
 
     // create data set that is always classifiable
-    plssvm::classification_data_set<label_type> test_data = util::generate_trivially_solvable_classification_data_set<label_type>();
+    plssvm::classification_data_set<label_type> test_data = util::generate_trivially_solvable_classification_data_set<label_type>();  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (test_data.labels().has_value()) {
-            test_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(test_data.data()), *test_data.labels() };
+        const auto &labels_opt = test_data.labels();
+        if (labels_opt.has_value()) {
+            test_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(test_data.data()), labels_opt.value() };
         }
     }
 
     // create normal C-SVC
-    const csvc_type svc = util::construct_from_tuple<csvc_type>(params, csvm_test_type::additional_arguments);
+    const auto svc = util::construct_from_tuple<csvc_type>(params, csvm_test_type::additional_arguments);
 
     // fitting the test data will ALWAYS score 100% accuracy
     const plssvm::classification_model<label_type> model = svc.fit(test_data, plssvm::epsilon = 1e-16, plssvm::classification = classification);
@@ -205,9 +208,9 @@ TYPED_TEST_P(GenericCSVCKernelFunctionClassification, score) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVCKernelFunctionClassification,
-                            predict,
-                            score_model,
-                            score);
+                            Predict,
+                            ScoreModel,
+                            Score);
 
 //*************************************************************************************************************************************//
 //                            C-SVC tests depending on the solver, kernel function, and classification type                            //
@@ -215,7 +218,8 @@ REGISTER_TYPED_TEST_SUITE_P(GenericCSVCKernelFunctionClassification,
 
 template <typename T>
 class GenericCSVCSolverKernelFunctionClassification : public GenericCSVC<T>,
-                                                      protected util::temporary_file {
+                                                      protected util::temporary_file,
+                                                      protected util::redirect_output<&std::clog> {
   protected:
     using fixture_label_type = util::test_parameter_type_at_t<1, T>;
 
@@ -227,7 +231,7 @@ class GenericCSVCSolverKernelFunctionClassification : public GenericCSVC<T>,
 
 TYPED_TEST_SUITE_P(GenericCSVCSolverKernelFunctionClassification);
 
-TYPED_TEST_P(GenericCSVCSolverKernelFunctionClassification, fit) {
+TYPED_TEST_P(GenericCSVCSolverKernelFunctionClassification, Fit) {
     // note: only quantitative tests, doesn't check the real weights and rho values
     using label_type = util::test_parameter_type_at_t<1, TypeParam>;
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
@@ -240,16 +244,17 @@ TYPED_TEST_P(GenericCSVCSolverKernelFunctionClassification, fit) {
     const plssvm::parameter params{ plssvm::kernel_type = kernel };
 
     // create data set to be used
-    plssvm::classification_data_set<label_type> test_data{ this->filename };
+    plssvm::classification_data_set<label_type> test_data{ this->filename };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (test_data.labels().has_value()) {
-            test_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(test_data.data()), *test_data.labels() };
+        const auto &labels_opt = test_data.labels();
+        if (labels_opt.has_value()) {
+            test_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(test_data.data()), labels_opt.value() };
         }
     }
 
     // create normal C-SVC
-    const csvc_type svc = util::construct_from_tuple<csvc_type>(params, csvm_test_type::additional_arguments);
+    const auto svc = util::construct_from_tuple<csvc_type>(params, csvm_test_type::additional_arguments);
 
     // call fit
     const plssvm::classification_model<label_type> model = svc.fit(test_data, plssvm::epsilon = 1e-10, plssvm::solver = solver, plssvm::classification = classification);
@@ -259,9 +264,9 @@ TYPED_TEST_P(GenericCSVCSolverKernelFunctionClassification, fit) {
     EXPECT_EQ(model.num_features(), test_data.num_features());
     EXPECT_EQ(model.get_params(), (plssvm::parameter{ params, plssvm::gamma = plssvm::real_type{ 1.0 } / static_cast<plssvm::real_type>(test_data.num_features()) }));
     EXPECT_EQ(model.support_vectors(), test_data.data());
-    EXPECT_EQ(model.labels().value().get(), test_data.labels().value().get());
+    EXPECT_OPTIONAL_EQ(model.labels(), test_data.labels());
     EXPECT_EQ(model.num_classes(), test_data.num_classes());
-    EXPECT_EQ(model.classes(), test_data.classes().value());
+    EXPECT_OPTIONAL_EQ(model.classes(), test_data.classes());
     if constexpr (classification == plssvm::classification_type::oaa) {
         EXPECT_EQ(model.weights().size(), 1);
         EXPECT_EQ(model.rho().size(), test_data.num_classes());
@@ -270,11 +275,14 @@ TYPED_TEST_P(GenericCSVCSolverKernelFunctionClassification, fit) {
         EXPECT_EQ(model.rho().size(), plssvm::calculate_number_of_classifiers(classification, test_data.num_classes()));
     }
     EXPECT_EQ(model.get_classification_type(), classification);
-    EXPECT_TRUE(model.num_iters().has_value());
-    EXPECT_EQ(model.num_iters().value().size(), (plssvm::calculate_number_of_classifiers(classification, test_data.num_classes())));
+    const auto &num_iters_opt = model.num_iters();
+    ASSERT_TRUE(num_iters_opt.has_value());
+    if (num_iters_opt.has_value()) {
+        EXPECT_EQ(num_iters_opt.value().size(), (plssvm::calculate_number_of_classifiers(classification, test_data.num_classes())));
+    }
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVCSolverKernelFunctionClassification,
-                            fit);
+                            Fit);
 
 #endif  // PLSSVM_TESTS_BACKENDS_GENERIC_BASE_CSVC_TESTS_HPP_
diff --git a/tests/backends/generic_base_csvm_tests.hpp b/tests/backends/generic_base_csvm_tests.hpp
index fd93963c1..3856e4003 100644
--- a/tests/backends/generic_base_csvm_tests.hpp
+++ b/tests/backends/generic_base_csvm_tests.hpp
@@ -14,20 +14,21 @@
 #define PLSSVM_TESTS_BACKENDS_GENERIC_BASE_CSVM_TESTS_HPP_
 #pragma once
 
-#include "plssvm/backend_types.hpp"             // plssvm::backend_type
-#include "plssvm/backends/execution_range.hpp"  // plssvm::detail::execution_range
-#include "plssvm/constants.hpp"                 // plssvm::real_type, plssvm::PADDING_SIZE
-#include "plssvm/detail/data_distribution.hpp"  // plssvm::detail::{triangular_data_distribution, rectangular_data_distribution}
-#include "plssvm/detail/memory_size.hpp"        // memory size literals
-#include "plssvm/detail/move_only_any.hpp"      // plssvm::detail::move_only_any
-#include "plssvm/detail/utility.hpp"            // plssvm::detail::{unreachable, get}
-#include "plssvm/kernel_function_types.hpp"     // plssvm::csvm_to_backend_type_v, plssvm::backend_type
-#include "plssvm/matrix.hpp"                    // plssvm::aos_matrix
-#include "plssvm/mpi/communicator.hpp"          // plssvm::mpi::communicator
-#include "plssvm/parameter.hpp"                 // plssvm::parameter
-#include "plssvm/shape.hpp"                     // plssvm::shape
-#include "plssvm/solver_types.hpp"              // plssvm::solver_type
-#include "plssvm/target_platforms.hpp"          // plssvm::target_platform
+#include "plssvm/backend_types.hpp"                     // plssvm::backend_type
+#include "plssvm/backends/execution_range.hpp"          // plssvm::detail::execution_range
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"  // plssvm::kokkos::execution_space
+#include "plssvm/constants.hpp"                         // plssvm::real_type, plssvm::PADDING_SIZE
+#include "plssvm/detail/data_distribution.hpp"          // plssvm::detail::{triangular_data_distribution, rectangular_data_distribution}
+#include "plssvm/detail/memory_size.hpp"                // memory size literals
+#include "plssvm/detail/move_only_any.hpp"              // plssvm::detail::move_only_any
+#include "plssvm/detail/utility.hpp"                    // plssvm::detail::{unreachable, get}
+#include "plssvm/kernel_function_types.hpp"             // plssvm::csvm_to_backend_type_v, plssvm::backend_type
+#include "plssvm/matrix.hpp"                            // plssvm::aos_matrix
+#include "plssvm/mpi/communicator.hpp"                  // plssvm::mpi::communicator
+#include "plssvm/parameter.hpp"                         // plssvm::parameter
+#include "plssvm/shape.hpp"                             // plssvm::shape
+#include "plssvm/solver_types.hpp"                      // plssvm::solver_type
+#include "plssvm/target_platforms.hpp"                  // plssvm::target_platform
 
 #include "tests/backends/ground_truth.hpp"  // ground_truth::{kernel_function, perform_dimensional_reduction}
 #include "tests/custom_test_macros.hpp"     // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_VECTOR_NEAR, EXPECT_FLOATING_POINT_NEAR
@@ -39,13 +40,16 @@
 #include "gtest/gtest.h"  // TYPED_TEST_SUITE_P, TYPED_TEST_P, REGISTER_TYPED_TEST_SUITE_P, EXPECT_EQ, EXPECT_NE, EXPECT_GT, EXPECT_TRUE, EXPECT_DEATH,
                           // ASSERT_EQ, SUCCEED, ::testing::Test
 
-#include <cmath>    // std::sqrt, std::abs
-#include <cstddef>  // std::size_t
-#include <limits>   // std::numeric_limits::epsilon
-#include <memory>   // std::unique_ptr, std::make_unique
-#include <tuple>    // std::ignore, std::tuple, std::make_tuple
-#include <utility>  // std::move
-#include <vector>   // std::vector
+#include <cmath>       // std::sqrt, std::abs
+#include <cstddef>     // std::size_t
+#include <cstring>     // std::memcpy
+#include <functional>  // std::cref
+#include <limits>      // std::numeric_limits::epsilon
+#include <memory>      // std::unique_ptr, std::make_unique
+#include <optional>    // std::optional
+#include <tuple>       // std::ignore, std::tuple, std::make_tuple
+#include <utility>     // std::move
+#include <vector>      // std::vector
 
 namespace util {
 
@@ -61,7 +65,7 @@ namespace util {
  * @return a std::vector of `plssvm::detail::move_only_any` with a wrapped value usable in the PLSSVM functions (`[[nodiscard]]`)
  */
 template <typename csvm_type, typename device_ptr_type, typename matrix_type, typename used_csvm_type, typename... Args>
-[[nodiscard]] inline std::vector<plssvm::detail::move_only_any> init_explicit_matrices(matrix_type matr, used_csvm_type &csvm) {
+[[nodiscard]] inline std::vector<plssvm::detail::move_only_any> init_explicit_matrices(const matrix_type &matr, used_csvm_type &csvm) {
     using real_type = typename matrix_type::value_type;
     std::vector<plssvm::detail::move_only_any> result(csvm.num_available_devices());
 
@@ -86,7 +90,10 @@ template <typename csvm_type, typename device_ptr_type, typename matrix_type, ty
 
     if constexpr (plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::openmp || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::stdpar || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::hpx) {
         // only a single device for OpenMP, stdpar, and HPX on the CPU
-        result[0] = plssvm::detail::move_only_any{ calculate_partial_kernel_matrix(0, matr.num_rows()) };
+        const std::vector<real_type> partial_kernel_matrix = calculate_partial_kernel_matrix(0, matr.num_rows());
+        auto ptr = std::make_unique<real_type[]>(partial_kernel_matrix.size());  // NOLINT: C-style array must be used here to align with real implementation
+        std::memcpy(ptr.get(), partial_kernel_matrix.data(), partial_kernel_matrix.size() * sizeof(real_type));
+        result[0] = plssvm::detail::move_only_any{ std::move(ptr) };
     } else {
         for (std::size_t device_id = 0; device_id < csvm.num_available_devices(); ++device_id) {
             auto &device = csvm.devices_[device_id];
@@ -117,23 +124,15 @@ template <typename csvm_type, typename device_ptr_type, typename matrix_type, ty
  * @param[in] args the additional arguments
  * @return a std::vector of `plssvm::detail::move_only_any` with a wrapped value usable in the PLSSVM functions (`[[nodiscard]]`)
  */
-template <typename csvm_type, typename device_ptr_type, typename matrix_type, typename used_csvm_type, typename... Args>
-[[nodiscard]] inline std::vector<plssvm::detail::move_only_any> init_implicit_matrices(matrix_type matr, used_csvm_type &csvm, Args &&...args) {
-    using real_type = typename matrix_type::value_type;
+template <typename csvm_type, typename device_ptr_type, typename matrix_type, typename used_csvm_type, typename real_type = typename matrix_type::value_type>
+[[nodiscard]] inline std::vector<plssvm::detail::move_only_any> init_implicit_matrices(const matrix_type &matr, used_csvm_type &csvm, const plssvm::parameter params, const std::vector<real_type> &q_red, const real_type QA_cost) {
     std::vector<plssvm::detail::move_only_any> result(csvm.num_available_devices());
 
-    [[maybe_unused]] const auto params = static_cast<plssvm::parameter>(plssvm::detail::get<0>(args...));
-    [[maybe_unused]] const auto q_red = static_cast<std::vector<real_type>>(plssvm::detail::get<1>(args...));
-    [[maybe_unused]] const auto QA_cost = static_cast<real_type>(plssvm::detail::get<2>(args...));
-
-    // add padding to the input matrix
-    matr = matrix_type{ matr, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
-
     for (std::size_t device_id = 0; device_id < csvm.num_available_devices(); ++device_id) {
-        // created matrix is different for the OpenMP, stdpar or HPX backend and the GPU backends!
+        // created matrix is different for the OpenMP, stdpar or HPX backend and the GP92U backends!
         if constexpr (plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::openmp || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::stdpar || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::hpx) {
             // only a single device ever in use
-            result[0] = plssvm::detail::move_only_any{ std::make_tuple(plssvm::soa_matrix<real_type>{ matr, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } }, std::forward<Args>(args)...) };
+            result[0] = plssvm::detail::move_only_any{ std::make_tuple(std::cref(matr), params, std::cref(q_red), QA_cost) };
         } else {
             auto &device = csvm.devices_[device_id];
 
@@ -182,11 +181,12 @@ template <typename csvm_type, typename device_ptr_type, typename matrix_type, ty
  * @return a std::vector of `plssvm::detail::move_only_any` with a wrapped value usable in the PLSSVM functions (`[[nodiscard]]`)
  */
 template <typename csvm_type, typename device_ptr_type, typename matrix_type, typename used_csvm_type, typename... Args>
-[[nodiscard]] inline std::vector<plssvm::detail::move_only_any> init_matrices(matrix_type matr, const plssvm::solver_type solver, used_csvm_type &csvm, Args &&...args) {
+[[nodiscard]] inline std::vector<plssvm::detail::move_only_any> init_matrices(const matrix_type &matr, const plssvm::solver_type solver, used_csvm_type &csvm, Args &&...args) {
     switch (solver) {
         case plssvm::solver_type::automatic:
             {
                 std::vector<plssvm::detail::move_only_any> result;
+                result.reserve(csvm.num_available_devices());
                 for (std::size_t device_id = 0; device_id < csvm.num_available_devices(); ++device_id) {
                     result.push_back(plssvm::detail::move_only_any{ std::vector<typename matrix_type::value_type>{} });
                 }
@@ -194,10 +194,10 @@ template <typename csvm_type, typename device_ptr_type, typename matrix_type, ty
             }
         case plssvm::solver_type::cg_explicit:
             // no additional arguments are used
-            return init_explicit_matrices<csvm_type, device_ptr_type>(std::move(matr), csvm);
+            return init_explicit_matrices<csvm_type, device_ptr_type>(matr, csvm);
         case plssvm::solver_type::cg_implicit:
             // additional arguments are: params, q_red, QA_cost
-            return init_implicit_matrices<csvm_type, device_ptr_type>(std::move(matr), csvm, std::forward<Args>(args)...);
+            return init_implicit_matrices<csvm_type, device_ptr_type>(matr, csvm, std::forward<Args>(args)...);
     }
     // should never be reached!
     plssvm::detail::unreachable();
@@ -215,25 +215,25 @@ class GenericCSVM : public ::testing::Test,
 
 TYPED_TEST_SUITE_P(GenericCSVM);
 
-TYPED_TEST_P(GenericCSVM, get_target_platform) {
+TYPED_TEST_P(GenericCSVM, GetTargetPlatform) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
 
     // create normal C-SVM
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     // after construction: get_target_platform must refer to a plssvm::target_platform that is not automatic
     EXPECT_NE(svm.get_target_platform(), plssvm::target_platform::automatic);
 }
 
-TYPED_TEST_P(GenericCSVM, num_available_devices) {
-    using namespace plssvm::detail::literals;
+TYPED_TEST_P(GenericCSVM, NumAvailableDevices) {
+    using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvm_type = typename csvm_test_type::csvm_type;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
 
     // create normal C-SVM
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     // the maximum memory allocation size should be greater than 0!
     if constexpr (plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::openmp || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::stdpar || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::hpx) {
@@ -243,13 +243,13 @@ TYPED_TEST_P(GenericCSVM, num_available_devices) {
     }
 }
 
-TYPED_TEST_P(GenericCSVM, get_device_memory) {
-    using namespace plssvm::detail::literals;
+TYPED_TEST_P(GenericCSVM, GetDeviceMemory) {
+    using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     // the available device memory should be greater than 0!
     const std::vector<plssvm::detail::memory_size> mem = svm.get_device_memory();
@@ -259,13 +259,13 @@ TYPED_TEST_P(GenericCSVM, get_device_memory) {
     }
 }
 
-TYPED_TEST_P(GenericCSVM, get_max_mem_alloc_size) {
-    using namespace plssvm::detail::literals;
+TYPED_TEST_P(GenericCSVM, GetMaxMemAllocSize) {
+    using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     // the maximum memory allocation size should be greater than 0!
     const std::vector<plssvm::detail::memory_size> mem = svm.get_max_mem_alloc_size();
@@ -275,7 +275,49 @@ TYPED_TEST_P(GenericCSVM, get_max_mem_alloc_size) {
     }
 }
 
-TYPED_TEST_P(GenericCSVM, blas_level_3_explicit_without_C) {
+TYPED_TEST_P(GenericCSVM, GetLocalMemory) {
+    using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
+    using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
+    using csvm_type = typename csvm_test_type::csvm_type;
+    using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
+
+    // create C-SVM: must be done using the mock class since the member function to test is private or protected
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+
+    // the maximum memory allocation size should be greater than 0!
+    const std::vector<std::optional<plssvm::detail::memory_size>> local_mem = svm.get_local_memory();
+    EXPECT_GE(local_mem.size(), 1);
+    for (const std::optional<plssvm::detail::memory_size> ms : local_mem) {
+        if constexpr (plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::openmp || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::stdpar || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::hpx) {
+            // some backends inherently do not have the capability of local memory
+            EXPECT_EQ(ms, std::nullopt);
+        } else if constexpr (plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::kokkos) {
+            // for the Kokkos backend, the existence of the local memory size depends on the kokkos execution space
+            switch (svm.get_execution_space()) {
+                case plssvm::kokkos::execution_space::cuda:
+                case plssvm::kokkos::execution_space::hip:
+                case plssvm::kokkos::execution_space::sycl:
+                    EXPECT_GT(ms.value(), 0_B);
+                    break;
+                case plssvm::kokkos::execution_space::hpx:
+                case plssvm::kokkos::execution_space::openmp:
+                case plssvm::kokkos::execution_space::threads:
+                case plssvm::kokkos::execution_space::serial:
+                    EXPECT_EQ(ms, std::nullopt);
+                    break;
+                case plssvm::kokkos::execution_space::openmp_target:
+                case plssvm::kokkos::execution_space::openacc:
+                case plssvm::kokkos::execution_space::automatic:
+                    // should currently be unreachable!
+                    break;
+            }
+        } else {
+            EXPECT_GT(ms.value(), 0_B);
+        }
+    }
+}
+
+TYPED_TEST_P(GenericCSVM, BlasLevel3ExplicitWithoutC) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvm_type = typename csvm_test_type::csvm_type;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
@@ -284,7 +326,7 @@ TYPED_TEST_P(GenericCSVM, blas_level_3_explicit_without_C) {
     constexpr plssvm::solver_type solver = plssvm::solver_type::cg_explicit;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     const plssvm::real_type alpha{ 1.0 };
     const plssvm::aos_matrix<plssvm::real_type> matr_A{
@@ -320,7 +362,7 @@ TYPED_TEST_P(GenericCSVM, blas_level_3_explicit_without_C) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(C2, C);
 }
 
-TYPED_TEST_P(GenericCSVM, blas_level_3_explicit) {
+TYPED_TEST_P(GenericCSVM, BlasLevel3Explicit) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvm_type = typename csvm_test_type::csvm_type;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
@@ -329,7 +371,7 @@ TYPED_TEST_P(GenericCSVM, blas_level_3_explicit) {
     constexpr plssvm::solver_type solver = plssvm::solver_type::cg_explicit;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     const plssvm::real_type alpha{ 1.0 };
 
@@ -365,7 +407,7 @@ TYPED_TEST_P(GenericCSVM, blas_level_3_explicit) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(C2, C);
 }
 
-TYPED_TEST_P(GenericCSVM, conjugate_gradients_trivial) {
+TYPED_TEST_P(GenericCSVM, ConjugateGradientsTrivial) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvm_type = typename csvm_test_type::csvm_type;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
@@ -375,7 +417,7 @@ TYPED_TEST_P(GenericCSVM, conjugate_gradients_trivial) {
     constexpr plssvm::solver_type solver = plssvm::solver_type::cg_explicit;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     // create the data that should be used
     const plssvm::aos_matrix<plssvm::real_type> matr_A{
@@ -399,7 +441,7 @@ TYPED_TEST_P(GenericCSVM, conjugate_gradients_trivial) {
     EXPECT_THAT(num_iters, ::testing::Each(::testing::Gt(0)));
 }
 
-TYPED_TEST_P(GenericCSVM, conjugate_gradients) {
+TYPED_TEST_P(GenericCSVM, ConjugateGradients) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvm_type = typename csvm_test_type::csvm_type;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
@@ -409,7 +451,7 @@ TYPED_TEST_P(GenericCSVM, conjugate_gradients) {
     constexpr plssvm::solver_type solver = plssvm::solver_type::cg_explicit;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     // create the data that should be used
     const plssvm::aos_matrix<plssvm::real_type> matr_A{
@@ -435,14 +477,15 @@ TYPED_TEST_P(GenericCSVM, conjugate_gradients) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVM,
-                            get_target_platform,
-                            get_device_memory,
-                            get_max_mem_alloc_size,
-                            num_available_devices,
-                            blas_level_3_explicit_without_C,
-                            blas_level_3_explicit,
-                            conjugate_gradients_trivial,
-                            conjugate_gradients);
+                            GetTargetPlatform,
+                            GetDeviceMemory,
+                            GetLocalMemory,
+                            GetMaxMemAllocSize,
+                            NumAvailableDevices,
+                            BlasLevel3ExplicitWithoutC,
+                            BlasLevel3Explicit,
+                            ConjugateGradientsTrivial,
+                            ConjugateGradients);
 
 //*************************************************************************************************************************************//
 //                                          C-SVM tests depending on the kernel function type                                          //
@@ -453,7 +496,7 @@ class GenericCSVMKernelFunction : public GenericCSVM<T> { };
 
 TYPED_TEST_SUITE_P(GenericCSVMKernelFunction);
 
-TYPED_TEST_P(GenericCSVMKernelFunction, blas_level_3_assembly_implicit_without_C) {
+TYPED_TEST_P(GenericCSVMKernelFunction, BlasLevel3AssemblyImplicitWithoutC) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvm_type = typename csvm_test_type::csvm_type;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
@@ -464,7 +507,7 @@ TYPED_TEST_P(GenericCSVMKernelFunction, blas_level_3_assembly_implicit_without_C
     constexpr plssvm::solver_type solver = plssvm::solver_type::cg_implicit;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 2.0 };
+    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 2.0 };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -476,11 +519,11 @@ TYPED_TEST_P(GenericCSVMKernelFunction, blas_level_3_assembly_implicit_without_C
     }
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
 
     const plssvm::real_type alpha{ 1.0 };
 
-    const auto matr_A = util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ 4, 4 });
+    const auto matr_A = util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
     const auto [q, QA_cost] = ground_truth::perform_dimensional_reduction(params, matr_A);
 
     // be sure to use the correct data distribution
@@ -510,7 +553,7 @@ TYPED_TEST_P(GenericCSVMKernelFunction, blas_level_3_assembly_implicit_without_C
     EXPECT_FLOATING_POINT_MATRIX_EQ(C, C2);
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunction, blas_level_3_assembly_implicit) {
+TYPED_TEST_P(GenericCSVMKernelFunction, BlasLevel3AssemblyImplicit) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvm_type = typename csvm_test_type::csvm_type;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
@@ -521,7 +564,7 @@ TYPED_TEST_P(GenericCSVMKernelFunction, blas_level_3_assembly_implicit) {
     constexpr plssvm::solver_type solver = plssvm::solver_type::cg_implicit;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 2.0 };
+    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 2.0 };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -533,11 +576,11 @@ TYPED_TEST_P(GenericCSVMKernelFunction, blas_level_3_assembly_implicit) {
     }
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
 
     const plssvm::real_type alpha{ 1.0 };
 
-    const auto matr_A = util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ 4, 4 });
+    const auto matr_A = util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
     const auto [q, QA_cost] = ground_truth::perform_dimensional_reduction(params, matr_A);
 
     // be sure to use the correct data distribution
@@ -567,13 +610,13 @@ TYPED_TEST_P(GenericCSVMKernelFunction, blas_level_3_assembly_implicit) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(C, C2);
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunction, predict_values) {
+TYPED_TEST_P(GenericCSVMKernelFunction, PredictValues) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 2.0 };
+    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 2.0 };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -600,7 +643,7 @@ TYPED_TEST_P(GenericCSVMKernelFunction, predict_values) {
                                                       plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
 
     // be sure to use the correct data distribution
     svm.data_distribution_ = std::make_unique<plssvm::detail::rectangular_data_distribution>(plssvm::mpi::communicator{}, data.num_rows(), 1);
@@ -627,7 +670,7 @@ TYPED_TEST_P(GenericCSVMKernelFunction, predict_values) {
     }
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunction, predict_values_provided_w) {
+TYPED_TEST_P(GenericCSVMKernelFunction, PredictValuesProvidedW) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
@@ -636,7 +679,7 @@ TYPED_TEST_P(GenericCSVMKernelFunction, predict_values_provided_w) {
         SUCCEED() << "Test is only applicable for the linear kernel function!";
     } else {
         // create parameter struct
-        plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 2.0 };
+        plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 2.0 };  // NOLINT(misc-const-correctness): can change based on the kernel function
         if constexpr (kernel != plssvm::kernel_function_type::linear) {
             params.gamma = plssvm::real_type{ 1.0 };
         }
@@ -665,7 +708,7 @@ TYPED_TEST_P(GenericCSVMKernelFunction, predict_values_provided_w) {
                                                                             plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
 
         // create C-SVM: must be done using the mock class since the member function to test is private or protected
-        const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+        const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
 
         // be sure to use the correct data distribution
         svm.data_distribution_ = std::make_unique<plssvm::detail::rectangular_data_distribution>(plssvm::mpi::communicator{}, data.num_rows(), 1);
@@ -682,13 +725,13 @@ TYPED_TEST_P(GenericCSVMKernelFunction, predict_values_provided_w) {
     }
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunction, perform_dimensional_reduction) {
+TYPED_TEST_P(GenericCSVMKernelFunction, PerformDimensionalReduction) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -696,7 +739,7 @@ TYPED_TEST_P(GenericCSVMKernelFunction, perform_dimensional_reduction) {
     const auto data = util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ 6, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
 
     // perform dimensional reduction
     const auto [q_red, QA_cost] = svm.perform_dimensional_reduction(params, data);
@@ -709,11 +752,11 @@ TYPED_TEST_P(GenericCSVMKernelFunction, perform_dimensional_reduction) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVMKernelFunction,
-                            blas_level_3_assembly_implicit_without_C,
-                            blas_level_3_assembly_implicit,
-                            predict_values,
-                            predict_values_provided_w,
-                            perform_dimensional_reduction);
+                            BlasLevel3AssemblyImplicitWithoutC,
+                            BlasLevel3AssemblyImplicit,
+                            PredictValues,
+                            PredictValuesProvidedW,
+                            PerformDimensionalReduction);
 
 //*************************************************************************************************************************************//
 //                                              C-SVM tests depending on the solver type                                               //
@@ -724,7 +767,7 @@ class GenericCSVMSolver : public GenericCSVM<T> { };
 
 TYPED_TEST_SUITE_P(GenericCSVMSolver);
 
-TYPED_TEST_P(GenericCSVMSolver, solve_lssvm_system_of_linear_equations_trivial) {
+TYPED_TEST_P(GenericCSVMSolver, SolveLssvmSystemOfLinearEquationsTrivial) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::solver_type solver = util::test_parameter_value_at_v<0, TypeParam>;
@@ -732,7 +775,7 @@ TYPED_TEST_P(GenericCSVMSolver, solve_lssvm_system_of_linear_equations_trivial)
     constexpr plssvm::kernel_function_type kernel = plssvm::kernel_function_type::linear;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 2.0 };
+    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 2.0 };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -749,7 +792,7 @@ TYPED_TEST_P(GenericCSVMSolver, solve_lssvm_system_of_linear_equations_trivial)
                                                    plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
 
     // solve the system of linear equations using the CG algorithm:
     // | Q  1 |  *  | x |  =  | y |
@@ -768,7 +811,7 @@ TYPED_TEST_P(GenericCSVMSolver, solve_lssvm_system_of_linear_equations_trivial)
     EXPECT_THAT(num_iters, ::testing::Each(::testing::Gt(0)));
 }
 
-TYPED_TEST_P(GenericCSVMSolver, solve_lssvm_system_of_linear_equations) {
+TYPED_TEST_P(GenericCSVMSolver, SolveLssvmSystemOfLinearEquations) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::solver_type solver = util::test_parameter_value_at_v<0, TypeParam>;
@@ -776,7 +819,7 @@ TYPED_TEST_P(GenericCSVMSolver, solve_lssvm_system_of_linear_equations) {
     constexpr plssvm::kernel_function_type kernel = plssvm::kernel_function_type::linear;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 1.0 };
+    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 1.0 };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -788,7 +831,7 @@ TYPED_TEST_P(GenericCSVMSolver, solve_lssvm_system_of_linear_equations) {
                                                    plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
 
     // solve the system of linear equations using the CG algorithm:
     // | Q  1 |  *  | x |  =  | y |
@@ -796,21 +839,23 @@ TYPED_TEST_P(GenericCSVMSolver, solve_lssvm_system_of_linear_equations) {
     // with Q = A^TA
     const auto &[calculated_x, calculated_rho, num_iters] = svm.solve_lssvm_system_of_linear_equations(A, B, params, plssvm::epsilon = 0.00001, plssvm::solver = solver);
 
-    plssvm::aos_matrix<plssvm::real_type> correct_x{ { { plssvm::real_type{ 0.4285714285714278 }, plssvm::real_type{ -1.1904761904761898 }, plssvm::real_type{ 1.1904761904761898 }, plssvm::real_type{ -0.4285714285714278 } },
-                                                       { plssvm::real_type{ -0.4285714285714278 }, plssvm::real_type{ 1.1904761904761898 }, plssvm::real_type{ -1.1904761904761898 }, plssvm::real_type{ 0.4285714285714278 } } },
-                                                     plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
+    const plssvm::aos_matrix<plssvm::real_type> correct_x{ { { plssvm::real_type{ 0.4285714285714278 }, plssvm::real_type{ -1.1904761904761898 }, plssvm::real_type{ 1.1904761904761898 }, plssvm::real_type{ -0.4285714285714278 } },
+                                                             { plssvm::real_type{ -0.4285714285714278 }, plssvm::real_type{ 1.1904761904761898 }, plssvm::real_type{ -1.1904761904761898 }, plssvm::real_type{ 0.4285714285714278 } } },
+                                                           plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
 
     // check the calculated result for correctness
     EXPECT_FLOATING_POINT_MATRIX_NEAR_EPS(calculated_x, correct_x, 1e6);  // due to hand provided results
     for (const auto rho : calculated_rho) {
-        EXPECT_FLOATING_POINT_NEAR_EPS(std::abs(rho), std::abs(calculated_rho.front()), 1e6);  // due to hand provided results
+        const auto rho_abs = std::abs(rho);
+        const auto calculated_rho_abs = std::abs(calculated_rho.front());
+        EXPECT_FLOATING_POINT_NEAR_EPS(rho_abs, calculated_rho_abs, 1e6);  // due to hand provided results
     }
     EXPECT_THAT(num_iters, ::testing::Each(::testing::Gt(0)));
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVMSolver,
-                            solve_lssvm_system_of_linear_equations_trivial,
-                            solve_lssvm_system_of_linear_equations);
+                            SolveLssvmSystemOfLinearEquationsTrivial,
+                            SolveLssvmSystemOfLinearEquations);
 
 //*************************************************************************************************************************************//
 //                                    C-SVM tests depending on the solver and kernel function type                                     //
@@ -821,7 +866,7 @@ class GenericCSVMSolverKernelFunction : public GenericCSVM<T> { };
 
 TYPED_TEST_SUITE_P(GenericCSVMSolverKernelFunction);
 
-TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix_minimal) {
+TYPED_TEST_P(GenericCSVMSolverKernelFunction, AssembleKernelMatrixMinimal) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvm_type = typename csvm_test_type::csvm_type;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
@@ -829,7 +874,7 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix_minimal) {
     constexpr plssvm::solver_type solver = util::test_parameter_value_at_v<0, TypeParam>;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<1, TypeParam>;
 
-    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 1.0 };
+    plssvm::parameter params{ plssvm::kernel_type = kernel, plssvm::cost = 1.0 };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -847,10 +892,11 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix_minimal) {
     [[maybe_unused]] const plssvm::real_type QA_cost{ 0.0 };
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
     // be sure to use the correct data distribution
-    svm.data_distribution_ = std::make_unique<plssvm::detail::triangular_data_distribution>(plssvm::mpi::communicator{}, data.num_rows() - 1, num_devices);
+    const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, data.num_rows() - 1, num_devices };
+    svm.data_distribution_ = std::make_unique<plssvm::detail::triangular_data_distribution>(dist);
 
     // automatic solver type not permitted
     if constexpr (solver == plssvm::solver_type::automatic) {
@@ -880,7 +926,9 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix_minimal) {
                 // get result based on used backend
                 std::vector<plssvm::real_type> kernel_matrix{};
                 if constexpr (plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::openmp || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::stdpar || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::hpx) {
-                    kernel_matrix = plssvm::detail::move_only_any_cast<std::vector<plssvm::real_type>>(kernel_matrix_d[device_id]);  // std::vector
+                    const auto &kernel_matrix_d_ptr = plssvm::detail::move_only_any_cast<const std::unique_ptr<plssvm::real_type[]> &>(kernel_matrix_d[device_id]);  // NOLINT: C-style array must be used here to align with real implementation
+                    kernel_matrix.resize(dist.calculate_explicit_kernel_matrix_num_entries_padded(0));
+                    std::memcpy(kernel_matrix.data(), kernel_matrix_d_ptr.get(), kernel_matrix.size() * sizeof(plssvm::real_type));
                 } else {
                     const auto &kernel_matrix_d_ptr = plssvm::detail::move_only_any_cast<const device_ptr_type &>(kernel_matrix_d[device_id]);  // device_ptr -> convert it to a std::vector
                     kernel_matrix.resize(kernel_matrix_d_ptr.size_padded());
@@ -907,7 +955,7 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix_minimal) {
 
                 // implicit doesn't assemble a kernel matrix!
                 if constexpr (plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::openmp || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::stdpar || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::hpx) {
-                    const auto &[data_d_ret, params_ret, q_red_ret, QA_cost_ret] = plssvm::detail::move_only_any_cast<const std::tuple<plssvm::soa_matrix<plssvm::real_type>, plssvm::parameter, std::vector<plssvm::real_type>, plssvm::real_type> &>(kernel_matrix_d[device_id]);
+                    const auto &[data_d_ret, params_ret, q_red_ret, QA_cost_ret] = plssvm::detail::move_only_any_cast<const std::tuple<const plssvm::soa_matrix<plssvm::real_type> &, plssvm::parameter, const std::vector<plssvm::real_type> &, plssvm::real_type> &>(kernel_matrix_d[device_id]);
 
                     // the values should not have changed! (except the matrix layout)
                     EXPECT_EQ(params_ret, params);
@@ -934,7 +982,7 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix_minimal) {
     }
 }
 
-TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix) {
+TYPED_TEST_P(GenericCSVMSolverKernelFunction, AssembleKernelMatrix) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvm_type = typename csvm_test_type::csvm_type;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
@@ -942,7 +990,7 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix) {
     constexpr plssvm::solver_type solver = util::test_parameter_value_at_v<0, TypeParam>;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<1, TypeParam>;
 
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can change based on the kernel function
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 / 3.0 };
     }
@@ -957,10 +1005,11 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix) {
     [[maybe_unused]] const plssvm::real_type QA_cost{ 2.0 };
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
     // be sure to use the correct data distribution
-    svm.data_distribution_ = std::make_unique<plssvm::detail::triangular_data_distribution>(plssvm::mpi::communicator{}, data.num_rows() - 1, num_devices);
+    const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, data.num_rows() - 1, num_devices };
+    svm.data_distribution_ = std::make_unique<plssvm::detail::triangular_data_distribution>(dist);
 
     // automatic solver type not permitted
     if constexpr (solver == plssvm::solver_type::automatic) {
@@ -990,7 +1039,9 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix) {
                 // get result based on used backend
                 std::vector<plssvm::real_type> kernel_matrix{};
                 if constexpr (plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::openmp || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::stdpar || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::hpx) {
-                    kernel_matrix = plssvm::detail::move_only_any_cast<std::vector<plssvm::real_type>>(kernel_matrix_d[device_id]);  // std::vector
+                    const auto &kernel_matrix_d_ptr = plssvm::detail::move_only_any_cast<const std::unique_ptr<plssvm::real_type[]> &>(kernel_matrix_d[device_id]);  // NOLINT: C-style array must be used here to align with real implementation
+                    kernel_matrix.resize(dist.calculate_explicit_kernel_matrix_num_entries_padded(0));
+                    std::memcpy(kernel_matrix.data(), kernel_matrix_d_ptr.get(), kernel_matrix.size() * sizeof(plssvm::real_type));
                 } else {
                     const auto &kernel_matrix_d_ptr = plssvm::detail::move_only_any_cast<const device_ptr_type &>(kernel_matrix_d[device_id]);  // device_ptr -> convert it to a std::vector
                     kernel_matrix.resize(kernel_matrix_d_ptr.size_padded());
@@ -1017,7 +1068,7 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix) {
 
                 // implicit doesn't assemble a kernel matrix!
                 if constexpr (plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::openmp || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::stdpar || plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::hpx) {
-                    const auto &[data_d_ret, params_ret, q_red_ret, QA_cost_ret] = plssvm::detail::move_only_any_cast<const std::tuple<plssvm::soa_matrix<plssvm::real_type>, plssvm::parameter, std::vector<plssvm::real_type>, plssvm::real_type> &>(kernel_matrix_d[device_id]);
+                    const auto &[data_d_ret, params_ret, q_red_ret, QA_cost_ret] = plssvm::detail::move_only_any_cast<const std::tuple<const plssvm::soa_matrix<plssvm::real_type> &, plssvm::parameter, const std::vector<plssvm::real_type> &, plssvm::real_type> &>(kernel_matrix_d[device_id]);
 
                     // the values should not have changed! (except the matrix layout)
                     EXPECT_EQ(params_ret, params);
@@ -1045,8 +1096,8 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunction, assemble_kernel_matrix) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVMSolverKernelFunction,
-                            assemble_kernel_matrix_minimal,
-                            assemble_kernel_matrix);
+                            AssembleKernelMatrixMinimal,
+                            AssembleKernelMatrix);
 
 //*************************************************************************************************************************************//
 //                                                          C-SVM DeathTests                                                           //
@@ -1057,7 +1108,7 @@ class GenericCSVMDeathTest : public GenericCSVM<T> { };
 
 TYPED_TEST_SUITE_P(GenericCSVMDeathTest);
 
-TYPED_TEST_P(GenericCSVMDeathTest, blas_level_3_automatic) {
+TYPED_TEST_P(GenericCSVMDeathTest, BlasLevel3Automatic) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvm_type = typename csvm_test_type::csvm_type;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
@@ -1066,7 +1117,7 @@ TYPED_TEST_P(GenericCSVMDeathTest, blas_level_3_automatic) {
     constexpr plssvm::solver_type solver = plssvm::solver_type::automatic;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     const plssvm::real_type alpha{ 1.0 };
 
@@ -1092,14 +1143,14 @@ TYPED_TEST_P(GenericCSVMDeathTest, blas_level_3_automatic) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVMDeathTest,
-                            blas_level_3_automatic);
+                            BlasLevel3Automatic);
 
 template <typename T>
 class GenericCSVMSolverDeathTest : public GenericCSVM<T> { };
 
 TYPED_TEST_SUITE_P(GenericCSVMSolverDeathTest);
 
-TYPED_TEST_P(GenericCSVMSolverDeathTest, conjugate_gradients_empty_B) {
+TYPED_TEST_P(GenericCSVMSolverDeathTest, ConjugateGradientsEmptyB) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using csvm_type = typename csvm_test_type::csvm_type;
@@ -1109,7 +1160,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, conjugate_gradients_empty_B) {
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
     const mock_csvm_type svm{};
 
-    const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 } };
+    const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
     // parameter necessary for cg_implicit
     const plssvm::parameter params{ plssvm::gamma = plssvm::real_type{ 1.0 } };
     const std::vector<plssvm::real_type> q_red(matr_A.num_rows() - 1);
@@ -1125,7 +1176,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, conjugate_gradients_empty_B) {
     EXPECT_DEATH(std::ignore = svm.conjugate_gradients(A, empty_matr, plssvm::real_type{ 0.001 }, 6, solver), "The right-hand sides must not be empty!");
 }
 
-TYPED_TEST_P(GenericCSVMSolverDeathTest, conjugate_gradients_invalid_eps) {
+TYPED_TEST_P(GenericCSVMSolverDeathTest, ConjugateGradientsInvalidEps) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using csvm_type = typename csvm_test_type::csvm_type;
@@ -1135,7 +1186,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, conjugate_gradients_invalid_eps) {
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
     const mock_csvm_type svm{};
 
-    const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 } };
+    const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
     // parameter necessary for cg_implicit
     const plssvm::parameter params{ plssvm::gamma = plssvm::real_type{ 1.0 } };
     const std::vector<plssvm::real_type> q_red(matr_A.num_rows() - 1);
@@ -1151,7 +1202,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, conjugate_gradients_invalid_eps) {
     EXPECT_DEATH(std::ignore = svm.conjugate_gradients(A, B, -0.5, 6, solver), "The epsilon value must be greater than 0.0!");
 }
 
-TYPED_TEST_P(GenericCSVMSolverDeathTest, conjugate_gradients_invalid_max_cg_iter) {
+TYPED_TEST_P(GenericCSVMSolverDeathTest, ConjugateGradientsInvalidMaxCgIter) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using csvm_type = typename csvm_test_type::csvm_type;
@@ -1161,7 +1212,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, conjugate_gradients_invalid_max_cg_iter
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
     const mock_csvm_type svm{};
 
-    const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 } };
+    const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
     // parameter necessary for cg_implicit
     const plssvm::parameter params{ plssvm::gamma = plssvm::real_type{ 1.0 } };
     const std::vector<plssvm::real_type> q_red(matr_A.num_rows() - 1);
@@ -1176,7 +1227,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, conjugate_gradients_invalid_max_cg_iter
     EXPECT_DEATH(std::ignore = svm.conjugate_gradients(A, B, plssvm::real_type{ 0.001 }, 0, solver), "The maximum number of iterations must be greater than 0!");
 }
 
-TYPED_TEST_P(GenericCSVMSolverDeathTest, run_blas_level_3_wrong_number_of_kernel_matrix_parts) {
+TYPED_TEST_P(GenericCSVMSolverDeathTest, RunBlasLevel3WrongNumberOfKernelMatrixParts) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using csvm_type = typename csvm_test_type::csvm_type;
@@ -1189,7 +1240,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, run_blas_level_3_wrong_number_of_kernel
         // create C-SVM: must be done using the mock class since the member function to test is private or protected
         const mock_csvm_type svm{};
 
-        const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 } };
+        const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
         // parameter necessary for cg_implicit
         const plssvm::parameter params{ plssvm::gamma = plssvm::real_type{ 1.0 } };
         const std::vector<plssvm::real_type> q_red(matr_A.num_rows() - 1);
@@ -1208,7 +1259,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, run_blas_level_3_wrong_number_of_kernel
     }
 }
 
-TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_empty_matrices) {
+TYPED_TEST_P(GenericCSVMSolverDeathTest, BlasLevel3EmptyMatrices) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using csvm_type = typename csvm_test_type::csvm_type;
@@ -1221,7 +1272,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_empty_matrices) {
         // create C-SVM: must be done using the mock class since the member function to test is private or protected
         const mock_csvm_type svm{};
 
-        const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 } };
+        const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
         // parameter necessary for cg_implicit
         const plssvm::parameter params{ plssvm::gamma = plssvm::real_type{ 1.0 } };
         const std::vector<plssvm::real_type> q_red(matr_A.num_rows() - 1);
@@ -1239,7 +1290,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_empty_matrices) {
     }
 }
 
-TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_missing_padding) {
+TYPED_TEST_P(GenericCSVMSolverDeathTest, BlasLevel3MissingPadding) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using csvm_type = typename csvm_test_type::csvm_type;
@@ -1252,7 +1303,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_missing_padding) {
         // create C-SVM: must be done using the mock class since the member function to test is private or protected
         const mock_csvm_type svm{};
 
-        const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 } };
+        const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
         // parameter necessary for cg_implicit
         const plssvm::parameter params{ plssvm::gamma = plssvm::real_type{ 1.0 } };
         const std::vector<plssvm::real_type> q_red(matr_A.num_rows() - 1);
@@ -1270,7 +1321,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_missing_padding) {
     }
 }
 
-TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_matrix_shape_mismatch) {
+TYPED_TEST_P(GenericCSVMSolverDeathTest, BlasLevel3MatrixShapeMismatch) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using csvm_type = typename csvm_test_type::csvm_type;
@@ -1283,7 +1334,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_matrix_shape_mismatch) {
         // create C-SVM: must be done using the mock class since the member function to test is private or protected
         const mock_csvm_type svm{};
 
-        const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 } };
+        const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
         // parameter necessary for cg_implicit
         const plssvm::parameter params{ plssvm::gamma = plssvm::real_type{ 1.0 } };
         const std::vector<plssvm::real_type> q_red(matr_A.num_rows() - 1);
@@ -1293,7 +1344,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_matrix_shape_mismatch) {
         svm.data_distribution_ = std::make_unique<plssvm::detail::triangular_data_distribution>(plssvm::mpi::communicator{}, matr_A.num_rows(), svm.num_available_devices());
         const std::vector<plssvm::detail::move_only_any> A{ util::init_matrices<csvm_type, device_ptr_type>(matr_A, solver, svm, params, q_red, QA_cost) };
 
-        plssvm::soa_matrix<plssvm::real_type> B{ plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
+        const plssvm::soa_matrix<plssvm::real_type> B{ plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
         plssvm::soa_matrix<plssvm::real_type> C{ plssvm::shape{ 3, 3 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
 
         EXPECT_DEATH(svm.blas_level_3(solver, plssvm::real_type{ 1.0 }, A, B, plssvm::real_type{ 1.0 }, C),
@@ -1301,7 +1352,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_matrix_shape_mismatch) {
     }
 }
 
-TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_matrix_padding_mismatch) {
+TYPED_TEST_P(GenericCSVMSolverDeathTest, BlasLevel3MatrixPaddingMismatch) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using csvm_type = typename csvm_test_type::csvm_type;
@@ -1314,7 +1365,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_matrix_padding_mismatch) {
         // create C-SVM: must be done using the mock class since the member function to test is private or protected
         const mock_csvm_type svm{};
 
-        const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 } };
+        const plssvm::soa_matrix<plssvm::real_type> matr_A{ plssvm::shape{ 4, 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
         // parameter necessary for cg_implicit
         const plssvm::parameter params{ plssvm::gamma = plssvm::real_type{ 1.0 } };
         const std::vector<plssvm::real_type> q_red(matr_A.num_rows() - 1);
@@ -1324,7 +1375,7 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_matrix_padding_mismatch) {
         svm.data_distribution_ = std::make_unique<plssvm::detail::triangular_data_distribution>(plssvm::mpi::communicator{}, matr_A.num_rows(), svm.num_available_devices());
         const std::vector<plssvm::detail::move_only_any> A{ util::init_matrices<csvm_type, device_ptr_type>(matr_A, solver, svm, params, q_red, QA_cost) };
 
-        plssvm::soa_matrix<plssvm::real_type> B{ plssvm::shape{ 4, 4 }, plssvm::shape{ 3, 3 } };
+        const plssvm::soa_matrix<plssvm::real_type> B{ plssvm::shape{ 4, 4 }, plssvm::shape{ 3, 3 } };
         plssvm::soa_matrix<plssvm::real_type> C{ plssvm::shape{ 4, 4 }, plssvm::shape{ 4, 4 } };
 
         EXPECT_DEATH(svm.blas_level_3(solver, plssvm::real_type{ 1.0 }, A, B, plssvm::real_type{ 1.0 }, C),
@@ -1333,27 +1384,27 @@ TYPED_TEST_P(GenericCSVMSolverDeathTest, blas_level_3_matrix_padding_mismatch) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVMSolverDeathTest,
-                            conjugate_gradients_empty_B,
-                            conjugate_gradients_invalid_eps,
-                            conjugate_gradients_invalid_max_cg_iter,
-                            run_blas_level_3_wrong_number_of_kernel_matrix_parts,
-                            blas_level_3_empty_matrices,
-                            blas_level_3_missing_padding,
-                            blas_level_3_matrix_shape_mismatch,
-                            blas_level_3_matrix_padding_mismatch);
+                            ConjugateGradientsEmptyB,
+                            ConjugateGradientsInvalidEps,
+                            ConjugateGradientsInvalidMaxCgIter,
+                            RunBlasLevel3WrongNumberOfKernelMatrixParts,
+                            BlasLevel3EmptyMatrices,
+                            BlasLevel3MissingPadding,
+                            BlasLevel3MatrixShapeMismatch,
+                            BlasLevel3MatrixPaddingMismatch);
 
 template <typename T>
 class GenericCSVMKernelFunctionDeathTest : public GenericCSVMKernelFunction<T> { };
 
 TYPED_TEST_SUITE_P(GenericCSVMKernelFunctionDeathTest);
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, solve_lssvm_system_of_linear_equations_empty_A) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, SolveLssvmSystemOfLinearEquationsEmptyA) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1368,13 +1419,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, solve_lssvm_system_of_linear_eq
     EXPECT_DEATH(std::ignore = svm.solve_lssvm_system_of_linear_equations(empty_matr, B, params), "The A matrix must not be empty!");
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, solve_lssvm_system_of_linear_equations_A_without_padding) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, SolveLssvmSystemOfLinearEquationsAWithoutPadding) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1389,13 +1440,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, solve_lssvm_system_of_linear_eq
     EXPECT_DEATH(std::ignore = svm.solve_lssvm_system_of_linear_equations(A, B, params), "The A matrix must be padded!");
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, solve_lssvm_system_of_linear_equations_A_wrong_padding_sizes) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, SolveLssvmSystemOfLinearEquationsAWrongPaddingSizes) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1411,13 +1462,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, solve_lssvm_system_of_linear_eq
                  ::testing::HasSubstr(fmt::format("The provided matrix must be padded with [{}, {}], but is padded with [0, 1]!", plssvm::PADDING_SIZE, plssvm::PADDING_SIZE)));
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, solve_lssvm_system_of_linear_equations_empty_B) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, SolveLssvmSystemOfLinearEquationsEmptyB) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1432,13 +1483,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, solve_lssvm_system_of_linear_eq
     EXPECT_DEATH(std::ignore = svm.solve_lssvm_system_of_linear_equations(A, empty_matr, params), "The B matrix must not be empty!");
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, solve_lssvm_system_of_linear_equations_size_mismatch) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, SolveLssvmSystemOfLinearEquationsSizeMismatch) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1453,13 +1504,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, solve_lssvm_system_of_linear_eq
     EXPECT_DEATH(std::ignore = svm.solve_lssvm_system_of_linear_equations(A, B, params), ::testing::HasSubstr("The number of data points in A (6) and B (3) must be the same!"));
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, perform_dimensional_reduction_empty_A) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, PerformDimensionalReductionEmptyA) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1473,13 +1524,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, perform_dimensional_reduction_e
     EXPECT_DEATH(std::ignore = svm.perform_dimensional_reduction(params, empty_matr), "The matrix must not be empty!");
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, assemble_kernel_matrix_automatic) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, AssembleKernelMatrixAutomatic) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1499,13 +1550,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, assemble_kernel_matrix_automati
     EXPECT_DEATH(std::ignore = svm.assemble_kernel_matrix(plssvm::solver_type::automatic, params, A, q_red, QA_cost), ::testing::HasSubstr("An explicit solver type must be provided instead of solver_type::automatic!"));
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_empty_matrices) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, PredictValuesEmptyMatrices) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1535,13 +1586,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_empty_matrices)
     EXPECT_DEATH(std::ignore = svm.predict_values(params, support_vectors, weights, rho, w, empty_soa_matr), "The data points to predict must not be empty!");
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_missing_padding) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, PredictValuesMissingPadding) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1577,13 +1628,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_missing_padding)
     EXPECT_DEATH(std::ignore = svm.predict_values(params, support_vectors, weights, rho, w, data_without_padding), "The data points to predict must be padded!");
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_sv_alpha_size_mismatch) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, PredictValuesSvAlphaSizeMismatch) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1605,13 +1656,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_sv_alpha_size_mi
     EXPECT_DEATH(std::ignore = svm.predict_values(params, support_vectors, weights, rho, w, data), ::testing::HasSubstr("The number of support vectors (3) and number of weights (4) must be the same!"));
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_rho_alpha_size_mismatch) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, PredictValuesRhoAlphaSizeMismatch) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1633,13 +1684,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_rho_alpha_size_m
     EXPECT_DEATH(std::ignore = svm.predict_values(params, support_vectors, weights, rho, w, data), ::testing::HasSubstr("The number of rho values (1) and the number of weight vectors (2) must be the same!"));
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_w_size_mismatch) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, PredictValuesWSizeMismatch) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1664,13 +1715,13 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_w_size_mismatch)
     EXPECT_DEATH(std::ignore = svm.predict_values(params, support_vectors, weights, rho, w, data), ::testing::HasSubstr("Either w must be empty or contain exactly the same number of vectors (3) as the alpha vector (2)!"));
 }
 
-TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_num_features_mismatch) {
+TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, PredictValuesNumFeaturesMismatch) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
@@ -1693,26 +1744,26 @@ TYPED_TEST_P(GenericCSVMKernelFunctionDeathTest, predict_values_num_features_mis
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVMKernelFunctionDeathTest,
-                            solve_lssvm_system_of_linear_equations_empty_A,
-                            solve_lssvm_system_of_linear_equations_A_without_padding,
-                            solve_lssvm_system_of_linear_equations_A_wrong_padding_sizes,
-                            solve_lssvm_system_of_linear_equations_empty_B,
-                            solve_lssvm_system_of_linear_equations_size_mismatch,
-                            perform_dimensional_reduction_empty_A,
-                            assemble_kernel_matrix_automatic,
-                            predict_values_empty_matrices,
-                            predict_values_missing_padding,
-                            predict_values_sv_alpha_size_mismatch,
-                            predict_values_rho_alpha_size_mismatch,
-                            predict_values_w_size_mismatch,
-                            predict_values_num_features_mismatch);
+                            SolveLssvmSystemOfLinearEquationsEmptyA,
+                            SolveLssvmSystemOfLinearEquationsAWithoutPadding,
+                            SolveLssvmSystemOfLinearEquationsAWrongPaddingSizes,
+                            SolveLssvmSystemOfLinearEquationsEmptyB,
+                            SolveLssvmSystemOfLinearEquationsSizeMismatch,
+                            PerformDimensionalReductionEmptyA,
+                            AssembleKernelMatrixAutomatic,
+                            PredictValuesEmptyMatrices,
+                            PredictValuesMissingPadding,
+                            PredictValuesSvAlphaSizeMismatch,
+                            PredictValuesRhoAlphaSizeMismatch,
+                            PredictValuesWSizeMismatch,
+                            PredictValuesNumFeaturesMismatch);
 
 template <typename T>
 class GenericCSVMSolverKernelFunctionDeathTest : public GenericCSVMSolverKernelFunction<T> { };
 
 TYPED_TEST_SUITE_P(GenericCSVMSolverKernelFunctionDeathTest);
 
-TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, assemble_kernel_matrix_empty_matrices) {
+TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, AssembleKernelMatrixEmptyMatrices) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::solver_type solver = util::test_parameter_value_at_v<0, TypeParam>;
@@ -1722,7 +1773,7 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, assemble_kernel_matrix_em
         SUCCEED() << "Test not applicable for the automatic solver type!";
     } else {
         // create parameter
-        plssvm::parameter params{ plssvm::kernel_type = kernel };
+        plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can change based on the kernel function
         if constexpr (kernel != plssvm::kernel_function_type::linear) {
             params.gamma = plssvm::real_type{ 1.0 };
         }
@@ -1748,7 +1799,7 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, assemble_kernel_matrix_em
     }
 }
 
-TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, assemble_kernel_matrix_A_not_padded) {
+TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, AssembleKernelMatrixANotPadded) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::solver_type solver = util::test_parameter_value_at_v<0, TypeParam>;
@@ -1758,7 +1809,7 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, assemble_kernel_matrix_A_
         SUCCEED() << "Test not applicable for the automatic solver type!";
     } else {
         // create parameter
-        plssvm::parameter params{ plssvm::kernel_type = kernel };
+        plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can change based on the kernel function
         if constexpr (kernel != plssvm::kernel_function_type::linear) {
             params.gamma = plssvm::real_type{ 1.0 };
         }
@@ -1779,7 +1830,7 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, assemble_kernel_matrix_A_
     }
 }
 
-TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, assemble_kernel_matrix_size_mismatch) {
+TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, AssembleKernelMatrixSizeMismatch) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     constexpr plssvm::solver_type solver = util::test_parameter_value_at_v<0, TypeParam>;
@@ -1789,7 +1840,7 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, assemble_kernel_matrix_si
         SUCCEED() << "Test not applicable for the automatic solver type!";
     } else {
         // create parameter
-        plssvm::parameter params{ plssvm::kernel_type = kernel };
+        plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can change based on the kernel function
         if constexpr (kernel != plssvm::kernel_function_type::linear) {
             params.gamma = plssvm::real_type{ 1.0 };
         }
@@ -1811,8 +1862,8 @@ TYPED_TEST_P(GenericCSVMSolverKernelFunctionDeathTest, assemble_kernel_matrix_si
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVMSolverKernelFunctionDeathTest,
-                            assemble_kernel_matrix_empty_matrices,
-                            assemble_kernel_matrix_A_not_padded,
-                            assemble_kernel_matrix_size_mismatch);
+                            AssembleKernelMatrixEmptyMatrices,
+                            AssembleKernelMatrixANotPadded,
+                            AssembleKernelMatrixSizeMismatch);
 
 #endif  // PLSSVM_TESTS_BACKENDS_GENERIC_BASE_CSVM_TESTS_HPP_
diff --git a/tests/backends/generic_base_csvr_tests.hpp b/tests/backends/generic_base_csvr_tests.hpp
index 064a1808d..71449b59f 100644
--- a/tests/backends/generic_base_csvr_tests.hpp
+++ b/tests/backends/generic_base_csvr_tests.hpp
@@ -14,7 +14,7 @@
 #define PLSSVM_TESTS_BACKENDS_GENERIC_BASE_CSVR_TESTS_HPP_
 #pragma once
 
-#include "plssvm/constants.hpp"                     // plssvm::real_type, plssvm::PADDING_SIZE
+#include "plssvm/constants.hpp"                     // plssvm::real_type
 #include "plssvm/data_set/regression_data_set.hpp"  // plssvm::regression_data_set
 #include "plssvm/kernel_function_types.hpp"         // plssvm::kernel_function_type
 #include "plssvm/model/regression_model.hpp"        // plssvm::regression_model
@@ -36,7 +36,7 @@ class GenericCSVR : public ::testing::Test,
 
 TYPED_TEST_SUITE_P(GenericCSVR);
 
-TYPED_TEST_P(GenericCSVR, move_constructor) {
+TYPED_TEST_P(GenericCSVR, MoveConstructor) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvr_type = typename csvm_test_type::csvr_type;
 
@@ -55,7 +55,7 @@ TYPED_TEST_P(GenericCSVR, move_constructor) {
     EXPECT_EQ(new_svr.get_target_platform(), target);
 }
 
-TYPED_TEST_P(GenericCSVR, move_assignment) {
+TYPED_TEST_P(GenericCSVR, MoveAssignment) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvr_type = typename csvm_test_type::csvr_type;
 
@@ -78,8 +78,8 @@ TYPED_TEST_P(GenericCSVR, move_assignment) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVR,
-                            move_constructor,
-                            move_assignment);
+                            MoveConstructor,
+                            MoveAssignment);
 
 //*************************************************************************************************************************************//
 //                                            C-SVR tests depending on the kernel function                                             //
@@ -90,14 +90,14 @@ class GenericCSVRKernelFunction : public GenericCSVR<T> { };
 
 TYPED_TEST_SUITE_P(GenericCSVRKernelFunction);
 
-TYPED_TEST_P(GenericCSVRKernelFunction, predict) {
+TYPED_TEST_P(GenericCSVRKernelFunction, Predict) {
     using label_type = util::test_parameter_type_at_t<1, TypeParam>;
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvr_type = typename csvm_test_type::csvr_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::cost = 1000.0, plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::cost = 1000.0, plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::polynomial) {
         params.degree = 1;
         params.gamma = 1.0;
@@ -107,56 +107,58 @@ TYPED_TEST_P(GenericCSVRKernelFunction, predict) {
     }
 
     // create data set that is always classifiable
-    plssvm::regression_data_set<label_type> test_data = util::generate_trivially_solvable_regression_data_set<label_type>();
+    plssvm::regression_data_set<label_type> test_data = util::generate_trivially_solvable_regression_data_set<label_type>();  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (test_data.labels().has_value()) {
-            test_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(test_data.data()), *test_data.labels() };
+        const auto &labels_opt = test_data.labels();
+        if (labels_opt.has_value()) {
+            test_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(test_data.data()), labels_opt.value() };
         }
     }
 
     // create normal C-SVR
-    const csvr_type svr = util::construct_from_tuple<csvr_type>(params, csvm_test_type::additional_arguments);
+    const auto svr = util::construct_from_tuple<csvr_type>(params, csvm_test_type::additional_arguments);
 
     // fitting the test data will ALWAYS score 100% accuracy
     const plssvm::regression_model<label_type> model = svr.fit(test_data, plssvm::epsilon = 1e-16);
 
     // actual TEST: predict label
-    std::vector<label_type> calculated = svr.predict(model, test_data);
+    std::vector<label_type> calculated = svr.predict(model, test_data);  // NOLINT(misc-const-correctness): can't be const for floating point label types
 
     // check the calculated result for correctness
     if constexpr (std::is_floating_point_v<label_type>) {
         // convert a floating point label_type back to a plain integer
         for (label_type &val : calculated) {
-            val = static_cast<label_type>(std::round(val));
+            val = static_cast<label_type>(std::round(val));  // NOLINT(misc-const-correctness): can't be const for floating point label types
         }
     }
-    EXPECT_EQ(calculated, test_data.labels().value().get());
+    EXPECT_OPTIONAL_EQ(calculated, test_data.labels());
 }
 
-TYPED_TEST_P(GenericCSVRKernelFunction, score_model) {
+TYPED_TEST_P(GenericCSVRKernelFunction, ScoreModel) {
     using label_type = util::test_parameter_type_at_t<1, TypeParam>;
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvr_type = typename csvm_test_type::csvr_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
 
     // create data set that is always classifiable
-    plssvm::regression_data_set<label_type> test_data = util::generate_trivially_solvable_regression_data_set<label_type>();
+    plssvm::regression_data_set<label_type> test_data = util::generate_trivially_solvable_regression_data_set<label_type>();  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (test_data.labels().has_value()) {
-            test_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(test_data.data()), *test_data.labels() };
+        const auto &labels_opt = test_data.labels();
+        if (labels_opt.has_value()) {
+            test_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(test_data.data()), labels_opt.value() };
         }
     }
 
     // create normal C-SVR
-    const csvr_type svr = util::construct_from_tuple<csvr_type>(params, csvm_test_type::additional_arguments);
+    const auto svr = util::construct_from_tuple<csvr_type>(params, csvm_test_type::additional_arguments);
 
     // fitting the test data will ALWAYS score 100% accuracy
     const plssvm::regression_model<label_type> model = svr.fit(test_data, plssvm::epsilon = 1e-16);
@@ -170,29 +172,30 @@ TYPED_TEST_P(GenericCSVRKernelFunction, score_model) {
     EXPECT_INCLUSIVE_RANGE(calculated, plssvm::real_type{ 0.0 }, plssvm::real_type{ 1.0 });
 }
 
-TYPED_TEST_P(GenericCSVRKernelFunction, score) {
+TYPED_TEST_P(GenericCSVRKernelFunction, Score) {
     using label_type = util::test_parameter_type_at_t<1, TypeParam>;
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using csvr_type = typename csvm_test_type::csvr_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
 
     // create data set that is always classifiable
-    plssvm::regression_data_set<label_type> test_data = util::generate_trivially_solvable_regression_data_set<label_type>();
+    plssvm::regression_data_set<label_type> test_data = util::generate_trivially_solvable_regression_data_set<label_type>();  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (test_data.labels().has_value()) {
-            test_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(test_data.data()), *test_data.labels() };
+        const auto &labels_opt = test_data.labels();
+        if (labels_opt.has_value()) {
+            test_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(test_data.data()), labels_opt.value() };
         }
     }
 
     // create normal C-SVR
-    const csvr_type svr = util::construct_from_tuple<csvr_type>(params, csvm_test_type::additional_arguments);
+    const auto svr = util::construct_from_tuple<csvr_type>(params, csvm_test_type::additional_arguments);
 
     // fitting the test data will ALWAYS score 100% accuracy
     const plssvm::regression_model<label_type> model = svr.fit(test_data, plssvm::epsilon = 1e-16);
@@ -207,9 +210,9 @@ TYPED_TEST_P(GenericCSVRKernelFunction, score) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVRKernelFunction,
-                            predict,
-                            score_model,
-                            score);
+                            Predict,
+                            ScoreModel,
+                            Score);
 
 //*************************************************************************************************************************************//
 //                                       C-SVR tests depending on the solver and kernel function                                       //
@@ -220,7 +223,7 @@ class GenericCSVRSolverKernelFunction : public GenericCSVR<T> { };
 
 TYPED_TEST_SUITE_P(GenericCSVRSolverKernelFunction);
 
-TYPED_TEST_P(GenericCSVRSolverKernelFunction, fit) {
+TYPED_TEST_P(GenericCSVRSolverKernelFunction, Fit) {
     // note: only quantitative tests, doesn't check the real weights and rho values
     using label_type = util::test_parameter_type_at_t<1, TypeParam>;
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
@@ -232,17 +235,17 @@ TYPED_TEST_P(GenericCSVRSolverKernelFunction, fit) {
     const plssvm::parameter params{ plssvm::kernel_type = kernel };
 
     // create data set to be used
-    plssvm::regression_data_set<label_type> test_data{ PLSSVM_TEST_PATH "/data/libsvm/regression/6x4.libsvm" };
+    plssvm::regression_data_set<label_type> test_data{ PLSSVM_TEST_PATH "/data/libsvm/regression/6x4.libsvm" };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (test_data.labels().has_value()) {
-            test_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(test_data.data()), *test_data.labels() };
+        const auto &labels_opt = test_data.labels();
+        if (labels_opt.has_value()) {
+            test_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(test_data.data()), labels_opt.value() };
         }
     }
 
     // create normal C-SVR
-    // const csvr_type svr = util::construct_from_tuple<csvr_type>(params, csvm_test_type::additional_arguments);
-    const csvr_type svr{ params };
+    const auto svr = util::construct_from_tuple<csvr_type>(params, csvm_test_type::additional_arguments);
 
     // call fit
     const plssvm::regression_model<label_type> model = svr.fit(test_data, plssvm::epsilon = 1e-10, plssvm::solver = solver);
@@ -252,14 +255,17 @@ TYPED_TEST_P(GenericCSVRSolverKernelFunction, fit) {
     EXPECT_EQ(model.num_features(), test_data.num_features());
     EXPECT_EQ(model.get_params(), (plssvm::parameter{ params, plssvm::gamma = plssvm::real_type{ 1.0 } / static_cast<plssvm::real_type>(test_data.num_features()) }));
     EXPECT_EQ(model.support_vectors(), test_data.data());
-    EXPECT_EQ(model.labels().value().get(), test_data.labels().value().get());
+    EXPECT_OPTIONAL_EQ(model.labels(), test_data.labels());
     EXPECT_EQ(model.weights().size(), 1);
     EXPECT_EQ(model.rho().size(), 1);
-    EXPECT_TRUE(model.num_iters().has_value());
-    EXPECT_EQ(model.num_iters().value().size(), 1);
+    const auto &num_iters_opt = model.num_iters();
+    ASSERT_TRUE(num_iters_opt.has_value());
+    if (num_iters_opt.has_value()) {
+        EXPECT_EQ(num_iters_opt.value().size(), 1);
+    }
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVRSolverKernelFunction,
-                            fit);
+                            Fit);
 
 #endif  // PLSSVM_TESTS_BACKENDS_GENERIC_BASE_CSVR_TESTS_HPP_
diff --git a/tests/backends/generic_csvm_tests.hpp b/tests/backends/generic_csvm_tests.hpp
index 84b9b7ad9..642b2785a 100644
--- a/tests/backends/generic_csvm_tests.hpp
+++ b/tests/backends/generic_csvm_tests.hpp
@@ -16,6 +16,7 @@
 #include "plssvm/constants.hpp"                         // plssvm::real_type, plssvm::PADDING_SIZE
 #include "plssvm/data_set/classification_data_set.hpp"  // plssvm::classification_data_set
 #include "plssvm/detail/data_distribution.hpp"          // plssvm::detail::{triangular_data_distribution, rectangular_data_distribution}
+#include "plssvm/detail/operators.hpp"                  // operator overloads for std::vector (+ scalars)
 #include "plssvm/kernel_function_types.hpp"             // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                            // plssvm::aos_matrix
 #include "plssvm/mpi/communicator.hpp"                  // plssvm::mpi::communicator
@@ -31,9 +32,11 @@
 #include "fmt/format.h"   // fmt::format
 #include "gtest/gtest.h"  // TYPED_TEST_SUITE_P, TYPED_TEST_P, REGISTER_TYPED_TEST_SUITE_P, EXPECT_GT, EXPECT_GE, ASSERT_EQ, ::testing::Test
 
-#include <cstddef>  // std::size_t
-#include <tuple>    // std::get
-#include <vector>   // std::vector
+#include <algorithm>  // std::min
+#include <cstddef>    // std::size_t
+#include <cstring>    // std::memcpy
+#include <tuple>      // std::get
+#include <vector>     // std::vector
 
 //*************************************************************************************************************************************//
 //                                              non-GPU C-SVM tests depending on nothing                                               //
@@ -45,7 +48,7 @@ class GenericBackendCSVM : public ::testing::Test,
 
 TYPED_TEST_SUITE_P(GenericBackendCSVM);
 
-TYPED_TEST_P(GenericBackendCSVM, blas_level_3_kernel_explicit) {
+TYPED_TEST_P(GenericBackendCSVM, BlasLevel3KernelExplicit) {
     const plssvm::real_type alpha{ 1.0 };
 
     // create kernel matrix to use in the BLAS calculation
@@ -81,14 +84,15 @@ TYPED_TEST_P(GenericBackendCSVM, blas_level_3_kernel_explicit) {
 
         const std::size_t specific_num_rows = dist.place_specific_num_rows(device);
         const std::size_t row_offset = dist.place_row_offset(device);
-        device_kernel_symm(num_rows, num_rhs, specific_num_rows, row_offset, alpha, kernel_matrix, B, beta, C_temp);
+        device_kernel_symm(num_rows, num_rhs, specific_num_rows, row_offset, alpha, kernel_matrix.data(), B, beta, C_temp);
         const std::size_t num_mirror_rows = num_rows - row_offset - specific_num_rows;
         if (num_mirror_rows > 0) {
-            device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, specific_num_rows, row_offset, alpha, kernel_matrix, B, beta, C_temp);
+            device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, specific_num_rows, row_offset, alpha, kernel_matrix.data(), B, beta, C_temp);
         }
 
         C_res += C_temp;
     }
+    C_res.restore_padding();
 
     // calculate correct results
     const plssvm::aos_matrix<plssvm::real_type> kernel_matrix_gemm_padded = ground_truth::assemble_full_kernel_matrix(params, data.data(), q_red, QA_cost);
@@ -98,7 +102,7 @@ TYPED_TEST_P(GenericBackendCSVM, blas_level_3_kernel_explicit) {
     EXPECT_FLOATING_POINT_MATRIX_NEAR(C_res, ground_truth_C);
 }
 
-TYPED_TEST_P(GenericBackendCSVM, calculate_w) {
+TYPED_TEST_P(GenericBackendCSVM, CalculateW) {
     // the data used for prediction
     const plssvm::classification_data_set data{ PLSSVM_CLASSIFICATION_TEST_FILE };
 
@@ -112,6 +116,7 @@ TYPED_TEST_P(GenericBackendCSVM, calculate_w) {
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, data.num_data_points(), 1 };
 
     device_kernel_w_linear(w, weights, data.data(), dist.place_specific_num_rows(0), dist.place_row_offset(0));
+    w.restore_padding();
 
     // calculate correct results
     const plssvm::soa_matrix<plssvm::real_type> correct_w = ground_truth::calculate_w(weights, data.data());
@@ -121,8 +126,8 @@ TYPED_TEST_P(GenericBackendCSVM, calculate_w) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericBackendCSVM,
-                            blas_level_3_kernel_explicit,
-                            calculate_w);
+                            BlasLevel3KernelExplicit,
+                            CalculateW);
 
 //*************************************************************************************************************************************//
 //                                      non-GPU C-SVM tests depending on the kernel function type                                      //
@@ -133,7 +138,7 @@ class GenericBackendCSVMKernelFunction : public GenericBackendCSVM<T> { };
 
 TYPED_TEST_SUITE_P(GenericBackendCSVMKernelFunction);
 
-TYPED_TEST_P(GenericBackendCSVMKernelFunction, assemble_kernel_matrix_explicit) {
+TYPED_TEST_P(GenericBackendCSVMKernelFunction, AssembleKernelMatrixExplicit) {
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     plssvm::parameter params{ plssvm::kernel_type = kernel };
@@ -141,7 +146,7 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunction, assemble_kernel_matrix_explicit)
         params.gamma = plssvm::real_type{ 0.001 };
     }
     const plssvm::classification_data_set data{ PLSSVM_CLASSIFICATION_TEST_FILE };
-    auto data_matr{ data.data() };
+    auto data_matr{ data.data() };  // NOLINT: can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
         data_matr = util::matrix_abs(data_matr);
@@ -160,22 +165,22 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunction, assemble_kernel_matrix_explicit)
 
     switch (kernel) {
         case plssvm::kernel_function_type::linear:
-            device_kernel_assembly<plssvm::kernel_function_type::linear>(kernel_matrix, data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost);
+            device_kernel_assembly<plssvm::kernel_function_type::linear>(kernel_matrix.data(), data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost);
             break;
         case plssvm::kernel_function_type::polynomial:
-            device_kernel_assembly<plssvm::kernel_function_type::polynomial>(kernel_matrix, data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost, params.degree, std::get<plssvm::real_type>(params.gamma), params.coef0);
+            device_kernel_assembly<plssvm::kernel_function_type::polynomial, int, plssvm::real_type, plssvm::real_type>(kernel_matrix.data(), data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost, params.degree, std::get<plssvm::real_type>(params.gamma), params.coef0);
             break;
         case plssvm::kernel_function_type::rbf:
-            device_kernel_assembly<plssvm::kernel_function_type::rbf>(kernel_matrix, data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<plssvm::real_type>(params.gamma));
+            device_kernel_assembly<plssvm::kernel_function_type::rbf, plssvm::real_type>(kernel_matrix.data(), data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<plssvm::real_type>(params.gamma));
             break;
         case plssvm::kernel_function_type::sigmoid:
-            device_kernel_assembly<plssvm::kernel_function_type::sigmoid>(kernel_matrix, data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<plssvm::real_type>(params.gamma), params.coef0);
+            device_kernel_assembly<plssvm::kernel_function_type::sigmoid, plssvm::real_type, plssvm::real_type>(kernel_matrix.data(), data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<plssvm::real_type>(params.gamma), params.coef0);
             break;
         case plssvm::kernel_function_type::laplacian:
-            device_kernel_assembly<plssvm::kernel_function_type::laplacian>(kernel_matrix, data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<plssvm::real_type>(params.gamma));
+            device_kernel_assembly<plssvm::kernel_function_type::laplacian, plssvm::real_type>(kernel_matrix.data(), data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<plssvm::real_type>(params.gamma));
             break;
         case plssvm::kernel_function_type::chi_squared:
-            device_kernel_assembly<plssvm::kernel_function_type::chi_squared>(kernel_matrix, data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<plssvm::real_type>(params.gamma));
+            device_kernel_assembly<plssvm::kernel_function_type::chi_squared, plssvm::real_type>(kernel_matrix.data(), data_matr, device_specific_num_rows, row_offset, q_red, QA_cost, cost, std::get<plssvm::real_type>(params.gamma));
             break;
     }
     const std::vector<plssvm::real_type> correct_kernel_matrix = ground_truth::assemble_device_specific_kernel_matrix(params, data_matr, q_red, QA_cost, dist, 0);
@@ -185,8 +190,8 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunction, assemble_kernel_matrix_explicit)
     EXPECT_FLOATING_POINT_VECTOR_NEAR_EPS(kernel_matrix, correct_kernel_matrix, 1e6);
 }
 
-TYPED_TEST_P(GenericBackendCSVMKernelFunction, blas_level_3_kernel_implicit) {
-    using namespace plssvm::operators;
+TYPED_TEST_P(GenericBackendCSVMKernelFunction, BlasLevel3KernelImplicit) {
+    using namespace plssvm::operators;  // NOLINT(google-build-using-namespace): only imports custom math operations on vectors (and scalars)
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     const plssvm::real_type alpha{ 1.0 };
@@ -197,7 +202,7 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunction, blas_level_3_kernel_implicit) {
         params.gamma = plssvm::real_type{ 0.001 };
     }
     const plssvm::classification_data_set data{ PLSSVM_CLASSIFICATION_TEST_FILE };
-    auto data_matr{ data.data() };
+    auto data_matr{ data.data() };  // NOLINT: can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
         data_matr = util::matrix_abs(data_matr);
@@ -226,19 +231,19 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunction, blas_level_3_kernel_implicit) {
             device_kernel_assembly_symm<plssvm::kernel_function_type::linear>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C);
             break;
         case plssvm::kernel_function_type::polynomial:
-            device_kernel_assembly_symm<plssvm::kernel_function_type::polynomial>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C, params.degree, std::get<plssvm::real_type>(params.gamma), params.coef0);
+            device_kernel_assembly_symm<plssvm::kernel_function_type::polynomial, int, plssvm::real_type, plssvm::real_type>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C, params.degree, std::get<plssvm::real_type>(params.gamma), params.coef0);
             break;
         case plssvm::kernel_function_type::rbf:
-            device_kernel_assembly_symm<plssvm::kernel_function_type::rbf>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<plssvm::real_type>(params.gamma));
+            device_kernel_assembly_symm<plssvm::kernel_function_type::rbf, plssvm::real_type>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<plssvm::real_type>(params.gamma));
             break;
         case plssvm::kernel_function_type::sigmoid:
-            device_kernel_assembly_symm<plssvm::kernel_function_type::sigmoid>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<plssvm::real_type>(params.gamma), params.coef0);
+            device_kernel_assembly_symm<plssvm::kernel_function_type::sigmoid, plssvm::real_type, plssvm::real_type>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<plssvm::real_type>(params.gamma), params.coef0);
             break;
         case plssvm::kernel_function_type::laplacian:
-            device_kernel_assembly_symm<plssvm::kernel_function_type::laplacian>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<plssvm::real_type>(params.gamma));
+            device_kernel_assembly_symm<plssvm::kernel_function_type::laplacian, plssvm::real_type>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<plssvm::real_type>(params.gamma));
             break;
         case plssvm::kernel_function_type::chi_squared:
-            device_kernel_assembly_symm<plssvm::kernel_function_type::chi_squared>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<plssvm::real_type>(params.gamma));
+            device_kernel_assembly_symm<plssvm::kernel_function_type::chi_squared, plssvm::real_type>(alpha, q_red, data_matr, device_specific_num_rows, row_offset, QA_cost, cost, B, C, std::get<plssvm::real_type>(params.gamma));
             break;
     }
 
@@ -250,7 +255,7 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunction, blas_level_3_kernel_implicit) {
     EXPECT_FLOATING_POINT_MATRIX_NEAR_EPS(C, ground_truth_C, 1e6);
 }
 
-TYPED_TEST_P(GenericBackendCSVMKernelFunction, predict_values) {
+TYPED_TEST_P(GenericBackendCSVMKernelFunction, PredictValues) {
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     plssvm::parameter params{ plssvm::kernel_type = kernel };
@@ -258,7 +263,7 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunction, predict_values) {
         params.gamma = plssvm::real_type{ 0.001 };
     }
     const plssvm::classification_data_set data{ PLSSVM_CLASSIFICATION_TEST_FILE };
-    auto data_matr{ data.data() };
+    auto data_matr{ data.data() };  // NOLINT: can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
         data_matr = util::matrix_abs(data_matr);
@@ -279,24 +284,29 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunction, predict_values) {
 
     switch (kernel) {
         case plssvm::kernel_function_type::linear:
-            device_kernel_predict_linear(out, correct_w, rho, predict_points, device_specific_num_predict_points, row_offset);
+            {
+                std::vector<plssvm::real_type> rho_padded(rho.size() + plssvm::PADDING_SIZE, plssvm::real_type{ 0.0 });
+                std::memcpy(rho_padded.data(), rho.data(), rho.size() * sizeof(plssvm::real_type));
+                device_kernel_predict_linear(out, correct_w, rho_padded, predict_points, device_specific_num_predict_points, row_offset);
+            }
             break;
         case plssvm::kernel_function_type::polynomial:
-            device_kernel_predict<plssvm::kernel_function_type::polynomial>(out, weights, rho, data_matr, predict_points, device_specific_num_predict_points, row_offset, params.degree, std::get<plssvm::real_type>(params.gamma), params.coef0);
+            device_kernel_predict<plssvm::kernel_function_type::polynomial, int, plssvm::real_type, plssvm::real_type>(out, weights, rho, data_matr, predict_points, device_specific_num_predict_points, row_offset, params.degree, std::get<plssvm::real_type>(params.gamma), params.coef0);
             break;
         case plssvm::kernel_function_type::rbf:
-            device_kernel_predict<plssvm::kernel_function_type::rbf>(out, weights, rho, data_matr, predict_points, device_specific_num_predict_points, row_offset, std::get<plssvm::real_type>(params.gamma));
+            device_kernel_predict<plssvm::kernel_function_type::rbf, plssvm::real_type>(out, weights, rho, data_matr, predict_points, device_specific_num_predict_points, row_offset, std::get<plssvm::real_type>(params.gamma));
             break;
         case plssvm::kernel_function_type::sigmoid:
-            device_kernel_predict<plssvm::kernel_function_type::sigmoid>(out, weights, rho, data_matr, predict_points, device_specific_num_predict_points, row_offset, std::get<plssvm::real_type>(params.gamma), params.coef0);
+            device_kernel_predict<plssvm::kernel_function_type::sigmoid, plssvm::real_type, plssvm::real_type>(out, weights, rho, data_matr, predict_points, device_specific_num_predict_points, row_offset, std::get<plssvm::real_type>(params.gamma), params.coef0);
             break;
         case plssvm::kernel_function_type::laplacian:
-            device_kernel_predict<plssvm::kernel_function_type::laplacian>(out, weights, rho, data_matr, predict_points, device_specific_num_predict_points, row_offset, std::get<plssvm::real_type>(params.gamma));
+            device_kernel_predict<plssvm::kernel_function_type::laplacian, plssvm::real_type>(out, weights, rho, data_matr, predict_points, device_specific_num_predict_points, row_offset, std::get<plssvm::real_type>(params.gamma));
             break;
         case plssvm::kernel_function_type::chi_squared:
-            device_kernel_predict<plssvm::kernel_function_type::chi_squared>(out, weights, rho, data_matr, predict_points, device_specific_num_predict_points, row_offset, std::get<plssvm::real_type>(params.gamma));
+            device_kernel_predict<plssvm::kernel_function_type::chi_squared, plssvm::real_type>(out, weights, rho, data_matr, predict_points, device_specific_num_predict_points, row_offset, std::get<plssvm::real_type>(params.gamma));
             break;
     }
+    out.restore_padding();
 
     // check out for correctness
     const plssvm::aos_matrix<plssvm::real_type> correct_out = ground_truth::predict_values(params, correct_w, weights, rho, data_matr, predict_points);
@@ -304,9 +314,9 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunction, predict_values) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericBackendCSVMKernelFunction,
-                            assemble_kernel_matrix_explicit,
-                            blas_level_3_kernel_implicit,
-                            predict_values);
+                            AssembleKernelMatrixExplicit,
+                            BlasLevel3KernelImplicit,
+                            PredictValues);
 
 //*************************************************************************************************************************************//
 //                                            non-GPU C-SVM DeathTests depending on nothing                                            //
@@ -317,7 +327,7 @@ class GenericBackendCSVMDeathTest : public GenericBackendCSVM<T> { };
 
 TYPED_TEST_SUITE_P(GenericBackendCSVMDeathTest);
 
-TYPED_TEST_P(GenericBackendCSVMDeathTest, blas_level_3_kernel_explicit) {
+TYPED_TEST_P(GenericBackendCSVMDeathTest, BlasLevel3KernelExplicit) {
     const plssvm::real_type alpha{ 1.0 };
 
     // create kernel matrix to use in the BLAS calculation
@@ -337,49 +347,43 @@ TYPED_TEST_P(GenericBackendCSVMDeathTest, blas_level_3_kernel_explicit) {
     const std::size_t row_offset = dist.place_row_offset(0);
 
     {
-        // the A matrix must have the correct size
-        EXPECT_DEATH(device_kernel_symm(num_rows, num_rhs, specific_num_rows, row_offset, alpha, std::vector<plssvm::real_type>{}, B, beta, C), "A matrix may not be empty!");
-
         // the B matrix must have the correct shape
         const auto B_wrong = util::generate_random_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ std::min<std::size_t>(0ULL, num_rows - 1), std::min<std::size_t>(0ULL, num_rhs - 2) }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
-        EXPECT_DEATH(device_kernel_symm(num_rows, num_rhs, specific_num_rows, row_offset, alpha, kernel_matrix, B_wrong, beta, C), ::testing::HasSubstr(fmt::format("B matrix sizes mismatch!: [{}, {}] != [{}, {}]", std::min(0, static_cast<int>(num_rows) - 1), std::min(0, static_cast<int>(num_rhs) - 2), num_rows, num_rhs)));
+        EXPECT_DEATH(device_kernel_symm(num_rows, num_rhs, specific_num_rows, row_offset, alpha, kernel_matrix.data(), B_wrong, beta, C), ::testing::HasSubstr(fmt::format("B matrix sizes mismatch!: [{}, {}] != [{}, {}]", std::min(0, static_cast<int>(num_rows) - 1), std::min(0, static_cast<int>(num_rhs) - 2), num_rows, num_rhs)));
 
         // the C matrix must have the correct shape
         auto C_wrong = util::generate_random_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ std::min<std::size_t>(0ULL, num_rows - 1), std::min<std::size_t>(0ULL, num_rhs - 2) }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
-        EXPECT_DEATH(device_kernel_symm(num_rows, num_rhs, specific_num_rows, row_offset, alpha, kernel_matrix, B, beta, C_wrong), ::testing::HasSubstr(fmt::format("C matrix sizes mismatch!: [{}, {}] != [{}, {}]", std::min(0, static_cast<int>(num_rows) - 1), std::min(0, static_cast<int>(num_rhs) - 2), num_rows, num_rhs)));
+        EXPECT_DEATH(device_kernel_symm(num_rows, num_rhs, specific_num_rows, row_offset, alpha, kernel_matrix.data(), B, beta, C_wrong), ::testing::HasSubstr(fmt::format("C matrix sizes mismatch!: [{}, {}] != [{}, {}]", std::min(0, static_cast<int>(num_rows) - 1), std::min(0, static_cast<int>(num_rhs) - 2), num_rows, num_rhs)));
 
         // the place specific number of rows may not be too large
-        EXPECT_DEATH(device_kernel_symm(num_rows, num_rhs, num_rows + 1, row_offset, alpha, kernel_matrix, B, beta, C), ::testing::HasSubstr(fmt::format("The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", num_rows + 1, num_rows)));
+        EXPECT_DEATH(device_kernel_symm(num_rows, num_rhs, num_rows + 1, row_offset, alpha, kernel_matrix.data(), B, beta, C), ::testing::HasSubstr(fmt::format("The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", num_rows + 1, num_rows)));
 
         // the row offset may not be too large
-        EXPECT_DEATH(device_kernel_symm(num_rows, num_rhs, specific_num_rows, num_rows + 1, alpha, kernel_matrix, B, beta, C), ::testing::HasSubstr(fmt::format("The row offset ({}) cannot be greater the the total number of rows ({})!", num_rows + 1, num_rows)));
+        EXPECT_DEATH(device_kernel_symm(num_rows, num_rhs, specific_num_rows, num_rows + 1, alpha, kernel_matrix.data(), B, beta, C), ::testing::HasSubstr(fmt::format("The row offset ({}) cannot be greater the the total number of rows ({})!", num_rows + 1, num_rows)));
     }
     {
         const std::size_t num_mirror_rows = num_rows - row_offset - specific_num_rows;
 
-        // the A matrix must have the correct size
-        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, specific_num_rows, row_offset, alpha, std::vector<plssvm::real_type>{}, B, beta, C), "A matrix may not be empty!");
-
         // the B matrix must have the correct shape
         const auto B_wrong = util::generate_random_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ std::min<std::size_t>(0ULL, num_rows - 1), std::min<std::size_t>(0ULL, num_rhs - 2) }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
-        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, specific_num_rows, row_offset, alpha, kernel_matrix, B_wrong, beta, C), ::testing::HasSubstr(fmt::format("B matrix sizes mismatch!: [{}, {}] != [{}, {}]", std::min(0, static_cast<int>(num_rows) - 1), std::min(0, static_cast<int>(num_rhs) - 2), num_rows, num_rhs)));
+        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, specific_num_rows, row_offset, alpha, kernel_matrix.data(), B_wrong, beta, C), ::testing::HasSubstr(fmt::format("B matrix sizes mismatch!: [{}, {}] != [{}, {}]", std::min(0, static_cast<int>(num_rows) - 1), std::min(0, static_cast<int>(num_rhs) - 2), num_rows, num_rhs)));
 
         // the C matrix must have the correct shape
         auto C_wrong = util::generate_random_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ std::min<std::size_t>(0ULL, num_rows - 1), std::min<std::size_t>(0ULL, num_rhs - 2) }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
-        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, specific_num_rows, row_offset, alpha, kernel_matrix, B, beta, C_wrong), ::testing::HasSubstr(fmt::format("C matrix sizes mismatch!: [{}, {}] != [{}, {}]", std::min(0, static_cast<int>(num_rows) - 1), std::min(0, static_cast<int>(num_rhs) - 2), num_rows, num_rhs)));
+        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, specific_num_rows, row_offset, alpha, kernel_matrix.data(), B, beta, C_wrong), ::testing::HasSubstr(fmt::format("C matrix sizes mismatch!: [{}, {}] != [{}, {}]", std::min(0, static_cast<int>(num_rows) - 1), std::min(0, static_cast<int>(num_rhs) - 2), num_rows, num_rhs)));
 
         // the place specific number of rows may not be too large
-        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, num_rows + 1, row_offset, alpha, kernel_matrix, B, beta, C), ::testing::HasSubstr(fmt::format("The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", num_rows + 1, num_rows)));
+        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, num_rows + 1, row_offset, alpha, kernel_matrix.data(), B, beta, C), ::testing::HasSubstr(fmt::format("The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", num_rows + 1, num_rows)));
 
         // the mirror number of rows may not be too large
-        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_rows + 1, specific_num_rows, row_offset, alpha, kernel_matrix, B, beta, C), ::testing::HasSubstr(fmt::format("The number of mirror rows ({}) cannot be greater the the total number of rows ({})!", num_rows + 1, num_rows)));
+        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_rows + 1, specific_num_rows, row_offset, alpha, kernel_matrix.data(), B, beta, C), ::testing::HasSubstr(fmt::format("The number of mirror rows ({}) cannot be greater the the total number of rows ({})!", num_rows + 1, num_rows)));
 
         // the row offset may not be too large
-        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, specific_num_rows, num_rows + 1, alpha, kernel_matrix, B, beta, C), ::testing::HasSubstr(fmt::format("The row offset ({}) cannot be greater the the total number of rows ({})!", num_rows + 1, num_rows)));
+        EXPECT_DEATH(device_kernel_symm_mirror(num_rows, num_rhs, num_mirror_rows, specific_num_rows, num_rows + 1, alpha, kernel_matrix.data(), B, beta, C), ::testing::HasSubstr(fmt::format("The row offset ({}) cannot be greater the the total number of rows ({})!", num_rows + 1, num_rows)));
     }
 }
 
-TYPED_TEST_P(GenericBackendCSVMDeathTest, calculate_w) {
+TYPED_TEST_P(GenericBackendCSVMDeathTest, CalculateW) {
     // the data used for prediction
     const plssvm::classification_data_set data{ PLSSVM_CLASSIFICATION_TEST_FILE };
 
@@ -408,8 +412,8 @@ TYPED_TEST_P(GenericBackendCSVMDeathTest, calculate_w) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericBackendCSVMDeathTest,
-                            blas_level_3_kernel_explicit,
-                            calculate_w);
+                            BlasLevel3KernelExplicit,
+                            CalculateW);
 
 //*************************************************************************************************************************************//
 //                                   non-GPU C-SVM DeathTests depending on the kernel function type                                    //
@@ -420,7 +424,7 @@ class GenericBackendCSVMKernelFunctionDeathTest : public GenericBackendCSVMDeath
 
 TYPED_TEST_SUITE_P(GenericBackendCSVMKernelFunctionDeathTest);
 
-TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, assemble_kernel_matrix_explicit) {
+TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, AssembleKernelMatrixExplicit) {
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create correct data for the function call
@@ -442,52 +446,51 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, assemble_kernel_matrix_e
     const std::size_t row_offset = dist.place_row_offset(0);
 
     // helper lambda to reduce the amount of needed switches!
-    const auto run_assembly = [=](const plssvm::parameter &params_p, std::vector<plssvm::real_type> &kernel_matrix_p, const plssvm::soa_matrix<plssvm::real_type> &data_p, const std::size_t device_specific_num_rows_p, const std::size_t row_offset_p, const std::vector<plssvm::real_type> &q_red_p, const plssvm::real_type QA_cost_p) {
+    const auto run_assembly = [=](const plssvm::parameter &params_p, plssvm::real_type *kernel_matrix_p, const plssvm::soa_matrix<plssvm::real_type> &data_p, const std::size_t device_specific_num_rows_p, const std::size_t row_offset_p, const std::vector<plssvm::real_type> &q_red_p, const plssvm::real_type QA_cost_p) {
         switch (kernel) {
             case plssvm::kernel_function_type::linear:
                 device_kernel_assembly<plssvm::kernel_function_type::linear>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost);
                 break;
             case plssvm::kernel_function_type::polynomial:
-                device_kernel_assembly<plssvm::kernel_function_type::polynomial>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost, params_p.degree, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
+                device_kernel_assembly<plssvm::kernel_function_type::polynomial, int, plssvm::real_type, plssvm::real_type>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost, params_p.degree, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
                 break;
             case plssvm::kernel_function_type::rbf:
-                device_kernel_assembly<plssvm::kernel_function_type::rbf>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost, std::get<plssvm::real_type>(params_p.gamma));
+                device_kernel_assembly<plssvm::kernel_function_type::rbf, plssvm::real_type>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost, std::get<plssvm::real_type>(params_p.gamma));
                 break;
             case plssvm::kernel_function_type::sigmoid:
-                device_kernel_assembly<plssvm::kernel_function_type::sigmoid>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
+                device_kernel_assembly<plssvm::kernel_function_type::sigmoid, plssvm::real_type, plssvm::real_type>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
                 break;
             case plssvm::kernel_function_type::laplacian:
-                device_kernel_assembly<plssvm::kernel_function_type::laplacian>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost, std::get<plssvm::real_type>(params_p.gamma));
+                device_kernel_assembly<plssvm::kernel_function_type::laplacian, plssvm::real_type>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost, std::get<plssvm::real_type>(params_p.gamma));
                 break;
             case plssvm::kernel_function_type::chi_squared:
-                device_kernel_assembly<plssvm::kernel_function_type::chi_squared>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost, std::get<plssvm::real_type>(params_p.gamma));
+                device_kernel_assembly<plssvm::kernel_function_type::chi_squared, plssvm::real_type>(kernel_matrix_p, data_p, device_specific_num_rows_p, row_offset_p, q_red_p, QA_cost_p, params_p.cost, std::get<plssvm::real_type>(params_p.gamma));
                 break;
         }
     };
 
     // check q_red size (must be equal to the number of data points - 1
-    EXPECT_DEATH(run_assembly(params, kernel_matrix, data.data(), device_specific_num_rows, row_offset, std::vector<plssvm::real_type>{}, QA_cost), fmt::format("Sizes mismatch!: 0 != {}", data.num_data_points() - 1));
+    EXPECT_DEATH(run_assembly(params, kernel_matrix.data(), data.data(), device_specific_num_rows, row_offset, std::vector<plssvm::real_type>{}, QA_cost), fmt::format("Sizes mismatch!: 0 != {}", data.num_data_points() - 1));
 
-    // check the kernel matrix size (depending on the usage of GEMM/SYMM)
-    std::vector<plssvm::real_type> ret;
-    EXPECT_DEATH(run_assembly(params, ret, data.data(), device_specific_num_rows, row_offset, q_red, QA_cost), "A matrix may not be empty!");
+    // the result kernel matrix must point to a valid chunk of memory
+    EXPECT_DEATH(run_assembly(params, nullptr, data.data(), device_specific_num_rows, row_offset, q_red, QA_cost), "The kernel matrix result pointer must be valid!");
 
     // check place specific number of rows
-    EXPECT_DEATH(run_assembly(params, kernel_matrix, data.data(), q_red.size() + 1, row_offset, q_red, QA_cost), ::testing::HasSubstr(fmt::format("The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", q_red.size() + 1, q_red.size())));
+    EXPECT_DEATH(run_assembly(params, kernel_matrix.data(), data.data(), q_red.size() + 1, row_offset, q_red, QA_cost), ::testing::HasSubstr(fmt::format("The number of place specific rows ({}) cannot be greater the the total number of rows ({})!", q_red.size() + 1, q_red.size())));
 
     // check the row offset
-    EXPECT_DEATH(run_assembly(params, kernel_matrix, data.data(), device_specific_num_rows, q_red.size() + 1, q_red, QA_cost), ::testing::HasSubstr(fmt::format("The row offset ({}) cannot be greater the the total number of rows ({})!", q_red.size() + 1, q_red.size())));
+    EXPECT_DEATH(run_assembly(params, kernel_matrix.data(), data.data(), device_specific_num_rows, q_red.size() + 1, q_red, QA_cost), ::testing::HasSubstr(fmt::format("The row offset ({}) cannot be greater the the total number of rows ({})!", q_red.size() + 1, q_red.size())));
 
     // cost must not be 0.0 since 1.0 / cost is used
     params.cost = plssvm::real_type{ 0.0 };
-    EXPECT_DEATH(run_assembly(params, kernel_matrix, data.data(), device_specific_num_rows, row_offset, q_red, QA_cost), "cost must not be 0.0 since it is 1 / plssvm::cost!");
+    EXPECT_DEATH(run_assembly(params, kernel_matrix.data(), data.data(), device_specific_num_rows, row_offset, q_red, QA_cost), "cost must not be 0.0 since it is 1 / plssvm::cost!");
 }
 
-TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, blas_level_3_kernel_implicit) {
+TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, BlasLevel3KernelImplicit) {
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create correct data for the function call
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 0.001 };
     }
@@ -517,19 +520,19 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, blas_level_3_kernel_impl
                 device_kernel_assembly_symm<plssvm::kernel_function_type::linear>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p);
                 break;
             case plssvm::kernel_function_type::polynomial:
-                device_kernel_assembly_symm<plssvm::kernel_function_type::polynomial>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p, params_p.degree, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
+                device_kernel_assembly_symm<plssvm::kernel_function_type::polynomial, int, plssvm::real_type, plssvm::real_type>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p, params_p.degree, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
                 break;
             case plssvm::kernel_function_type::rbf:
-                device_kernel_assembly_symm<plssvm::kernel_function_type::rbf>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p, std::get<plssvm::real_type>(params_p.gamma));
+                device_kernel_assembly_symm<plssvm::kernel_function_type::rbf, plssvm::real_type>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p, std::get<plssvm::real_type>(params_p.gamma));
                 break;
             case plssvm::kernel_function_type::sigmoid:
-                device_kernel_assembly_symm<plssvm::kernel_function_type::sigmoid>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
+                device_kernel_assembly_symm<plssvm::kernel_function_type::sigmoid, plssvm::real_type, plssvm::real_type>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
                 break;
             case plssvm::kernel_function_type::laplacian:
-                device_kernel_assembly_symm<plssvm::kernel_function_type::laplacian>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p, std::get<plssvm::real_type>(params_p.gamma));
+                device_kernel_assembly_symm<plssvm::kernel_function_type::laplacian, plssvm::real_type>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p, std::get<plssvm::real_type>(params_p.gamma));
                 break;
             case plssvm::kernel_function_type::chi_squared:
-                device_kernel_assembly_symm<plssvm::kernel_function_type::chi_squared>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p, std::get<plssvm::real_type>(params_p.gamma));
+                device_kernel_assembly_symm<plssvm::kernel_function_type::chi_squared, plssvm::real_type>(alpha, q_red_p, data_p, device_specific_num_rows_p, row_offset_p, QA_cost, params_p.cost, B_p, C_p, std::get<plssvm::real_type>(params_p.gamma));
                 break;
         }
     };
@@ -558,10 +561,10 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, blas_level_3_kernel_impl
     EXPECT_DEATH(run_assembly_symm(params, q_red, data.data(), device_specific_num_rows, row_offset, B, C), ::testing::HasSubstr(fmt::format("The number of columns in B ({}) must be the same as the values in q ({})!", B.num_cols(), data.num_data_points() - 1)));
 }
 
-TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, predict_values) {
+TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, PredictValues) {
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 0.001 };
     }
@@ -569,7 +572,6 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, predict_values) {
 
     const auto weights = util::generate_specific_matrix<plssvm::aos_matrix<plssvm::real_type>>(plssvm::shape{ 3, data.data().num_rows() }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
     const auto predict_points = util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ data.data().num_rows(), data.data().num_cols() }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
-    const std::vector<plssvm::real_type> rho = util::generate_random_vector<plssvm::real_type>(weights.num_rows());
     const plssvm::soa_matrix<plssvm::real_type> w = ground_truth::calculate_w(weights, data.data());
 
     plssvm::aos_matrix<plssvm::real_type> out{ plssvm::shape{ predict_points.num_rows(), weights.num_rows() }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
@@ -580,11 +582,12 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, predict_values) {
     const std::size_t row_offset = dist.place_row_offset(0);
 
     if constexpr (kernel == plssvm::kernel_function_type::linear) {
+        const std::vector<plssvm::real_type> rho = util::generate_random_vector<plssvm::real_type>(weights.num_rows() + plssvm::PADDING_SIZE);
+
         // the number of classes must match
-        std::vector<plssvm::real_type> rho_wrong = util::generate_random_vector<plssvm::real_type>(weights.num_rows());
-        rho_wrong.pop_back();
+        const std::vector<plssvm::real_type> rho_wrong = util::generate_random_vector<plssvm::real_type>(rho.size() - 1);
         EXPECT_DEATH(device_kernel_predict_linear(out, w, rho_wrong, predict_points, device_specific_num_predict_points, row_offset),
-                     ::testing::HasSubstr(fmt::format("Size mismatch: {} vs {}!", w.num_rows(), rho_wrong.size())));
+                     ::testing::HasSubstr(fmt::format("Size mismatch: {} vs {}!", w.num_rows(), rho_wrong.size() - plssvm::PADDING_SIZE)));
 
         // the number of features must match
         const auto predict_points_wrong = util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ data.data().num_rows(), data.data().num_cols() + 1 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
@@ -604,6 +607,8 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, predict_values) {
         EXPECT_DEATH(device_kernel_predict_linear(out, w, rho, predict_points, device_specific_num_predict_points, predict_points.num_rows() + 1),
                      ::testing::HasSubstr(fmt::format("The row offset ({}) cannot be greater the the total number of predict points ({})!", predict_points.num_rows() + 1, predict_points.num_rows())));
     } else {
+        const std::vector<plssvm::real_type> rho = util::generate_random_vector<plssvm::real_type>(weights.num_rows());
+
         // helper lambda to reduce the amount of needed switches!
         const auto run_predict_values = [=](const plssvm::parameter &params_p, plssvm::aos_matrix<plssvm::real_type> &out_p, const plssvm::aos_matrix<plssvm::real_type> &weights_p, const std::vector<plssvm::real_type> &rho_p, const plssvm::soa_matrix<plssvm::real_type> &support_vectors_p, const plssvm::soa_matrix<plssvm::real_type> &predict_points_p, const std::size_t device_specific_num_predict_points_p, const std::size_t row_offset_p) {
             switch (kernel) {
@@ -611,19 +616,19 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, predict_values) {
                     // unreachable
                     break;
                 case plssvm::kernel_function_type::polynomial:
-                    device_kernel_predict<plssvm::kernel_function_type::polynomial>(out_p, weights_p, rho_p, support_vectors_p, predict_points_p, device_specific_num_predict_points_p, row_offset_p, params_p.degree, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
+                    device_kernel_predict<plssvm::kernel_function_type::polynomial, int, plssvm::real_type, plssvm::real_type>(out_p, weights_p, rho_p, support_vectors_p, predict_points_p, device_specific_num_predict_points_p, row_offset_p, params_p.degree, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
                     break;
                 case plssvm::kernel_function_type::rbf:
-                    device_kernel_predict<plssvm::kernel_function_type::rbf>(out_p, weights_p, rho_p, support_vectors_p, predict_points_p, device_specific_num_predict_points_p, row_offset_p, std::get<plssvm::real_type>(params_p.gamma));
+                    device_kernel_predict<plssvm::kernel_function_type::rbf, plssvm::real_type>(out_p, weights_p, rho_p, support_vectors_p, predict_points_p, device_specific_num_predict_points_p, row_offset_p, std::get<plssvm::real_type>(params_p.gamma));
                     break;
                 case plssvm::kernel_function_type::sigmoid:
-                    device_kernel_predict<plssvm::kernel_function_type::sigmoid>(out_p, weights_p, rho_p, support_vectors_p, predict_points_p, device_specific_num_predict_points_p, row_offset_p, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
+                    device_kernel_predict<plssvm::kernel_function_type::sigmoid, plssvm::real_type, plssvm::real_type>(out_p, weights_p, rho_p, support_vectors_p, predict_points_p, device_specific_num_predict_points_p, row_offset_p, std::get<plssvm::real_type>(params_p.gamma), params_p.coef0);
                     break;
                 case plssvm::kernel_function_type::laplacian:
-                    device_kernel_predict<plssvm::kernel_function_type::laplacian>(out_p, weights_p, rho_p, support_vectors_p, predict_points_p, device_specific_num_predict_points_p, row_offset_p, std::get<plssvm::real_type>(params_p.gamma));
+                    device_kernel_predict<plssvm::kernel_function_type::laplacian, plssvm::real_type>(out_p, weights_p, rho_p, support_vectors_p, predict_points_p, device_specific_num_predict_points_p, row_offset_p, std::get<plssvm::real_type>(params_p.gamma));
                     break;
                 case plssvm::kernel_function_type::chi_squared:
-                    device_kernel_predict<plssvm::kernel_function_type::chi_squared>(out_p, weights_p, rho_p, support_vectors_p, predict_points_p, device_specific_num_predict_points_p, row_offset_p, std::get<plssvm::real_type>(params_p.gamma));
+                    device_kernel_predict<plssvm::kernel_function_type::chi_squared, plssvm::real_type>(out_p, weights_p, rho_p, support_vectors_p, predict_points_p, device_specific_num_predict_points_p, row_offset_p, std::get<plssvm::real_type>(params_p.gamma));
                     break;
             }
         };
@@ -660,8 +665,8 @@ TYPED_TEST_P(GenericBackendCSVMKernelFunctionDeathTest, predict_values) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericBackendCSVMKernelFunctionDeathTest,
-                            assemble_kernel_matrix_explicit,
-                            blas_level_3_kernel_implicit,
-                            predict_values);
+                            AssembleKernelMatrixExplicit,
+                            BlasLevel3KernelImplicit,
+                            PredictValues);
 
 #endif  // PLSSVM_TESTS_BACKENDS_GENERIC_CSVM_TESTS_HPP_
diff --git a/tests/backends/generic_device_ptr_tests.hpp b/tests/backends/generic_device_ptr_tests.hpp
index 3f2407005..d3f6af0ec 100644
--- a/tests/backends/generic_device_ptr_tests.hpp
+++ b/tests/backends/generic_device_ptr_tests.hpp
@@ -37,7 +37,7 @@ class DevicePtr : public ::testing::Test {
 
 TYPED_TEST_SUITE_P(DevicePtr);
 
-TYPED_TEST_P(DevicePtr, default_construct) {
+TYPED_TEST_P(DevicePtr, DefaultConstruct) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
 
@@ -52,7 +52,24 @@ TYPED_TEST_P(DevicePtr, default_construct) {
     EXPECT_TRUE(ptr.empty());
 }
 
-TYPED_TEST_P(DevicePtr, construct_size) {
+TYPED_TEST_P(DevicePtr, ConstructExplicitEmpty) {
+    using test_type = typename TestFixture::fixture_test_type;
+    using device_ptr_type = typename test_type::device_ptr_type;
+    using queue_type = typename test_type::queue_type;
+    const queue_type &queue = test_type::default_queue();
+
+    // construct device_ptr
+    const device_ptr_type ptr{ plssvm::shape{ 0, 0 }, plssvm::shape{ 0, 0 }, queue };
+
+    // empty data
+    EXPECT_FALSE(static_cast<bool>(ptr));
+    EXPECT_EQ(ptr.get(), typename device_ptr_type::device_pointer_type{});
+    EXPECT_EQ(ptr.size(), 0);
+    EXPECT_EQ(ptr.shape(), (plssvm::shape{ 0, 0 }));
+    EXPECT_TRUE(ptr.empty());
+}
+
+TYPED_TEST_P(DevicePtr, ConstructSize) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -70,7 +87,7 @@ TYPED_TEST_P(DevicePtr, construct_size) {
     EXPECT_EQ(ptr.shape_padded(), (plssvm::shape{ 42, 1 }));
 }
 
-TYPED_TEST_P(DevicePtr, construct_shape) {
+TYPED_TEST_P(DevicePtr, ConstructShape) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -88,7 +105,7 @@ TYPED_TEST_P(DevicePtr, construct_shape) {
     EXPECT_EQ(ptr.shape_padded(), (plssvm::shape{ 42, 16 }));
 }
 
-TYPED_TEST_P(DevicePtr, construct_shape_and_padding) {
+TYPED_TEST_P(DevicePtr, ConstructShapeAndPadding) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -106,7 +123,7 @@ TYPED_TEST_P(DevicePtr, construct_shape_and_padding) {
     EXPECT_EQ(ptr.shape_padded(), (plssvm::shape{ 46, 20 }));
 }
 
-TYPED_TEST_P(DevicePtr, move_construct) {
+TYPED_TEST_P(DevicePtr, MoveConstruct) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -126,15 +143,17 @@ TYPED_TEST_P(DevicePtr, move_construct) {
     EXPECT_EQ(second.shape_padded(), (plssvm::shape{ 42, 1 }));
 
     // check moved-from data
+    // NOLINTBEGIN: use after move wanted since this is tested here
     EXPECT_FALSE(static_cast<bool>(first));
     EXPECT_EQ(first.get(), typename device_ptr_type::device_pointer_type{});
     EXPECT_EQ(first.shape(), (plssvm::shape{ 0, 0 }));
     // check padding
     EXPECT_EQ(first.padding(), (plssvm::shape{ 0, 0 }));
     EXPECT_EQ(first.shape_padded(), (plssvm::shape{ 0, 0 }));
+    // NOLINTEND
 }
 
-TYPED_TEST_P(DevicePtr, move_construct_with_padding) {
+TYPED_TEST_P(DevicePtr, MoveConstructWithPadding) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -154,15 +173,17 @@ TYPED_TEST_P(DevicePtr, move_construct_with_padding) {
     EXPECT_EQ(second.shape_padded(), (plssvm::shape{ 46, 15 }));
 
     // check moved-from data
+    // NOLINTBEGIN: use after move wanted since this is tested here
     EXPECT_FALSE(static_cast<bool>(first));
     EXPECT_EQ(first.get(), typename device_ptr_type::device_pointer_type{});
     EXPECT_EQ(first.shape(), (plssvm::shape{ 0, 0 }));
     // check padding
     EXPECT_EQ(first.padding(), (plssvm::shape{ 0, 0 }));
     EXPECT_EQ(first.shape_padded(), (plssvm::shape{ 0, 0 }));
+    // NOLINTEND
 }
 
-TYPED_TEST_P(DevicePtr, move_assign) {
+TYPED_TEST_P(DevicePtr, MoveAssign) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -184,15 +205,17 @@ TYPED_TEST_P(DevicePtr, move_assign) {
     EXPECT_EQ(second.shape_padded(), (plssvm::shape{ 42, 1 }));
 
     // check moved-from data
+    // NOLINTBEGIN: use after move wanted since this is tested here
     EXPECT_FALSE(static_cast<bool>(first));
     EXPECT_EQ(first.get(), typename device_ptr_type::device_pointer_type{});
     EXPECT_EQ(first.shape(), (plssvm::shape{ 0, 0 }));
     // check padding
     EXPECT_EQ(first.padding(), (plssvm::shape{ 0, 0 }));
     EXPECT_EQ(first.shape_padded(), (plssvm::shape{ 0, 0 }));
+    // NOLINTEND
 }
 
-TYPED_TEST_P(DevicePtr, move_assign_with_padding) {
+TYPED_TEST_P(DevicePtr, MoveAssignWithPadding) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -214,15 +237,17 @@ TYPED_TEST_P(DevicePtr, move_assign_with_padding) {
     EXPECT_EQ(second.shape_padded(), (plssvm::shape{ 46, 15 }));
 
     // check moved-from data
+    // NOLINTBEGIN: use after move wanted since this is tested here
     EXPECT_FALSE(static_cast<bool>(first));
     EXPECT_EQ(first.get(), typename device_ptr_type::device_pointer_type{});
     EXPECT_EQ(first.shape(), (plssvm::shape{ 0, 0 }));
     // check padding
     EXPECT_EQ(first.padding(), (plssvm::shape{ 0, 0 }));
     EXPECT_EQ(first.shape_padded(), (plssvm::shape{ 0, 0 }));
+    // NOLINTEND
 }
 
-TYPED_TEST_P(DevicePtr, swap_member_function) {
+TYPED_TEST_P(DevicePtr, SwapMemberFunction) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -251,7 +276,7 @@ TYPED_TEST_P(DevicePtr, swap_member_function) {
     EXPECT_EQ(first.shape_padded(), (plssvm::shape{ 0, 0 }));
 }
 
-TYPED_TEST_P(DevicePtr, swap_member_function_with_padding) {
+TYPED_TEST_P(DevicePtr, SwapMemberFunctionWithPadding) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -280,7 +305,7 @@ TYPED_TEST_P(DevicePtr, swap_member_function_with_padding) {
     EXPECT_EQ(first.shape_padded(), (plssvm::shape{ 0, 0 }));
 }
 
-TYPED_TEST_P(DevicePtr, swap_free_function) {
+TYPED_TEST_P(DevicePtr, SwapFreeFunction) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -310,7 +335,7 @@ TYPED_TEST_P(DevicePtr, swap_free_function) {
     EXPECT_EQ(first.shape_padded(), (plssvm::shape{ 0, 0 }));
 }
 
-TYPED_TEST_P(DevicePtr, swap_free_function_with_padding) {
+TYPED_TEST_P(DevicePtr, SwapFreeFunctionWithPadding) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -340,7 +365,7 @@ TYPED_TEST_P(DevicePtr, swap_free_function_with_padding) {
     EXPECT_EQ(first.shape_padded(), (plssvm::shape{ 0, 0 }));
 }
 
-TYPED_TEST_P(DevicePtr, operator_bool) {
+TYPED_TEST_P(DevicePtr, OperatorBool) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -355,7 +380,7 @@ TYPED_TEST_P(DevicePtr, operator_bool) {
     EXPECT_FALSE(static_cast<bool>(ptr2));
 }
 
-TYPED_TEST_P(DevicePtr, size) {
+TYPED_TEST_P(DevicePtr, Size) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -378,7 +403,7 @@ TYPED_TEST_P(DevicePtr, size) {
     EXPECT_EQ(ptr4.size(), 0);
 }
 
-TYPED_TEST_P(DevicePtr, shape) {
+TYPED_TEST_P(DevicePtr, Shape) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -401,7 +426,7 @@ TYPED_TEST_P(DevicePtr, shape) {
     EXPECT_EQ(ptr4.shape(), (plssvm::shape{ 0, 0 }));
 }
 
-TYPED_TEST_P(DevicePtr, empty) {
+TYPED_TEST_P(DevicePtr, Empty) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -428,7 +453,7 @@ TYPED_TEST_P(DevicePtr, empty) {
     EXPECT_TRUE(ptr5.empty());
 }
 
-TYPED_TEST_P(DevicePtr, padding) {
+TYPED_TEST_P(DevicePtr, Padding) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -440,7 +465,7 @@ TYPED_TEST_P(DevicePtr, padding) {
     ;
 }
 
-TYPED_TEST_P(DevicePtr, size_padded) {
+TYPED_TEST_P(DevicePtr, SizePadded) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -451,7 +476,7 @@ TYPED_TEST_P(DevicePtr, size_padded) {
     EXPECT_EQ(ptr.size_padded(), (42 + 4) * (16 + 5));
 }
 
-TYPED_TEST_P(DevicePtr, shape_padded) {
+TYPED_TEST_P(DevicePtr, ShapePadded) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -474,7 +499,7 @@ TYPED_TEST_P(DevicePtr, shape_padded) {
     EXPECT_EQ(ptr4.shape_padded(), (plssvm::shape{ 0, 0 }));
 }
 
-TYPED_TEST_P(DevicePtr, is_padded) {
+TYPED_TEST_P(DevicePtr, IsPadded) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -505,7 +530,7 @@ TYPED_TEST_P(DevicePtr, is_padded) {
     EXPECT_FALSE(ptr6.is_padded());
 }
 
-TYPED_TEST_P(DevicePtr, memset) {
+TYPED_TEST_P(DevicePtr, Memset) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -528,7 +553,7 @@ TYPED_TEST_P(DevicePtr, memset) {
     EXPECT_EQ(result, correct);
 }
 
-TYPED_TEST_P(DevicePtr, memset_with_numbytes) {
+TYPED_TEST_P(DevicePtr, MemsetWithNumBytes) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -551,7 +576,7 @@ TYPED_TEST_P(DevicePtr, memset_with_numbytes) {
     EXPECT_EQ(result, correct);
 }
 
-TYPED_TEST_P(DevicePtr, memset_invalid_pos) {
+TYPED_TEST_P(DevicePtr, MemsetInvalidPos) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -566,7 +591,7 @@ TYPED_TEST_P(DevicePtr, memset_invalid_pos) {
                       "Illegal access in memset!: 10 >= 10");
 }
 
-TYPED_TEST_P(DevicePtr, fill) {
+TYPED_TEST_P(DevicePtr, Fill) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -589,7 +614,7 @@ TYPED_TEST_P(DevicePtr, fill) {
     EXPECT_EQ(result, correct);
 }
 
-TYPED_TEST_P(DevicePtr, fill_with_count) {
+TYPED_TEST_P(DevicePtr, FillWithCount) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -612,7 +637,7 @@ TYPED_TEST_P(DevicePtr, fill_with_count) {
     EXPECT_EQ(result, correct);
 }
 
-TYPED_TEST_P(DevicePtr, fill_invalid_pos) {
+TYPED_TEST_P(DevicePtr, FillInvalidPos) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -628,7 +653,7 @@ TYPED_TEST_P(DevicePtr, fill_invalid_pos) {
                       "Illegal access in fill!: 10 >= 10");
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector) {
+TYPED_TEST_P(DevicePtr, CopyVector) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -639,7 +664,7 @@ TYPED_TEST_P(DevicePtr, copy_vector) {
     device_ptr_type ptr{ 10, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(14, 42);
+    const std::vector<value_type> data(14, 42);
 
     // copy data to the device
     ptr.copy_to_device(data);
@@ -651,7 +676,7 @@ TYPED_TEST_P(DevicePtr, copy_vector) {
     EXPECT_EQ(result, std::vector<value_type>(10, 42));
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector_with_count_copy_back_all) {
+TYPED_TEST_P(DevicePtr, CopyVectorWithCountCopyBackAll) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -662,7 +687,7 @@ TYPED_TEST_P(DevicePtr, copy_vector_with_count_copy_back_all) {
     device_ptr_type ptr{ 6, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(6, 42);
+    const std::vector<value_type> data(6, 42);
 
     // copy data to the device
     ptr.copy_to_device(data, 1, 3);
@@ -674,7 +699,7 @@ TYPED_TEST_P(DevicePtr, copy_vector_with_count_copy_back_all) {
     EXPECT_EQ(result, (std::vector<value_type>{ value_type{ 0.0 }, value_type{ 42.0 }, value_type{ 42.0 }, value_type{ 42.0 }, value_type{ 0.0 }, value_type{ 0.0 } }));
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector_with_count_copy_back_some) {
+TYPED_TEST_P(DevicePtr, CopyVectorWithCountCopyBackSome) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -685,7 +710,7 @@ TYPED_TEST_P(DevicePtr, copy_vector_with_count_copy_back_some) {
     device_ptr_type ptr{ 6, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(6, 42);
+    const std::vector<value_type> data(6, 42);
 
     // copy data to the device
     ptr.copy_to_device(data, 1, 3);
@@ -697,7 +722,7 @@ TYPED_TEST_P(DevicePtr, copy_vector_with_count_copy_back_some) {
     EXPECT_EQ(result, (std::vector<value_type>{ value_type{ 42.0 }, value_type{ 42.0 }, value_type{ 0.0 } }));
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector_with_count_copy_to_too_many) {
+TYPED_TEST_P(DevicePtr, CopyVectorWithCountCopyToTooMany) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -708,7 +733,7 @@ TYPED_TEST_P(DevicePtr, copy_vector_with_count_copy_to_too_many) {
     device_ptr_type ptr{ 6, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(6, 42);
+    const std::vector<value_type> data(6, 42);
 
     // copy data to the device
     ptr.copy_to_device(data, 2, 6);
@@ -720,7 +745,7 @@ TYPED_TEST_P(DevicePtr, copy_vector_with_count_copy_to_too_many) {
     EXPECT_EQ(result, (std::vector<value_type>{ value_type{ 0.0 }, value_type{ 0.0 }, value_type{ 42.0 }, value_type{ 42.0 }, value_type{ 42.0 }, value_type{ 42.0 } }));
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector_too_few_host_elements) {
+TYPED_TEST_P(DevicePtr, CopyVectorTooFewHostElements) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -731,11 +756,11 @@ TYPED_TEST_P(DevicePtr, copy_vector_too_few_host_elements) {
     device_ptr_type ptr{ 10, queue };
 
     // try copying data to the device with too few elements
-    std::vector<value_type> data(8, 42);
+    const std::vector<value_type> data(8, 42);
     EXPECT_THROW_WHAT(ptr.copy_to_device(data), plssvm::gpu_device_ptr_exception, "Too few data to perform copy (needed: 10, provided: 8)!");
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector_too_few_buffer_elements) {
+TYPED_TEST_P(DevicePtr, CopyVectorTooFewBufferElements) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -743,14 +768,14 @@ TYPED_TEST_P(DevicePtr, copy_vector_too_few_buffer_elements) {
     const queue_type &queue = test_type::default_queue();
 
     // construct device_ptr
-    device_ptr_type ptr{ 10, queue };
+    const device_ptr_type ptr{ 10, queue };
 
     // try copying data back to the host with a buffer with too few elements
     std::vector<value_type> buffer(8);
     EXPECT_THROW_WHAT(ptr.copy_to_host(buffer), plssvm::gpu_device_ptr_exception, "Buffer too small to perform copy (needed: 10, provided: 8)!");
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector_with_count_too_few_host_elements) {
+TYPED_TEST_P(DevicePtr, CopyVectorWithCountTooFewHostElements) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -761,11 +786,11 @@ TYPED_TEST_P(DevicePtr, copy_vector_with_count_too_few_host_elements) {
     device_ptr_type ptr{ 10, queue };
 
     // try copying data to the device with too few elements
-    std::vector<value_type> data(4, 42);
+    const std::vector<value_type> data(4, 42);
     EXPECT_THROW_WHAT(ptr.copy_to_device(data, 1, 7), plssvm::gpu_device_ptr_exception, "Too few data to perform copy (needed: 7, provided: 4)!");
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector_with_count_too_few_buffer_elements) {
+TYPED_TEST_P(DevicePtr, CopyVectorWithCountTooFewBufferElements) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -773,14 +798,14 @@ TYPED_TEST_P(DevicePtr, copy_vector_with_count_too_few_buffer_elements) {
     const queue_type &queue = test_type::default_queue();
 
     // construct device_ptr
-    device_ptr_type ptr{ 6, queue };
+    const device_ptr_type ptr{ 6, queue };
 
     // try copying data back to the host with a buffer with too few elements
     std::vector<value_type> buffer(4);
     EXPECT_THROW_WHAT(ptr.copy_to_host(buffer, 1, 7), plssvm::gpu_device_ptr_exception, "Buffer too small to perform copy (needed: 5, provided: 4)!");
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector_strided) {
+TYPED_TEST_P(DevicePtr, CopyVectorStrided) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -805,7 +830,7 @@ TYPED_TEST_P(DevicePtr, copy_vector_strided) {
     EXPECT_EQ(result, correct_result);
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector_strided_invalid_spitch_width_combination) {
+TYPED_TEST_P(DevicePtr, CopyVectorStridedInvalidSpitchWidthCombination) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -816,13 +841,13 @@ TYPED_TEST_P(DevicePtr, copy_vector_strided_invalid_spitch_width_combination) {
     device_ptr_type ptr{ plssvm::shape{ 2, 2 }, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(20);  // 5 x 4
+    const std::vector<value_type> data(20);  // 5 x 4
 
     // copy data to the device
     EXPECT_THROW_WHAT(ptr.copy_to_device_strided(data, 5, 6, 2), plssvm::gpu_device_ptr_exception, "Invalid width and spitch combination specified (width: 6 <= spitch: 5)!");
 }
 
-TYPED_TEST_P(DevicePtr, copy_vector_strided_submatrix_too_big) {
+TYPED_TEST_P(DevicePtr, CopyVectorStridedSubmatrixTooBig) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -833,13 +858,13 @@ TYPED_TEST_P(DevicePtr, copy_vector_strided_submatrix_too_big) {
     device_ptr_type ptr{ plssvm::shape{ 2, 2 }, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(20);  // 5 x 4
+    const std::vector<value_type> data(20);  // 5 x 4
 
     // copy data to the device
     EXPECT_THROW_WHAT(ptr.copy_to_device_strided(data, 5, 5, 5), plssvm::gpu_device_ptr_exception, "The sub-matrix (5x5) to copy is to big (20)!");
 }
 
-TYPED_TEST_P(DevicePtr, copy_ptr) {
+TYPED_TEST_P(DevicePtr, CopyPointer) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -850,7 +875,7 @@ TYPED_TEST_P(DevicePtr, copy_ptr) {
     device_ptr_type ptr{ 10, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(14, 42);
+    const std::vector<value_type> data(14, 42);
 
     // copy data to the device
     ptr.copy_to_device(data.data());
@@ -862,7 +887,7 @@ TYPED_TEST_P(DevicePtr, copy_ptr) {
     EXPECT_EQ(result, std::vector<value_type>(10, 42));
 }
 
-TYPED_TEST_P(DevicePtr, copy_ptr_with_count_copy_back_all) {
+TYPED_TEST_P(DevicePtr, CopyPointerWithCountCopyBackAll) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -873,7 +898,7 @@ TYPED_TEST_P(DevicePtr, copy_ptr_with_count_copy_back_all) {
     device_ptr_type ptr{ 6, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(6, 42);
+    const std::vector<value_type> data(6, 42);
 
     // copy data to the device
     ptr.copy_to_device(data.data(), 1, 3);
@@ -885,7 +910,7 @@ TYPED_TEST_P(DevicePtr, copy_ptr_with_count_copy_back_all) {
     EXPECT_EQ(result, (std::vector<value_type>{ value_type{ 0.0 }, value_type{ 42.0 }, value_type{ 42.0 }, value_type{ 42.0 }, value_type{ 0.0 }, value_type{ 0.0 } }));
 }
 
-TYPED_TEST_P(DevicePtr, copy_ptr_with_count_copy_back_some) {
+TYPED_TEST_P(DevicePtr, CopyPointerWithCountCopyBackSome) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -896,7 +921,7 @@ TYPED_TEST_P(DevicePtr, copy_ptr_with_count_copy_back_some) {
     device_ptr_type ptr{ 6, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(6, 42);
+    const std::vector<value_type> data(6, 42);
 
     // copy data to the device
     ptr.copy_to_device(data.data(), 1, 3);
@@ -908,7 +933,7 @@ TYPED_TEST_P(DevicePtr, copy_ptr_with_count_copy_back_some) {
     EXPECT_EQ(result, (std::vector<value_type>{ value_type{ 42.0 }, value_type{ 42.0 }, value_type{ 0.0 } }));
 }
 
-TYPED_TEST_P(DevicePtr, copy_ptr_with_count_copy_to_too_many) {
+TYPED_TEST_P(DevicePtr, CopyPointerWithCountCopyToTooMany) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -919,7 +944,7 @@ TYPED_TEST_P(DevicePtr, copy_ptr_with_count_copy_to_too_many) {
     device_ptr_type ptr{ 6, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(6, 42);
+    const std::vector<value_type> data(6, 42);
 
     // copy data to the device
     ptr.copy_to_device(data.data(), 2, 6);
@@ -931,7 +956,7 @@ TYPED_TEST_P(DevicePtr, copy_ptr_with_count_copy_to_too_many) {
     EXPECT_EQ(result, (std::vector<value_type>{ value_type{ 0.0 }, value_type{ 0.0 }, value_type{ 42.0 }, value_type{ 42.0 }, value_type{ 42.0 }, value_type{ 42.0 } }));
 }
 
-TYPED_TEST_P(DevicePtr, copy_ptr_strided) {
+TYPED_TEST_P(DevicePtr, CopyPointerStrided) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -956,7 +981,7 @@ TYPED_TEST_P(DevicePtr, copy_ptr_strided) {
     EXPECT_EQ(result, correct_result);
 }
 
-TYPED_TEST_P(DevicePtr, copy_ptr_strided_invalid_spitch_width_combination) {
+TYPED_TEST_P(DevicePtr, CopyPointerStridedInvalidSpitchWidthCombination) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -967,13 +992,13 @@ TYPED_TEST_P(DevicePtr, copy_ptr_strided_invalid_spitch_width_combination) {
     device_ptr_type ptr{ plssvm::shape{ 2, 2 }, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(20);  // 5 x 4
+    const std::vector<value_type> data(20);  // 5 x 4
 
     // copy data to the device
     EXPECT_THROW_WHAT(ptr.copy_to_device_strided(data.data(), 5, 6, 2), plssvm::exception, "Invalid width and spitch combination specified (width: 6 <= spitch: 5)!");
 }
 
-TYPED_TEST_P(DevicePtr, copy_device_ptr_to_other_device) {
+TYPED_TEST_P(DevicePtr, CopyDevicePtrToOtherDevice) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -984,7 +1009,7 @@ TYPED_TEST_P(DevicePtr, copy_device_ptr_to_other_device) {
     device_ptr_type ptr{ 10, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(14, 42);
+    const std::vector<value_type> data(14, 42);
 
     // copy data to the device
     ptr.copy_to_device(data);
@@ -1001,7 +1026,7 @@ TYPED_TEST_P(DevicePtr, copy_device_ptr_to_other_device) {
     EXPECT_EQ(result, std::vector<value_type>(10, 42));
 }
 
-TYPED_TEST_P(DevicePtr, copy_device_ptr_to_other_device_too_few_device_elements) {
+TYPED_TEST_P(DevicePtr, CopyDevicePtrToOtherDeviceTooFewDeviceElements) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1012,7 +1037,7 @@ TYPED_TEST_P(DevicePtr, copy_device_ptr_to_other_device_too_few_device_elements)
     device_ptr_type ptr{ 10, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(14, 42);
+    const std::vector<value_type> data(14, 42);
 
     // copy data to the device
     ptr.copy_to_device(data);
@@ -1022,7 +1047,7 @@ TYPED_TEST_P(DevicePtr, copy_device_ptr_to_other_device_too_few_device_elements)
     EXPECT_THROW_WHAT(ptr.copy_to_other_device(other_ptr), plssvm::exception, "Buffer too small to perform copy (needed: 10, provided: 5)!");
 }
 
-TYPED_TEST_P(DevicePtr, copy_device_ptr_to_other_device_with_count) {
+TYPED_TEST_P(DevicePtr, CopyDevicePtrToOtherDeviceWithCount) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1033,7 +1058,7 @@ TYPED_TEST_P(DevicePtr, copy_device_ptr_to_other_device_with_count) {
     device_ptr_type ptr{ 10, queue };
 
     // create data to copy to the device
-    std::vector<value_type> data(14, 42);
+    const std::vector<value_type> data(14, 42);
 
     // copy data to the device
     ptr.copy_to_device(data);
@@ -1051,52 +1076,53 @@ TYPED_TEST_P(DevicePtr, copy_device_ptr_to_other_device_with_count) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(DevicePtr,
-                            default_construct,
-                            construct_size,
-                            construct_shape,
-                            construct_shape_and_padding,
-                            move_construct,
-                            move_construct_with_padding,
-                            move_assign,
-                            move_assign_with_padding,
-                            swap_member_function,
-                            swap_member_function_with_padding,
-                            swap_free_function,
-                            swap_free_function_with_padding,
-                            operator_bool,
-                            size,
-                            shape,
-                            empty,
-                            padding,
-                            size_padded,
-                            shape_padded,
-                            is_padded,
-                            memset,
-                            memset_with_numbytes,
-                            memset_invalid_pos,
-                            fill,
-                            fill_with_count,
-                            fill_invalid_pos,
-                            copy_vector,
-                            copy_vector_with_count_copy_back_all,
-                            copy_vector_with_count_copy_back_some,
-                            copy_vector_with_count_copy_to_too_many,
-                            copy_vector_too_few_host_elements,
-                            copy_vector_too_few_buffer_elements,
-                            copy_vector_with_count_too_few_host_elements,
-                            copy_vector_with_count_too_few_buffer_elements,
-                            copy_vector_strided,
-                            copy_vector_strided_invalid_spitch_width_combination,
-                            copy_vector_strided_submatrix_too_big,
-                            copy_ptr,
-                            copy_ptr_with_count_copy_back_all,
-                            copy_ptr_with_count_copy_back_some,
-                            copy_ptr_with_count_copy_to_too_many,
-                            copy_ptr_strided,
-                            copy_ptr_strided_invalid_spitch_width_combination,
-                            copy_device_ptr_to_other_device,
-                            copy_device_ptr_to_other_device_too_few_device_elements,
-                            copy_device_ptr_to_other_device_with_count);
+                            DefaultConstruct,
+                            ConstructExplicitEmpty,
+                            ConstructSize,
+                            ConstructShape,
+                            ConstructShapeAndPadding,
+                            MoveConstruct,
+                            MoveConstructWithPadding,
+                            MoveAssign,
+                            MoveAssignWithPadding,
+                            SwapMemberFunction,
+                            SwapMemberFunctionWithPadding,
+                            SwapFreeFunction,
+                            SwapFreeFunctionWithPadding,
+                            OperatorBool,
+                            Size,
+                            Shape,
+                            Empty,
+                            Padding,
+                            SizePadded,
+                            ShapePadded,
+                            IsPadded,
+                            Memset,
+                            MemsetWithNumBytes,
+                            MemsetInvalidPos,
+                            Fill,
+                            FillWithCount,
+                            FillInvalidPos,
+                            CopyVector,
+                            CopyVectorWithCountCopyBackAll,
+                            CopyVectorWithCountCopyBackSome,
+                            CopyVectorWithCountCopyToTooMany,
+                            CopyVectorTooFewHostElements,
+                            CopyVectorTooFewBufferElements,
+                            CopyVectorWithCountTooFewHostElements,
+                            CopyVectorWithCountTooFewBufferElements,
+                            CopyVectorStrided,
+                            CopyVectorStridedInvalidSpitchWidthCombination,
+                            CopyVectorStridedSubmatrixTooBig,
+                            CopyPointer,
+                            CopyPointerWithCountCopyBackAll,
+                            CopyPointerWithCountCopyBackSome,
+                            CopyPointerWithCountCopyToTooMany,
+                            CopyPointerStrided,
+                            CopyPointerStridedInvalidSpitchWidthCombination,
+                            CopyDevicePtrToOtherDevice,
+                            CopyDevicePtrToOtherDeviceTooFewDeviceElements,
+                            CopyDevicePtrToOtherDeviceWithCount);
 
 template <typename T>
 class DevicePtrLayout : public DevicePtr<T> {
@@ -1106,7 +1132,7 @@ class DevicePtrLayout : public DevicePtr<T> {
 
 TYPED_TEST_SUITE_P(DevicePtrLayout);
 
-TYPED_TEST_P(DevicePtrLayout, copy_matrix) {
+TYPED_TEST_P(DevicePtrLayout, CopyMatrix) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1139,7 +1165,7 @@ TYPED_TEST_P(DevicePtrLayout, copy_matrix) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(result, correct_result);
 }
 
-TYPED_TEST_P(DevicePtrLayout, copy_matrix_with_padding) {
+TYPED_TEST_P(DevicePtrLayout, CopyMatrixWithPadding) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1163,7 +1189,7 @@ TYPED_TEST_P(DevicePtrLayout, copy_matrix_with_padding) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(result, data);
 }
 
-TYPED_TEST_P(DevicePtrLayout, copy_matrix_different_layouts) {
+TYPED_TEST_P(DevicePtrLayout, CopyMatrixDifferentLayouts) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1197,7 +1223,7 @@ TYPED_TEST_P(DevicePtrLayout, copy_matrix_different_layouts) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(result, correct_result);
 }
 
-TYPED_TEST_P(DevicePtrLayout, copy_matrix_too_few_host_elements) {
+TYPED_TEST_P(DevicePtrLayout, CopyMatrixTooFewHostElements) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1209,11 +1235,11 @@ TYPED_TEST_P(DevicePtrLayout, copy_matrix_too_few_host_elements) {
     device_ptr_type ptr{ 10, queue };
 
     // try copying data to the device with too few elements
-    plssvm::matrix<value_type, layout> data{ plssvm::shape{ 2, 4 }, value_type{ 42 } };
+    const plssvm::matrix<value_type, layout> data{ plssvm::shape{ 2, 4 }, value_type{ 42 } };
     EXPECT_THROW_WHAT(ptr.copy_to_device(data), plssvm::gpu_device_ptr_exception, "Too few data to perform copy (needed: 10, provided: 8)!");
 }
 
-TYPED_TEST_P(DevicePtrLayout, copy_matrix_too_few_buffer_elements) {
+TYPED_TEST_P(DevicePtrLayout, CopyMatrixTooFewBufferElements) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1222,14 +1248,14 @@ TYPED_TEST_P(DevicePtrLayout, copy_matrix_too_few_buffer_elements) {
     constexpr plssvm::layout_type layout = util::test_parameter_value_at_v<0, TypeParam>;
 
     // construct device_ptr
-    device_ptr_type ptr{ 10, queue };
+    const device_ptr_type ptr{ 10, queue };
 
     // try copying data back to the host with a buffer with too few elements
     plssvm::matrix<value_type, layout> buffer{ plssvm::shape{ 2, 4 } };
     EXPECT_THROW_WHAT(ptr.copy_to_host(buffer), plssvm::gpu_device_ptr_exception, "Buffer too small to perform copy (needed: 10, provided: 8)!");
 }
 
-TYPED_TEST_P(DevicePtrLayout, copy_matrix_strided) {
+TYPED_TEST_P(DevicePtrLayout, CopyMatrixStrided) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1250,11 +1276,11 @@ TYPED_TEST_P(DevicePtrLayout, copy_matrix_strided) {
     ptr.copy_to_host(result);
 
     // check values for correctness
-    plssvm::matrix<value_type, layout> correct_result{ { { 1.1, 1.2, 1.3 }, { 2.1, 2.2, 2.3 } } };
+    const plssvm::matrix<value_type, layout> correct_result{ { { 1.1, 1.2, 1.3 }, { 2.1, 2.2, 2.3 } } };
     EXPECT_FLOATING_POINT_MATRIX_EQ(result, correct_result);
 }
 
-TYPED_TEST_P(DevicePtrLayout, copy_matrix_strided_with_padding) {
+TYPED_TEST_P(DevicePtrLayout, CopyMatrixStridedWithPadding) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1275,15 +1301,15 @@ TYPED_TEST_P(DevicePtrLayout, copy_matrix_strided_with_padding) {
     ptr.copy_to_host(result);
 
     // check values for correctness
-    plssvm::matrix<value_type, layout> correct_result{ { { 2.1, 2.2, 2.3 },
-                                                         { 3.1, 3.2, 3.3 },
-                                                         { 4.1, 4.2, 4.3 } },
-                                                       plssvm::shape{ 4, 4 } };
+    const plssvm::matrix<value_type, layout> correct_result{ { { 2.1, 2.2, 2.3 },
+                                                               { 3.1, 3.2, 3.3 },
+                                                               { 4.1, 4.2, 4.3 } },
+                                                             plssvm::shape{ 4, 4 } };
 
     EXPECT_FLOATING_POINT_MATRIX_EQ(result, correct_result);
 }
 
-TYPED_TEST_P(DevicePtrLayout, copy_matrix_strided_different_layouts) {
+TYPED_TEST_P(DevicePtrLayout, CopyMatrixStridedDifferentLayouts) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1318,7 +1344,7 @@ TYPED_TEST_P(DevicePtrLayout, copy_matrix_strided_different_layouts) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(result, correct_result);
 }
 
-TYPED_TEST_P(DevicePtrLayout, copy_full_matrix_strided) {
+TYPED_TEST_P(DevicePtrLayout, CopyFullMatrixStrided) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1342,7 +1368,7 @@ TYPED_TEST_P(DevicePtrLayout, copy_full_matrix_strided) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(result, data);
 }
 
-TYPED_TEST_P(DevicePtrLayout, copy_matrix_strided_too_few_host_elements) {
+TYPED_TEST_P(DevicePtrLayout, CopyMatrixStridedTooFewHostElements) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1354,11 +1380,11 @@ TYPED_TEST_P(DevicePtrLayout, copy_matrix_strided_too_few_host_elements) {
     device_ptr_type ptr{ plssvm::shape{ 2, 5 }, queue };
 
     // try copying data to the device with too few elements
-    plssvm::matrix<value_type, layout> data{ plssvm::shape{ 2, 4 }, value_type{ 42 } };
+    const plssvm::matrix<value_type, layout> data{ plssvm::shape{ 2, 4 }, value_type{ 42 } };
     EXPECT_THROW_WHAT(ptr.copy_to_device_strided(data, 1, 1), plssvm::gpu_device_ptr_exception, "Too few data to perform copy (needed: 10, provided: 4)!");
 }
 
-TYPED_TEST_P(DevicePtrLayout, copy_matrix_strided_invalid_submatrix) {
+TYPED_TEST_P(DevicePtrLayout, CopyMatrixStridedInvalidSubmatrix) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1370,30 +1396,30 @@ TYPED_TEST_P(DevicePtrLayout, copy_matrix_strided_invalid_submatrix) {
     device_ptr_type ptr{ plssvm::shape{ 2, 5 }, queue };
 
     // try copying data to the device with too few elements
-    plssvm::matrix<value_type, layout> data{ plssvm::shape{ 4, 5 }, value_type{ 42 } };
+    const plssvm::matrix<value_type, layout> data{ plssvm::shape{ 4, 5 }, value_type{ 42 } };
     EXPECT_THROW_WHAT(ptr.copy_to_device_strided(data, 4, 1), plssvm::gpu_device_ptr_exception, "Tried to copy lines 4-4 (zero-based index) to the device, but the matrix has only 4 lines!");
     EXPECT_THROW_WHAT(ptr.copy_to_device_strided(data, 3, 3), plssvm::gpu_device_ptr_exception, "Tried to copy lines 3-5 (zero-based index) to the device, but the matrix has only 4 lines!");
 }
 
 REGISTER_TYPED_TEST_SUITE_P(DevicePtrLayout,
-                            copy_matrix,
-                            copy_matrix_with_padding,
-                            copy_matrix_different_layouts,
-                            copy_matrix_too_few_host_elements,
-                            copy_matrix_too_few_buffer_elements,
-                            copy_matrix_strided,
-                            copy_matrix_strided_with_padding,
-                            copy_matrix_strided_different_layouts,
-                            copy_full_matrix_strided,
-                            copy_matrix_strided_too_few_host_elements,
-                            copy_matrix_strided_invalid_submatrix);
+                            CopyMatrix,
+                            CopyMatrixWithPadding,
+                            CopyMatrixDifferentLayouts,
+                            CopyMatrixTooFewHostElements,
+                            CopyMatrixTooFewBufferElements,
+                            CopyMatrixStrided,
+                            CopyMatrixStridedWithPadding,
+                            CopyMatrixStridedDifferentLayouts,
+                            CopyFullMatrixStrided,
+                            CopyMatrixStridedTooFewHostElements,
+                            CopyMatrixStridedInvalidSubmatrix);
 
 template <typename T>
 class DevicePtrDeathTest : public DevicePtr<T> { };
 
 TYPED_TEST_SUITE_P(DevicePtrDeathTest);
 
-TYPED_TEST_P(DevicePtrDeathTest, memset) {
+TYPED_TEST_P(DevicePtrDeathTest, Memset) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
 
@@ -1405,7 +1431,7 @@ TYPED_TEST_P(DevicePtrDeathTest, memset) {
     EXPECT_DEATH(ptr.memset(1, 2, 4), ::testing::HasSubstr("Invalid data pointer! Maybe *this has been default constructed?"));
 }
 
-TYPED_TEST_P(DevicePtrDeathTest, fill) {
+TYPED_TEST_P(DevicePtrDeathTest, Fill) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1418,7 +1444,7 @@ TYPED_TEST_P(DevicePtrDeathTest, fill) {
     EXPECT_DEATH(ptr.fill(value_type{ 1.0 }, 2, 4), ::testing::HasSubstr("Invalid data pointer! Maybe *this has been default constructed?"));
 }
 
-TYPED_TEST_P(DevicePtrDeathTest, copy_invalid_host_ptr) {
+TYPED_TEST_P(DevicePtrDeathTest, CopyInvalidHostPointer) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -1432,7 +1458,7 @@ TYPED_TEST_P(DevicePtrDeathTest, copy_invalid_host_ptr) {
     EXPECT_DEATH(ptr.copy_to_host(nullptr), ::testing::HasSubstr("Invalid host pointer for the data to copy!"));
 }
 
-TYPED_TEST_P(DevicePtrDeathTest, copy_invalid_device_ptr) {
+TYPED_TEST_P(DevicePtrDeathTest, CopyInvalidDevicePtr) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1451,7 +1477,7 @@ TYPED_TEST_P(DevicePtrDeathTest, copy_invalid_device_ptr) {
     EXPECT_DEATH(def.copy_to_host(data), ::testing::HasSubstr("Invalid data pointer! Maybe *this has been default constructed?"));
 }
 
-TYPED_TEST_P(DevicePtrDeathTest, copy_with_count_invalid_host_ptr) {
+TYPED_TEST_P(DevicePtrDeathTest, CopyWithCountInvalidHostPointer) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -1465,7 +1491,7 @@ TYPED_TEST_P(DevicePtrDeathTest, copy_with_count_invalid_host_ptr) {
     EXPECT_DEATH(ptr.copy_to_host(nullptr, 0, 10), ::testing::HasSubstr("Invalid host pointer for the data to copy!"));
 }
 
-TYPED_TEST_P(DevicePtrDeathTest, copy_with_count_invalid_device_ptr) {
+TYPED_TEST_P(DevicePtrDeathTest, CopyWithCountInvalidDevicePtr) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1481,7 +1507,7 @@ TYPED_TEST_P(DevicePtrDeathTest, copy_with_count_invalid_device_ptr) {
     EXPECT_DEATH(def.copy_to_host(data, 0, 0), ::testing::HasSubstr("Invalid data pointer! Maybe *this has been default constructed?"));
 }
 
-TYPED_TEST_P(DevicePtrDeathTest, copy_strided_invalid_host_ptr) {
+TYPED_TEST_P(DevicePtrDeathTest, CopyStridedInvalidHostPointer) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -1494,7 +1520,7 @@ TYPED_TEST_P(DevicePtrDeathTest, copy_strided_invalid_host_ptr) {
     EXPECT_DEATH(ptr.copy_to_device_strided(nullptr, 0, 0, 0), ::testing::HasSubstr("Invalid host pointer for the data to copy!"));
 }
 
-TYPED_TEST_P(DevicePtrDeathTest, copy_strided_invalid_device_ptr) {
+TYPED_TEST_P(DevicePtrDeathTest, CopyStridedInvalidDevicePtr) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using value_type = typename device_ptr_type::value_type;
@@ -1508,7 +1534,7 @@ TYPED_TEST_P(DevicePtrDeathTest, copy_strided_invalid_device_ptr) {
     EXPECT_DEATH(def.copy_to_device_strided(data, 0, 0, 0), ::testing::HasSubstr("Invalid data pointer! Maybe *this has been default constructed?"));
 }
 
-TYPED_TEST_P(DevicePtrDeathTest, copy_to_other_device_invalid_device_ptr) {
+TYPED_TEST_P(DevicePtrDeathTest, CopyToOtherDeviceInvalidDevicePtr) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -1523,7 +1549,7 @@ TYPED_TEST_P(DevicePtrDeathTest, copy_to_other_device_invalid_device_ptr) {
     EXPECT_DEATH(ptr.copy_to_other_device(def), ::testing::HasSubstr("Invalid target pointer! Maybe target has been default constructed?"));
 }
 
-TYPED_TEST_P(DevicePtrDeathTest, copy_to_other_device_with_count_invalid_device_ptr) {
+TYPED_TEST_P(DevicePtrDeathTest, CopyToOtherDeviceWithCountInvalidDevicePtr) {
     using test_type = typename TestFixture::fixture_test_type;
     using device_ptr_type = typename test_type::device_ptr_type;
     using queue_type = typename test_type::queue_type;
@@ -1539,15 +1565,15 @@ TYPED_TEST_P(DevicePtrDeathTest, copy_to_other_device_with_count_invalid_device_
 }
 
 REGISTER_TYPED_TEST_SUITE_P(DevicePtrDeathTest,
-                            memset,
-                            fill,
-                            copy_invalid_host_ptr,
-                            copy_invalid_device_ptr,
-                            copy_with_count_invalid_host_ptr,
-                            copy_with_count_invalid_device_ptr,
-                            copy_strided_invalid_host_ptr,
-                            copy_strided_invalid_device_ptr,
-                            copy_to_other_device_invalid_device_ptr,
-                            copy_to_other_device_with_count_invalid_device_ptr);
+                            Memset,
+                            Fill,
+                            CopyInvalidHostPointer,
+                            CopyInvalidDevicePtr,
+                            CopyWithCountInvalidHostPointer,
+                            CopyWithCountInvalidDevicePtr,
+                            CopyStridedInvalidHostPointer,
+                            CopyStridedInvalidDevicePtr,
+                            CopyToOtherDeviceInvalidDevicePtr,
+                            CopyToOtherDeviceWithCountInvalidDevicePtr);
 
 #endif  // PLSSVM_TESTS_BACKENDS_GENERIC_DEVICE_PTR_TESTS_HPP_
diff --git a/tests/backends/generic_exceptions_tests.hpp b/tests/backends/generic_exceptions_tests.hpp
index b55418ff3..460c9290f 100644
--- a/tests/backends/generic_exceptions_tests.hpp
+++ b/tests/backends/generic_exceptions_tests.hpp
@@ -38,7 +38,7 @@ class Exception : public ::testing::Test { };
 TYPED_TEST_SUITE_P(Exception);
 
 // check whether throwing exceptions works as intended
-TYPED_TEST_P(Exception, throwing_exception) {
+TYPED_TEST_P(Exception, ThrowingException) {
     using exception_type = typename TypeParam::exception_type;
 
     // throw the specified exception
@@ -47,10 +47,10 @@ TYPED_TEST_P(Exception, throwing_exception) {
 }
 
 // check whether the source location information are populated correctly
-TYPED_TEST_P(Exception, exception_source_location) {
+TYPED_TEST_P(Exception, ExceptionSourceLocation) {
     using exception_type = typename TypeParam::exception_type;
 
-    const exception_type exc = dummy<exception_type>("exception message");
+    const auto exc = dummy<exception_type>("exception message");
 
     EXPECT_EQ(exc.loc().file_name(), std::string{ __builtin_FILE() });
     EXPECT_THAT(exc.loc().function_name(), ::testing::HasSubstr("dummy"));
@@ -59,11 +59,11 @@ TYPED_TEST_P(Exception, exception_source_location) {
 }
 
 // check whether what message including the source location information is assembled correctly
-TYPED_TEST_P(Exception, exception_what_with_source_location) {
+TYPED_TEST_P(Exception, ExceptionWhatWithSourceLocation) {
     using exception_type = typename TypeParam::exception_type;
     constexpr std::string_view exception_name = TypeParam::name;
 
-    const exception_type exc = dummy<exception_type>("exception message");
+    const auto exc = dummy<exception_type>("exception message");
 
     // get exception message with source location information split into a vector of separate lines
     const std::string what = exc.what_with_loc();
@@ -81,8 +81,8 @@ TYPED_TEST_P(Exception, exception_what_with_source_location) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(Exception,
-                            throwing_exception,
-                            exception_source_location,
-                            exception_what_with_source_location);
+                            ThrowingException,
+                            ExceptionSourceLocation,
+                            ExceptionWhatWithSourceLocation);
 
 #endif  // PLSSVM_TESTS_BACKENDS_GENERIC_EXCEPTIONS_TESTS_HPP_
diff --git a/tests/backends/generic_gpu_csvm_tests.hpp b/tests/backends/generic_gpu_csvm_tests.hpp
index b68453801..1dd03f701 100644
--- a/tests/backends/generic_gpu_csvm_tests.hpp
+++ b/tests/backends/generic_gpu_csvm_tests.hpp
@@ -13,9 +13,12 @@
 #define PLSSVM_TESTS_BACKENDS_GENERIC_GPU_CSVM_TESTS_HPP_
 #pragma once
 
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"  // plssvm::kokkos::execution_space
 #include "plssvm/constants.hpp"                         // plssvm::real_type, plssvm::PADDING_SIZE
 #include "plssvm/data_set/classification_data_set.hpp"  // plssvm::classification_data_set
 #include "plssvm/detail/data_distribution.hpp"          // plssvm::detail::{triangular_data_distribution, rectangular_data_distribution}
+#include "plssvm/detail/memory_size.hpp"                // plssvm::detail::memory_size
+#include "plssvm/detail/operators.hpp"                  // operator overloads for std::vector(+scalars)
 #include "plssvm/kernel_function_types.hpp"             // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                            // plssvm::aos_matrix
 #include "plssvm/mpi/communicator.hpp"                  // plssvm::mpi::communicator
@@ -31,10 +34,11 @@
 #include "fmt/format.h"   // fmt::format
 #include "gtest/gtest.h"  // TYPED_TEST_SUITE_P, TYPED_TEST_P, REGISTER_TYPED_TEST_SUITE_P, EXPECT_GT, EXPECT_GE, ASSERT_EQ, ::testing::Test
 
-#include <cstddef>  // std::size_t
-#include <memory>   // std::unique_ptr, std::make_unique
-#include <tuple>    // std::ignore
-#include <vector>   // std::vector
+#include <cstddef>   // std::size_t
+#include <memory>    // std::unique_ptr, std::make_unique
+#include <optional>  // std::optional, std::nullopt
+#include <tuple>     // std::ignore
+#include <vector>    // std::vector
 
 //*************************************************************************************************************************************//
 //                                                GPU C-SVM tests depending on nothing                                                 //
@@ -46,12 +50,48 @@ class GenericGPUCSVM : public ::testing::Test,
 
 TYPED_TEST_SUITE_P(GenericGPUCSVM);
 
-TYPED_TEST_P(GenericGPUCSVM, get_max_work_group_size) {
+TYPED_TEST_P(GenericGPUCSVM, GetLocalMemory) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
+    using csvm_type = typename csvm_test_type::csvm_type;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+
+    // for GPU C-SVMs, the local memory size must NOT be nullopt, except for Kokkos with CPU-only execution spaces
+    const std::vector<std::optional<plssvm::detail::memory_size>> local_mem = svm.get_local_memory();
+    for (const std::optional<plssvm::detail::memory_size> &val : local_mem) {
+        if constexpr (plssvm::csvm_to_backend_type_v<csvm_type> == plssvm::backend_type::kokkos) {
+            switch (svm.get_execution_space()) {
+                case plssvm::kokkos::execution_space::cuda:
+                case plssvm::kokkos::execution_space::hip:
+                case plssvm::kokkos::execution_space::sycl:
+                    EXPECT_NE(val, std::nullopt);
+                    break;
+                case plssvm::kokkos::execution_space::hpx:
+                case plssvm::kokkos::execution_space::openmp:
+                case plssvm::kokkos::execution_space::threads:
+                case plssvm::kokkos::execution_space::serial:
+                    EXPECT_EQ(val, std::nullopt);
+                    break;
+                case plssvm::kokkos::execution_space::openmp_target:
+                case plssvm::kokkos::execution_space::openacc:
+                case plssvm::kokkos::execution_space::automatic:
+                    // should currently be unreachable!
+                    break;
+            }
+        } else {
+            EXPECT_NE(val, std::nullopt);
+        }
+    }
+}
+
+TYPED_TEST_P(GenericGPUCSVM, GetMaxWorkGroupSize) {
+    using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
+    using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
+
+    // create C-SVM: must be done using the mock class since the member function to test is private or protected
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     // the maximum allowed work-group size should be greater than 0!
     for (std::size_t device_id = 0; device_id < svm.num_available_devices(); ++device_id) {
@@ -59,12 +99,12 @@ TYPED_TEST_P(GenericGPUCSVM, get_max_work_group_size) {
     }
 }
 
-TYPED_TEST_P(GenericGPUCSVM, get_max_grid_size) {
+TYPED_TEST_P(GenericGPUCSVM, GetMaxGridSize) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
 
     // the maximum allowed work-group size should be greater than 0!
     for (std::size_t device_id = 0; device_id < svm.num_available_devices(); ++device_id) {
@@ -75,7 +115,7 @@ TYPED_TEST_P(GenericGPUCSVM, get_max_grid_size) {
     }
 }
 
-TYPED_TEST_P(GenericGPUCSVM, run_blas_level_3_kernel_explicit) {
+TYPED_TEST_P(GenericGPUCSVM, RunBlasLevel3KernelExplicit) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using device_ptr_type = typename csvm_test_type::device_ptr_type;
@@ -84,7 +124,7 @@ TYPED_TEST_P(GenericGPUCSVM, run_blas_level_3_kernel_explicit) {
     const plssvm::classification_data_set data{ PLSSVM_CLASSIFICATION_TEST_FILE };
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
     // be sure to use the correct data distribution
     svm.data_distribution_ = std::make_unique<plssvm::detail::triangular_data_distribution>(plssvm::mpi::communicator{}, data.num_data_points() - 1, num_devices);
@@ -161,7 +201,7 @@ TYPED_TEST_P(GenericGPUCSVM, run_blas_level_3_kernel_explicit) {
     }
 }
 
-TYPED_TEST_P(GenericGPUCSVM, run_w_kernel) {
+TYPED_TEST_P(GenericGPUCSVM, RunWKernel) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using device_ptr_type = typename csvm_test_type::device_ptr_type;
@@ -174,7 +214,7 @@ TYPED_TEST_P(GenericGPUCSVM, run_w_kernel) {
     const auto weights = util::generate_specific_matrix<plssvm::aos_matrix<plssvm::real_type>>(plssvm::shape{ 3, data.num_data_points() }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE });
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
     // be sure to use the correct data distribution
     svm.data_distribution_ = std::make_unique<plssvm::detail::rectangular_data_distribution>(plssvm::mpi::communicator{}, data.num_data_points(), num_devices);
@@ -228,8 +268,8 @@ TYPED_TEST_P(GenericGPUCSVM, run_w_kernel) {
     }
 }
 
-TYPED_TEST_P(GenericGPUCSVM, run_inplace_matrix_addition) {
-    using namespace plssvm::operators;
+TYPED_TEST_P(GenericGPUCSVM, RunInplaceMatrixAddition) {
+    using namespace plssvm::operators;  // NOLINT(google-build-using-namespace): only imports custom math operations on vectors (and scalars)
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using device_ptr_type = typename csvm_test_type::device_ptr_type;
@@ -238,7 +278,7 @@ TYPED_TEST_P(GenericGPUCSVM, run_inplace_matrix_addition) {
     const plssvm::soa_matrix<plssvm::real_type> &matr = data.data();
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
 
     // calculate correct output
@@ -281,8 +321,8 @@ TYPED_TEST_P(GenericGPUCSVM, run_inplace_matrix_addition) {
     }
 }
 
-TYPED_TEST_P(GenericGPUCSVM, run_inplace_matrix_scale) {
-    using namespace plssvm::operators;
+TYPED_TEST_P(GenericGPUCSVM, RunInplaceMatrixScale) {
+    using namespace plssvm::operators;  // NOLINT(google-build-using-namespace): only imports custom math operations on vectors (and scalars)
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using device_ptr_type = typename csvm_test_type::device_ptr_type;
@@ -292,7 +332,7 @@ TYPED_TEST_P(GenericGPUCSVM, run_inplace_matrix_scale) {
     const plssvm::real_type scaling_factor = 3.1415;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
 
     // calculate correct output
@@ -334,12 +374,13 @@ TYPED_TEST_P(GenericGPUCSVM, run_inplace_matrix_scale) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericGPUCSVM,
-                            get_max_work_group_size,
-                            get_max_grid_size,
-                            run_blas_level_3_kernel_explicit,
-                            run_w_kernel,
-                            run_inplace_matrix_addition,
-                            run_inplace_matrix_scale);
+                            GetLocalMemory,
+                            GetMaxWorkGroupSize,
+                            GetMaxGridSize,
+                            RunBlasLevel3KernelExplicit,
+                            RunWKernel,
+                            RunInplaceMatrixAddition,
+                            RunInplaceMatrixScale);
 
 //*************************************************************************************************************************************//
 //                                        GPU C-SVM tests depending on the kernel function type                                        //
@@ -350,25 +391,25 @@ class GenericGPUCSVMKernelFunction : public GenericGPUCSVM<T> { };
 
 TYPED_TEST_SUITE_P(GenericGPUCSVMKernelFunction);
 
-TYPED_TEST_P(GenericGPUCSVMKernelFunction, run_assemble_kernel_matrix_explicit) {
+TYPED_TEST_P(GenericGPUCSVMKernelFunction, RunAssembleKernelMatrixExplicit) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using device_ptr_type = typename csvm_test_type::device_ptr_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 0.001 };
     }
     const plssvm::classification_data_set data{ PLSSVM_CLASSIFICATION_TEST_FILE };
-    auto data_matr{ data.data() };
+    auto data_matr{ data.data() };  // NOLINT: can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
         data_matr = util::matrix_abs(data_matr);
     }
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
     // be sure to use the correct data distribution
     svm.data_distribution_ = std::make_unique<plssvm::detail::triangular_data_distribution>(plssvm::mpi::communicator{}, data.num_data_points() - 1, num_devices);
@@ -425,25 +466,25 @@ TYPED_TEST_P(GenericGPUCSVMKernelFunction, run_assemble_kernel_matrix_explicit)
     }
 }
 
-TYPED_TEST_P(GenericGPUCSVMKernelFunction, run_assemble_kernel_matrix_implicit_blas_level_3) {
+TYPED_TEST_P(GenericGPUCSVMKernelFunction, RunAssembleKernelMatrixImplicitBlasLevel3) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using device_ptr_type = typename csvm_test_type::device_ptr_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 0.001 };
     }
     const plssvm::classification_data_set data{ PLSSVM_CLASSIFICATION_TEST_FILE };
-    auto data_matr{ data.data() };
+    auto data_matr{ data.data() };  // NOLINT: can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
         data_matr = util::matrix_abs(data_matr);
     }
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
     // be sure to use the correct data distribution
     svm.data_distribution_ = std::make_unique<plssvm::detail::triangular_data_distribution>(plssvm::mpi::communicator{}, data.num_data_points() - 1, num_devices);
@@ -513,19 +554,19 @@ TYPED_TEST_P(GenericGPUCSVMKernelFunction, run_assemble_kernel_matrix_implicit_b
     }
 }
 
-TYPED_TEST_P(GenericGPUCSVMKernelFunction, run_predict_kernel) {
+TYPED_TEST_P(GenericGPUCSVMKernelFunction, RunPredictKernel) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
     using device_ptr_type = typename csvm_test_type::device_ptr_type;
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
+    plssvm::parameter params{ plssvm::kernel_type = kernel };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel != plssvm::kernel_function_type::linear) {
         params.gamma = plssvm::real_type{ 1.0 };
     }
 
     const plssvm::classification_data_set data{ PLSSVM_CLASSIFICATION_TEST_FILE };
-    auto data_matr{ data.data() };
+    auto data_matr{ data.data() };  // NOLINT: can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
         data_matr = util::matrix_abs(data_matr);
@@ -537,7 +578,7 @@ TYPED_TEST_P(GenericGPUCSVMKernelFunction, run_predict_kernel) {
     const plssvm::soa_matrix<plssvm::real_type> correct_w = ground_truth::calculate_w(weights, data_matr);
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(params, csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
     // be sure to use the correct data distribution
     svm.data_distribution_ = std::make_unique<plssvm::detail::rectangular_data_distribution>(plssvm::mpi::communicator{}, predict_points.num_rows(), num_devices);
@@ -606,33 +647,33 @@ TYPED_TEST_P(GenericGPUCSVMKernelFunction, run_predict_kernel) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericGPUCSVMKernelFunction,
-                            run_assemble_kernel_matrix_explicit,
-                            run_assemble_kernel_matrix_implicit_blas_level_3,
-                            run_predict_kernel);
+                            RunAssembleKernelMatrixExplicit,
+                            RunAssembleKernelMatrixImplicitBlasLevel3,
+                            RunPredictKernel);
 
 template <typename T>
 class GenericGPUCSVMDeathTest : public GenericGPUCSVM<T> { };
 
 TYPED_TEST_SUITE_P(GenericGPUCSVMDeathTest);
 
-TYPED_TEST_P(GenericGPUCSVMDeathTest, get_max_work_group_size_out_of_range) {
+TYPED_TEST_P(GenericGPUCSVMDeathTest, GetMaxWorkGroupSizeOutOfRange) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
 
     // try querying an invalid device_id
     EXPECT_DEATH(std::ignore = svm.get_max_work_group_size(num_devices), fmt::format("Invalid device {} requested!", num_devices));
 }
 
-TYPED_TEST_P(GenericGPUCSVMDeathTest, get_max_grid_size_out_of_range) {
+TYPED_TEST_P(GenericGPUCSVMDeathTest, GetMaxGridSizeOutOfRange) {
     using csvm_test_type = util::test_parameter_type_at_t<0, TypeParam>;
     using mock_csvm_type = typename csvm_test_type::mock_csvm_type;
 
     // create C-SVM: must be done using the mock class since the member function to test is private or protected
-    const mock_csvm_type svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
+    const auto svm = util::construct_from_tuple<mock_csvm_type>(csvm_test_type::additional_arguments);
     const std::size_t num_devices = svm.num_available_devices();
 
     // try querying an invalid device_id
@@ -640,7 +681,7 @@ TYPED_TEST_P(GenericGPUCSVMDeathTest, get_max_grid_size_out_of_range) {
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericGPUCSVMDeathTest,
-                            get_max_work_group_size_out_of_range,
-                            get_max_grid_size_out_of_range);
+                            GetMaxWorkGroupSizeOutOfRange,
+                            GetMaxGridSizeOutOfRange);
 
 #endif  // PLSSVM_TESTS_BACKENDS_GENERIC_GPU_CSVM_TESTS_HPP_
diff --git a/tests/backends/generic_pinned_memory_tests.hpp b/tests/backends/generic_pinned_memory_tests.hpp
index 12d92c5c9..26c1c5a25 100644
--- a/tests/backends/generic_pinned_memory_tests.hpp
+++ b/tests/backends/generic_pinned_memory_tests.hpp
@@ -30,7 +30,7 @@ class PinnedMemory : public ::testing::Test {
 
 TYPED_TEST_SUITE_P(PinnedMemory);
 
-TYPED_TEST_P(PinnedMemory, construct_vector) {
+TYPED_TEST_P(PinnedMemory, ConstructVector) {
     using test_type = typename TestFixture::fixture_test_type;
     using pinned_memory_type = typename test_type::pinned_memory_type;
     using real_type = typename pinned_memory_type::value_type;
@@ -45,7 +45,7 @@ TYPED_TEST_P(PinnedMemory, construct_vector) {
     EXPECT_EQ(mem.is_pinned(), can_pin);
 }
 
-TYPED_TEST_P(PinnedMemory, construct_pointer_and_size) {
+TYPED_TEST_P(PinnedMemory, ConstructPointerAndSize) {
     using test_type = typename TestFixture::fixture_test_type;
     using pinned_memory_type = typename test_type::pinned_memory_type;
     using real_type = typename pinned_memory_type::value_type;
@@ -60,7 +60,7 @@ TYPED_TEST_P(PinnedMemory, construct_pointer_and_size) {
     EXPECT_EQ(mem.is_pinned(), can_pin);
 }
 
-TYPED_TEST_P(PinnedMemory, is_pinned) {
+TYPED_TEST_P(PinnedMemory, IsPinned) {
     using test_type = typename TestFixture::fixture_test_type;
     using pinned_memory_type = typename test_type::pinned_memory_type;
     using real_type = typename pinned_memory_type::value_type;
@@ -75,7 +75,7 @@ TYPED_TEST_P(PinnedMemory, is_pinned) {
     EXPECT_EQ(mem.is_pinned(), can_pin);
 }
 
-REGISTER_TYPED_TEST_SUITE_P(PinnedMemory, construct_vector, construct_pointer_and_size, is_pinned);
+REGISTER_TYPED_TEST_SUITE_P(PinnedMemory, ConstructVector, ConstructPointerAndSize, IsPinned);
 
 template <typename T>
 class PinnedMemoryLayout : public PinnedMemory<T> {
@@ -85,7 +85,7 @@ class PinnedMemoryLayout : public PinnedMemory<T> {
 
 TYPED_TEST_SUITE_P(PinnedMemoryLayout);
 
-TYPED_TEST_P(PinnedMemoryLayout, construct_matrix) {
+TYPED_TEST_P(PinnedMemoryLayout, ConstructMatrix) {
     using test_type = typename TestFixture::fixture_test_type;
     using pinned_memory_type = typename test_type::pinned_memory_type;
     using real_type = typename pinned_memory_type::value_type;
@@ -101,7 +101,7 @@ TYPED_TEST_P(PinnedMemoryLayout, construct_matrix) {
     EXPECT_EQ(mem.is_pinned(), can_pin);
 }
 
-REGISTER_TYPED_TEST_SUITE_P(PinnedMemoryLayout, construct_matrix);
+REGISTER_TYPED_TEST_SUITE_P(PinnedMemoryLayout, ConstructMatrix);
 
 template <typename T>
 class PinnedMemoryDeathTest : public PinnedMemory<T> {
@@ -111,7 +111,7 @@ class PinnedMemoryDeathTest : public PinnedMemory<T> {
 
 TYPED_TEST_SUITE_P(PinnedMemoryDeathTest);
 
-TYPED_TEST_P(PinnedMemoryDeathTest, construct_empty_vector) {
+TYPED_TEST_P(PinnedMemoryDeathTest, ConstructEmptyVector) {
     using test_type = typename TestFixture::fixture_test_type;
     using pinned_memory_type = typename test_type::pinned_memory_type;
     using real_type = typename pinned_memory_type::value_type;
@@ -125,7 +125,7 @@ TYPED_TEST_P(PinnedMemoryDeathTest, construct_empty_vector) {
     }
 }
 
-TYPED_TEST_P(PinnedMemoryDeathTest, construct_empty_pointer_and_size) {
+TYPED_TEST_P(PinnedMemoryDeathTest, ConstructEmptyPointerAndSize) {
     using test_type = typename TestFixture::fixture_test_type;
     using pinned_memory_type = typename test_type::pinned_memory_type;
     using real_type = typename pinned_memory_type::value_type;
@@ -139,7 +139,7 @@ TYPED_TEST_P(PinnedMemoryDeathTest, construct_empty_pointer_and_size) {
     }
 }
 
-TYPED_TEST_P(PinnedMemoryDeathTest, construct_nullptr) {
+TYPED_TEST_P(PinnedMemoryDeathTest, ConstructNullptr) {
     using test_type = typename TestFixture::fixture_test_type;
     using pinned_memory_type = typename test_type::pinned_memory_type;
     constexpr bool can_pin = test_type::can_pin;
@@ -150,17 +150,17 @@ TYPED_TEST_P(PinnedMemoryDeathTest, construct_nullptr) {
     }
 }
 
-REGISTER_TYPED_TEST_SUITE_P(PinnedMemoryDeathTest, construct_empty_vector, construct_empty_pointer_and_size, construct_nullptr);
+REGISTER_TYPED_TEST_SUITE_P(PinnedMemoryDeathTest, ConstructEmptyVector, ConstructEmptyPointerAndSize, ConstructNullptr);
 
 template <typename T>
-class PinnedMemoryLayoutDeathTest : public PinnedMemory<T> {
+class PinnedMemoryLayoutDeathTest : public PinnedMemoryLayout<T> {
   protected:
     using fixture_test_type = util::test_parameter_type_at_t<0, T>;
 };
 
 TYPED_TEST_SUITE_P(PinnedMemoryLayoutDeathTest);
 
-TYPED_TEST_P(PinnedMemoryLayoutDeathTest, construct_empty_matrix) {
+TYPED_TEST_P(PinnedMemoryLayoutDeathTest, ConstructEmptyMatrix) {
     using test_type = typename TestFixture::fixture_test_type;
     using pinned_memory_type = typename test_type::pinned_memory_type;
     using real_type = typename pinned_memory_type::value_type;
@@ -175,6 +175,6 @@ TYPED_TEST_P(PinnedMemoryLayoutDeathTest, construct_empty_matrix) {
     }
 }
 
-REGISTER_TYPED_TEST_SUITE_P(PinnedMemoryLayoutDeathTest, construct_empty_matrix);
+REGISTER_TYPED_TEST_SUITE_P(PinnedMemoryLayoutDeathTest, ConstructEmptyMatrix);
 
 #endif  // PLSSVM_TESTS_BACKENDS_GENERIC_PINNED_MEMORY_TESTS_HPP_
diff --git a/tests/backends/ground_truth.cpp b/tests/backends/ground_truth.cpp
index 640b88fde..09a05e9d8 100644
--- a/tests/backends/ground_truth.cpp
+++ b/tests/backends/ground_truth.cpp
@@ -19,8 +19,7 @@
 
 #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 <utility>  // std::pair, std::make_pair, std::move, std::get
 #include <vector>   // std::vector
 
 namespace ground_truth {
diff --git a/tests/backends/stdpar/AdaptiveCpp/stdpar_csvm.cpp b/tests/backends/stdpar/AdaptiveCpp/stdpar_csvm.cpp
index 160528862..2efb2c1d7 100644
--- a/tests/backends/stdpar/AdaptiveCpp/stdpar_csvm.cpp
+++ b/tests/backends/stdpar/AdaptiveCpp/stdpar_csvm.cpp
@@ -27,30 +27,30 @@ using stdpar_csvm_types_list = std::tuple<plssvm::stdpar::csvc, plssvm::stdpar::
 using stdpar_csvm_types_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<stdpar_csvm_types_list>>;
 
 template <typename T>
-class adaptivecpp_stdparCSVMConstructor : public ::testing::Test,
-                                          private util::redirect_output<> {
+class AdaptiveCppStdparCSVMConstructor : public ::testing::Test,
+                                         private util::redirect_output<> {
   protected:
     using fixture_csvm_type = util::test_parameter_type_at_t<0, T>;
 };
 
-TYPED_TEST_SUITE(adaptivecpp_stdparCSVMConstructor, stdpar_csvm_types_gtest, naming::test_parameter_to_name);
+TYPED_TEST_SUITE(AdaptiveCppStdparCSVMConstructor, stdpar_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(adaptivecpp_stdparCSVMConstructor, default_construct) {
+TYPED_TEST(AdaptiveCppStdparCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // default constructor must always work
     EXPECT_NO_THROW(csvm_type{});
 }
 
-TYPED_TEST(adaptivecpp_stdparCSVMConstructor, construct_parameter) {
+TYPED_TEST(AdaptiveCppStdparCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // the automatic target platform must always be available
     EXPECT_NO_THROW(csvm_type{ plssvm::parameter{} });
 }
 
-TYPED_TEST(adaptivecpp_stdparCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(AdaptiveCppStdparCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -87,7 +87,7 @@ TYPED_TEST(adaptivecpp_stdparCSVMConstructor, construct_target_and_parameter) {
 #endif
 }
 
-TYPED_TEST(adaptivecpp_stdparCSVMConstructor, construct_named_args) {
+TYPED_TEST(AdaptiveCppStdparCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // every target is allowed for the stdpar backend using AdaptiveCpp as implementation
@@ -95,7 +95,7 @@ TYPED_TEST(adaptivecpp_stdparCSVMConstructor, construct_named_args) {
     EXPECT_NO_THROW((csvm_type{ plssvm::cost = 2.0 }));
 }
 
-TYPED_TEST(adaptivecpp_stdparCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(AdaptiveCppStdparCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 // every target is allowed for the stdpar backend using AdaptiveCpp as implementation
diff --git a/tests/backends/stdpar/CMakeLists.txt b/tests/backends/stdpar/CMakeLists.txt
index 3998d63ae..a182c9095 100644
--- a/tests/backends/stdpar/CMakeLists.txt
+++ b/tests/backends/stdpar/CMakeLists.txt
@@ -31,6 +31,14 @@ elseif (PLSSVM_STDPAR_BACKEND STREQUAL "IntelLLVM")
     list(APPEND PLSSVM_STDPAR_TEST_SOURCES ${CMAKE_CURRENT_LIST_DIR}/IntelLLVM/stdpar_csvm.cpp)
 elseif (PLSSVM_STDPAR_BACKEND STREQUAL "ACPP")
     list(APPEND PLSSVM_STDPAR_TEST_SOURCES ${CMAKE_CURRENT_LIST_DIR}/AdaptiveCpp/stdpar_csvm.cpp)
+    if ("${PLSSVM_TARGET_PLATFORMS}" MATCHES "(nvidia|amd|intel)" AND PLSSVM_STDPAR_BACKEND_ACPP_USE_GENERIC_SSCP)
+        message(
+            WARNING
+                "AdaptiveCpp stdpar tests running on a target platform other than CPU using AdaptiveCpp's SSCP compiler may result in SegFaults during test discovery. "
+                "Note that normal execution works perfectly fine. "
+                "To run the tests, either use the CPU or the old legacy AdaptiveCpp compiler by setting \"-DPLSSVM_STDPAR_BACKEND_ACPP_USE_GENERIC_SSCP=OFF\"."
+        )
+    endif ()
 elseif (PLSSVM_STDPAR_BACKEND STREQUAL "GNU_TBB")
     list(APPEND PLSSVM_STDPAR_TEST_SOURCES ${CMAKE_CURRENT_LIST_DIR}/GNU_TBB/stdpar_csvm.cpp)
 endif ()
@@ -47,20 +55,20 @@ include(${PROJECT_SOURCE_DIR}/cmake/discover_tests_with_death_test_filter.cmake)
 discover_tests_with_death_test_filter(${PLSSVM_STDPAR_TEST_NAME})
 
 # add minimal run test for the classification task with the stdpar backend
-add_test(NAME MainTrainClassificationStdpar/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b stdpar "${PLSSVM_CLASSIFICATION_TEST_FILE}"
-                                                                       "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
+add_test(NAME MainTrainClassificationStdpar/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 0 -b stdpar "${PLSSVM_CLASSIFICATION_TEST_FILE}"
+                                                                      "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.model"
 )
-add_test(NAME MainPredictClassificationStdpar/executable_minimal
+add_test(NAME MainPredictClassificationStdpar/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b stdpar "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/classification/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/classification/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_classification.libsvm.predict" # predict file (result)
 )
 
 # add minimal run test for the regression task with the stdpar backend
-add_test(NAME MainTrainRegressionStdpar/executable_minimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b stdpar "${PLSSVM_REGRESSION_TEST_FILE}"
-                                                                   "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
+add_test(NAME MainTrainRegressionStdpar/ExecutableMinimal COMMAND ${PLSSVM_EXECUTABLE_TRAIN_NAME} -s 1 -b stdpar "${PLSSVM_REGRESSION_TEST_FILE}"
+                                                                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.model"
 )
-add_test(NAME MainPredictRegressionStdpar/executable_minimal
+add_test(NAME MainPredictRegressionStdpar/ExecutableMinimal
          COMMAND ${PLSSVM_EXECUTABLE_PREDICT_NAME} -b stdpar "${CMAKE_CURRENT_LIST_DIR}/../../data/libsvm/regression/5x4.libsvm" # test file
                  "${CMAKE_CURRENT_LIST_DIR}/../../data/model/regression/5x4.libsvm.model" # model file
                  "${CMAKE_CURRENT_BINARY_DIR}/test_regression.libsvm.predict" # predict file (result)
diff --git a/tests/backends/stdpar/GNU_TBB/stdpar_csvm.cpp b/tests/backends/stdpar/GNU_TBB/stdpar_csvm.cpp
index 179001a1b..48661f51f 100644
--- a/tests/backends/stdpar/GNU_TBB/stdpar_csvm.cpp
+++ b/tests/backends/stdpar/GNU_TBB/stdpar_csvm.cpp
@@ -27,16 +27,16 @@ using stdpar_csvm_types_list = std::tuple<plssvm::stdpar::csvc, plssvm::stdpar::
 using stdpar_csvm_types_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<stdpar_csvm_types_list>>;
 
 template <typename T>
-class gnu_tbb_stdparCSVMConstructor : public ::testing::Test,
-                                      private util::redirect_output<> {
+class GnuTbbStdparCSVMConstructor : public ::testing::Test,
+                                    private util::redirect_output<> {
   protected:
     using fixture_csvm_type = util::test_parameter_type_at_t<0, T>;
 };
 
-TYPED_TEST_SUITE(gnu_tbb_stdparCSVMConstructor, stdpar_csvm_types_gtest, naming::test_parameter_to_name);
+TYPED_TEST_SUITE(GnuTbbStdparCSVMConstructor, stdpar_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(gnu_tbb_stdparCSVMConstructor, default_construct) {
+TYPED_TEST(GnuTbbStdparCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -49,7 +49,7 @@ TYPED_TEST(gnu_tbb_stdparCSVMConstructor, default_construct) {
 #endif
 }
 
-TYPED_TEST(gnu_tbb_stdparCSVMConstructor, construct_parameter) {
+TYPED_TEST(GnuTbbStdparCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -62,7 +62,7 @@ TYPED_TEST(gnu_tbb_stdparCSVMConstructor, construct_parameter) {
 #endif
 }
 
-TYPED_TEST(gnu_tbb_stdparCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(GnuTbbStdparCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -93,7 +93,7 @@ TYPED_TEST(gnu_tbb_stdparCSVMConstructor, construct_target_and_parameter) {
                       "Invalid target platform 'gpu_intel' for the gnu_tbb stdpar backend!");
 }
 
-TYPED_TEST(gnu_tbb_stdparCSVMConstructor, construct_named_args) {
+TYPED_TEST(GnuTbbStdparCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
@@ -110,7 +110,7 @@ TYPED_TEST(gnu_tbb_stdparCSVMConstructor, construct_named_args) {
 #endif
 }
 
-TYPED_TEST(gnu_tbb_stdparCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(GnuTbbStdparCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
diff --git a/tests/backends/stdpar/IntelLLVM/stdpar_csvm.cpp b/tests/backends/stdpar/IntelLLVM/stdpar_csvm.cpp
index 1560462dc..db6d98e81 100644
--- a/tests/backends/stdpar/IntelLLVM/stdpar_csvm.cpp
+++ b/tests/backends/stdpar/IntelLLVM/stdpar_csvm.cpp
@@ -27,30 +27,30 @@ using stdpar_csvm_types_list = std::tuple<plssvm::stdpar::csvc, plssvm::stdpar::
 using stdpar_csvm_types_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<stdpar_csvm_types_list>>;
 
 template <typename T>
-class intel_llvm_stdparCSVMConstructor : public ::testing::Test,
-                                         private util::redirect_output<> {
+class IntelLLVMStdparCSVMConstructor : public ::testing::Test,
+                                       private util::redirect_output<> {
   protected:
     using fixture_csvm_type = util::test_parameter_type_at_t<0, T>;
 };
 
-TYPED_TEST_SUITE(intel_llvm_stdparCSVMConstructor, stdpar_csvm_types_gtest, naming::test_parameter_to_name);
+TYPED_TEST_SUITE(IntelLLVMStdparCSVMConstructor, stdpar_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(intel_llvm_stdparCSVMConstructor, default_construct) {
+TYPED_TEST(IntelLLVMStdparCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // default constructor must always work
     EXPECT_NO_THROW(csvm_type{});
 }
 
-TYPED_TEST(intel_llvm_stdparCSVMConstructor, construct_parameter) {
+TYPED_TEST(IntelLLVMStdparCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // the automatic target platform must always be available
     EXPECT_NO_THROW(csvm_type{ plssvm::parameter{} });
 }
 
-TYPED_TEST(intel_llvm_stdparCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(IntelLLVMStdparCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -87,7 +87,7 @@ TYPED_TEST(intel_llvm_stdparCSVMConstructor, construct_target_and_parameter) {
 #endif
 }
 
-TYPED_TEST(intel_llvm_stdparCSVMConstructor, construct_named_args) {
+TYPED_TEST(IntelLLVMStdparCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // every target is allowed for the stdpar backend using Intel LLVM as implementation
@@ -95,7 +95,7 @@ TYPED_TEST(intel_llvm_stdparCSVMConstructor, construct_named_args) {
     EXPECT_NO_THROW((csvm_type{ plssvm::cost = 2.0 }));
 }
 
-TYPED_TEST(intel_llvm_stdparCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(IntelLLVMStdparCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 // every target is allowed for the stdpar backend using Intel LLVM as implementation
diff --git a/tests/backends/stdpar/NVHPC/stdpar_csvm.cpp b/tests/backends/stdpar/NVHPC/stdpar_csvm.cpp
index 03ce37f24..32a7a1c16 100644
--- a/tests/backends/stdpar/NVHPC/stdpar_csvm.cpp
+++ b/tests/backends/stdpar/NVHPC/stdpar_csvm.cpp
@@ -19,7 +19,7 @@
 #include "tests/types_to_test.hpp"       // util::{cartesian_type_product_t, test_parameter_type_at_t}
 #include "tests/utility.hpp"             // util::redirect_output
 
-#include "fmt/format.h"   // fmt::format
+#include "fmt/format.h"   // NOLINT: fmt::format
 #include "gtest/gtest.h"  // TYPED_TEST, TYPED_TEST_SUITE, EXPECT_NO_THROW, ::testing::Test
 
 #include <tuple>  // std::tuple
@@ -28,16 +28,16 @@ using stdpar_csvm_types_list = std::tuple<plssvm::stdpar::csvc, plssvm::stdpar::
 using stdpar_csvm_types_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<stdpar_csvm_types_list>>;
 
 template <typename T>
-class nvhpc_stdparCSVMConstructor : public ::testing::Test,
-                                    private util::redirect_output<> {
+class NVHPCStdparCSVMConstructor : public ::testing::Test,
+                                   private util::redirect_output<> {
   protected:
     using fixture_csvm_type = util::test_parameter_type_at_t<0, T>;
 };
 
-TYPED_TEST_SUITE(nvhpc_stdparCSVMConstructor, stdpar_csvm_types_gtest, naming::test_parameter_to_name);
+TYPED_TEST_SUITE(NVHPCStdparCSVMConstructor, stdpar_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(nvhpc_stdparCSVMConstructor, default_construct) {
+TYPED_TEST(NVHPCStdparCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET) || defined(PLSSVM_HAS_NVIDIA_TARGET)
@@ -50,7 +50,7 @@ TYPED_TEST(nvhpc_stdparCSVMConstructor, default_construct) {
 #endif
 }
 
-TYPED_TEST(nvhpc_stdparCSVMConstructor, construct_parameter) {
+TYPED_TEST(NVHPCStdparCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET) || defined(PLSSVM_HAS_NVIDIA_TARGET)
@@ -63,7 +63,7 @@ TYPED_TEST(nvhpc_stdparCSVMConstructor, construct_parameter) {
 #endif
 }
 
-TYPED_TEST(nvhpc_stdparCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(NVHPCStdparCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -93,7 +93,7 @@ TYPED_TEST(nvhpc_stdparCSVMConstructor, construct_target_and_parameter) {
                       "Invalid target platform 'gpu_intel' for the nvhpc stdpar backend!");
 }
 
-TYPED_TEST(nvhpc_stdparCSVMConstructor, construct_named_args) {
+TYPED_TEST(NVHPCStdparCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET) || defined(PLSSVM_HAS_NVIDIA_TARGET)
@@ -109,7 +109,7 @@ TYPED_TEST(nvhpc_stdparCSVMConstructor, construct_named_args) {
 #endif
 }
 
-TYPED_TEST(nvhpc_stdparCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(NVHPCStdparCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_CPU_TARGET)
diff --git a/tests/backends/stdpar/detail/utility.cpp b/tests/backends/stdpar/detail/utility.cpp
index 4de0a0d59..9cb5a599b 100644
--- a/tests/backends/stdpar/detail/utility.cpp
+++ b/tests/backends/stdpar/detail/utility.cpp
@@ -12,10 +12,6 @@
 
 #include "gtest/gtest.h"  // TEST, EXPECT_NE
 
-TEST(stdparUtility, get_stdpar_implementation) {
-#if defined(PLSSVM_STDPAR_BACKEND_HAS_HIPSTDPAR)
-    EXPECT_EQ(plssvm::stdpar::detail::get_stdpar_version(), "unknown");
-#else
+TEST(stdparUtility, GetStdparImplementation) {
     EXPECT_NE(plssvm::stdpar::detail::get_stdpar_version(), "unknown");
-#endif
 }
diff --git a/tests/backends/stdpar/implementation_types.cpp b/tests/backends/stdpar/implementation_types.cpp
index b8fcf1268..61859695e 100644
--- a/tests/backends/stdpar/implementation_types.cpp
+++ b/tests/backends/stdpar/implementation_types.cpp
@@ -18,7 +18,7 @@
 #include <vector>   // std::vector
 
 // check whether the plssvm::stdpar::implementation_type -> std::string conversions are correct
-TEST(stdparImplementationType, to_string) {
+TEST(stdparImplementationType, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::stdpar::implementation_type::nvhpc, "nvhpc");
     EXPECT_CONVERSION_TO_STRING(plssvm::stdpar::implementation_type::roc_stdpar, "roc-stdpar");
@@ -27,13 +27,13 @@ TEST(stdparImplementationType, to_string) {
     EXPECT_CONVERSION_TO_STRING(plssvm::stdpar::implementation_type::gnu_tbb, "gnu_tbb");
 }
 
-TEST(stdparImplementationType, to_string_unknown) {
+TEST(stdparImplementationType, ToStringUnknown) {
     // check conversions to std::string from unknown implementation_type
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::stdpar::implementation_type>(5), "unknown");
 }
 
 // check whether the std::string -> plssvm::stdpar::implementation_type conversions are correct
-TEST(stdparImplementationType, from_string) {
+TEST(stdparImplementationType, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("NVHPC", plssvm::stdpar::implementation_type::nvhpc);
     EXPECT_CONVERSION_FROM_STRING("nvcpp", plssvm::stdpar::implementation_type::nvhpc);
@@ -60,7 +60,7 @@ TEST(stdparImplementationType, from_string) {
     EXPECT_CONVERSION_FROM_STRING("g++", plssvm::stdpar::implementation_type::gnu_tbb);
 }
 
-TEST(stdparImplementationType, from_string_unknown) {
+TEST(stdparImplementationType, FromStringUnknown) {
     // foo isn't a valid implementation_type
     std::istringstream input{ "foo" };
     plssvm::stdpar::implementation_type impl{};
@@ -68,7 +68,7 @@ TEST(stdparImplementationType, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(stdparImplementationType, minimal_available_stdpar_implementation_type) {
+TEST(stdparImplementationType, MinimalAvailableStdparImplementationType) {
     const std::vector<plssvm::stdpar::implementation_type> implementation_type = plssvm::stdpar::list_available_stdpar_implementations();
 
 #if defined(PLSSVM_HAS_STDPAR_BACKEND)
diff --git a/tests/backends/stdpar/mock_stdpar_csvm.hpp b/tests/backends/stdpar/mock_stdpar_csvm.hpp
index 906a8ea2a..fa8c7710c 100644
--- a/tests/backends/stdpar/mock_stdpar_csvm.hpp
+++ b/tests/backends/stdpar/mock_stdpar_csvm.hpp
@@ -9,8 +9,8 @@
  * @brief MOCK class for the C-SVM class using the stdpar backend.
  */
 
-#ifndef PLSSVM_TESTS_BACKENDS_STDPAR_MOCK_OPENMP_CSVM_HPP_
-#define PLSSVM_TESTS_BACKENDS_STDPAR_MOCK_OPENMP_CSVM_HPP_
+#ifndef PLSSVM_TESTS_BACKENDS_STDPAR_MOCK_STDPAR_CSVM_HPP_
+#define PLSSVM_TESTS_BACKENDS_STDPAR_MOCK_STDPAR_CSVM_HPP_
 #pragma once
 
 #include "plssvm/backends/stdpar/csvm.hpp"  // plssvm::stdpar::csvm
@@ -33,6 +33,7 @@ class mock_stdpar_csvm final : public plssvm::stdpar::csvm {
     using base_type::assemble_kernel_matrix;
     using base_type::blas_level_3;
     using base_type::get_device_memory;
+    using base_type::get_local_memory;
     using base_type::num_available_devices;
 
     using base_type::predict_values;
@@ -47,4 +48,4 @@ class mock_stdpar_csvm final : public plssvm::stdpar::csvm {
     using base_type::data_distribution_;
 };
 
-#endif  // PLSSVM_TESTS_BACKENDS_STDPAR_MOCK_OPENMP_CSVM_HPP_
+#endif  // PLSSVM_TESTS_BACKENDS_STDPAR_MOCK_STDPAR_CSVM_HPP_
diff --git a/tests/backends/stdpar/roc-stdpar/stdpar_csvm.cpp b/tests/backends/stdpar/roc-stdpar/stdpar_csvm.cpp
index 639712fc1..4bb9d4751 100644
--- a/tests/backends/stdpar/roc-stdpar/stdpar_csvm.cpp
+++ b/tests/backends/stdpar/roc-stdpar/stdpar_csvm.cpp
@@ -27,16 +27,16 @@ using stdpar_csvm_types_list = std::tuple<plssvm::stdpar::csvc, plssvm::stdpar::
 using stdpar_csvm_types_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<stdpar_csvm_types_list>>;
 
 template <typename T>
-class roc_stdpar_stdparCSVMConstructor : public ::testing::Test,
-                                         private util::redirect_output<> {
+class RocStdparStdparCSVMConstructor : public ::testing::Test,
+                                       private util::redirect_output<> {
   protected:
     using fixture_csvm_type = util::test_parameter_type_at_t<0, T>;
 };
 
-TYPED_TEST_SUITE(roc_stdpar_stdparCSVMConstructor, stdpar_csvm_types_gtest, naming::test_parameter_to_name);
+TYPED_TEST_SUITE(RocStdparStdparCSVMConstructor, stdpar_csvm_types_gtest, naming::test_parameter_to_name);
 
 // check whether the constructor correctly fails when using an incompatible target platform
-TYPED_TEST(roc_stdpar_stdparCSVMConstructor, default_construct) {
+TYPED_TEST(RocStdparStdparCSVMConstructor, DefaultConstruct) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_AMD_TARGET)
@@ -49,7 +49,7 @@ TYPED_TEST(roc_stdpar_stdparCSVMConstructor, default_construct) {
 #endif
 }
 
-TYPED_TEST(roc_stdpar_stdparCSVMConstructor, construct_parameter) {
+TYPED_TEST(RocStdparStdparCSVMConstructor, ConstructParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
 #if defined(PLSSVM_HAS_AMD_TARGET)
@@ -62,7 +62,7 @@ TYPED_TEST(roc_stdpar_stdparCSVMConstructor, construct_parameter) {
 #endif
 }
 
-TYPED_TEST(roc_stdpar_stdparCSVMConstructor, construct_target_and_parameter) {
+TYPED_TEST(RocStdparStdparCSVMConstructor, ConstructTargetAndParameter) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
     // create parameter struct
@@ -93,10 +93,10 @@ TYPED_TEST(roc_stdpar_stdparCSVMConstructor, construct_target_and_parameter) {
                       "Invalid target platform 'gpu_intel' for the roc-stdpar stdpar backend!");
 }
 
-TYPED_TEST(roc_stdpar_stdparCSVMConstructor, construct_named_args) {
+TYPED_TEST(RocStdparStdparCSVMConstructor, ConstructNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
-#if defined(PLSSVM_HAS_CPU_TARGET)
+#if defined(PLSSVM_HAS_AMD_TARGET)
     // only automatic or AMD GPU are allowed as target platform for the stdpar backend using roc-stdpar
     EXPECT_NO_THROW((csvm_type{ plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::cost = 2.0 }));
@@ -110,10 +110,10 @@ TYPED_TEST(roc_stdpar_stdparCSVMConstructor, construct_named_args) {
 #endif
 }
 
-TYPED_TEST(roc_stdpar_stdparCSVMConstructor, construct_target_and_named_args) {
+TYPED_TEST(RocStdparStdparCSVMConstructor, ConstructTargetAndNamedArgs) {
     using csvm_type = typename TestFixture::fixture_csvm_type;
 
-#if defined(PLSSVM_HAS_CPU_TARGET)
+#if defined(PLSSVM_HAS_AMD_TARGET)
     // only automatic or AMD GPU are allowed as target platform for the stdpar backend using roc-stdpar
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::automatic, plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 }));
     EXPECT_NO_THROW((csvm_type{ plssvm::target_platform::gpu_amd, plssvm::cost = 2.0 }));
diff --git a/tests/backends/stdpar/stdpar_csvm.cpp b/tests/backends/stdpar/stdpar_csvm.cpp
index 83c881229..4d8e8c899 100644
--- a/tests/backends/stdpar/stdpar_csvm.cpp
+++ b/tests/backends/stdpar/stdpar_csvm.cpp
@@ -10,39 +10,27 @@
 
 #include "plssvm/backend_types.hpp"                                                   // plssvm::csvm_to_backend_type_v
 #include "plssvm/backends/stdpar/csvm.hpp"                                            // plssvm::stdpar::{csvm, csvc, csvr}
-#include "plssvm/backends/stdpar/exceptions.hpp"                                      // plssvm::stdpar::backend_exception
 #include "plssvm/backends/stdpar/kernel/cg_explicit/blas.hpp"                         // plssvm::stdpar::{device_kernel_symm, device_ce_kernel_symm_mirror}
 #include "plssvm/backends/stdpar/kernel/cg_explicit/kernel_matrix_assembly.hpp"       // plssvm::stdpar::device_kernel_assembly
 #include "plssvm/backends/stdpar/kernel/cg_implicit/kernel_matrix_assembly_blas.hpp"  // plssvm::stdpar::device_kernel_assembly_symm
 #include "plssvm/backends/stdpar/kernel/predict_kernel.hpp"                           // plssvm::stdpar::{device_kernel_w_linear, device_kernel_predict_linear, device_kernel_predict}
-#include "plssvm/constants.hpp"                                                       // plssvm::PADDING_SIZE
-#include "plssvm/data_set/classification_data_set.hpp"                                // plssvm::classification_data_set
-#include "plssvm/detail/arithmetic_type_name.hpp"                                     // plssvm::detail::arithmetic_type_name
-#include "plssvm/detail/data_distribution.hpp"                                        // plssvm::detail::triangular_data_distribution
-#include "plssvm/detail/type_list.hpp"                                                // plssvm::detail::supported_label_types
+#include "plssvm/constants.hpp"                                                       // plssvm::real_type
 #include "plssvm/kernel_function_types.hpp"                                           // plssvm::kernel_function_type
-#include "plssvm/matrix.hpp"                                                          // plssvm::soa_matrix
-#include "plssvm/parameter.hpp"                                                       // plssvm::parameter, plssvm::detail::parameter, plssvm::kernel_type, plssvm::cost
-#include "plssvm/shape.hpp"                                                           // plssvm::shape
+#include "plssvm/matrix.hpp"                                                          // plssvm::soa_matrix. plssvm::aos_matrix
 #include "plssvm/target_platforms.hpp"                                                // plssvm::target_platform
 
 #include "tests/backends/generic_base_csvc_tests.hpp"  // generic C-SVC tests to instantiate
 #include "tests/backends/generic_base_csvm_tests.hpp"  // generic C-SVM tests to instantiate
 #include "tests/backends/generic_base_csvr_tests.hpp"  // generic C-SVR tests to instantiate
-#include "tests/backends/ground_truth.hpp"             // ground_truth::{perform_dimensional_reduction, assemble_device_specific_kernel_matrix, assemble_full_kernel_matrix, gemm, calculate_w}
 #include "tests/backends/stdpar/mock_stdpar_csvm.hpp"  // mock_stdpar_csvm
-#include "tests/custom_test_macros.hpp"                // EXPECT_THROW_WHAT
 #include "tests/naming.hpp"                            // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"                     // util::{cartesian_type_product_t, combine_test_parameters_gtest_t}
-#include "tests/utility.hpp"                           // util::redirect_output
 
-#include "fmt/format.h"   // fmt::format
 #include "gtest/gtest.h"  // TEST_F, EXPECT_NO_THROW, INSTANTIATE_TYPED_TEST_SUITE_P, ::testing::Test
 
-#include <algorithm>  // std::min
-#include <cstddef>    // std::size_t
-#include <tuple>      // std::make_tuple, std::tuple
-#include <vector>     // std::vector
+#include <cstddef>  // std::size_t
+#include <tuple>    // std::make_tuple, std::tuple
+#include <vector>   // std::vector
 
 struct stdpar_csvm_test_type {
     using mock_csvm_type = mock_stdpar_csvm;
@@ -50,7 +38,7 @@ struct stdpar_csvm_test_type {
     using csvc_type = plssvm::stdpar::csvc;
     using csvr_type = plssvm::stdpar::csvr;
     using device_ptr_type = const plssvm::soa_matrix<plssvm::real_type> *;
-    inline constexpr static auto additional_arguments = std::make_tuple();
+    constexpr static auto additional_arguments = std::make_tuple();
 };
 
 // a tuple containing the test structs
@@ -93,14 +81,154 @@ INSTANTIATE_TYPED_TEST_SUITE_P(stdparCSVMDeathTest, GenericCSVMSolverDeathTest,
 INSTANTIATE_TYPED_TEST_SUITE_P(stdparCSVMDeathTest, GenericCSVMKernelFunctionDeathTest, stdpar_kernel_function_type_gtest, naming::test_parameter_to_name);
 INSTANTIATE_TYPED_TEST_SUITE_P(stdparCSVMDeathTest, GenericCSVMSolverKernelFunctionDeathTest, stdpar_solver_and_kernel_function_type_gtest, naming::test_parameter_to_name);
 
+namespace {
+
 // define the exact functions to be used in the generic header
-using plssvm::stdpar::detail::device_kernel_assembly;
-using plssvm::stdpar::detail::device_kernel_assembly_symm;
-using plssvm::stdpar::detail::device_kernel_predict;
-using plssvm::stdpar::detail::device_kernel_predict_linear;
-using plssvm::stdpar::detail::device_kernel_symm;
-using plssvm::stdpar::detail::device_kernel_symm_mirror;
-using plssvm::stdpar::detail::device_kernel_w_linear;
+template <plssvm::kernel_function_type kernel_function, typename... Args>
+void device_kernel_assembly(plssvm::real_type *kernel_matrix, const plssvm::soa_matrix<plssvm::real_type> &data, const std::size_t device_num_rows, const std::size_t device_row_offset, const std::vector<plssvm::real_type> &q, const plssvm::real_type QA_cost, const plssvm::real_type cost, Args... kernel_function_parameter) {
+    switch (plssvm::determine_default_target_platform()) {
+        case plssvm::target_platform::automatic:
+            // may never be reached
+            break;
+        case plssvm::target_platform::gpu_nvidia:
+            plssvm::stdpar::detail::device_kernel_assembly<plssvm::target_platform::gpu_nvidia, kernel_function, Args...>{}(kernel_matrix, data, device_num_rows, device_row_offset, q, QA_cost, cost, kernel_function_parameter...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            plssvm::stdpar::detail::device_kernel_assembly<plssvm::target_platform::gpu_amd, kernel_function, Args...>{}(kernel_matrix, data, device_num_rows, device_row_offset, q, QA_cost, cost, kernel_function_parameter...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            plssvm::stdpar::detail::device_kernel_assembly<plssvm::target_platform::gpu_intel, kernel_function, Args...>{}(kernel_matrix, data, device_num_rows, device_row_offset, q, QA_cost, cost, kernel_function_parameter...);
+            break;
+        case plssvm::target_platform::cpu:
+            plssvm::stdpar::detail::device_kernel_assembly<plssvm::target_platform::cpu, kernel_function, Args...>{}(kernel_matrix, data, device_num_rows, device_row_offset, q, QA_cost, cost, kernel_function_parameter...);
+            break;
+    }
+}
+
+void device_kernel_symm(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t device_num_rows, const std::size_t device_row_offset, const plssvm::real_type alpha, const plssvm::real_type *A, const plssvm::soa_matrix<plssvm::real_type> &B, const plssvm::real_type beta, plssvm::soa_matrix<plssvm::real_type> &C) {
+    switch (plssvm::determine_default_target_platform()) {
+        case plssvm::target_platform::automatic:
+            // may never be reached
+            break;
+        case plssvm::target_platform::gpu_nvidia:
+            plssvm::stdpar::detail::device_kernel_symm<plssvm::target_platform::gpu_nvidia>{}(num_rows, num_rhs, device_num_rows, device_row_offset, alpha, A, B, beta, C);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            plssvm::stdpar::detail::device_kernel_symm<plssvm::target_platform::gpu_amd>{}(num_rows, num_rhs, device_num_rows, device_row_offset, alpha, A, B, beta, C);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            plssvm::stdpar::detail::device_kernel_symm<plssvm::target_platform::gpu_intel>{}(num_rows, num_rhs, device_num_rows, device_row_offset, alpha, A, B, beta, C);
+            break;
+        case plssvm::target_platform::cpu:
+            plssvm::stdpar::detail::device_kernel_symm<plssvm::target_platform::cpu>{}(num_rows, num_rhs, device_num_rows, device_row_offset, alpha, A, B, beta, C);
+            break;
+    }
+}
+
+void device_kernel_symm_mirror(const std::size_t num_rows, const std::size_t num_rhs, const std::size_t num_mirror_rows, const std::size_t device_num_rows, const std::size_t device_row_offset, const plssvm::real_type alpha, const plssvm::real_type *A, const plssvm::soa_matrix<plssvm::real_type> &B, const plssvm::real_type beta, plssvm::soa_matrix<plssvm::real_type> &C) {
+    switch (plssvm::determine_default_target_platform()) {
+        case plssvm::target_platform::automatic:
+            // may never be reached
+            break;
+        case plssvm::target_platform::gpu_nvidia:
+            plssvm::stdpar::detail::device_kernel_symm_mirror<plssvm::target_platform::gpu_nvidia>{}(num_rows, num_rhs, num_mirror_rows, device_num_rows, device_row_offset, alpha, A, B, beta, C);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            plssvm::stdpar::detail::device_kernel_symm_mirror<plssvm::target_platform::gpu_amd>{}(num_rows, num_rhs, num_mirror_rows, device_num_rows, device_row_offset, alpha, A, B, beta, C);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            plssvm::stdpar::detail::device_kernel_symm_mirror<plssvm::target_platform::gpu_intel>{}(num_rows, num_rhs, num_mirror_rows, device_num_rows, device_row_offset, alpha, A, B, beta, C);
+            break;
+        case plssvm::target_platform::cpu:
+            plssvm::stdpar::detail::device_kernel_symm_mirror<plssvm::target_platform::cpu>{}(num_rows, num_rhs, num_mirror_rows, device_num_rows, device_row_offset, alpha, A, B, beta, C);
+            break;
+    }
+}
+
+template <plssvm::kernel_function_type kernel_function, typename... Args>
+void device_kernel_assembly_symm(const plssvm::real_type alpha, const std::vector<plssvm::real_type> &q, const plssvm::soa_matrix<plssvm::real_type> &data, const std::size_t device_num_rows, const std::size_t device_row_offset, const plssvm::real_type QA_cost, const plssvm::real_type cost, const plssvm::soa_matrix<plssvm::real_type> &B, plssvm::soa_matrix<plssvm::real_type> &C, Args... kernel_function_parameter) {
+    switch (plssvm::determine_default_target_platform()) {
+        case plssvm::target_platform::automatic:
+            // may never be reached
+            break;
+        case plssvm::target_platform::gpu_nvidia:
+            plssvm::stdpar::detail::device_kernel_assembly_symm<plssvm::target_platform::gpu_nvidia, kernel_function, Args...>{}(alpha, q, data, device_num_rows, device_row_offset, QA_cost, cost, B, C, kernel_function_parameter...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            plssvm::stdpar::detail::device_kernel_assembly_symm<plssvm::target_platform::gpu_amd, kernel_function, Args...>{}(alpha, q, data, device_num_rows, device_row_offset, QA_cost, cost, B, C, kernel_function_parameter...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            plssvm::stdpar::detail::device_kernel_assembly_symm<plssvm::target_platform::gpu_intel, kernel_function, Args...>{}(alpha, q, data, device_num_rows, device_row_offset, QA_cost, cost, B, C, kernel_function_parameter...);
+            break;
+        case plssvm::target_platform::cpu:
+            plssvm::stdpar::detail::device_kernel_assembly_symm<plssvm::target_platform::cpu, kernel_function, Args...>{}(alpha, q, data, device_num_rows, device_row_offset, QA_cost, cost, B, C, kernel_function_parameter...);
+            break;
+    }
+}
+
+void device_kernel_w_linear(plssvm::soa_matrix<plssvm::real_type> &w, const plssvm::aos_matrix<plssvm::real_type> &alpha, const plssvm::soa_matrix<plssvm::real_type> &support_vectors, const std::size_t device_num_sv, const std::size_t device_sv_offset) {
+    switch (plssvm::determine_default_target_platform()) {
+        case plssvm::target_platform::automatic:
+            // may never be reached
+            break;
+        case plssvm::target_platform::gpu_nvidia:
+            plssvm::stdpar::detail::device_kernel_w_linear<plssvm::target_platform::gpu_nvidia>{}(w, alpha, support_vectors, device_num_sv, device_sv_offset);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            plssvm::stdpar::detail::device_kernel_w_linear<plssvm::target_platform::gpu_amd>{}(w, alpha, support_vectors, device_num_sv, device_sv_offset);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            plssvm::stdpar::detail::device_kernel_w_linear<plssvm::target_platform::gpu_intel>{}(w, alpha, support_vectors, device_num_sv, device_sv_offset);
+            break;
+        case plssvm::target_platform::cpu:
+            plssvm::stdpar::detail::device_kernel_w_linear<plssvm::target_platform::cpu>{}(w, alpha, support_vectors, device_num_sv, device_sv_offset);
+            break;
+    }
+}
+
+void device_kernel_predict_linear(plssvm::aos_matrix<plssvm::real_type> &prediction, const plssvm::soa_matrix<plssvm::real_type> &w, const std::vector<plssvm::real_type> &rho, const plssvm::soa_matrix<plssvm::real_type> &predict_points, const std::size_t device_num_predict_points, const std::size_t device_row_offset) {
+    switch (plssvm::determine_default_target_platform()) {
+        case plssvm::target_platform::automatic:
+            // may never be reached
+            break;
+        case plssvm::target_platform::gpu_nvidia:
+            plssvm::stdpar::detail::device_kernel_predict_linear<plssvm::target_platform::gpu_nvidia>{}(prediction, w, rho, predict_points, device_num_predict_points, device_row_offset);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            plssvm::stdpar::detail::device_kernel_predict_linear<plssvm::target_platform::gpu_amd>{}(prediction, w, rho, predict_points, device_num_predict_points, device_row_offset);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            plssvm::stdpar::detail::device_kernel_predict_linear<plssvm::target_platform::gpu_intel>{}(prediction, w, rho, predict_points, device_num_predict_points, device_row_offset);
+            break;
+        case plssvm::target_platform::cpu:
+            plssvm::stdpar::detail::device_kernel_predict_linear<plssvm::target_platform::cpu>{}(prediction, w, rho, predict_points, device_num_predict_points, device_row_offset);
+            break;
+    }
+}
+
+template <plssvm::kernel_function_type kernel_function, typename... Args>
+void device_kernel_predict(plssvm::aos_matrix<plssvm::real_type> &prediction, const plssvm::aos_matrix<plssvm::real_type> &alpha, const std::vector<plssvm::real_type> &rho, const plssvm::soa_matrix<plssvm::real_type> &support_vectors, const plssvm::soa_matrix<plssvm::real_type> &predict_points, const std::size_t device_num_predict_points, const std::size_t device_row_offset, Args... kernel_function_parameter) {
+    switch (plssvm::determine_default_target_platform()) {
+        case plssvm::target_platform::automatic:
+            // may never be reached
+            break;
+        case plssvm::target_platform::gpu_nvidia:
+            plssvm::stdpar::detail::device_kernel_predict<plssvm::target_platform::gpu_nvidia, kernel_function, Args...>{}(prediction, alpha, rho, support_vectors, predict_points, device_num_predict_points, device_row_offset, kernel_function_parameter...);
+            break;
+        case plssvm::target_platform::gpu_amd:
+            plssvm::stdpar::detail::device_kernel_predict<plssvm::target_platform::gpu_amd, kernel_function, Args...>{}(prediction, alpha, rho, support_vectors, predict_points, device_num_predict_points, device_row_offset, kernel_function_parameter...);
+            break;
+        case plssvm::target_platform::gpu_intel:
+            plssvm::stdpar::detail::device_kernel_predict<plssvm::target_platform::gpu_intel, kernel_function, Args...>{}(prediction, alpha, rho, support_vectors, predict_points, device_num_predict_points, device_row_offset, kernel_function_parameter...);
+            break;
+        case plssvm::target_platform::cpu:
+            plssvm::stdpar::detail::device_kernel_predict<plssvm::target_platform::cpu, kernel_function, Args...>{}(prediction, alpha, rho, support_vectors, predict_points, device_num_predict_points, device_row_offset, kernel_function_parameter...);
+            break;
+    }
+}
+
+}  // namespace
+
 #include "tests/backends/generic_csvm_tests.hpp"  // generic backend C-SVM tests to instantiate
 
 // generic non-GPU C-SVM tests
diff --git a/tests/classification_report.cpp b/tests/classification_report.cpp
index ff5c2afd7..614208d06 100644
--- a/tests/classification_report.cpp
+++ b/tests/classification_report.cpp
@@ -18,7 +18,6 @@
 
 #include "gtest/gtest.h"  // TEST, TEST_F, EXPECT_EQ, EXPECT_TRUE, EXPECT_FALSE, ::testing::Test
 
-#include <cmath>     // std::isnan
 #include <iostream>  // std::cout
 #include <sstream>   // std::istringstream
 #include <string>    // std::string
@@ -33,7 +32,7 @@ class ZeroDivisionBehavior : public ::testing::Test,
                              public util::redirect_output<&std::cout> { };
 
 // check whether the plssvm::classification_report::zero_division_behavior -> std::string conversions are correct
-TEST_F(ZeroDivisionBehavior, to_string) {
+TEST_F(ZeroDivisionBehavior, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::classification_report::zero_division_behavior::warn, "warn");
     EXPECT_CONVERSION_TO_STRING(plssvm::classification_report::zero_division_behavior::zero, "0.0");
@@ -41,13 +40,13 @@ TEST_F(ZeroDivisionBehavior, to_string) {
     EXPECT_CONVERSION_TO_STRING(plssvm::classification_report::zero_division_behavior::nan, "nan");
 }
 
-TEST_F(ZeroDivisionBehavior, to_string_unknown) {
+TEST_F(ZeroDivisionBehavior, ToStringUnknown) {
     // check conversions to std::string from unknown zero_division_behavior
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::classification_report::zero_division_behavior>(4), "unknown");
 }
 
 // check whether the std::string -> plssvm::classification_report::zero_division_behavior conversions are correct
-TEST_F(ZeroDivisionBehavior, from_string) {
+TEST_F(ZeroDivisionBehavior, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("warn", plssvm::classification_report::zero_division_behavior::warn);
     EXPECT_CONVERSION_FROM_STRING("WARN", plssvm::classification_report::zero_division_behavior::warn);
@@ -59,7 +58,7 @@ TEST_F(ZeroDivisionBehavior, from_string) {
     EXPECT_CONVERSION_FROM_STRING("NaN", plssvm::classification_report::zero_division_behavior::nan);
 }
 
-TEST_F(ZeroDivisionBehavior, from_string_unknown) {
+TEST_F(ZeroDivisionBehavior, FromStringUnknown) {
     // foo isn't a valid zero_division_behavior
     std::istringstream input{ "foo" };
     plssvm::classification_report::zero_division_behavior zero_div{};
@@ -67,7 +66,7 @@ TEST_F(ZeroDivisionBehavior, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST_F(ZeroDivisionBehavior, sanitize_nan_warn) {
+TEST_F(ZeroDivisionBehavior, SanitizeNaNWarn) {
     // sanitize NaN using warn
     EXPECT_EQ(plssvm::detail::sanitize_nan(42.0, 0.0, plssvm::classification_report::zero_division_behavior::warn, "Foo"), 0.0);
     EXPECT_EQ(this->get_capture(), "Foo is ill-defined and is set to 0.0 in labels with no predicted samples. "
@@ -75,19 +74,19 @@ TEST_F(ZeroDivisionBehavior, sanitize_nan_warn) {
     EXPECT_EQ(plssvm::detail::sanitize_nan(42.0, 1.0, plssvm::classification_report::zero_division_behavior::warn, "Foo"), 42.0);
 }
 
-TEST_F(ZeroDivisionBehavior, sanitize_nan_zero) {
+TEST_F(ZeroDivisionBehavior, SanitizeNaNZero) {
     // sanitize NaN using zero
     EXPECT_EQ(plssvm::detail::sanitize_nan(42.0, 0.0, plssvm::classification_report::zero_division_behavior::zero, "Foo"), 0.0);
     EXPECT_EQ(plssvm::detail::sanitize_nan(42.0, 1.0, plssvm::classification_report::zero_division_behavior::zero, "Foo"), 42.0);
 }
 
-TEST_F(ZeroDivisionBehavior, sanitize_nan_one) {
+TEST_F(ZeroDivisionBehavior, SanitizeNaNOne) {
     // sanitize NaN using one
     EXPECT_EQ(plssvm::detail::sanitize_nan(42.0, 0.0, plssvm::classification_report::zero_division_behavior::one, "Foo"), 1.0);
     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) {
+TEST_F(ZeroDivisionBehavior, SanitizeNaNNaN) {
     // 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
@@ -103,7 +102,7 @@ TEST_F(ZeroDivisionBehavior, sanitize_nan_nan) {
 //                                                               metrics                                                               //
 //*************************************************************************************************************************************//
 
-TEST(ClassificationReportMetrics, construct_metric) {
+TEST(ClassificationReportMetrics, ConstructMetric) {
     // construct a metric object
     const plssvm::classification_report::metric m{ 10, 42, 3, 0.1, 0.2, 0.3, 42 };
 
@@ -117,7 +116,7 @@ TEST(ClassificationReportMetrics, construct_metric) {
     EXPECT_EQ(m.support, 42);
 }
 
-TEST(ClassificationReportMetrics, output_metric) {
+TEST(ClassificationReportMetrics, OutputMetric) {
     // construct a metric object
     EXPECT_CONVERSION_TO_STRING((plssvm::classification_report::metric{ 10, 42, 3, 0.1, 0.2, 0.3, 42 }),
                                 "TP: 10\n"
@@ -129,7 +128,7 @@ TEST(ClassificationReportMetrics, output_metric) {
                                 "support:   42");
 }
 
-TEST(ClassificationReportMetrics, construct_accuracy_metric) {
+TEST(ClassificationReportMetrics, ConstructAccuracyMetric) {
     // construct a accuracy metric object
     const plssvm::classification_report::accuracy_metric am{ 0.5, 50, 100 };
 
@@ -139,7 +138,7 @@ TEST(ClassificationReportMetrics, construct_accuracy_metric) {
     EXPECT_EQ(am.num_total, 100);
 }
 
-TEST(ClassificationReportMetrics, output_accuracy_metric) {
+TEST(ClassificationReportMetrics, OutputAccuracyMetric) {
     // construct a accuracy metric object
     EXPECT_CONVERSION_TO_STRING((plssvm::classification_report::accuracy_metric{ 0.5, 50, 100 }), "Accuracy = 50.00% (50/100)");
 }
@@ -184,7 +183,7 @@ class ClassificationReport : public ::testing::Test {
     // clang-format on
 };
 
-TEST_F(ClassificationReport, construct) {
+TEST_F(ClassificationReport, Construct) {
     // construct a classification report
     const plssvm::classification_report report{ this->get_correct_label(), this->get_predicted_label() };
 
@@ -224,7 +223,7 @@ TEST_F(ClassificationReport, construct) {
     EXPECT_EQ(report.accuracy().num_total, 45);
 }
 
-TEST_F(ClassificationReport, construct_target_names) {
+TEST_F(ClassificationReport, ConstructTargetNames) {
     // construct a classification report
     const plssvm::classification_report report{ this->get_correct_label(), this->get_predicted_label(), plssvm::classification_report::target_names = std::vector<std::string>{ "Foo", "Bar", "Baz" } };
 
@@ -263,7 +262,7 @@ TEST_F(ClassificationReport, construct_target_names) {
     EXPECT_EQ(report.accuracy().num_total, 45);
 }
 
-TEST_F(ClassificationReport, construct_target_names_size_mismatch) {
+TEST_F(ClassificationReport, ConstructTargetNamesSizeMismatch) {
     // too few new target names
     EXPECT_THROW_WHAT((plssvm::classification_report{ this->get_correct_label(), this->get_predicted_label(), plssvm::classification_report::target_names = std::vector<std::string>{ "Foo", "Bar" } }),
                       plssvm::classification_report_exception,
@@ -274,7 +273,7 @@ TEST_F(ClassificationReport, construct_target_names_size_mismatch) {
                       "Provided 4 target names, but found 3 distinct labels!");
 }
 
-TEST_F(ClassificationReport, construct_zero_division_behavior) {
+TEST_F(ClassificationReport, ConstructZeroDivisionBehavior) {
     // construct a classification report
     const plssvm::classification_report report{ std::vector<int>{ 0, 0, 0 }, std::vector<int>{ 1, 1, 1 }, plssvm::classification_report::zero_division = plssvm::classification_report::zero_division_behavior::one };
 
@@ -305,35 +304,35 @@ TEST_F(ClassificationReport, construct_zero_division_behavior) {
     EXPECT_EQ(report.accuracy().num_total, 3);
 }
 
-TEST_F(ClassificationReport, construct_digits_negative) {
+TEST_F(ClassificationReport, ConstructDigitsNegative) {
     // too few new target names
     EXPECT_THROW_WHAT((plssvm::classification_report{ this->get_correct_label(), this->get_predicted_label(), plssvm::classification_report::digits = -1 }),
                       plssvm::classification_report_exception,
                       "Invalid number of output digits provided! Number of digits must be greater than zero but is -1!");
 }
 
-TEST_F(ClassificationReport, construct_empty_correct_label) {
+TEST_F(ClassificationReport, ConstructEmptyCorrectLabel) {
     // the correct labels vector must not be empty
     EXPECT_THROW_WHAT((plssvm::classification_report{ std::vector<int>{}, this->get_predicted_label() }),
                       plssvm::classification_report_exception,
                       "The correct labels list must not be empty!");
 }
 
-TEST_F(ClassificationReport, construct_empty_predicted_label) {
+TEST_F(ClassificationReport, ConstructEmptyPredictedLabel) {
     // the predicted labels vector must not be empty
     EXPECT_THROW_WHAT((plssvm::classification_report{ this->get_correct_label(), std::vector<int>{} }),
                       plssvm::classification_report_exception,
                       "The predicted labels list must not be empty!");
 }
 
-TEST_F(ClassificationReport, construct_label_size_mismatch) {
+TEST_F(ClassificationReport, ConstructLabelSizeMismatch) {
     // constructing a classification report with different number of correct and predicted labels must throw
     EXPECT_THROW_WHAT((plssvm::classification_report{ std::vector<int>{ 0, 0, 0 }, std::vector<int>{ 0, 0 } }),
                       plssvm::classification_report_exception,
                       "The number of correct labels (3) and predicted labels (2) must be the same!");
 }
 
-TEST_F(ClassificationReport, confusion_matrix) {
+TEST_F(ClassificationReport, ConfusionMatrix) {
     // construct a classification report
     const plssvm::classification_report report{ this->get_correct_label(), this->get_predicted_label() };
 
@@ -341,7 +340,7 @@ TEST_F(ClassificationReport, confusion_matrix) {
     EXPECT_EQ(report.confusion_matrix(), this->get_confusion_matrix());
 }
 
-TEST_F(ClassificationReport, accuracy_metrics) {
+TEST_F(ClassificationReport, AccuracyMetrics) {
     // construct a classification report
     const plssvm::classification_report report{ this->get_correct_label(), this->get_predicted_label() };
 
@@ -351,7 +350,7 @@ TEST_F(ClassificationReport, accuracy_metrics) {
     EXPECT_EQ(report.accuracy().num_total, 45);
 }
 
-TEST_F(ClassificationReport, metric_for_class) {
+TEST_F(ClassificationReport, MetricForClass) {
     // construct a classification report
     const plssvm::classification_report report{ this->get_correct_label(), this->get_predicted_label() };
 
@@ -389,7 +388,7 @@ TEST_F(ClassificationReport, metric_for_class) {
     EXPECT_EQ(report.metric_for_class(0).support + report.metric_for_class(1).support + report.metric_for_class(2).support, this->get_correct_label().size());
 }
 
-TEST_F(ClassificationReport, metric_for_invalid_class) {
+TEST_F(ClassificationReport, MetricForInvalidClass) {
     // construct a classification report
     const plssvm::classification_report report{ this->get_correct_label(), this->get_predicted_label() };
 
@@ -398,7 +397,7 @@ TEST_F(ClassificationReport, metric_for_invalid_class) {
     EXPECT_THROW_WHAT(std::ignore = report.metric_for_class("foo"), plssvm::classification_report_exception, "Couldn't find the label \"foo\"!");
 }
 
-TEST_F(ClassificationReport, classification_report) {
+TEST_F(ClassificationReport, ClassificationReport) {
     // construct a classification report
     const plssvm::classification_report report{ this->get_correct_label(), this->get_predicted_label() };
 
@@ -417,7 +416,7 @@ TEST_F(ClassificationReport, classification_report) {
     EXPECT_CONVERSION_TO_STRING(report, correct_output);
 }
 
-TEST_F(ClassificationReport, classification_report_target_names) {
+TEST_F(ClassificationReport, ClassificationReportTargetNames) {
     // construct a classification report
     const plssvm::classification_report report{ this->get_correct_label(), this->get_predicted_label(), plssvm::classification_report::target_names = std::vector<std::string>{ "cat", "dog", "African elephant" } };
 
@@ -436,7 +435,7 @@ TEST_F(ClassificationReport, classification_report_target_names) {
     EXPECT_CONVERSION_TO_STRING(report, correct_output);
 }
 
-TEST_F(ClassificationReport, classification_report_digits) {
+TEST_F(ClassificationReport, ClassificationReportDigits) {
     // construct a classification report
     const plssvm::classification_report report{ this->get_correct_label(), this->get_predicted_label(), plssvm::classification_report::digits = 3 };
 
diff --git a/tests/classification_types.cpp b/tests/classification_types.cpp
index bcb5c326c..9b455028b 100644
--- a/tests/classification_types.cpp
+++ b/tests/classification_types.cpp
@@ -18,19 +18,19 @@
 #include <tuple>    // std::ignore
 
 // check whether the plssvm::classification_type -> std::string conversions are correct
-TEST(ClassificationType, to_string) {
+TEST(ClassificationType, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::classification_type::oaa, "oaa");
     EXPECT_CONVERSION_TO_STRING(plssvm::classification_type::oao, "oao");
 }
 
-TEST(ClassificationType, to_string_unknown) {
+TEST(ClassificationType, ToStringUnknown) {
     // check conversions to std::string from unknown classification_type
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::classification_type>(2), "unknown");
 }
 
 // check whether the std::string -> plssvm::classification_type conversions are correct
-TEST(ClassificationType, from_string) {
+TEST(ClassificationType, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("oaa", plssvm::classification_type::oaa);
     EXPECT_CONVERSION_FROM_STRING("OAA", plssvm::classification_type::oaa);
@@ -49,7 +49,7 @@ TEST(ClassificationType, from_string) {
     EXPECT_CONVERSION_FROM_STRING("one_vs_one", plssvm::classification_type::oao);
 }
 
-TEST(ClassificationType, from_string_unknown) {
+TEST(ClassificationType, FromStringUnknown) {
     // foo isn't a valid classification_type
     std::istringstream input{ "foo" };
     plssvm::classification_type classification{};
@@ -57,18 +57,18 @@ TEST(ClassificationType, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(ClassificationType, classification_type_to_full_string) {
+TEST(ClassificationType, ClassificationTypeToFullString) {
     // check conversion from plssvm::classification_type to a full string
     EXPECT_EQ(plssvm::classification_type_to_full_string(plssvm::classification_type::oaa), "one vs. all");
     EXPECT_EQ(plssvm::classification_type_to_full_string(plssvm::classification_type::oao), "one vs. one");
 }
 
-TEST(ClassificationType, classification_type_to_full_string_unknown) {
+TEST(ClassificationType, ClassificationTypeToFullStringUnknown) {
     // check conversion from unknown classification_typ to a full string
     EXPECT_EQ(plssvm::classification_type_to_full_string(static_cast<plssvm::classification_type>(2)), "unknown");
 }
 
-TEST(ClassificationType, calculate_number_of_classifiers) {
+TEST(ClassificationType, CalculateNumberOfClassifiers) {
     // check whether the number of weights for OAA is correct
     EXPECT_EQ(calculate_number_of_classifiers(plssvm::classification_type::oaa, 2), 2);
     EXPECT_EQ(calculate_number_of_classifiers(plssvm::classification_type::oaa, 3), 3);
@@ -82,12 +82,12 @@ TEST(ClassificationType, calculate_number_of_classifiers) {
     EXPECT_EQ(calculate_number_of_classifiers(plssvm::classification_type::oao, 42), 861);
 }
 
-TEST(ClassificationType, calculate_number_of_classifiers_unknown) {
+TEST(ClassificationType, CalculateNumberOfClassifiersUnknown) {
     // should return 0 if the provided classification_type is invalid
     EXPECT_EQ(calculate_number_of_classifiers(static_cast<plssvm::classification_type>(2), 2), 0);
 }
 
-TEST(ClassificationTypeDeathTest, too_few_classes) {
+TEST(ClassificationTypeDeathTest, TooFewClasses) {
     // at least two classes must be provided
     EXPECT_DEATH(std::ignore = plssvm::calculate_number_of_classifiers(plssvm::classification_type::oaa, 1), "At least two classes must be given!");
     EXPECT_DEATH(std::ignore = plssvm::calculate_number_of_classifiers(plssvm::classification_type::oao, 0), "At least two classes must be given!");
diff --git a/tests/csvc_factory.cpp b/tests/csvc_factory.cpp
index 74761131a..e289f80bf 100644
--- a/tests/csvc_factory.cpp
+++ b/tests/csvc_factory.cpp
@@ -49,7 +49,7 @@ class CSVCFactory : public ::testing::Test,
 
 TYPED_TEST_SUITE(CSVCFactory, util::csvc_types_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(CSVCFactory, factory_backend) {
+TYPED_TEST(CSVCFactory, FactoryBackend) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     const plssvm::backend_type backend = plssvm::csvm_to_backend_type_v<backend_type>;
@@ -69,13 +69,13 @@ TYPED_TEST(CSVCFactory, factory_backend) {
     }
 }
 
-TEST(CSVCFactory, factory_default) {
+TEST(CSVCFactory, FactoryDefault) {
     // with the automatic backend type there MUST be a C-SVR creatable
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvc());
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvc>());
 }
 
-TYPED_TEST(CSVCFactory, factory_backend_parameter) {
+TYPED_TEST(CSVCFactory, FactoryBackendParameter) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     // the backend to use
@@ -98,7 +98,7 @@ TYPED_TEST(CSVCFactory, factory_backend_parameter) {
     }
 }
 
-TEST(CSVCFactory, factory_parameter) {
+TEST(CSVCFactory, FactoryParameter) {
     // create the parameter class used
     const plssvm::parameter params{};
     // with the automatic backend type there MUST be a C-SVR creatable
@@ -106,7 +106,7 @@ TEST(CSVCFactory, factory_parameter) {
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvc>(params));
 }
 
-TYPED_TEST(CSVCFactory, factory_backend_target) {
+TYPED_TEST(CSVCFactory, FactoryBackendTarget) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     // the backend to use
@@ -129,7 +129,7 @@ TYPED_TEST(CSVCFactory, factory_backend_target) {
     }
 }
 
-TEST(CSVCFactory, factory_target) {
+TEST(CSVCFactory, FactoryTarget) {
     // the target platform to use
     const plssvm::target_platform target = plssvm::target_platform::automatic;
     // with the automatic backend type there MUST be a C-SVR creatable
@@ -137,7 +137,7 @@ TEST(CSVCFactory, factory_target) {
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvc>(target));
 }
 
-TYPED_TEST(CSVCFactory, factory_backend_target_and_parameter) {
+TYPED_TEST(CSVCFactory, FactoryBackendTargetAndParameter) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     // the backend to use
@@ -162,7 +162,7 @@ TYPED_TEST(CSVCFactory, factory_backend_target_and_parameter) {
     }
 }
 
-TEST(CSVCFactory, factory_target_and_parameter) {
+TEST(CSVCFactory, FactoryTargetAndParameter) {
     // the target platform to use
     const plssvm::target_platform target = plssvm::target_platform::automatic;
     // create the parameter class used
@@ -172,7 +172,7 @@ TEST(CSVCFactory, factory_target_and_parameter) {
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvc>(target, params));
 }
 
-TYPED_TEST(CSVCFactory, factory_backend_target_and_named_parameter) {
+TYPED_TEST(CSVCFactory, FactoryBackendTargetAndNamedParameter) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     // the backend to use
@@ -197,7 +197,7 @@ TYPED_TEST(CSVCFactory, factory_backend_target_and_named_parameter) {
     }
 }
 
-TEST(CSVCFactory, factory_target_and_named_parameter) {
+TEST(CSVCFactory, FactoryTargetAndNamedParameter) {
     // the target platform to use
     const plssvm::target_platform target = plssvm::target_platform::automatic;
     // the kernel function to use
@@ -207,7 +207,7 @@ TEST(CSVCFactory, factory_target_and_named_parameter) {
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvc>(target, plssvm::kernel_type = kernel_type, plssvm::gamma = 0.01));
 }
 
-TYPED_TEST(CSVCFactory, factory_backend_named_parameter) {
+TYPED_TEST(CSVCFactory, FactoryBackendNamedParameter) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     // the backend to use
@@ -230,7 +230,7 @@ TYPED_TEST(CSVCFactory, factory_backend_named_parameter) {
     }
 }
 
-TEST(CSVCFactory, factory_named_parameter) {
+TEST(CSVCFactory, FactoryNamedParameter) {
     // the kernel function to use
     const plssvm::kernel_function_type kernel_type = plssvm::kernel_function_type::polynomial;
     // with the automatic backend type there MUST be a C-SVR creatable
@@ -238,7 +238,7 @@ TEST(CSVCFactory, factory_named_parameter) {
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvc>(plssvm::kernel_type = kernel_type, plssvm::gamma = 0.01));
 }
 
-TEST(CSVCFactory, invalid_backend) {
+TEST(CSVCFactory, InvalidBackend) {
     EXPECT_THROW_WHAT(std::ignore = plssvm::make_csvc(static_cast<plssvm::backend_type>(9)),
                       plssvm::unsupported_backend_exception,
                       "Unrecognized backend provided!");
@@ -247,7 +247,7 @@ TEST(CSVCFactory, invalid_backend) {
                       "Unrecognized backend provided!");
 }
 
-TEST(CSVCFactory, unsupported_backend) {
+TEST(CSVCFactory, UnsupportedBackend) {
     if constexpr (plssvm::csvm_backend_exists_v<plssvm::cuda::csvm>) {
         EXPECT_THROW_WHAT(std::ignore = plssvm::make_csvc(plssvm::backend_type::cuda, plssvm::sycl_implementation_type = plssvm::sycl::implementation_type::automatic),
                           plssvm::unsupported_backend_exception,
@@ -273,7 +273,7 @@ class SYCLCSVCFactory : public CSVCFactory<T> {
 
 TYPED_TEST_SUITE(SYCLCSVCFactory, util::sycl_csvc_types_gtest);
 
-TYPED_TEST(SYCLCSVCFactory, factory_backend) {
+TYPED_TEST(SYCLCSVCFactory, FactoryBackend) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     const plssvm::backend_type backend = plssvm::csvm_to_backend_type_v<sycl_backend_type>;
@@ -293,7 +293,7 @@ TYPED_TEST(SYCLCSVCFactory, factory_backend) {
     }
 }
 
-TYPED_TEST(SYCLCSVCFactory, factory_backend_parameter) {
+TYPED_TEST(SYCLCSVCFactory, FactoryBackendParameter) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     // the backend to use
@@ -316,7 +316,7 @@ TYPED_TEST(SYCLCSVCFactory, factory_backend_parameter) {
     }
 }
 
-TYPED_TEST(SYCLCSVCFactory, factory_backend_target) {
+TYPED_TEST(SYCLCSVCFactory, FactoryBackendTarget) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     // the backend to use
@@ -339,7 +339,7 @@ TYPED_TEST(SYCLCSVCFactory, factory_backend_target) {
     }
 }
 
-TYPED_TEST(SYCLCSVCFactory, factory_backend_target_and_parameter) {
+TYPED_TEST(SYCLCSVCFactory, FactoryBackendTargetAndParameter) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     // the backend to use
@@ -364,7 +364,7 @@ TYPED_TEST(SYCLCSVCFactory, factory_backend_target_and_parameter) {
     }
 }
 
-TYPED_TEST(SYCLCSVCFactory, factory_backend_target_and_named_parameter) {
+TYPED_TEST(SYCLCSVCFactory, FactoryBackendTargetAndNamedParameter) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     // the backend to use
@@ -389,7 +389,7 @@ TYPED_TEST(SYCLCSVCFactory, factory_backend_target_and_named_parameter) {
     }
 }
 
-TYPED_TEST(SYCLCSVCFactory, factory_backend_named_parameter) {
+TYPED_TEST(SYCLCSVCFactory, FactoryBackendNamedParameter) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     // the backend to use
@@ -412,7 +412,7 @@ TYPED_TEST(SYCLCSVCFactory, factory_backend_named_parameter) {
     }
 }
 
-TEST(SYCLCSVCFactory, invalid_sycl_implementation) {
+TEST(SYCLCSVCFactory, InvalidSYCLImplementation) {
     EXPECT_THROW_WHAT(std::ignore = plssvm::make_csvc(plssvm::backend_type::sycl, plssvm::sycl_implementation_type = static_cast<plssvm::sycl::implementation_type>(3)),
                       plssvm::unsupported_backend_exception,
                       "No sycl backend available!");
diff --git a/tests/csvr_factory.cpp b/tests/csvr_factory.cpp
index 1efe93caf..cbb308095 100644
--- a/tests/csvr_factory.cpp
+++ b/tests/csvr_factory.cpp
@@ -49,7 +49,7 @@ class CSVRFactory : public ::testing::Test,
 
 TYPED_TEST_SUITE(CSVRFactory, util::csvr_types_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(CSVRFactory, factory_backend) {
+TYPED_TEST(CSVRFactory, FactoryBackend) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     const plssvm::backend_type backend = plssvm::csvm_to_backend_type_v<backend_type>;
@@ -69,13 +69,13 @@ TYPED_TEST(CSVRFactory, factory_backend) {
     }
 }
 
-TEST(CSVRFactory, factory_default) {
+TEST(CSVRFactory, FactoryDefault) {
     // with the automatic backend type there MUST be a C-SVR creatable
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvr());
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvr>());
 }
 
-TYPED_TEST(CSVRFactory, factory_backend_parameter) {
+TYPED_TEST(CSVRFactory, FactoryBackendParameter) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     // the backend to use
@@ -98,7 +98,7 @@ TYPED_TEST(CSVRFactory, factory_backend_parameter) {
     }
 }
 
-TEST(CSVRFactory, factory_parameter) {
+TEST(CSVRFactory, FactoryParameter) {
     // create the parameter class used
     const plssvm::parameter params{};
     // with the automatic backend type there MUST be a C-SVR creatable
@@ -106,7 +106,7 @@ TEST(CSVRFactory, factory_parameter) {
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvr>(params));
 }
 
-TYPED_TEST(CSVRFactory, factory_backend_target) {
+TYPED_TEST(CSVRFactory, FactoryBackendTarget) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     // the backend to use
@@ -129,7 +129,7 @@ TYPED_TEST(CSVRFactory, factory_backend_target) {
     }
 }
 
-TEST(CSVRFactory, factory_target) {
+TEST(CSVRFactory, FactoryTarget) {
     // the target platform to use
     const plssvm::target_platform target = plssvm::target_platform::automatic;
     // with the automatic backend type there MUST be a C-SVR creatable
@@ -137,7 +137,7 @@ TEST(CSVRFactory, factory_target) {
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvr>(target));
 }
 
-TYPED_TEST(CSVRFactory, factory_backend_target_and_parameter) {
+TYPED_TEST(CSVRFactory, FactoryBackendTargetAndParameter) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     // the backend to use
@@ -162,7 +162,7 @@ TYPED_TEST(CSVRFactory, factory_backend_target_and_parameter) {
     }
 }
 
-TEST(CSVRFactory, factory_target_and_parameter) {
+TEST(CSVRFactory, FactoryTargetAndParameter) {
     // the target platform to use
     const plssvm::target_platform target = plssvm::target_platform::automatic;
     // create the parameter class used
@@ -172,7 +172,7 @@ TEST(CSVRFactory, factory_target_and_parameter) {
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvr>(target, params));
 }
 
-TYPED_TEST(CSVRFactory, factory_backend_target_and_named_parameter) {
+TYPED_TEST(CSVRFactory, FactoryBackendTargetAndNamedParameter) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     // the backend to use
@@ -197,7 +197,7 @@ TYPED_TEST(CSVRFactory, factory_backend_target_and_named_parameter) {
     }
 }
 
-TEST(CSVRFactory, factory_target_and_named_parameter) {
+TEST(CSVRFactory, FactoryTargetAndNamedParameter) {
     // the target platform to use
     const plssvm::target_platform target = plssvm::target_platform::automatic;
     // the kernel function to use
@@ -207,7 +207,7 @@ TEST(CSVRFactory, factory_target_and_named_parameter) {
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvr>(target, plssvm::kernel_type = kernel_type, plssvm::gamma = 0.01));
 }
 
-TYPED_TEST(CSVRFactory, factory_backend_named_parameter) {
+TYPED_TEST(CSVRFactory, FactoryBackendNamedParameter) {
     using backend_type = typename TestFixture::fixture_backend_type;
 
     // the backend to use
@@ -230,7 +230,7 @@ TYPED_TEST(CSVRFactory, factory_backend_named_parameter) {
     }
 }
 
-TEST(CSVRFactory, factory_named_parameter) {
+TEST(CSVRFactory, FactoryNamedParameter) {
     // the kernel function to use
     const plssvm::kernel_function_type kernel_type = plssvm::kernel_function_type::polynomial;
     // with the automatic backend type there MUST be a C-SVR creatable
@@ -238,7 +238,7 @@ TEST(CSVRFactory, factory_named_parameter) {
     EXPECT_NO_THROW(std::ignore = plssvm::make_csvm<plssvm::csvr>(plssvm::kernel_type = kernel_type, plssvm::gamma = 0.01));
 }
 
-TEST(CSVRFactory, invalid_backend) {
+TEST(CSVRFactory, InvalidBackend) {
     EXPECT_THROW_WHAT(std::ignore = plssvm::make_csvr(static_cast<plssvm::backend_type>(9)),
                       plssvm::unsupported_backend_exception,
                       "Unrecognized backend provided!");
@@ -247,7 +247,7 @@ TEST(CSVRFactory, invalid_backend) {
                       "Unrecognized backend provided!");
 }
 
-TEST(CSVRFactory, unsupported_backend) {
+TEST(CSVRFactory, UnsupportedBackend) {
     if constexpr (plssvm::csvm_backend_exists_v<plssvm::cuda::csvm>) {
         EXPECT_THROW_WHAT(std::ignore = plssvm::make_csvr(plssvm::backend_type::cuda, plssvm::sycl_implementation_type = plssvm::sycl::implementation_type::automatic),
                           plssvm::unsupported_backend_exception,
@@ -273,7 +273,7 @@ class SYCLCSVRFactory : public CSVRFactory<T> {
 
 TYPED_TEST_SUITE(SYCLCSVRFactory, util::sycl_csvr_types_gtest);
 
-TYPED_TEST(SYCLCSVRFactory, factory_backend) {
+TYPED_TEST(SYCLCSVRFactory, FactoryBackend) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     const plssvm::backend_type backend = plssvm::csvm_to_backend_type_v<sycl_backend_type>;
@@ -293,7 +293,7 @@ TYPED_TEST(SYCLCSVRFactory, factory_backend) {
     }
 }
 
-TYPED_TEST(SYCLCSVRFactory, factory_backend_parameter) {
+TYPED_TEST(SYCLCSVRFactory, FactoryBackendParameter) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     // the backend to use
@@ -316,7 +316,7 @@ TYPED_TEST(SYCLCSVRFactory, factory_backend_parameter) {
     }
 }
 
-TYPED_TEST(SYCLCSVRFactory, factory_backend_target) {
+TYPED_TEST(SYCLCSVRFactory, FactoryBackendTarget) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     // the backend to use
@@ -339,7 +339,7 @@ TYPED_TEST(SYCLCSVRFactory, factory_backend_target) {
     }
 }
 
-TYPED_TEST(SYCLCSVRFactory, factory_backend_target_and_parameter) {
+TYPED_TEST(SYCLCSVRFactory, FactoryBackendTargetAndParameter) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     // the backend to use
@@ -364,7 +364,7 @@ TYPED_TEST(SYCLCSVRFactory, factory_backend_target_and_parameter) {
     }
 }
 
-TYPED_TEST(SYCLCSVRFactory, factory_backend_target_and_named_parameter) {
+TYPED_TEST(SYCLCSVRFactory, FactoryBackendTargetAndNamedParameter) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     // the backend to use
@@ -389,7 +389,7 @@ TYPED_TEST(SYCLCSVRFactory, factory_backend_target_and_named_parameter) {
     }
 }
 
-TYPED_TEST(SYCLCSVRFactory, factory_backend_named_parameter) {
+TYPED_TEST(SYCLCSVRFactory, FactoryBackendNamedParameter) {
     using sycl_backend_type = typename TestFixture::fixture_sycl_backend_type;
 
     // the backend to use
@@ -412,7 +412,7 @@ TYPED_TEST(SYCLCSVRFactory, factory_backend_named_parameter) {
     }
 }
 
-TEST(SYCLCSVRFactory, invalid_sycl_implementation) {
+TEST(SYCLCSVRFactory, InvalidSYCLImplementation) {
     EXPECT_THROW_WHAT(std::ignore = plssvm::make_csvr(plssvm::backend_type::sycl, plssvm::sycl_implementation_type = static_cast<plssvm::sycl::implementation_type>(3)),
                       plssvm::unsupported_backend_exception,
                       "No sycl backend available!");
diff --git a/tests/custom_test_macros.hpp b/tests/custom_test_macros.hpp
index 591cb086d..547601173 100644
--- a/tests/custom_test_macros.hpp
+++ b/tests/custom_test_macros.hpp
@@ -14,7 +14,7 @@
 #pragma once
 
 #include "plssvm/detail/assert.hpp"       // PLSSVM_ASSERT
-#include "plssvm/detail/type_traits.hpp"  // plssvm::detail::{always_false_v, remove_cvref_t}
+#include "plssvm/detail/type_traits.hpp"  // plssvm::detail::{always_false_v, remove_cvref_t, is_optional_v, is_reference_wrapper_v}, PLSSVM_REQUIRES
 #include "plssvm/matrix.hpp"              // plssvm::matrix
 
 #include "fmt/format.h"   // fmt::format
@@ -32,30 +32,16 @@
 
 namespace detail {
 
-// type_trait to get the `value_type` of a `std::vector<T>`, `std::vector<std::vector<T>>`, etc.
-template <typename T>
-struct get_value_type {
-    using type = T;
-};
-
-template <typename T>
-struct get_value_type<std::vector<T>> {
-    using type = typename get_value_type<T>::type;
-};
-
-template <typename T>
-using get_value_type_t = typename get_value_type<T>::type;
-
 /**
  * @brief Compares the two floating point values @p val1 and @p val2.
  * @details Wrapper around GoogleTest's `EXPECT_FLOAT_EQ` and `ASSERT_DOUBLE_EQ` if @p expect is `true`, otherwise wraps `ASSERT_FLOAT_EQ` and `ASSERT_DOUBLE_EQ`.
- * @tparam T the floating point type
  * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam T the floating point type
  * @param[in] val1 first value to compare (the actual value)
  * @param[in] val2 second value to compare (the expected value)
  * @param[in] msg an optional message
  */
-template <typename T, bool expect>
+template <bool expect, typename T>
 inline void floating_point_eq(const T val1, const T val2, const std::string &msg = "") {
     if constexpr (std::is_same_v<plssvm::detail::remove_cvref_t<T>, float>) {
         if constexpr (expect) {
@@ -76,65 +62,65 @@ inline void floating_point_eq(const T val1, const T val2, const std::string &msg
 
 /**
  * @brief Compares the two vectors of floating point values @p val1 and @p val2.
- * @tparam T the floating point type
  * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam T the floating point type
  * @param[in] val1 the first vector to compare (the actual value)
  * @param[in] val2 the second vector to compare (the expected value)
  */
-template <typename T, bool expect>
+template <bool expect, typename T>
 inline void floating_point_vector_eq(const std::vector<T> &val1, const std::vector<T> &val2) {
     ASSERT_EQ(val1.size(), val2.size());
     for (typename std::vector<T>::size_type col = 0; col < val1.size(); ++col) {
-        floating_point_eq<T, expect>(val1[col], val2[col], fmt::format("values at [{}] are not equal: ", col));
+        floating_point_eq<expect>(val1[col], val2[col], fmt::format("values at [{}] are not equal: ", col));
     }
 }
 
 /**
  * @brief Compares the two 2D vectors of floating point values @p val1 and @p val2.
- * @tparam T the floating point type
  * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam T the floating point type
  * @param[in] val1 the first 2D vector to compare (the actual value)
  * @param[in] val2 the second 2D vector to compare (the expected value)
  */
-template <typename T, bool expect>
+template <bool expect, typename T>
 inline void floating_point_2d_vector_eq(const std::vector<std::vector<T>> &val1, const std::vector<std::vector<T>> &val2) {
     ASSERT_EQ(val1.size(), val2.size());
     for (typename std::vector<T>::size_type row = 0; row < val1.size(); ++row) {
         ASSERT_EQ(val1[row].size(), val2[row].size());
         for (typename std::vector<T>::size_type col = 0; col < val1[row].size(); ++col) {
-            floating_point_eq<T, expect>(val1[row][col], val2[row][col], fmt::format("values at [{}][{}] are not equal: ", row, col));
+            floating_point_eq<expect>(val1[row][col], val2[row][col], fmt::format("values at [{}][{}] are not equal: ", row, col));
         }
     }
 }
 
 /**
  * @brief Compares the two matrices of floating point values @p matr1 and @p matr2.
- * @tparam matrix_type the matrix type (AoS vs SoA)
  * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam matrix_type the matrix type (AoS vs SoA)
  * @param[in] matr1 the first matrix to compare (the actual value)
  * @param[in] matr2 the second matrix to compare (the expected value)
  */
-template <typename matrix_type, bool expect>
+template <bool expect, typename matrix_type>
 inline void floating_point_matrix_eq(const matrix_type &matr1, const matrix_type &matr2) {
     ASSERT_EQ(matr1.shape(), matr2.shape());
     ASSERT_EQ(matr1.padding(), matr2.padding());
     for (typename matrix_type::size_type row = 0; row < matr1.num_rows_padded(); ++row) {
         for (typename matrix_type::size_type col = 0; col < matr1.num_cols_padded(); ++col) {
-            floating_point_eq<typename matrix_type::value_type, expect>(matr1(row, col), matr2(row, col), fmt::format("values at [{}][{}] are not equal: ", row, col));
+            floating_point_eq<expect>(matr1(row, col), matr2(row, col), fmt::format("values at [{}][{}] are not equal: ", row, col));
         }
     }
 }
 
 /**
  * @brief Compares the two floating point values @p val1 and @p val2 using a mixture of relative and absolute mode.
- * @tparam T the floating point type
  * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam T the floating point type
  * @param[in] val1 first value to compare (the actual value)
  * @param[in] val2 second value to compare (the expected value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  * @param[in] msg an optional message
  */
-template <typename T, bool expect>
+template <bool expect, typename T>
 inline void floating_point_near(const T val1, const T val2, const T eps_factor = T{ 128.0 }, const std::string &msg = "") {
     // based on: https://stackoverflow.com/questions/4915462/how-should-i-do-floating-point-comparison
 
@@ -161,67 +147,67 @@ inline void floating_point_near(const T val1, const T val2, const T eps_factor =
 
 /**
  * @brief Compares the two vectors of floating point values @p val1 and @p val2 using a mixture of relative and absolute mode.
- * @tparam T the floating point type
  * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam T the floating point type
  * @param[in] val1 the first vector to compare (the actual value)
  * @param[in] val2 the second vector to compare (the expected value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
-template <typename T, bool expect>
+template <bool expect, typename T>
 inline void floating_point_vector_near(const std::vector<T> &val1, const std::vector<T> &val2, const T eps_factor = T{ 128.0 }) {
     ASSERT_EQ(val1.size(), val2.size());
     for (typename std::vector<T>::size_type col = 0; col < val1.size(); ++col) {
-        floating_point_near<T, expect>(val1[col], val2[col], eps_factor, fmt::format("values at [{}] are not equal enough: ", col));
+        floating_point_near<expect>(val1[col], val2[col], eps_factor, fmt::format("values at [{}] are not equal enough: ", col));
     }
 }
 
 /**
  * @brief Compares the two 2D vectors of floating point values @p val1 and @p val2 using a mixture of relative and absolute mode.
- * @tparam T the floating point type
  * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam T the floating point type
  * @param[in] val1 the first 2D vector to compare (the actual value)
  * @param[in] val2 the second 2D vector to compare (the expected value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
-template <typename T, bool expect>
+template <bool expect, typename T>
 inline void floating_point_2d_vector_near(const std::vector<std::vector<T>> &val1, const std::vector<std::vector<T>> &val2, const T eps_factor = T{ 128.0 }) {
     ASSERT_EQ(val1.size(), val2.size());
     for (typename std::vector<T>::size_type row = 0; row < val1.size(); ++row) {
         ASSERT_EQ(val1[row].size(), val2[row].size());
         for (typename std::vector<T>::size_type col = 0; col < val1[row].size(); ++col) {
-            floating_point_near<T, expect>(val1[row][col], val2[row][col], eps_factor, fmt::format("values at [{}][{}] are not equal enough: ", row, col));
+            floating_point_near<expect>(val1[row][col], val2[row][col], eps_factor, fmt::format("values at [{}][{}] are not equal enough: ", row, col));
         }
     }
 }
 
 /**
  * @brief Compares the two matrices @p matr1 and @p matr2 using a mixture of relative and absolute mode.
- * @tparam matrix_type the matrix type (AoS vs SoA)
  * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam matrix_type the matrix type (AoS vs SoA)
  * @tparam T the floating point type
  * @param[in] matr1 the first 2D vector to compare (the actual value)
  * @param[in] matr2 the second 2D vector to compare (the expected value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
-template <typename matrix_type, bool expect, typename T = typename matrix_type::value_type>
+template <bool expect, typename matrix_type, typename T = typename matrix_type::value_type>
 inline void floating_point_matrix_near(const matrix_type &matr1, const matrix_type &matr2, const T eps_factor = T{ 128.0 }) {
     ASSERT_EQ(matr1.shape(), matr2.shape());
     ASSERT_EQ(matr1.padding(), matr2.padding());
     for (typename matrix_type::size_type row = 0; row < matr1.num_rows_padded(); ++row) {
         for (typename matrix_type::size_type col = 0; col < matr2.num_cols_padded(); ++col) {
-            floating_point_near<T, expect>(matr1(row, col), matr2(row, col), eps_factor, fmt::format("values at [{}][{}] are not equal enough: ", row, col));
+            floating_point_near<expect>(matr1(row, col), matr2(row, col), eps_factor, fmt::format("values at [{}][{}] are not equal enough: ", row, col));
         }
     }
 }
 
 /**
  * @brief Tries to convert the @p value to a string using std::ostringstream. If it succeeds, compares the value to @p expected_str.
- * @tparam T the type of the value to convert
  * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam T the type of the value to convert
  * @param[in] value the value to convert to a string
  * @param[in] expected_str the expected string representation of @p value
  */
-template <typename T, bool expect>
+template <bool expect, typename T>
 inline void convert_to_string(const T &value, const std::string_view expected_str) {
     // convert value to a string
     std::ostringstream output;
@@ -240,12 +226,12 @@ inline void convert_to_string(const T &value, const std::string_view expected_st
 
 /**
  * @brief Tries to convert the string @p str to a value of type T using std::istringstream. If it succeeds, compares the value to @p expected_value.
- * @tparam T the type to which the string should be converted
  * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam T the type to which the string should be converted
  * @param[in] str the string to convert to a value of type T
  * @param[in] expected_value the expected value after conversion
  */
-template <typename T, bool expect>
+template <bool expect, typename T>
 inline void convert_from_string(const std::string &str, const T &expected_value) {
     // convert a string to a value of type T
     std::istringstream input{ str };
@@ -263,6 +249,64 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
     }
 }
 
+/**
+ * @brief Checks whether the content of @p lhs, ignoring a potential std::reference_wrapper, is equal to @p rhs, also ignoring a potential std::reference_wrapper.
+ * @details At least one of @p lhs or @p rhs must be an optional. If only one of them is an optional, which is empty, directly fails.
+ * @tparam expect if `false` maps to `EXPECT_*`, else maps to `ASSERT_*`
+ * @tparam T the type contained in the first optional
+ * @tparam U the type contained in the second optional
+ * @param[in] lhs the first optional
+ * @param[in] rhs the second optional
+ */
+template <bool expect, typename T, typename U, PLSSVM_REQUIRES(plssvm::detail::is_optional_v<T> || plssvm::detail::is_optional_v<U>)>
+void expect_optional_equal(const T &lhs, const U &rhs) {
+    // get the value of an optional, also supports std::optional<std::reference_wrapper<T>>
+    const auto get_value = [](const auto &opt) {
+        using value_type = typename plssvm::detail::remove_cvref_t<decltype(opt)>::value_type;
+        if constexpr (plssvm::detail::is_reference_wrapper_v<value_type>) {
+            return opt.value().get();
+        } else {
+            return opt.value();
+        }
+    };
+
+    // case 1: lhs and rhs are both optionals
+    // case 2: lhs is an optional, but rhs not
+    // case 3: lhs is no optional, but rhs is
+    // case 4: no optional -> can't happen due to template constraints
+    if constexpr (plssvm::detail::is_optional_v<T> && plssvm::detail::is_optional_v<U>) {
+        // if both optionals are empty, they are equal
+        if (!lhs.has_value() && !rhs.has_value()) {
+            SUCCEED();
+        } else {
+            // check the actual content
+            if constexpr (expect) {
+                EXPECT_EQ(get_value(lhs), get_value(rhs));
+            } else {
+                ASSERT_EQ(get_value(lhs), get_value(rhs));
+            }
+        }
+    } else if constexpr (plssvm::detail::is_optional_v<T> && !plssvm::detail::is_optional_v<U>) {
+        // the optional is empty, so there are unequal
+        if (!lhs.has_value()) {
+            FAIL() << "Provided optional does not contain a value!";
+        }
+
+        // check the actual content
+        if constexpr (expect) {
+            EXPECT_EQ(get_value(lhs), rhs);
+        } else {
+            ASSERT_EQ(get_value(lhs), rhs);
+        }
+    } else if constexpr (!plssvm::detail::is_optional_v<T> && plssvm::detail::is_optional_v<U>) {
+        // call same function with reversed parameters
+        expect_optional_equal<expect>(rhs, lhs);
+    } else {
+        // unreachable
+        FAIL();
+    }
+}
+
 }  // namespace detail
 
 /**
@@ -272,7 +316,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define EXPECT_FLOATING_POINT_EQ(val1, val2) \
-    ::detail::floating_point_eq<decltype(val1), true>(val1, val2)
+    ::detail::floating_point_eq<true>(val1, val2)
 /**
  * @brief Check whether the two floating point values @p val1 and @p val2 are "equal".
  * @details Other tests in the test case are aborted if this test fails.
@@ -280,7 +324,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define ASSERT_FLOATING_POINT_EQ(val1, val2) \
-    ::detail::floating_point_eq<decltype(val1), false>(val1, val2)
+    ::detail::floating_point_eq<false>(val1, val2)
 
 /**
  * @brief Check whether the floating point values in the vectors @p val1 and @p val2 are "equal".
@@ -289,7 +333,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define EXPECT_FLOATING_POINT_VECTOR_EQ(val1, val2) \
-    ::detail::floating_point_vector_eq<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, true>(val1, val2)
+    ::detail::floating_point_vector_eq<true>(val1, val2)
 /**
  * @brief Check whether the floating point values in the vectors @p val1 and @p val2 are "equal".
  * @details Other tests in the test case are aborted if this test fails.
@@ -297,7 +341,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define ASSERT_FLOATING_POINT_VECTOR_EQ(val1, val2) \
-    ::detail::floating_point_vector_eq<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, false>(val1, val2)
+    ::detail::floating_point_vector_eq<false>(val1, val2)
 
 /**
  * @brief Check whether the floating point values in the 2D vectors @p val1 and @p val2 are "equal".
@@ -306,7 +350,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define EXPECT_FLOATING_POINT_2D_VECTOR_EQ(val1, val2) \
-    ::detail::floating_point_2d_vector_eq<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, true>(val1, val2)
+    ::detail::floating_point_2d_vector_eq<true>(val1, val2)
 /**
  * @brief Check whether the floating point values in the 2D vectors @p val1 and @p val2 are "equal".
  * @details Other tests in the test case are aborted if this test fails.
@@ -314,7 +358,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define ASSERT_FLOATING_POINT_2D_VECTOR_EQ(val1, val2) \
-    ::detail::floating_point_2d_vector_eq<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, false>(val1, val2)
+    ::detail::floating_point_2d_vector_eq<false>(val1, val2)
 
 /**
  * @brief Check whether the floating point values in the matrix @p val1 and @p val2 are "equal".
@@ -323,7 +367,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define EXPECT_FLOATING_POINT_MATRIX_EQ(val1, val2) \
-    ::detail::floating_point_matrix_eq<plssvm::detail::remove_cvref_t<decltype(val1)>, true>(val1, val2)
+    ::detail::floating_point_matrix_eq<true>(val1, val2)
 /**
  * @brief Check whether the floating point values in the matrix @p val1 and @p val2 are "equal".
  * @details Other tests in the test case are aborted if this test fails.
@@ -331,7 +375,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define ASSERT_FLOATING_POINT_MATRIX_EQ(val1, val2) \
-    ::detail::floating_point_matrix_eq<plssvm::detail::remove_cvref_t<decltype(val1)>, false>(val1, val2)
+    ::detail::floating_point_matrix_eq<false>(val1, val2)
 
 /**
  * @brief Check whether the two floating point values @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
@@ -340,7 +384,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define EXPECT_FLOATING_POINT_NEAR(val1, val2) \
-    ::detail::floating_point_near<decltype(val1), true>(val1, val2)
+    ::detail::floating_point_near<true>(val1, val2)
 /**
  * @brief Check whether the two floating point values @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
  * @details Other tests in the test case are aborted if this test fails.
@@ -348,7 +392,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define ASSERT_FLOATING_POINT_NEAR(val1, val2) \
-    ::detail::floating_point_near<decltype(val1), false>(val1, val2)
+    ::detail::floating_point_near<false>(val1, val2)
 
 /**
  * @brief Check whether the floating point values in the vectors @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
@@ -357,7 +401,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define EXPECT_FLOATING_POINT_VECTOR_NEAR(val1, val2) \
-    ::detail::floating_point_vector_near<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, true>(val1, val2)
+    ::detail::floating_point_vector_near<true>(val1, val2)
 /**
  * @brief Check whether the floating point values in the vectors @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
  * @details Other tests in the test case are aborted if this test fails.
@@ -365,7 +409,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define ASSERT_FLOATING_POINT_VECTOR_NEAR(val1, val2) \
-    ::detail::floating_point_vector_near<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, false>(val1, val2)
+    ::detail::floating_point_vector_near<false>(val1, val2)
 
 /**
  * @brief Check whether the floating point values in the 2D vectors @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
@@ -374,7 +418,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define EXPECT_FLOATING_POINT_2D_VECTOR_NEAR(val1, val2) \
-    ::detail::floating_point_2d_vector_near<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, true>(val1, val2)
+    ::detail::floating_point_2d_vector_near<true>(val1, val2)
 
 /**
  * @brief Check whether the floating point values in the 2D vectors @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
@@ -383,7 +427,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define ASSERT_FLOATING_POINT_2D_VECTOR_NEAR(val1, val2) \
-    ::detail::floating_point_2d_vector_near<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, false>(val1, val2)
+    ::detail::floating_point_2d_vector_near<false>(val1, val2)
 
 /**
  * @brief Check whether the floating point values in the plssvm::matrix @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
@@ -392,7 +436,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define EXPECT_FLOATING_POINT_MATRIX_NEAR(val1, val2) \
-    ::detail::floating_point_matrix_near<plssvm::detail::remove_cvref_t<decltype(val1)>, true>(val1, val2)
+    ::detail::floating_point_matrix_near<true>(val1, val2)
 /**
  * @brief Check whether the floating point values in the plssvm::matrix @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
  * @details Other tests in the test case are aborted if this test fails.
@@ -400,7 +444,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val2 the second value to compare (the expected value)
  */
 #define ASSERT_FLOATING_POINT_MATRIX_NEAR(val1, val2) \
-    ::detail::floating_point_matrix_near<plssvm::detail::remove_cvref_t<decltype(val1)>, false>(val1, val2)
+    ::detail::floating_point_matrix_near<false>(val1, val2)
 
 /**
  * @brief Check whether the two floating point values @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
@@ -410,7 +454,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
 #define EXPECT_FLOATING_POINT_NEAR_EPS(val1, val2, eps_factor) \
-    ::detail::floating_point_near<decltype(val1), true>(val1, val2, eps_factor)
+    ::detail::floating_point_near<true>(val1, val2, eps_factor)
 /**
  * @brief Check whether the two floating point values @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
  * @details Other tests in the test case are aborted if this test fails.
@@ -419,7 +463,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
 #define ASSERT_FLOATING_POINT_NEAR_EPS(val1, val2, eps_factor) \
-    ::detail::floating_point_near<decltype(val1), false>(val1, val2, eps_factor)
+    ::detail::floating_point_near<false>(val1, val2, eps_factor)
 
 /**
  * @brief Check whether the floating point values in the vectors @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
@@ -429,7 +473,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
 #define EXPECT_FLOATING_POINT_VECTOR_NEAR_EPS(val1, val2, eps_factor) \
-    ::detail::floating_point_vector_near<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, true>(val1, val2, eps_factor)
+    ::detail::floating_point_vector_near<true>(val1, val2, eps_factor)
 /**
  * @brief Check whether the floating point values in the vectors @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
  * @details Other tests in the test case are aborted if this test fails.
@@ -438,7 +482,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
 #define ASSERT_FLOATING_POINT_VECTOR_NEAR_EPS(val1, val2, eps_factor) \
-    ::detail::floating_point_vector_near<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, false>(val1, val2, eps_factor)
+    ::detail::floating_point_vector_near<false>(val1, val2, eps_factor)
 
 /**
  * @brief Check whether the floating point values in the 2D vectors @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
@@ -448,7 +492,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
 #define EXPECT_FLOATING_POINT_2D_VECTOR_NEAR_EPS(val1, val2, eps_factor) \
-    ::detail::floating_point_2d_vector_near<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, true>(val1, val2, eps_factor)
+    ::detail::floating_point_2d_vector_near<true>(val1, val2, eps_factor)
 /**
  * @brief Check whether the floating point values in the 2D vectors @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
  * @details Other tests in the test case are aborted if this test fails.
@@ -457,7 +501,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
 #define ASSERT_FLOATING_POINT_2D_VECTOR_NEAR_EPS(val1, val2, eps_factor) \
-    ::detail::floating_point_2d_vector_near<detail::get_value_type_t<plssvm::detail::remove_cvref_t<decltype(val1)>>, false>(val1, val2, eps_factor)
+    ::detail::floating_point_2d_vector_near<false>(val1, val2, eps_factor)
 
 /**
  * @brief Check whether the floating point values in the plssvm::matrix @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
@@ -467,7 +511,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
 #define EXPECT_FLOATING_POINT_MATRIX_NEAR_EPS(val1, val2, eps_factor) \
-    ::detail::floating_point_matrix_near<plssvm::detail::remove_cvref_t<decltype(val1)>, true>(val1, val2, eps_factor)
+    ::detail::floating_point_matrix_near<true>(val1, val2, eps_factor)
 /**
  * @brief Check whether the floating point values in the plssvm::matrix @p val1 and @p val2 are "equal enough" with respect to a mixture of a relative and absolute mode.
  * @details Other tests in the test case are aborted if this test fails.
@@ -476,7 +520,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] eps_factor a scaling factor in the floating point near calculation
  */
 #define ASSERT_FLOATING_POINT_MATRIX_NEAR_EPS(val1, val2, eps_factor) \
-    ::detail::floating_point_matrix_near<plssvm::detail::remove_cvref_t<decltype(val1)>, false>(val1, val2, eps_factor)
+    ::detail::floating_point_matrix_near<false>(val1, val2, eps_factor)
 
 /**
  * @brief Tries to convert the @p val to a string. If it succeeds, compares the value to @p str.
@@ -485,7 +529,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] str the expected string representation of @p value
  */
 #define EXPECT_CONVERSION_TO_STRING(val, str) \
-    ::detail::convert_to_string<decltype(val), true>(val, str)
+    ::detail::convert_to_string<true>(val, str)
 /**
  * @brief Tries to convert the @p val to a string. If it succeeds, compares the value to @p str.
  * @details Other tests in the test case are aborted if this test fails.
@@ -493,7 +537,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] str the expected string representation of @p value
  */
 #define ASSERT_CONVERSION_TO_STRING(val, str) \
-    ::detail::convert_to_string<decltype(val), false>(val, str)
+    ::detail::convert_to_string<false>(val, str)
 
 /**
  * @brief Tries to convert the string @p str to a value of type `decltype(T)`. If it succeeds, compares the value to @p val.
@@ -502,7 +546,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val the expected value after conversion
  */
 #define EXPECT_CONVERSION_FROM_STRING(str, val) \
-    ::detail::convert_from_string<decltype(val), true>(str, val)
+    ::detail::convert_from_string<true>(str, val)
 /**
  * @brief Tries to convert the string @p str to a value of type `decltype(T)`. If it succeeds, compares the value to @p val.
  * @details Other tests in the test case are aborted if this test fails.
@@ -510,8 +554,9 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  * @param[in] val the expected value after conversion
  */
 #define ASSERT_CONVERSION_FROM_STRING(str, val) \
-    ::detail::convert_from_string<decltype(val), false>(str, val)
+    ::detail::convert_from_string<false>(str, val)
 
+// NOLINTBEGIN(cppcoreguidelines-avoid-do-while): the idiomatic C++ way to ensure that the macro behaves properly with semicolons
 /**
  * @brief Check whether @p statement throws an exception of type @p expected_exception and the exception's `what()` message matches the GTest @p matcher.
  * @details Succeeds only if the exception type **and** message match.
@@ -530,6 +575,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
             FAIL() << "The expected exception type (" #expected_exception ") doesn't match the caught one!"; \
         }                                                                                                    \
     } while (false)
+// NOLINTEND(cppcoreguidelines-avoid-do-while)
 
 /**
  * @brief Check whether @p statement throws an exception of type @p expected_exception with the exception's `what()` message @p msg.
@@ -540,6 +586,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  */
 #define EXPECT_THROW_WHAT(statement, expected_exception, msg) EXPECT_THROW_WHAT_MATCHER(statement, expected_exception, ::testing::StrEq(msg))
 
+// NOLINTBEGIN(cppcoreguidelines-avoid-do-while): the idiomatic C++ way to ensure that the macro behaves properly with semicolons
 /**
  * @brief Check whether the value of @p instance is an instance of the @p type.
  * @param[in] type the type the @p instance should have, assumed to not be a pointer type
@@ -550,6 +597,7 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
         auto ptr = dynamic_cast<type *>(&*instance); \
         EXPECT_NE(ptr, nullptr);                     \
     } while (false)
+// NOLINTEND(cppcoreguidelines-avoid-do-while)
 
 /**
  * @brief Check whether @p val is in the **inclusive** range [@p min, @p max].
@@ -584,4 +632,19 @@ inline void convert_from_string(const std::string &str, const T &expected_value)
  */
 #define ASSERT_EXCLUSIVE_RANGE(val, min, max) ASSERT_THAT((val), ::testing::AllOf(::testing::Gt((min)), ::testing::Lt((max))))
 
+/**
+ * @brief Checks whether the content of @p val1 is equal to @p val2. Both or one of both can be a std::optional (potentially containing a std::reference_wrapper).
+ * @details Other tests in the test case are executed even if this test fails.
+ * @param[in] val1 the optional to check (must be an optional)
+ * @param[in] val2 the value to check the optional against (may also be an optional, but not necessarily)
+ */
+#define EXPECT_OPTIONAL_EQ(val1, val2) ::detail::expect_optional_equal<false>(val1, val2)
+/**
+ * @brief Checks whether the content of @p val1 is equal to @p val2. Both or one of both can be a std::optional (potentially containing a std::reference_wrapper).
+ * @details Other tests in the test case are aborted if this test fails.
+ * @param[in] val1 the optional to check (must be an optional)
+ * @param[in] val2 the value to check the optional against (may also be an optional, but not necessarily)
+ */
+#define ASSERT_OPTIONAL_EQ(val1, val2) ::detail::expect_optional_equal<true>(val1, val2)
+
 #endif  // PLSSVM_TESTS_CUSTOM_TEST_MACROS_HPP_
diff --git a/tests/data_set/classification/constructors.cpp b/tests/data_set/classification/constructors.cpp
index d6213df9b..786ad2f5c 100644
--- a/tests/data_set/classification/constructors.cpp
+++ b/tests/data_set/classification/constructors.cpp
@@ -14,15 +14,16 @@
 #include "plssvm/exceptions/exceptions.hpp"             // plssvm::data_set_exception, plssvm::mpi_exception
 #include "plssvm/file_format_types.hpp"                 // plssvm::file_format_type
 #include "plssvm/matrix.hpp"                            // plssvm::matrix, plssvm::layout_type
-#include "plssvm/mpi/communicator.hpp"                  // plssvm::mpi::communicator
 #include "plssvm/shape.hpp"                             // plssvm::shape
 
-#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_MATRIX_NEAR, EXPECT_FLOATING_POINT_NEAR, EXPECT_THROW_WHAT
+#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_MATRIX_NEAR, EXPECT_FLOATING_POINT_NEAR, EXPECT_THROW_WHAT, EXPECT_OPTIONAL_EQ
 #include "tests/naming.hpp"              // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"       // util::{classification_label_type_gtest, classification_label_type_layout_type_gtest, test_parameter_type_at_t, test_parameter_value_at_v}
 #include "tests/utility.hpp"             // util::{redirect_output, temporary_file, instantiate_template_file, get_distinct_label, get_correct_data_file_labels, generate_specific_matrix, scale}
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/mpi/communicator.hpp"  // plssvm::mpi::communicator
+
     #include "mpi.h"  // MPI_COMM_WORLD, MPI_Comm_dup, MPI_Comm_free
 #endif
 
@@ -31,6 +32,7 @@
 #include <cstddef>      // std::size_t
 #include <tuple>        // std::get
 #include <type_traits>  // std::is_integral_v
+#include <utility>      // std::move
 #include <vector>       // std::vector
 
 template <typename T>
@@ -59,7 +61,7 @@ class ClassificationDataSetConstructors : public ::testing::Test,
 
 TYPED_TEST_SUITE(ClassificationDataSetConstructors, util::classification_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ClassificationDataSetConstructors, typedefs) {
+TYPED_TEST(ClassificationDataSetConstructors, Typedefs) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a data_set using an existing LIBSVM data set file
@@ -75,7 +77,7 @@ TYPED_TEST(ClassificationDataSetConstructors, typedefs) {
 //                                                         construct from file                                                         //
 //*************************************************************************************************************************************//
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_arff_from_file_with_label) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructARFFFromFileWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // must append .arff to filename so that the correct function is called in the data_set constructor
@@ -91,10 +93,8 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_arff_from_file_with_labe
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), this->get_correct_template_file_data_points());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), correct_different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), correct_different_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_template_file_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_template_file_data_points().num_cols());
@@ -104,7 +104,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_arff_from_file_with_labe
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_arff_from_file_without_label) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructARFFFromFileWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -129,7 +129,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_arff_from_file_without_l
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_libsvm_from_file_with_label) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructLIBSVMFromFileWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -142,10 +142,8 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_libsvm_from_file_with_la
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), this->get_correct_template_file_data_points());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), correct_different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), correct_different_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_template_file_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_template_file_data_points().num_cols());
@@ -155,7 +153,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_libsvm_from_file_with_la
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_libsvm_from_file_without_label) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructLIBSVMFromFileWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -180,7 +178,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_libsvm_from_file_without
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_explicit_arff_from_file) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructExplicitARFFFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -193,10 +191,8 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_explicit_arff_from_file)
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), this->get_correct_template_file_data_points());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), correct_different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), correct_different_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_template_file_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_template_file_data_points().num_cols());
@@ -206,7 +202,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_explicit_arff_from_file)
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_explicit_libsvm_from_file) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructExplicitLIBSVMFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -219,10 +215,8 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_explicit_libsvm_from_fil
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), this->get_correct_template_file_data_points());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), correct_different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), correct_different_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_template_file_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_template_file_data_points().num_cols());
@@ -232,7 +226,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_explicit_libsvm_from_fil
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_arff_from_file) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledARFFFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // must append .arff to filename so that the correct function is called in the data_set constructor
@@ -249,34 +243,38 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_arff_from_file) {
     const auto [scaled_data_points, scaling_factors] = util::scale(this->get_correct_template_file_data_points(), plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 });
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), plssvm::soa_matrix<plssvm::real_type>{ scaled_data_points });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), correct_different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), correct_different_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_template_file_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_template_file_data_points().num_cols());
     EXPECT_EQ(data.num_classes(), correct_different_labels.size());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_arff_from_file_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledARFFFromFileCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -294,7 +292,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_arff_from_file_co
 
 #endif
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_libsvm_from_file) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledLIBSVMFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -308,34 +306,38 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_libsvm_from_file)
     const auto [scaled_data_points, scaling_factors] = util::scale(this->get_correct_template_file_data_points(), plssvm::real_type{ -2.5 }, plssvm::real_type{ 2.5 });
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), plssvm::soa_matrix<plssvm::real_type>{ scaled_data_points });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), correct_different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), correct_different_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_template_file_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_template_file_data_points().num_cols());
     EXPECT_EQ(data.num_classes(), correct_different_labels.size());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_libsvm_from_file_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledLIBSVMFromFileCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -350,7 +352,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_libsvm_from_file_
 
 #endif
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_explicit_arff_from_file) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledExplicitARFFFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -364,34 +366,38 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_explicit_arff_fro
     const auto [scaled_data_points, scaling_factors] = util::scale(this->get_correct_template_file_data_points(), plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 });
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), plssvm::soa_matrix<plssvm::real_type>{ scaled_data_points });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), correct_different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), correct_different_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_template_file_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_template_file_data_points().num_cols());
     EXPECT_EQ(data.num_classes(), correct_different_labels.size());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_explicit_arff_from_file_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledExplicitARFFFromFileCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -406,7 +412,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_explicit_arff_fro
 
 #endif
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_explicit_libsvm_from_file) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledExplicitLIBSVMFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -420,34 +426,38 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_explicit_libsvm_f
     const auto [scaled_data_points, scaling_factors] = util::scale(this->get_correct_template_file_data_points(), plssvm::real_type{ -2.5 }, plssvm::real_type{ 2.5 });
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), plssvm::soa_matrix<plssvm::real_type>{ scaled_data_points });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), correct_different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), correct_different_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_template_file_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_template_file_data_points().num_cols());
     EXPECT_EQ(data.num_classes(), correct_different_labels.size());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_explicit_libsvm_from_file_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledExplicitLIBSVMFromFileCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -466,7 +476,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_explicit_libsvm_f
 //                                                      construct from 2D vector                                                       //
 //*************************************************************************************************************************************//
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_without_label) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructFromVectorWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -489,7 +499,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_without_labe
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_from_empty_vector) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructFromEmptyVector) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // creating a data set from an empty vector is illegal
@@ -498,7 +508,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_from_empty_vector) {
                       "Data vector is empty!");
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_with_differing_num_features) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructFromVectorWithDifferingNumFeatures) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -513,7 +523,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_with_differi
                       "Each row in the matrix must contain the same amount of columns!");
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_with_no_features) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructFromVectorWithNoFeatures) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -525,7 +535,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_with_no_feat
                       "The data to create the matrix must at least have one column!");
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_with_label) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructFromVectorWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points and labels
@@ -539,10 +549,8 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_with_label)
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), correct_data_points);
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), different_labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points.num_cols());
@@ -552,7 +560,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_with_label)
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_from_empty_vector_and_labels) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructFromEmptyVectorAndLabels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     const std::vector<label_type> labels = util::get_correct_data_file_labels<label_type>();
@@ -563,7 +571,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_from_empty_vector_and_la
                       "Data vector is empty!");
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_mismatching_num_data_points_and_labels) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructFromVectorMismatchingNumDataPointsAndLabels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points and labels
@@ -577,7 +585,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_from_vector_mismatching_
                       fmt::format("Number of labels ({}) must match the number of data points ({})!", labels.size(), correct_data_points.num_rows()));
 }
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_from_vector_without_label) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledFromVectorWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -598,24 +606,30 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_from_vector_witho
     EXPECT_EQ(data.num_classes(), 0);
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_from_vector_without_label_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledFromVectorWithoutLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -630,7 +644,7 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_from_vector_witho
 
 #endif
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_from_vector_with_label) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledFromVectorWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points and labels
@@ -645,34 +659,38 @@ TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_from_vector_with_
     // check values
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), correct_data_points_scaled);
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), different_labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points_scaled.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
     EXPECT_EQ(data.num_classes(), different_labels.size());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetConstructors, construct_scaled_from_vector_with_label_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetConstructors, ConstructScaledFromVectorWithLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -702,7 +720,7 @@ class ClassificationDataSetMatrixConstructors : public ClassificationDataSetCons
 
 TYPED_TEST_SUITE(ClassificationDataSetMatrixConstructors, util::classification_label_type_layout_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_without_label_no_padding) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructFromMatrixWithoutLabelNoPadding) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -727,7 +745,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_withou
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_without_label) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructFromMatrixWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -751,7 +769,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_withou
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_empty_matrix_no_padding) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructFromEmptyMatrixNoPadding) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -763,7 +781,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_empty_matrix_
                       "Data vector is empty!");
 }
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_empty_matrix) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructFromEmptyMatrix) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -775,7 +793,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_empty_matrix)
                       "Data vector is empty!");
 }
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_with_label_no_padding) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructFromMatrixWithLabelNoPadding) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -791,10 +809,8 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_with_l
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), (plssvm::soa_matrix<plssvm::real_type>{ correct_data_points, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } }));
     EXPECT_TRUE(data.data().is_padded());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), different_labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points.num_cols());
@@ -804,7 +820,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_with_l
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_with_label) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructFromMatrixWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -819,10 +835,8 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_with_l
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), plssvm::soa_matrix<plssvm::real_type>{ correct_data_points });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), different_labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points.num_cols());
@@ -832,7 +846,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_with_l
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_empty_matrix_with_label) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructFromEmptyMatrixWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -846,7 +860,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_empty_matrix_
                       "Data vector is empty!");
 }
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_with_label_size_mismatch) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructFromMatrixWithLabelSizeMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -860,7 +874,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_from_matrix_with_l
                               ::testing::HasSubstr(fmt::format("Number of labels ({}) must match the number of data points ({})!", labels.size(), labels.size() - 1)));
 }
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix_without_label_no_padding) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructScaledFromMatrixWthoutLabelNoPadding) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -883,25 +897,31 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix
     EXPECT_EQ(data.num_classes(), 0);
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix_without_label_no_padding_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructScaledFromMatrixWithoutLabelNoPaddingCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -916,7 +936,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix
 
 #endif
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix_without_label) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructScaledFromMatrixWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -938,25 +958,31 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix
     EXPECT_EQ(data.num_classes(), 0);
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix_without_label_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructScaledFromMatrixWithoutLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -971,7 +997,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix
 
 #endif
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix_with_label_no_padding) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructScaledFromMatrixWithLabelNoPadding) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -988,35 +1014,39 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), (plssvm::soa_matrix<plssvm::real_type>{ correct_data_points_scaled, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } }));
     EXPECT_TRUE(data.data().is_padded());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), different_labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points_scaled.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
     EXPECT_EQ(data.num_classes(), different_labels.size());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix_with_label_no_padding_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructScaledFromMatrixWithLabelNoPaddingCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -1032,7 +1062,7 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix
 }
 #endif
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix_with_label) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructScaledFromMatrixWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -1048,35 +1078,39 @@ TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix
     // check values
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), plssvm::soa_matrix<plssvm::real_type>{ correct_data_points_scaled });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), different_labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points_scaled.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
     EXPECT_EQ(data.num_classes(), different_labels.size());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetMatrixConstructors, construct_scaled_from_matrix_with_label_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetMatrixConstructors, ConstructScaledFromMatrixWithLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -1105,7 +1139,7 @@ class ClassificationDataSetRValueMatrixConstructors : public ClassificationDataS
 
 TYPED_TEST_SUITE(ClassificationDataSetRValueMatrixConstructors, util::classification_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_rvalue_matrix_without_label) {
+TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, ConstructFromRvalueMatrixWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -1130,7 +1164,7 @@ TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_rvalue_
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_empty_rvalue_matrix) {
+TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, ConstructFromEmptyRvalueMatrix) {
     using label_type = typename TestFixture::fixture_label_type;
 
     plssvm::soa_matrix<plssvm::real_type> data_points{ plssvm::shape{ 0, 0 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
@@ -1141,7 +1175,7 @@ TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_empty_r
                       "Data vector is empty!");
 }
 
-TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_rvalue_matrix_wrong_padding) {
+TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, ConstructFromRvalueMatrixWrongPadding) {
     using label_type = typename TestFixture::fixture_label_type;
 
     plssvm::soa_matrix<plssvm::real_type> data_points{ plssvm::shape{ 4, 4 }, plssvm::shape{ 0, 0 } };
@@ -1152,7 +1186,7 @@ TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_rvalue_
                       "Data vector has the wring padding ([0, 0])!");
 }
 
-TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_rvalue_matrix_with_label) {
+TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, ConstructFromRvalueMatrixWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points and labels
@@ -1168,10 +1202,8 @@ TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_rvalue_
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), copied_correct_data_points);
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), copied_labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), copied_labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), different_labels);
 
     EXPECT_EQ(data.num_data_points(), copied_correct_data_points.num_rows());
     EXPECT_EQ(data.num_features(), copied_correct_data_points.num_cols());
@@ -1181,7 +1213,7 @@ TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_rvalue_
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_rvalue_matrix_with_label_wrong_padding) {
+TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, ConstructFromRvalueMatrixWithLabelWrongPadding) {
     using label_type = typename TestFixture::fixture_label_type;
 
     std::vector<label_type> labels = util::get_correct_data_file_labels<label_type>();
@@ -1193,7 +1225,7 @@ TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_from_rvalue_
                       "Data vector has the wring padding ([0, 0])!");
 }
 
-TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_scaled_from_rvalue_matrix_without_label) {
+TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, ConstructScaledFromRvalueMatrixWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -1215,24 +1247,30 @@ TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_scaled_from_
     EXPECT_EQ(data.num_classes(), 0);
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_scaled_from_rvalue_matrix_without_label_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, ConstructScaledFromRvalueMatrixWithoutLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -1247,7 +1285,7 @@ TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_scaled_from_
 
 #endif
 
-TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_scaled_from_rvalue_matrix_with_label) {
+TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, ConstructScaledFromRvalueMatrixWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points and labels
@@ -1264,34 +1302,38 @@ TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_scaled_from_
     // check values
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), correct_data_points_scaled);
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), copied_labels);
-    ASSERT_TRUE(data.classes().has_value());
-    EXPECT_EQ(data.classes().value(), different_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), copied_labels);
+    EXPECT_OPTIONAL_EQ(data.classes(), different_labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points_scaled.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
     EXPECT_EQ(data.num_classes(), different_labels.size());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, construct_scaled_from_rvalue_matrix_with_label_comm_mismatch) {
+TYPED_TEST(ClassificationDataSetRValueMatrixConstructors, ConstructScaledFromRvalueMatrixWithLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
diff --git a/tests/data_set/classification/getter.cpp b/tests/data_set/classification/getter.cpp
index 76a447ee0..5011630b3 100644
--- a/tests/data_set/classification/getter.cpp
+++ b/tests/data_set/classification/getter.cpp
@@ -11,10 +11,11 @@
 #include "plssvm/constants.hpp"                         // plssvm::real_type, plssvm::PADDING_SIZE
 #include "plssvm/data_set/classification_data_set.hpp"  // data set class to test
 #include "plssvm/data_set/min_max_scaler.hpp"           // plssvm::min_max_scaler
-#include "plssvm/matrix.hpp"                            // plssvm::aos_matrix
+#include "plssvm/matrix.hpp"                            // plssvm::soa_matrix
 #include "plssvm/shape.hpp"                             // plssvm::shape
+#include "plssvm/svm_types.hpp"                         // plssvm::svm_type
 
-#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_EQ, EXPECT_FLOATING_POINT_NEAR
+#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_EQ, EXPECT_FLOATING_POINT_NEAR, EXPECT_OPTIONAL_EQ
 #include "tests/naming.hpp"              // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"       // util::{classification_label_type_gtest, test_parameter_type_at_t}
 #include "tests/utility.hpp"             // util::{redirect_output, scale}
@@ -22,7 +23,7 @@
 #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
+#include <utility>  // std::get
 #include <vector>   // std::vector
 
 template <typename T>
@@ -55,12 +56,12 @@ class ClassificationDataSetGetter : public ::testing::Test,
     /// The correct labels.
     std::vector<fixture_label_type> label_{ util::get_correct_data_file_labels<fixture_label_type, plssvm::svm_type::csvc>() };
     /// The correct data points.
-    plssvm::soa_matrix<plssvm::real_type> data_points_{ util::generate_specific_matrix<plssvm::aos_matrix<plssvm::real_type>>(plssvm::shape{ label_.size(), 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE }) };
+    plssvm::soa_matrix<plssvm::real_type> data_points_{ util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ label_.size(), 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE }) };
 };
 
 TYPED_TEST_SUITE(ClassificationDataSetGetter, util::classification_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ClassificationDataSetGetter, data) {
+TYPED_TEST(ClassificationDataSetGetter, Data) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set without labels
@@ -69,7 +70,7 @@ TYPED_TEST(ClassificationDataSetGetter, data) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), this->get_data_points());
 }
 
-TYPED_TEST(ClassificationDataSetGetter, has_labels) {
+TYPED_TEST(ClassificationDataSetGetter, HasLabels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set without labels
@@ -82,7 +83,7 @@ TYPED_TEST(ClassificationDataSetGetter, has_labels) {
     EXPECT_TRUE(data_with_labels.has_labels());
 }
 
-TYPED_TEST(ClassificationDataSetGetter, labels) {
+TYPED_TEST(ClassificationDataSetGetter, Labels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set without labels
@@ -92,11 +93,10 @@ TYPED_TEST(ClassificationDataSetGetter, labels) {
     // create data set with labels
     const plssvm::classification_data_set<label_type> data_with_labels{ this->get_data_points(), this->get_label() };
     // check labels getter
-    ASSERT_TRUE(data_with_labels.labels().has_value());
-    EXPECT_EQ(data_with_labels.labels()->get(), this->get_label());
+    EXPECT_OPTIONAL_EQ(data_with_labels.labels(), this->get_label());
 }
 
-TYPED_TEST(ClassificationDataSetGetter, classes) {
+TYPED_TEST(ClassificationDataSetGetter, Classes) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set without labels
@@ -106,11 +106,10 @@ TYPED_TEST(ClassificationDataSetGetter, classes) {
     // create data set with labels
     const plssvm::classification_data_set<label_type> data_with_labels{ this->get_data_points(), this->get_label() };
     // check different_labels getter
-    ASSERT_TRUE(data_with_labels.classes().has_value());
-    EXPECT_EQ(*data_with_labels.classes(), this->get_classes());
+    EXPECT_OPTIONAL_EQ(data_with_labels.classes(), this->get_classes());
 }
 
-TYPED_TEST(ClassificationDataSetGetter, num_data_points) {
+TYPED_TEST(ClassificationDataSetGetter, NumDataPoints) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -119,7 +118,7 @@ TYPED_TEST(ClassificationDataSetGetter, num_data_points) {
     EXPECT_EQ(data.num_data_points(), this->get_data_points().num_rows());
 }
 
-TYPED_TEST(ClassificationDataSetGetter, num_features) {
+TYPED_TEST(ClassificationDataSetGetter, NumFeatures) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -128,7 +127,7 @@ TYPED_TEST(ClassificationDataSetGetter, num_features) {
     EXPECT_EQ(data.num_features(), this->get_data_points().num_cols());
 }
 
-TYPED_TEST(ClassificationDataSetGetter, num_classes) {
+TYPED_TEST(ClassificationDataSetGetter, NumClasses) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set without labels
@@ -142,7 +141,7 @@ TYPED_TEST(ClassificationDataSetGetter, num_classes) {
     EXPECT_EQ(data_with_label.num_classes(), this->get_classes().size());
 }
 
-TYPED_TEST(ClassificationDataSetGetter, is_scaled) {
+TYPED_TEST(ClassificationDataSetGetter, IsScaled) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -156,7 +155,7 @@ TYPED_TEST(ClassificationDataSetGetter, is_scaled) {
     EXPECT_TRUE(data_scaled.is_scaled());
 }
 
-TYPED_TEST(ClassificationDataSetGetter, scaling_factors) {
+TYPED_TEST(ClassificationDataSetGetter, ScalingFactors) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -167,16 +166,25 @@ TYPED_TEST(ClassificationDataSetGetter, scaling_factors) {
     // create scaled data set
     const plssvm::classification_data_set<label_type> data_scaled{ this->get_data_points(), plssvm::min_max_scaler{ plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 } } };
     // check scaling_factors getter
-    ASSERT_TRUE(data_scaled.scaling_factors().has_value());
-    const auto &[ignored, correct_scaling_factors] = util::scale(this->get_data_points(), plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 });
-    const plssvm::min_max_scaler &scaling_factors = *data_scaled.scaling_factors();
-    EXPECT_FLOATING_POINT_EQ(scaling_factors.scaling_interval().first, plssvm::real_type{ -1.0 });
-    EXPECT_FLOATING_POINT_EQ(scaling_factors.scaling_interval().second, plssvm::real_type{ 1.0 });
-    ASSERT_TRUE(scaling_factors.scaling_factors().has_value());
-    ASSERT_EQ(scaling_factors.scaling_factors()->size(), correct_scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.scaling_factors()->size(); ++i) {
-        EXPECT_EQ(scaling_factors.scaling_factors().value()[i].feature, std::get<0>(correct_scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(scaling_factors.scaling_factors().value()[i].lower, std::get<1>(correct_scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(scaling_factors.scaling_factors().value()[i].upper, std::get<2>(correct_scaling_factors[i]));
+    const auto &scaling_factors_opt = data_scaled.scaling_factors();
+    ASSERT_TRUE(scaling_factors_opt.has_value());
+    if (scaling_factors_opt.has_value()) {
+        const plssvm::min_max_scaler scaling_factors = scaling_factors_opt.value().get();
+
+        // check scaling factor content
+        const auto &[ignored, correct_scaling_factors] = util::scale(this->get_data_points(), plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 });
+        EXPECT_FLOATING_POINT_EQ(scaling_factors.scaling_interval().first, plssvm::real_type{ -1.0 });
+        EXPECT_FLOATING_POINT_EQ(scaling_factors.scaling_interval().second, plssvm::real_type{ 1.0 });
+        const auto &factors_opt = scaling_factors.scaling_factors();
+        ASSERT_TRUE(factors_opt.has_value());
+        if (factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = factors_opt.value();
+            ASSERT_EQ(factors.size(), correct_scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(correct_scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(correct_scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(correct_scaling_factors[i]));
+            }
+        }
     }
 }
diff --git a/tests/data_set/classification/label_mapper.cpp b/tests/data_set/classification/label_mapper.cpp
index 9f7e04c5d..44dbab4ae 100644
--- a/tests/data_set/classification/label_mapper.cpp
+++ b/tests/data_set/classification/label_mapper.cpp
@@ -34,7 +34,7 @@ class ClassificationDataSetLabelMapper : public ::testing::Test {
 
 TYPED_TEST_SUITE(ClassificationDataSetLabelMapper, util::label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ClassificationDataSetLabelMapper, construct) {
+TYPED_TEST(ClassificationDataSetLabelMapper, Construct) {
     using label_type = typename TestFixture::fixture_label_type;
     using label_mapper_type = typename plssvm::classification_data_set<label_type>::label_mapper;
 
@@ -54,7 +54,7 @@ TYPED_TEST(ClassificationDataSetLabelMapper, construct) {
     }
 }
 
-TYPED_TEST(ClassificationDataSetLabelMapper, get_mapped_index_by_label) {
+TYPED_TEST(ClassificationDataSetLabelMapper, GetMappedIndexByLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     using label_mapper_type = typename plssvm::classification_data_set<label_type>::label_mapper;
 
@@ -73,7 +73,7 @@ TYPED_TEST(ClassificationDataSetLabelMapper, get_mapped_index_by_label) {
     }
 }
 
-TYPED_TEST(ClassificationDataSetLabelMapper, get_mapped_index_by_invalid_label) {
+TYPED_TEST(ClassificationDataSetLabelMapper, GetMappedIndexByInvalidLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     using label_mapper_type = typename plssvm::classification_data_set<label_type>::label_mapper;
 
@@ -94,7 +94,7 @@ TYPED_TEST(ClassificationDataSetLabelMapper, get_mapped_index_by_invalid_label)
     }
 }
 
-TYPED_TEST(ClassificationDataSetLabelMapper, get_label_by_mapped_index) {
+TYPED_TEST(ClassificationDataSetLabelMapper, GetLabelByMappedIndex) {
     using label_type = typename TestFixture::fixture_label_type;
     using label_mapper_type = typename plssvm::classification_data_set<label_type>::label_mapper;
 
@@ -113,7 +113,7 @@ TYPED_TEST(ClassificationDataSetLabelMapper, get_label_by_mapped_index) {
     }
 }
 
-TYPED_TEST(ClassificationDataSetLabelMapper, get_label_by_invalid_mapped_index) {
+TYPED_TEST(ClassificationDataSetLabelMapper, GetLabelByInvalidMappedIndex) {
     using label_type = typename TestFixture::fixture_label_type;
     using label_mapper_type = typename plssvm::classification_data_set<label_type>::label_mapper;
 
@@ -129,7 +129,7 @@ TYPED_TEST(ClassificationDataSetLabelMapper, get_label_by_invalid_mapped_index)
                       fmt::format("Mapped index \"{}\" unknown in this label mapping!", mapper.num_mappings() + 1));
 }
 
-TYPED_TEST(ClassificationDataSetLabelMapper, num_mappings) {
+TYPED_TEST(ClassificationDataSetLabelMapper, NumMappings) {
     using label_type = typename TestFixture::fixture_label_type;
     using label_mapper_type = typename plssvm::classification_data_set<label_type>::label_mapper;
 
@@ -143,7 +143,7 @@ TYPED_TEST(ClassificationDataSetLabelMapper, num_mappings) {
     EXPECT_EQ(mapper.num_mappings(), different_labels.size());
 }
 
-TYPED_TEST(ClassificationDataSetLabelMapper, labels) {
+TYPED_TEST(ClassificationDataSetLabelMapper, Labels) {
     using label_type = typename TestFixture::fixture_label_type;
     using label_mapper_type = typename plssvm::classification_data_set<label_type>::label_mapper;
 
@@ -162,7 +162,7 @@ class ClassificationDataSetLabelMapperDeathTest : public ClassificationDataSetLa
 
 TYPED_TEST_SUITE(ClassificationDataSetLabelMapperDeathTest, util::label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ClassificationDataSetLabelMapperDeathTest, duplicated_labels) {
+TYPED_TEST(ClassificationDataSetLabelMapperDeathTest, DuplicatedLabels) {
     using label_type = typename TestFixture::fixture_label_type;
     using label_mapper_type = typename plssvm::classification_data_set<label_type>::label_mapper;
 
diff --git a/tests/data_set/classification/save.cpp b/tests/data_set/classification/save.cpp
index 296600b81..fa0aaea2b 100644
--- a/tests/data_set/classification/save.cpp
+++ b/tests/data_set/classification/save.cpp
@@ -15,6 +15,7 @@
 #include "plssvm/file_format_types.hpp"                 // plssvm::file_format_type
 #include "plssvm/matrix.hpp"                            // plssvm::aos_matrix
 #include "plssvm/shape.hpp"                             // plssvm::shape
+#include "plssvm/svm_types.hpp"                         // plssvm::svm_type
 
 #include "tests/naming.hpp"         // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"  // util::{classification_label_type_gtest, test_parameter_type_at_t}
@@ -58,7 +59,7 @@ class ClassificationDataSetSave : public ::testing::Test,
 
 TYPED_TEST_SUITE(ClassificationDataSetSave, util::classification_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ClassificationDataSetSave, save_libsvm_with_label) {
+TYPED_TEST(ClassificationDataSetSave, SaveLIBSVMWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set with labels
@@ -78,7 +79,7 @@ TYPED_TEST(ClassificationDataSetSave, save_libsvm_with_label) {
     }
 }
 
-TYPED_TEST(ClassificationDataSetSave, save_libsvm_without_label) {
+TYPED_TEST(ClassificationDataSetSave, SaveLIBSVMWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set without labels
@@ -98,7 +99,7 @@ TYPED_TEST(ClassificationDataSetSave, save_libsvm_without_label) {
     }
 }
 
-TYPED_TEST(ClassificationDataSetSave, save_libsvm_automatic_format) {
+TYPED_TEST(ClassificationDataSetSave, SaveLIBSVMAutomaticFormat) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set with labels
@@ -122,7 +123,7 @@ TYPED_TEST(ClassificationDataSetSave, save_libsvm_automatic_format) {
     }
 }
 
-TYPED_TEST(ClassificationDataSetSave, save_arff_with_label) {
+TYPED_TEST(ClassificationDataSetSave, SaveARFFWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set with labels
@@ -152,7 +153,7 @@ TYPED_TEST(ClassificationDataSetSave, save_arff_with_label) {
     }
 }
 
-TYPED_TEST(ClassificationDataSetSave, save_arff_without_label) {
+TYPED_TEST(ClassificationDataSetSave, SaveARFFWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set with labels
@@ -181,7 +182,7 @@ TYPED_TEST(ClassificationDataSetSave, save_arff_without_label) {
     }
 }
 
-TYPED_TEST(ClassificationDataSetSave, save_arff_automatic_format) {
+TYPED_TEST(ClassificationDataSetSave, SaveARFFAutomaticFormat) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set with labels
diff --git a/tests/data_set/min_max_scaler.cpp b/tests/data_set/min_max_scaler.cpp
index 611aca495..bec30fb25 100644
--- a/tests/data_set/min_max_scaler.cpp
+++ b/tests/data_set/min_max_scaler.cpp
@@ -14,17 +14,19 @@
 #include "plssvm/detail/io/file_reader.hpp"     // plssvm::detail::io::file_reader
 #include "plssvm/detail/string_conversion.hpp"  // plssvm::detail::convert_to
 #include "plssvm/exceptions/exceptions.hpp"     // plssvm::min_max_scaler_exception
+#include "plssvm/matrix.hpp"                    // plssvm::soa_matrix
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_EQ, EXPECT_THROW_WHAT
 #include "tests/utility.hpp"             // util::{temporary_file, redirect_output}
 
+#include "gmock/gmock.h"  // ::testing::HasSubstr
 #include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_TRUE, ASSERT_EQ, ASSERT_GE, ASSERT_TRUE, ::testing::Test
 
 #include <cstddef>  // std::size_t
 #include <regex>    // std::regex, std::regex::extended, std::regex_match
 #include <vector>   // std::vector
 
-TEST(MinMaxScaler, default_construct_factor) {
+TEST(MinMaxScaler, DefaultConstructFactor) {
     // create factor
     const plssvm::min_max_scaler::factors factor{};
 
@@ -34,7 +36,7 @@ TEST(MinMaxScaler, default_construct_factor) {
     EXPECT_FLOATING_POINT_EQ(factor.upper, plssvm::real_type{});
 }
 
-TEST(MinMaxScaler, construct_factor) {
+TEST(MinMaxScaler, ConstructFactor) {
     // create factor
     const plssvm::min_max_scaler::factors factor{ 1, plssvm::real_type{ -2.5 }, plssvm::real_type{ 2.5 } };
 
@@ -44,7 +46,7 @@ TEST(MinMaxScaler, construct_factor) {
     EXPECT_FLOATING_POINT_EQ(factor.upper, plssvm::real_type{ 2.5 });
 }
 
-TEST(MinMaxScaler, construct_interval) {
+TEST(MinMaxScaler, ConstructInterval) {
     // create scaling class
     const plssvm::min_max_scaler scaler{ plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 } };
 
@@ -54,14 +56,14 @@ TEST(MinMaxScaler, construct_interval) {
     EXPECT_FALSE(scaler.scaling_factors().has_value());
 }
 
-TEST(MinMaxScaler, construct_invalid_interval) {
+TEST(MinMaxScaler, ConstructInvalidInterval) {
     // create scaling class with an invalid interval
     EXPECT_THROW_WHAT((plssvm::min_max_scaler{ plssvm::real_type{ 1.0 }, plssvm::real_type{ -1.0 } }),
                       plssvm::min_max_scaler_exception,
                       "Inconsistent scaling interval specification: lower (1) must be less than upper (-1)!");
 }
 
-TEST(MinMaxScaler, construct_from_file) {
+TEST(MinMaxScaler, ConstructFromFile) {
     using factors_type = plssvm::min_max_scaler::factors;
 
     // create scaling class
@@ -76,16 +78,20 @@ TEST(MinMaxScaler, construct_from_file) {
         factors_type{ 3, plssvm::real_type{ 3.3 }, plssvm::real_type{ 4.3 } },
         factors_type{ 4, plssvm::real_type{ 4.4 }, plssvm::real_type{ 5.4 } },
     };
-    ASSERT_TRUE(scaler.scaling_factors().has_value());
-    ASSERT_EQ(scaler.scaling_factors()->size(), correct_factors.size());
-    for (std::size_t i = 0; i < correct_factors.size(); ++i) {
-        EXPECT_EQ(scaler.scaling_factors().value()[i].feature, correct_factors[i].feature);
-        EXPECT_FLOATING_POINT_EQ(scaler.scaling_factors().value()[i].lower, correct_factors[i].lower);
-        EXPECT_FLOATING_POINT_EQ(scaler.scaling_factors().value()[i].upper, correct_factors[i].upper);
+    const auto &factors_opt = scaler.scaling_factors();
+    ASSERT_TRUE(factors_opt.has_value());
+    if (factors_opt.has_value()) {
+        const std::vector<plssvm::min_max_scaler::factors> factors = factors_opt.value();
+        ASSERT_EQ(factors.size(), correct_factors.size());
+        for (std::size_t i = 0; i < factors.size(); ++i) {
+            EXPECT_EQ(factors[i].feature, correct_factors[i].feature);
+            EXPECT_FLOATING_POINT_EQ(factors[i].lower, correct_factors[i].lower);
+            EXPECT_FLOATING_POINT_EQ(factors[i].upper, correct_factors[i].upper);
+        }
     }
 }
 
-TEST(MinMaxScaler, save) {
+TEST(MinMaxScaler, Save) {
     // create scaling class
     const plssvm::min_max_scaler scaler{ PLSSVM_TEST_PATH "/data/scaling_factors/scaling_factors.txt" };
 
@@ -109,7 +115,7 @@ TEST(MinMaxScaler, save) {
     }
 }
 
-TEST(MinMaxScaler, save_empty_scaling_factors) {
+TEST(MinMaxScaler, SaveEmptyScalingFactors) {
     // create scaling class
     const plssvm::min_max_scaler scaler{ plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 } };
 
@@ -129,7 +135,7 @@ TEST(MinMaxScaler, save_empty_scaling_factors) {
     EXPECT_TRUE(std::regex_match(std::string{ reader.line(1) }, reg));
 }
 
-TEST(MinMaxScaler, scale_scaling_factors_empty) {
+TEST(MinMaxScaler, ScaleScalingFactorsEmpty) {
     // create scaling class
     plssvm::min_max_scaler scaler{ plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 } };
 
@@ -144,7 +150,7 @@ TEST(MinMaxScaler, scale_scaling_factors_empty) {
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data, data_scaled);
 }
 
-TEST(MinMaxScaler, scale_scaling_factors) {
+TEST(MinMaxScaler, ScaleScalingFactors) {
     // create temporary file
     const util::temporary_file tmp_file{};  // automatically removes the created file at the end of its scope
 
@@ -173,7 +179,7 @@ TEST(MinMaxScaler, scale_scaling_factors) {
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data_2, data_scaled);
 }
 
-TEST(MinMaxScaler, scale_too_many_scaling_factors) {
+TEST(MinMaxScaler, ScaleTooManyScalingFactors) {
     // create scaling class
     plssvm::min_max_scaler scaler{ PLSSVM_TEST_PATH "/data/scaling_factors/scaling_factors.txt" };
 
@@ -184,7 +190,7 @@ TEST(MinMaxScaler, scale_too_many_scaling_factors) {
     EXPECT_THROW_WHAT_MATCHER(scaler.scale(data), plssvm::min_max_scaler_exception, ::testing::HasSubstr("Need at most as much scaling factors as features in the data set are present (3), but 4 were given!"));
 }
 
-TEST(MinMaxScaler, scale_feature_index_too_big) {
+TEST(MinMaxScaler, ScaleFeatureIndexTooBig) {
     // create scaling class
     plssvm::min_max_scaler scaler{ PLSSVM_TEST_PATH "/data/scaling_factors/scaling_factors.txt" };
 
@@ -195,7 +201,7 @@ TEST(MinMaxScaler, scale_feature_index_too_big) {
     EXPECT_THROW_WHAT(scaler.scale(data), plssvm::min_max_scaler_exception, "The maximum scaling feature index most not be greater or equal than 4, but is 4!");
 }
 
-TEST(MinMaxScaler, scale_scaling_factor_more_than_once) {
+TEST(MinMaxScaler, ScaleScalingFactorMoreThanOnce) {
     // create scaling class
     plssvm::min_max_scaler scaler{ PLSSVM_TEST_PATH "/data/scaling_factors/invalid/feature_index_more_than_once.txt" };
 
diff --git a/tests/data_set/regression/constructors.cpp b/tests/data_set/regression/constructors.cpp
index d6001c93c..04ca4023f 100644
--- a/tests/data_set/regression/constructors.cpp
+++ b/tests/data_set/regression/constructors.cpp
@@ -14,16 +14,17 @@
 #include "plssvm/exceptions/exceptions.hpp"         // plssvm::data_set_exception, plssvm::mpi_exception
 #include "plssvm/file_format_types.hpp"             // plssvm::file_format_type
 #include "plssvm/matrix.hpp"                        // plssvm::matrix, plssvm::layout_type
-#include "plssvm/mpi/communicator.hpp"              // plssvm::mpi::communicator
 #include "plssvm/shape.hpp"                         // plssvm::shape
 #include "plssvm/svm_types.hpp"                     // plssvm::svm_type
 
-#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_MATRIX_NEAR, EXPECT_FLOATING_POINT_NEAR, EXPECT_THROW_WHAT
+#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_MATRIX_NEAR, EXPECT_FLOATING_POINT_NEAR, EXPECT_THROW_WHAT, EXPECT_OPTIONAL_EQ
 #include "tests/naming.hpp"              // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"       // util::{regression_label_type_gtest, regression_label_type_layout_type_gtest, test_parameter_type_at_t, test_parameter_value_at_v}
 #include "tests/utility.hpp"             // util::{redirect_output, temporary_file, instantiate_template_file, get_distinct_label, get_correct_data_file_labels, generate_specific_matrix, scale}
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/mpi/communicator.hpp"  // plssvm::mpi::communicator
+
     #include "mpi.h"  // MPI_COMM_WORLD, MPI_Comm_dup, MPI_Comm_free
 #endif
 
@@ -32,6 +33,7 @@
 #include <cstddef>      // std::size_t
 #include <tuple>        // std::get
 #include <type_traits>  // std::is_integral_v
+#include <utility>      // std::move
 #include <vector>       // std::vector
 
 template <typename T>
@@ -59,7 +61,7 @@ class RegressionDataSetConstructors : public ::testing::Test,
 
 TYPED_TEST_SUITE(RegressionDataSetConstructors, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(RegressionDataSetConstructors, typedefs) {
+TYPED_TEST(RegressionDataSetConstructors, Typedefs) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a data_set using an existing LIBSVM data set file
@@ -74,7 +76,7 @@ TYPED_TEST(RegressionDataSetConstructors, typedefs) {
 //                                                         construct from file                                                         //
 //*************************************************************************************************************************************//
 
-TYPED_TEST(RegressionDataSetConstructors, construct_arff_from_file_with_label) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructARFFFromFileWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -85,8 +87,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_arff_from_file_with_label) {
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), this->get_correct_data_points());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_data_points().num_cols());
@@ -95,7 +96,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_arff_from_file_with_label) {
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_arff_from_file_without_label) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructARFFFromFileWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -118,7 +119,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_arff_from_file_without_label
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_libsvm_from_file_with_label) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructLIBSVMFromFileWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -129,8 +130,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_libsvm_from_file_with_label)
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), this->get_correct_data_points());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_data_points().num_cols());
@@ -139,7 +139,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_libsvm_from_file_with_label)
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_libsvm_from_file_without_label) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructLIBSVMFromFileWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -162,7 +162,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_libsvm_from_file_without_lab
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_explicit_arff_from_file) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructExplicitARFFFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -173,8 +173,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_explicit_arff_from_file) {
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), this->get_correct_data_points());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_data_points().num_cols());
@@ -183,7 +182,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_explicit_arff_from_file) {
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_explicit_libsvm_from_file) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructExplicitLIBSVMFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -194,8 +193,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_explicit_libsvm_from_file) {
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), this->get_correct_data_points());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_data_points().num_cols());
@@ -204,7 +202,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_explicit_libsvm_from_file) {
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_arff_from_file) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledARFFFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -216,31 +214,36 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_arff_from_file) {
     const auto [scaled_data_points, scaling_factors] = util::scale(this->get_correct_data_points(), plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 });
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), plssvm::soa_matrix<plssvm::real_type>{ scaled_data_points });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_data_points().num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_arff_from_file_comm_mismatch) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledARFFFromFileCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -254,7 +257,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_arff_from_file_comm_m
 
 #endif
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_libsvm_from_file) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledLIBSVMFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -266,31 +269,36 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_libsvm_from_file) {
     const auto [scaled_data_points, scaling_factors] = util::scale(this->get_correct_data_points(), plssvm::real_type{ -2.5 }, plssvm::real_type{ 2.5 });
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), plssvm::soa_matrix<plssvm::real_type>{ scaled_data_points });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_data_points().num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_libsvm_from_file_comm_mismatch) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledLIBSVMFromFileCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -304,7 +312,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_libsvm_from_file_comm
 
 #endif
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_explicit_arff_from_file) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledExplicitARFFFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -316,31 +324,36 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_explicit_arff_from_fi
     const auto [scaled_data_points, scaling_factors] = util::scale(this->get_correct_data_points(), plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 });
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), plssvm::soa_matrix<plssvm::real_type>{ scaled_data_points });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_data_points().num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_explicit_arff_from_file_comm_mismatch) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledExplicitARFFFromFileCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -354,7 +367,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_explicit_arff_from_fi
 
 #endif
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_explicit_libsvm_from_file) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledExplicitLIBSVMFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -366,31 +379,36 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_explicit_libsvm_from_
     const auto [scaled_data_points, scaling_factors] = util::scale(this->get_correct_data_points(), plssvm::real_type{ -2.5 }, plssvm::real_type{ 2.5 });
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), plssvm::soa_matrix<plssvm::real_type>{ scaled_data_points });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), correct_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), correct_labels);
 
     EXPECT_EQ(data.num_data_points(), this->get_correct_data_points().num_rows());
     EXPECT_EQ(data.num_features(), this->get_correct_data_points().num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_explicit_libsvm_from_file_comm_mismatch) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledExplicitLIBSVMFromFileCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -408,7 +426,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_explicit_libsvm_from_
 //                                                      construct from 2D vector                                                       //
 //*************************************************************************************************************************************//
 
-TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_without_label) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructFromVectorWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -429,7 +447,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_without_label) {
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_from_empty_vector) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructFromEmptyVector) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // creating a data set from an empty vector is illegal
@@ -438,7 +456,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_from_empty_vector) {
                       "Data vector is empty!");
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_with_differing_num_features) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructFromVectorWithDifferentNumFeatures) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -453,7 +471,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_with_differing_n
                       "Each row in the matrix must contain the same amount of columns!");
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_with_no_features) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructFromVectorWithNoFeatures) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -465,7 +483,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_with_no_features
                       "The data to create the matrix must at least have one column!");
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_with_label) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructFromVectorWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points and labels
@@ -478,8 +496,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_with_label) {
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), correct_data_points);
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points.num_cols());
@@ -488,7 +505,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_with_label) {
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_from_empty_vector_and_labels) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructFromEmptyVectorAndLabels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     const std::vector<label_type> labels = util::get_correct_data_file_labels<label_type>();
@@ -499,7 +516,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_from_empty_vector_and_labels
                       "Data vector is empty!");
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_mismatching_num_data_points_and_labels) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructFromVectorMismatchingNumDataPointsAndLabels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points and labels
@@ -513,7 +530,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_from_vector_mismatching_num_
                       fmt::format("Number of labels ({}) must match the number of data points ({})!", labels.size(), correct_data_points.num_rows()));
 }
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_from_vector_without_label) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledFromVectorWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -532,24 +549,30 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_from_vector_without_l
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_from_vector_without_label_comm_mismatch) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledFromVectorWithoutLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -564,7 +587,7 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_from_vector_without_l
 
 #endif
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_from_vector_with_label) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledFromVectorWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points and labels
@@ -578,31 +601,36 @@ TYPED_TEST(RegressionDataSetConstructors, construct_scaled_from_vector_with_labe
     // check values
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), correct_data_points_scaled);
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points_scaled.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetConstructors, construct_scaled_from_vector_with_label_comm_mismatch) {
+TYPED_TEST(RegressionDataSetConstructors, ConstructScaledFromVectorWithLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -631,7 +659,7 @@ class RegressionDataSetMatrixConstructors : public RegressionDataSetConstructors
 
 TYPED_TEST_SUITE(RegressionDataSetMatrixConstructors, util::regression_label_type_layout_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_without_label_no_padding) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructFromMatrixWithoutLabelNoPadding) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -654,7 +682,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_without_la
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_without_label) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructFromMatrixWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -676,7 +704,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_without_la
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_empty_matrix_no_padding) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructFromEmptyMatrixNoPadding) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -688,7 +716,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_empty_matrix_no_p
                       "Data vector is empty!");
 }
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_empty_matrix) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructFromEmptyMatrix) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -700,7 +728,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_empty_matrix) {
                       "Data vector is empty!");
 }
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_with_label_no_padding) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructFromMatrixWithLabelNoPadding) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -715,8 +743,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_with_label
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), (plssvm::soa_matrix<plssvm::real_type>{ correct_data_points, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } }));
     EXPECT_TRUE(data.data().is_padded());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points.num_cols());
@@ -725,7 +752,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_with_label
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_with_label) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructFromMatrixWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -739,8 +766,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_with_label
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), plssvm::soa_matrix<plssvm::real_type>{ correct_data_points });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points.num_cols());
@@ -749,7 +775,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_with_label
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_empty_matrix_with_label) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructFromEmptyMatrixWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -763,7 +789,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_empty_matrix_with
                       "Data vector is empty!");
 }
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_with_label_size_mismatch) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructFromMatrixWithLabelSizeMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -777,7 +803,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_from_matrix_with_label
                               ::testing::HasSubstr(fmt::format("Number of labels ({}) must match the number of data points ({})!", labels.size(), labels.size() - 1)));
 }
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_without_label_no_padding) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructScaledFromMatrixWithoutLabelNoPadding) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -798,25 +824,31 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_wit
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_without_label_no_padding_comm_mismatch) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructScaledFromMatrixWithoutLabelNoPaddingCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -831,7 +863,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_wit
 
 #endif
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_without_label) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructScaledFromMatrixWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -851,25 +883,31 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_wit
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_without_label_comm_mismatch) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructScaledFromMatrixWithoutLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -884,7 +922,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_wit
 
 #endif
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_with_label_no_padding) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructScaledFromMatrixWithLabelNoPadding) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -900,32 +938,37 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_wit
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), (plssvm::soa_matrix<plssvm::real_type>{ correct_data_points_scaled, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } }));
     EXPECT_TRUE(data.data().is_padded());
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points_scaled.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_with_label_no_padding_comm_mismatch) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructScaledFromMatrixWithLabelNoPaddingCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -940,7 +983,7 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_wit
 }
 #endif
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_with_label) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructScaledFromMatrixWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -955,32 +998,37 @@ TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_wit
     // check values
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), plssvm::soa_matrix<plssvm::real_type>{ correct_data_points_scaled });
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points_scaled.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetMatrixConstructors, construct_scaled_from_matrix_with_label_comm_mismatch) {
+TYPED_TEST(RegressionDataSetMatrixConstructors, ConstructScaledFromMatrixWithLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -1009,7 +1057,7 @@ class RegressionDataSetRValueMatrixConstructors : public RegressionDataSetConstr
 
 TYPED_TEST_SUITE(RegressionDataSetRValueMatrixConstructors, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_rvalue_matrix_without_label) {
+TYPED_TEST(RegressionDataSetRValueMatrixConstructors, ConstructFromRvalueMatrixWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -1032,7 +1080,7 @@ TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_rvalue_matr
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_empty_rvalue_matrix) {
+TYPED_TEST(RegressionDataSetRValueMatrixConstructors, ConstructFromEmptyRvalueMatrix) {
     using label_type = typename TestFixture::fixture_label_type;
 
     plssvm::soa_matrix<plssvm::real_type> data_points{ plssvm::shape{ 0, 0 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
@@ -1043,7 +1091,7 @@ TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_empty_rvalu
                       "Data vector is empty!");
 }
 
-TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_rvalue_matrix_wrong_padding) {
+TYPED_TEST(RegressionDataSetRValueMatrixConstructors, ConstructFromRvalueMatrixWrongPadding) {
     using label_type = typename TestFixture::fixture_label_type;
 
     plssvm::soa_matrix<plssvm::real_type> data_points{ plssvm::shape{ 4, 4 }, plssvm::shape{ 0, 0 } };
@@ -1054,7 +1102,7 @@ TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_rvalue_matr
                       "Data vector has the wring padding ([0, 0])!");
 }
 
-TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_rvalue_matrix_with_label) {
+TYPED_TEST(RegressionDataSetRValueMatrixConstructors, ConstructFromRvalueMatrixWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points and labels
@@ -1069,8 +1117,7 @@ TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_rvalue_matr
     // check values
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), copied_correct_data_points);
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), copied_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), copied_labels);
 
     EXPECT_EQ(data.num_data_points(), copied_correct_data_points.num_rows());
     EXPECT_EQ(data.num_features(), copied_correct_data_points.num_cols());
@@ -1079,7 +1126,7 @@ TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_rvalue_matr
     EXPECT_FALSE(data.scaling_factors().has_value());
 }
 
-TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_rvalue_matrix_with_label_wrong_padding) {
+TYPED_TEST(RegressionDataSetRValueMatrixConstructors, ConstructFromRvalueMatrixWithLabelWrongPadding) {
     using label_type = typename TestFixture::fixture_label_type;
 
     std::vector<label_type> labels = util::get_correct_data_file_labels<label_type, plssvm::svm_type::csvr>();
@@ -1091,7 +1138,7 @@ TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_from_rvalue_matr
                       "Data vector has the wring padding ([0, 0])!");
 }
 
-TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_scaled_from_rvalue_matrix_without_label) {
+TYPED_TEST(RegressionDataSetRValueMatrixConstructors, ConstructScaledFromRvalueMatrixWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points
@@ -1111,24 +1158,30 @@ TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_scaled_from_rval
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_scaled_from_rvalue_matrix_without_label_comm_mismatch) {
+TYPED_TEST(RegressionDataSetRValueMatrixConstructors, ConstructScaledFromRvalueMatrixWithoutLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -1143,7 +1196,7 @@ TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_scaled_from_rval
 
 #endif
 
-TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_scaled_from_rvalue_matrix_with_label) {
+TYPED_TEST(RegressionDataSetRValueMatrixConstructors, ConstructScaledFromRvalueMatrixWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data points and labels
@@ -1159,31 +1212,36 @@ TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_scaled_from_rval
     // check values
     EXPECT_FLOATING_POINT_MATRIX_NEAR(data.data(), correct_data_points_scaled);
     EXPECT_TRUE(data.has_labels());
-    ASSERT_TRUE(data.labels().has_value());
-    EXPECT_EQ(data.labels().value().get(), copied_labels);
+    EXPECT_OPTIONAL_EQ(data.labels(), copied_labels);
 
     EXPECT_EQ(data.num_data_points(), correct_data_points_scaled.num_rows());
     EXPECT_EQ(data.num_features(), correct_data_points_scaled.num_cols());
 
     EXPECT_TRUE(data.is_scaled());
-    EXPECT_TRUE(data.scaling_factors().has_value());
-    ASSERT_TRUE(data.scaling_factors().value().get().scaling_factors().has_value());
-    ASSERT_EQ(data.scaling_factors().value().get().scaling_factors()->size(), scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.size(); ++i) {
-        auto factors = data.scaling_factors().value().get().scaling_factors().value()[i];
-        EXPECT_EQ(factors.feature, std::get<0>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.lower, std::get<1>(scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(factors.upper, std::get<2>(scaling_factors[i]));
+    const auto &data_scaling_factors_opt = data.scaling_factors();
+    EXPECT_TRUE(data_scaling_factors_opt.has_value());
+    if (data_scaling_factors_opt.has_value()) {
+        const auto &scaling_factors_opt = data_scaling_factors_opt.value().get().scaling_factors();
+        ASSERT_TRUE(scaling_factors_opt.has_value());
+        if (scaling_factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = scaling_factors_opt.value();
+            ASSERT_EQ(factors.size(), scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(scaling_factors[i]));
+            }
+        }
     }
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(RegressionDataSetRValueMatrixConstructors, construct_scaled_from_rvalue_matrix_with_label_comm_mismatch) {
+TYPED_TEST(RegressionDataSetRValueMatrixConstructors, ConstructScaledFromRvalueMatrixWithLabelCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
diff --git a/tests/data_set/regression/getter.cpp b/tests/data_set/regression/getter.cpp
index 9022cf7bc..4cf65cb92 100644
--- a/tests/data_set/regression/getter.cpp
+++ b/tests/data_set/regression/getter.cpp
@@ -11,11 +11,11 @@
 #include "plssvm/constants.hpp"                     // plssvm::real_type, plssvm::PADDING_SIZE
 #include "plssvm/data_set/min_max_scaler.hpp"       // plssvm::min_max_scaler
 #include "plssvm/data_set/regression_data_set.hpp"  // data set class to test
-#include "plssvm/matrix.hpp"                        // plssvm::aos_matrix
+#include "plssvm/matrix.hpp"                        // plssvm::soa_matrix
 #include "plssvm/shape.hpp"                         // plssvm::shape
 #include "plssvm/svm_types.hpp"                     // plssvm::svm_type
 
-#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_EQ, EXPECT_FLOATING_POINT_NEAR
+#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_EQ, EXPECT_FLOATING_POINT_NEAR, EXPECT_OPTIONAL_EQ
 #include "tests/naming.hpp"              // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"       // util::{regression_label_type_gtest, test_parameter_type_at_t}
 #include "tests/utility.hpp"             // util::{redirect_output, scale}
@@ -23,7 +23,6 @@
 #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
 #include <vector>   // std::vector
 
 template <typename T>
@@ -48,12 +47,12 @@ class RegressionDataSetGetter : public ::testing::Test,
     /// The correct labels.
     std::vector<fixture_label_type> label_{ util::get_correct_data_file_labels<fixture_label_type, plssvm::svm_type::csvr>() };
     /// The correct data points.
-    plssvm::soa_matrix<plssvm::real_type> data_points_{ util::generate_specific_matrix<plssvm::aos_matrix<plssvm::real_type>>(plssvm::shape{ label_.size(), 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE }) };
+    plssvm::soa_matrix<plssvm::real_type> data_points_{ util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ label_.size(), 4 }, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE }) };
 };
 
 TYPED_TEST_SUITE(RegressionDataSetGetter, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(RegressionDataSetGetter, data) {
+TYPED_TEST(RegressionDataSetGetter, Data) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set without labels
@@ -62,7 +61,7 @@ TYPED_TEST(RegressionDataSetGetter, data) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(data.data(), this->get_data_points());
 }
 
-TYPED_TEST(RegressionDataSetGetter, has_labels) {
+TYPED_TEST(RegressionDataSetGetter, HasLabels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set without labels
@@ -75,7 +74,7 @@ TYPED_TEST(RegressionDataSetGetter, has_labels) {
     EXPECT_TRUE(data_with_labels.has_labels());
 }
 
-TYPED_TEST(RegressionDataSetGetter, labels) {
+TYPED_TEST(RegressionDataSetGetter, Labels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set without labels
@@ -85,11 +84,10 @@ TYPED_TEST(RegressionDataSetGetter, labels) {
     // create data set with labels
     const plssvm::regression_data_set<label_type> data_with_labels{ this->get_data_points(), this->get_label() };
     // check labels getter
-    ASSERT_TRUE(data_with_labels.labels().has_value());
-    EXPECT_EQ(data_with_labels.labels()->get(), this->get_label());
+    EXPECT_OPTIONAL_EQ(data_with_labels.labels(), this->get_label());
 }
 
-TYPED_TEST(RegressionDataSetGetter, num_data_points) {
+TYPED_TEST(RegressionDataSetGetter, NumDataPoints) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -98,7 +96,7 @@ TYPED_TEST(RegressionDataSetGetter, num_data_points) {
     EXPECT_EQ(data.num_data_points(), this->get_data_points().num_rows());
 }
 
-TYPED_TEST(RegressionDataSetGetter, num_features) {
+TYPED_TEST(RegressionDataSetGetter, NumFeatures) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -107,7 +105,7 @@ TYPED_TEST(RegressionDataSetGetter, num_features) {
     EXPECT_EQ(data.num_features(), this->get_data_points().num_cols());
 }
 
-TYPED_TEST(RegressionDataSetGetter, is_scaled) {
+TYPED_TEST(RegressionDataSetGetter, IsScaled) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -121,7 +119,7 @@ TYPED_TEST(RegressionDataSetGetter, is_scaled) {
     EXPECT_TRUE(data_scaled.is_scaled());
 }
 
-TYPED_TEST(RegressionDataSetGetter, scaling_factors) {
+TYPED_TEST(RegressionDataSetGetter, ScalingFactors) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set
@@ -132,16 +130,25 @@ TYPED_TEST(RegressionDataSetGetter, scaling_factors) {
     // create scaled data set
     const plssvm::regression_data_set<label_type> data_scaled{ this->get_data_points(), plssvm::min_max_scaler{ plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 } } };
     // check scaling_factors getter
-    ASSERT_TRUE(data_scaled.scaling_factors().has_value());
-    const auto &[ignored, correct_scaling_factors] = util::scale(this->get_data_points(), plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 });
-    const plssvm::min_max_scaler &scaling_factors = *data_scaled.scaling_factors();
-    EXPECT_FLOATING_POINT_EQ(scaling_factors.scaling_interval().first, plssvm::real_type{ -1.0 });
-    EXPECT_FLOATING_POINT_EQ(scaling_factors.scaling_interval().second, plssvm::real_type{ 1.0 });
-    ASSERT_TRUE(scaling_factors.scaling_factors().has_value());
-    ASSERT_EQ(scaling_factors.scaling_factors()->size(), correct_scaling_factors.size());
-    for (std::size_t i = 0; i < scaling_factors.scaling_factors()->size(); ++i) {
-        EXPECT_EQ(scaling_factors.scaling_factors().value()[i].feature, std::get<0>(correct_scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(scaling_factors.scaling_factors().value()[i].lower, std::get<1>(correct_scaling_factors[i]));
-        EXPECT_FLOATING_POINT_NEAR(scaling_factors.scaling_factors().value()[i].upper, std::get<2>(correct_scaling_factors[i]));
+    const auto &scaling_factors_opt = data_scaled.scaling_factors();
+    ASSERT_TRUE(scaling_factors_opt.has_value());
+    if (scaling_factors_opt.has_value()) {
+        const plssvm::min_max_scaler scaling_factors = scaling_factors_opt.value().get();
+
+        // check scaling factor content
+        const auto &[ignored, correct_scaling_factors] = util::scale(this->get_data_points(), plssvm::real_type{ -1.0 }, plssvm::real_type{ 1.0 });
+        EXPECT_FLOATING_POINT_EQ(scaling_factors.scaling_interval().first, plssvm::real_type{ -1.0 });
+        EXPECT_FLOATING_POINT_EQ(scaling_factors.scaling_interval().second, plssvm::real_type{ 1.0 });
+        const auto &factors_opt = scaling_factors.scaling_factors();
+        ASSERT_TRUE(factors_opt.has_value());
+        if (factors_opt.has_value()) {
+            const std::vector<plssvm::min_max_scaler::factors> factors = factors_opt.value();
+            ASSERT_EQ(factors.size(), correct_scaling_factors.size());
+            for (std::size_t i = 0; i < factors.size(); ++i) {
+                EXPECT_EQ(factors[i].feature, std::get<0>(correct_scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].lower, std::get<1>(correct_scaling_factors[i]));
+                EXPECT_FLOATING_POINT_NEAR(factors[i].upper, std::get<2>(correct_scaling_factors[i]));
+            }
+        }
     }
 }
diff --git a/tests/data_set/regression/save.cpp b/tests/data_set/regression/save.cpp
index c4462d345..26de2a535 100644
--- a/tests/data_set/regression/save.cpp
+++ b/tests/data_set/regression/save.cpp
@@ -14,6 +14,8 @@
 #include "plssvm/detail/string_utility.hpp"         // plssvm::detail::as_lower_case
 #include "plssvm/file_format_types.hpp"             // plssvm::file_format_type
 #include "plssvm/matrix.hpp"                        // plssvm::aos_matrix
+#include "plssvm/shape.hpp"                         // plssvm::shape
+#include "plssvm/svm_types.hpp"                     // plssvm::svm_type
 
 #include "tests/naming.hpp"         // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"  // util::{regression_label_type_gtest, test_parameter_type_at_t}
@@ -57,7 +59,7 @@ class RegressionDataSetSave : public ::testing::Test,
 
 TYPED_TEST_SUITE(RegressionDataSetSave, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(RegressionDataSetSave, save_libsvm_with_label) {
+TYPED_TEST(RegressionDataSetSave, SaveLIBSVMWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set with labels
@@ -77,7 +79,7 @@ TYPED_TEST(RegressionDataSetSave, save_libsvm_with_label) {
     }
 }
 
-TYPED_TEST(RegressionDataSetSave, save_libsvm_without_label) {
+TYPED_TEST(RegressionDataSetSave, SaveLIBSVMWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set without labels
@@ -97,7 +99,7 @@ TYPED_TEST(RegressionDataSetSave, save_libsvm_without_label) {
     }
 }
 
-TYPED_TEST(RegressionDataSetSave, save_libsvm_automatic_format) {
+TYPED_TEST(RegressionDataSetSave, SaveLIBSVMAutomaticFormat) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set with labels
@@ -121,7 +123,7 @@ TYPED_TEST(RegressionDataSetSave, save_libsvm_automatic_format) {
     }
 }
 
-TYPED_TEST(RegressionDataSetSave, save_arff_with_label) {
+TYPED_TEST(RegressionDataSetSave, SaveARFFWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set with labels
@@ -151,7 +153,7 @@ TYPED_TEST(RegressionDataSetSave, save_arff_with_label) {
     }
 }
 
-TYPED_TEST(RegressionDataSetSave, save_arff_without_label) {
+TYPED_TEST(RegressionDataSetSave, SaveARFFWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set with labels
@@ -180,7 +182,7 @@ TYPED_TEST(RegressionDataSetSave, save_arff_without_label) {
     }
 }
 
-TYPED_TEST(RegressionDataSetSave, save_arff_automatic_format) {
+TYPED_TEST(RegressionDataSetSave, SaveARFFAutomaticFormat) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create data set with labels
diff --git a/tests/detail/arithmetic_type_name.cpp b/tests/detail/arithmetic_type_name.cpp
index 0a61293cd..d2646cb95 100644
--- a/tests/detail/arithmetic_type_name.cpp
+++ b/tests/detail/arithmetic_type_name.cpp
@@ -12,7 +12,7 @@
 
 #include "gtest/gtest.h"  // TEST, EXPECT_EQ
 
-TEST(ArithmeticTypeName, type) {
+TEST(ArithmeticTypeName, Type) {
     EXPECT_EQ(plssvm::detail::arithmetic_type_name<bool>(), "bool");
 
     // character types
@@ -39,7 +39,7 @@ TEST(ArithmeticTypeName, type) {
     EXPECT_EQ(plssvm::detail::arithmetic_type_name<long double>(), "long double");
 }
 
-TEST(ArithmeticTypeName, const_type) {
+TEST(ArithmeticTypeName, ConstType) {
     EXPECT_EQ(plssvm::detail::arithmetic_type_name<const bool>(), "const bool");
 
     // character types
@@ -66,7 +66,7 @@ TEST(ArithmeticTypeName, const_type) {
     EXPECT_EQ(plssvm::detail::arithmetic_type_name<const long double>(), "const long double");
 }
 
-TEST(ArithmeticTypeName, volatile_type) {
+TEST(ArithmeticTypeName, VolatileType) {
     EXPECT_EQ(plssvm::detail::arithmetic_type_name<volatile bool>(), "volatile bool");
 
     // character types
@@ -93,7 +93,7 @@ TEST(ArithmeticTypeName, volatile_type) {
     EXPECT_EQ(plssvm::detail::arithmetic_type_name<volatile long double>(), "volatile long double");
 }
 
-TEST(ArithmeticTypeName, const_volatile_type) {
+TEST(ArithmeticTypeName, ConstVolatileType) {
     EXPECT_EQ(plssvm::detail::arithmetic_type_name<const volatile bool>(), "const volatile bool");
 
     // character types
diff --git a/tests/detail/assert.cpp b/tests/detail/assert.cpp
index 4ae3154ab..65bbc5c75 100644
--- a/tests/detail/assert.cpp
+++ b/tests/detail/assert.cpp
@@ -10,24 +10,29 @@
 
 #include "plssvm/detail/assert.hpp"
 
-#include "gmock/gmock.h"  // ::testing::ContainsRegex
-#include "gtest/gtest.h"  // TEST, ASSERT_DEATH, EXPECT_DEATH
+#include "plssvm/exceptions/source_location.hpp"  // plssvm::source_location
 
-#include <string>  // std::string
+#if defined(PLSSVM_ENABLE_ASSERTS)
+    #include "fmt/format.h"  // fmt::format
+
+    #include <string>  // std::string
+#endif
+
+#include "gtest/gtest.h"  // TEST, ASSERT_DEATH, EXPECT_DEATH, ::testing::ContainsRegex
 
 // only test if assertions are enabled
 #if defined(PLSSVM_ENABLE_ASSERTS)
 
-TEST(PLSSVMAssert, assert_true) {
+TEST(PLSSVMAssert, AssertTrue) {
     // must not trigger an assertion
     PLSSVM_ASSERT(true, "TRUE");
 }
 
-TEST(PLSSVMAssert, assert_false) {
+TEST(PLSSVMAssert, AssertFalse) {
     ASSERT_DEATH(PLSSVM_ASSERT(false, "FALSE"), ::testing::ContainsRegex("Assertion '.*false.*' failed!"));
 }
 
-TEST(PLSSVMAssertDeathTest, check_assertion_false) {
+TEST(PLSSVMAssertDeathTest, CheckAssertionFalse) {
     const auto loc = plssvm::source_location::current();
 
     // test regex
@@ -46,7 +51,7 @@ TEST(PLSSVMAssertDeathTest, check_assertion_false) {
 #endif
 
 // check the internal check_assertion function
-TEST(PLSSVMAssert, check_assertion_true) {
+TEST(PLSSVMAssert, CheckAssertionTrue) {
     // calling check assertion with true shouldn't do anything
     plssvm::detail::check_assertion(true, "", plssvm::source_location::current(), "");
 }
diff --git a/tests/detail/cmd/cmd_utility.hpp b/tests/detail/cmd/cmd_utility.hpp
index 60dc120e8..e9f5bf2a6 100644
--- a/tests/detail/cmd/cmd_utility.hpp
+++ b/tests/detail/cmd/cmd_utility.hpp
@@ -9,8 +9,8 @@
  * @brief Utility functions and classes (fixtures) for testing the parameter_* classes' functionality.
  */
 
-#ifndef PLSSVM_TESTS_DETAIL_CMD_UTILITY_HPP_
-#define PLSSVM_TESTS_DETAIL_CMD_UTILITY_HPP_
+#ifndef PLSSVM_TESTS_DETAIL_CMD_CMD_UTILITY_HPP_
+#define PLSSVM_TESTS_DETAIL_CMD_CMD_UTILITY_HPP_
 #pragma once
 
 #include "plssvm/mpi/communicator.hpp"  // plssvm::mpi::communicator
@@ -45,8 +45,8 @@ class ParameterBase : public ::testing::Test,
         // create argc and argv from a std::string
         cmd_options_ = std::move(cmd_line_split);
         cmd_argv_.reserve(cmd_options_.size());
-        for (std::vector<std::string>::size_type i = 0; i < cmd_options_.size(); ++i) {
-            cmd_argv_.push_back(cmd_options_[i].data());
+        for (std::string &cmd_opt : cmd_options_) {
+            cmd_argv_.push_back(cmd_opt.data());
         }
     }
 
@@ -62,7 +62,7 @@ class ParameterBase : public ::testing::Test,
      * @brief Return the used MPI communicator.
      * @return the MPI communicator (`[[nodiscard]]`)
      */
-    [[nodiscard]] const plssvm::mpi::communicator get_comm() const noexcept { return comm_; }
+    [[nodiscard]] const plssvm::mpi::communicator &get_comm() const noexcept { return comm_; }
 
     /**
      * @brief Return the number of command line arguments encapsulated in this class.
@@ -78,15 +78,15 @@ class ParameterBase : public ::testing::Test,
 
   private:
     /// The provided command line options.
-    mutable std::vector<std::string> cmd_options_{};
+    mutable std::vector<std::string> cmd_options_;
     /// The command line options cast to a char *.
-    mutable std::vector<char *> cmd_argv_{};
+    mutable std::vector<char *> cmd_argv_;
     /// The MPI communicator (unused during testing since we do not support MPI runtime tests).
-    plssvm::mpi::communicator comm_{};
+    plssvm::mpi::communicator comm_;
     /// The verbosity level at the time of the test start.
     plssvm::verbosity_level verbosity_save_{};
 };
 
 }  // namespace util
 
-#endif  // PLSSVM_TESTS_DETAIL_CMD_UTILITY_HPP_
+#endif  // PLSSVM_TESTS_DETAIL_CMD_CMD_UTILITY_HPP_
diff --git a/tests/detail/cmd/data_set_variants.cpp b/tests/detail/cmd/data_set_variants.cpp
index 68529fac2..d1b29127a 100644
--- a/tests/detail/cmd/data_set_variants.cpp
+++ b/tests/detail/cmd/data_set_variants.cpp
@@ -14,7 +14,6 @@
 #include "plssvm/detail/cmd/parser_predict.hpp"  // plssvm::detail::cmd::parser_predict
 #include "plssvm/detail/cmd/parser_scale.hpp"    // plssvm::detail::cmd::parser_scale
 #include "plssvm/detail/cmd/parser_train.hpp"    // plssvm::detail::cmd::parser_train
-#include "plssvm/mpi/communicator.hpp"           // plssvm::mpi::communicator
 #include "plssvm/svm_types.hpp"                  // plssvm::svm_type
 
 #include "tests/detail/cmd/cmd_utility.hpp"  // util::ParameterBase
@@ -35,7 +34,7 @@ class DataSetFactory : public util::ParameterBase,
                        public ::testing::WithParamInterface<std::tuple<bool, plssvm::svm_type, std::size_t>>,
                        protected util::temporary_file { };
 
-TEST_P(DataSetFactory, data_set_factory_predict) {
+TEST_P(DataSetFactory, DataSetFactoryPredict) {
     // get parameter
     const auto [strings_as_labels, svm, result_index] = GetParam();
 
@@ -70,7 +69,7 @@ TEST_P(DataSetFactory, data_set_factory_predict) {
     EXPECT_EQ(var.index(), result_index);
 }
 
-TEST_P(DataSetFactory, data_set_factory_scale) {
+TEST_P(DataSetFactory, DataSetFactoryScale) {
     // get parameter
     const auto [strings_as_labels, svm, result_index] = GetParam();
 
@@ -102,7 +101,7 @@ TEST_P(DataSetFactory, data_set_factory_scale) {
     }
 }
 
-TEST_P(DataSetFactory, data_set_factory_scale_restore_filename) {
+TEST_P(DataSetFactory, DataSetFactoryScaleRestoreFilename) {
     // get parameter
     const auto [strings_as_labels, svm, result_index] = GetParam();
 
@@ -134,7 +133,7 @@ TEST_P(DataSetFactory, data_set_factory_scale_restore_filename) {
     }
 }
 
-TEST_P(DataSetFactory, data_set_factory_train) {
+TEST_P(DataSetFactory, DataSetFactoryTrain) {
     // get parameter
     const auto [strings_as_labels, svm, result_index] = GetParam();
 
diff --git a/tests/detail/cmd/parser_predict.cpp b/tests/detail/cmd/parser_predict.cpp
index 8365494b7..200045a08 100644
--- a/tests/detail/cmd/parser_predict.cpp
+++ b/tests/detail/cmd/parser_predict.cpp
@@ -10,14 +10,14 @@
 
 #include "plssvm/detail/cmd/parser_predict.hpp"
 
-#include "plssvm/backend_types.hpp"                          // plssvm::backend_type
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::execution_space
-#include "plssvm/backends/SYCL/implementation_types.hpp"     // plssvm::sycl::implementation_type
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/constants.hpp"                              // plssvm::real_type
-#include "plssvm/exceptions/exceptions.hpp"                  // plssvm::cmd_parser_exit
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
-#include "plssvm/verbosity_levels.hpp"                       // plssvm::verbosity
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"     // plssvm::kokkos::execution_space
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::implementation_type
+#include "plssvm/constants.hpp"                            // plssvm::real_type
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::cmd_parser_exit
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
+#include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity
 
 #include "tests/custom_test_macros.hpp"      // EXPECT_CONVERSION_TO_STRING, EXPECT_THROW_WHAT
 #include "tests/detail/cmd/cmd_utility.hpp"  // util::ParameterBase
@@ -38,7 +38,7 @@
 
 class ParserPredict : public util::ParameterBase { };
 
-TEST_F(ParserPredict, minimal) {
+TEST_F(ParserPredict, Minimal) {
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", "data.libsvm", "data.libsvm.model" });
 
@@ -48,7 +48,7 @@ TEST_F(ParserPredict, minimal) {
     // check parsed values
     EXPECT_EQ(parser.backend, plssvm::backend_type::automatic);
     EXPECT_EQ(parser.target, plssvm::target_platform::automatic);
-    EXPECT_EQ(parser.sycl_kernel_invocation_type, plssvm::sycl::kernel_invocation_type::automatic);
+    EXPECT_EQ(parser.sycl_data_parallel_kernel, plssvm::sycl::data_parallel_kernel::automatic);
     EXPECT_EQ(parser.sycl_implementation_type, plssvm::sycl::implementation_type::automatic);
     EXPECT_EQ(parser.kokkos_execution_space, plssvm::kokkos::execution_space::automatic);
     EXPECT_FALSE(parser.strings_as_labels);
@@ -60,7 +60,7 @@ TEST_F(ParserPredict, minimal) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::full);
 }
 
-TEST_F(ParserPredict, minimal_output) {
+TEST_F(ParserPredict, MinimalOutput) {
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", "data.libsvm", "data.libsvm.model" });
 
@@ -72,7 +72,7 @@ TEST_F(ParserPredict, minimal_output) {
         "backend: automatic\n"
         "target platform: automatic\n"
         "SYCL implementation type: automatic\n"
-        "SYCL kernel invocation type: automatic\n"
+        "SYCL data parallel kernel: automatic\n"
         "Kokkos execution space: automatic\n"
         "label_type: int (default)\n"
         "real_type: {}\n"
@@ -86,11 +86,11 @@ TEST_F(ParserPredict, minimal_output) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::full);
 }
 
-TEST_F(ParserPredict, all_arguments) {
+TEST_F(ParserPredict, AllArguments) {
     // create artificial command line arguments in test fixture
     std::vector<std::string> cmd_args = { "./plssvm-predict", "--backend", "cuda", "--target_platform", "gpu_nvidia", "--use_strings_as_labels", "--verbosity", "libsvm" };
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
-    cmd_args.insert(cmd_args.end(), { "--sycl_kernel_invocation_type", "work_group", "--sycl_implementation_type", "dpcpp" });
+    cmd_args.insert(cmd_args.end(), { "--sycl_data_parallel_kernel", "work_group", "--sycl_implementation_type", "dpcpp" });
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
     const plssvm::kokkos::execution_space space = plssvm::kokkos::list_available_execution_spaces()[1];  // [0] would be automatic
@@ -112,10 +112,10 @@ TEST_F(ParserPredict, all_arguments) {
     EXPECT_EQ(parser.backend, plssvm::backend_type::cuda);
     EXPECT_EQ(parser.target, plssvm::target_platform::gpu_nvidia);
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
-    EXPECT_EQ(parser.sycl_kernel_invocation_type, plssvm::sycl::kernel_invocation_type::work_group);
+    EXPECT_EQ(parser.sycl_data_parallel_kernel, plssvm::sycl::data_parallel_kernel::work_group);
     EXPECT_EQ(parser.sycl_implementation_type, plssvm::sycl::implementation_type::dpcpp);
 #else
-    EXPECT_EQ(parser.sycl_kernel_invocation_type, plssvm::sycl::kernel_invocation_type::automatic);
+    EXPECT_EQ(parser.sycl_data_parallel_kernel, plssvm::sycl::data_parallel_kernel::automatic);
     EXPECT_EQ(parser.sycl_implementation_type, plssvm::sycl::implementation_type::automatic);
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
@@ -139,11 +139,11 @@ TEST_F(ParserPredict, all_arguments) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::libsvm);
 }
 
-TEST_F(ParserPredict, all_arguments_output) {
+TEST_F(ParserPredict, AllArgumentsOutput) {
     // create artificial command line arguments in test fixture
     std::vector<std::string> cmd_args = { "./plssvm-predict", "--backend", "automatic", "--target_platform", "gpu_nvidia", "--use_strings_as_labels", "--verbosity", "libsvm" };
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
-    cmd_args.insert(cmd_args.end(), { "--sycl_kernel_invocation_type", "work_group", "--sycl_implementation_type", "dpcpp" });
+    cmd_args.insert(cmd_args.end(), { "--sycl_data_parallel_kernel", "work_group", "--sycl_implementation_type", "dpcpp" });
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
     const plssvm::kokkos::execution_space space = plssvm::kokkos::list_available_execution_spaces()[1];  // [0] would be automatic
@@ -168,10 +168,10 @@ TEST_F(ParserPredict, all_arguments_output) {
     };
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
     correct += "SYCL implementation type: dpcpp\n"
-               "SYCL kernel invocation type: work_group\n";
+               "SYCL data parallel kernel: work_group\n";
 #else
     correct += "SYCL implementation type: automatic\n"
-               "SYCL kernel invocation type: automatic\n";
+               "SYCL data parallel kernel: automatic\n";
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
     correct += fmt::format("Kokkos execution space: {}\n", space);
@@ -201,7 +201,7 @@ TEST_F(ParserPredict, all_arguments_output) {
 class ParserPredictBackend : public ParserPredict,
                              public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserPredictBackend, parsing) {
+TEST_P(ParserPredictBackend, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to backend
     const auto backend = util::convert_from_string<plssvm::backend_type>(value);
@@ -223,7 +223,7 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictBackend, ::testing::Combine
 class ParserPredictTargetPlatform : public ParserPredict,
                                     public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserPredictTargetPlatform, parsing) {
+TEST_P(ParserPredictTargetPlatform, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to target_platform
     const auto target_platform = util::convert_from_string<plssvm::target_platform>(value);
@@ -244,32 +244,32 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictTargetPlatform, ::testing::
 
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
 
-class ParserPredictSYCLKernelInvocation : public ParserPredict,
-                                          public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
+class ParserPredictSYCLDataParallelKernel : public ParserPredict,
+                                            public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserPredictSYCLKernelInvocation, parsing) {
+TEST_P(ParserPredictSYCLDataParallelKernel, Parsing) {
     const auto &[flag, value] = GetParam();
-    // convert string to sycl::kernel_invocation_type
-    const auto sycl_kernel_invocation_type = util::convert_from_string<plssvm::sycl::kernel_invocation_type>(value);
+    // convert string to sycl::data_parallel_kernel
+    const auto sycl_data_parallel_kernel = util::convert_from_string<plssvm::sycl::data_parallel_kernel>(value);
     // create artificial command line arguments in test fixture
-    this->CreateCMDArgs({ "./plssvm-predict", flag, value, "data.libsvm" });
+    this->CreateCMDArgs({ "./plssvm-predict", flag, value, "data.libsvm", "data.libsvm.model" });
     // create parameter object
     const plssvm::detail::cmd::parser_predict parser{ this->get_comm(), this->get_argc(), this->get_argv() };
     // test for correctness
-    EXPECT_EQ(parser.sycl_kernel_invocation_type, sycl_kernel_invocation_type);
+    EXPECT_EQ(parser.sycl_data_parallel_kernel, sycl_data_parallel_kernel);
 }
 
 // clang-format off
-INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictSYCLKernelInvocation, ::testing::Combine(
-                ::testing::Values("--sycl_kernel_invocation_type"),
+INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictSYCLDataParallelKernel, ::testing::Combine(
+                ::testing::Values("--sycl_data_parallel_kernel"),
                 ::testing::Values("automatic", "auto", "basic", "nd_range", "work_group", "hierarchical", "scoped")),
-                naming::pretty_print_parameter_flag_and_value<ParserPredictSYCLKernelInvocation>);
+                naming::pretty_print_parameter_flag_and_value<ParserPredictSYCLDataParallelKernel>);
 // clang-format on
 
 class ParserPredictSYCLImplementation : public ParserPredict,
                                         public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserPredictSYCLImplementation, parsing) {
+TEST_P(ParserPredictSYCLImplementation, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to sycl::implementation_type
     const auto sycl_implementation_type = util::convert_from_string<plssvm::sycl::implementation_type>(value);
@@ -295,7 +295,7 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictSYCLImplementation, ::testi
 class ParserPredictKokkosExecutionSpace : public ParserPredict,
                                           public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserPredictKokkosExecutionSpace, parsing) {
+TEST_P(ParserPredictKokkosExecutionSpace, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to kokkos::execution_space
     const auto kokkos_execution_space = util::convert_from_string<plssvm::kokkos::execution_space>(value);
@@ -321,7 +321,7 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictKokkosExecutionSpace, ::tes
 class ParserPredictPerformanceTrackingFilename : public ParserPredict,
                                                  public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserPredictPerformanceTrackingFilename, parsing) {
+TEST_P(ParserPredictPerformanceTrackingFilename, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", flag, value, "data.libsvm", "data.libsvm.model" });
@@ -345,7 +345,7 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictPerformanceTrackingFilename
 class ParserPredictMPILoadBalancingWeights : public ParserPredict,
                                              public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserPredictMPILoadBalancingWeights, parsing) {
+TEST_P(ParserPredictMPILoadBalancingWeights, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to std::vector
     const std::vector<std::size_t> weights{ util::convert_from_string<std::size_t>(value) };
@@ -367,7 +367,7 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictMPILoadBalancingWeights, ::
 class ParserPredictMPILoadBalancingWeightsInvalid : public ParserPredict,
                                                     public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserPredictMPILoadBalancingWeightsInvalid, parsing) {
+TEST_P(ParserPredictMPILoadBalancingWeightsInvalid, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", flag, value, "data.libsvm", "data.libsvm.model" });
@@ -387,7 +387,7 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictMPILoadBalancingWeightsInva
 class ParserPredictUseStringsAsLabels : public ParserPredict,
                                         public ::testing::WithParamInterface<std::tuple<std::string, bool>> { };
 
-TEST_P(ParserPredictUseStringsAsLabels, parsing) {
+TEST_P(ParserPredictUseStringsAsLabels, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", fmt::format("{}={}", flag, value), "data.libsvm", "data.libsvm.model" });
@@ -407,7 +407,7 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictUseStringsAsLabels, ::testi
 class ParserPredictVerbosity : public ParserPredict,
                                public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserPredictVerbosity, parsing) {
+TEST_P(ParserPredictVerbosity, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", flag, value, "data.libsvm", "data.libsvm.model" });
@@ -427,7 +427,7 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictVerbosity, ::testing::Combi
 class ParserPredictQuiet : public ParserPredict,
                            public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserPredictQuiet, parsing) {
+TEST_P(ParserPredictQuiet, Parsing) {
     const plssvm::verbosity_level old_verbosity = plssvm::verbosity;
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
@@ -443,7 +443,7 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictQuiet, ::testing::Values("-
 class ParserPredictVerbosityAndQuiet : public ParserPredict,
                                        private util::redirect_output<&std::clog> { };
 
-TEST_F(ParserPredictVerbosityAndQuiet, parsing) {
+TEST_F(ParserPredictVerbosityAndQuiet, Parsing) {
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", "--quiet", "--verbosity", "full", "data.libsvm", "data.libsvm.model" });
     // create parameter object
@@ -455,7 +455,7 @@ TEST_F(ParserPredictVerbosityAndQuiet, parsing) {
 class ParserPredictHelp : public ParserPredict,
                           public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserPredictHelp, parsing) {
+TEST_P(ParserPredictHelp, Parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", flag });
@@ -468,7 +468,7 @@ INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictHelp, ::testing::Values("-h
 class ParserPredictVersion : public ParserPredict,
                              public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserPredictVersion, parsing) {
+TEST_P(ParserPredictVersion, Parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", flag });
@@ -478,22 +478,22 @@ TEST_P(ParserPredictVersion, parsing) {
 
 INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictVersion, ::testing::Values("-v", "--version"), naming::pretty_print_parameter_flag<ParserPredictVersion>);
 
-TEST_F(ParserPredict, no_positional_argument) {
+TEST_F(ParserPredict, NoPositionalArgument) {
     this->CreateCMDArgs({ "./plssvm-predict" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_predict{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
 
-TEST_F(ParserPredict, single_positional_argument) {
+TEST_F(ParserPredict, SinglePositionalArgument) {
     this->CreateCMDArgs({ "./plssvm-predict", "data.libsvm" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_predict{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
 
-TEST_F(ParserPredict, too_many_positional_arguments) {
+TEST_F(ParserPredict, TooManyPositionalArguments) {
     this->CreateCMDArgs({ "./plssvm-predict", "p1", "p2", "p3", "p4" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_predict{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
 
-TEST_F(ParserPredict, unrecognized_option) {
+TEST_F(ParserPredict, UnrecognizedOption) {
     this->CreateCMDArgs({ "./plssvm-predict", "--foo", "bar" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_predict{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
@@ -501,12 +501,12 @@ TEST_F(ParserPredict, unrecognized_option) {
 class ParserPredictDeathTest : public ParserPredict { };
 
 // test whether nonsensical cmd arguments trigger the assertions
-TEST_F(ParserPredictDeathTest, too_few_argc) {
+TEST_F(ParserPredictDeathTest, TooFewArgc) {
     EXPECT_DEATH((plssvm::detail::cmd::parser_predict{ this->get_comm(), 0, nullptr }),
                  ::testing::HasSubstr("At least one argument is always given (the executable name), but argc is 0!"));
 }
 
-TEST_F(ParserPredictDeathTest, nullptr_argv) {
+TEST_F(ParserPredictDeathTest, NullptrArgv) {
     EXPECT_DEATH((plssvm::detail::cmd::parser_predict{ this->get_comm(), 1, nullptr }),
                  ::testing::HasSubstr("At least one argument is always given (the executable name), but argv is a nullptr!"));
 }
diff --git a/tests/detail/cmd/parser_scale.cpp b/tests/detail/cmd/parser_scale.cpp
index f38bc3d0b..8b6ffb61d 100644
--- a/tests/detail/cmd/parser_scale.cpp
+++ b/tests/detail/cmd/parser_scale.cpp
@@ -13,7 +13,6 @@
 #include "plssvm/constants.hpp"              // plssvm::real_type
 #include "plssvm/exceptions/exceptions.hpp"  // plssvm::cmd_parser_exit
 #include "plssvm/file_format_types.hpp"      // plssvm::file_format_type
-#include "plssvm/mpi/communicator.hpp"       // plssvm::mpi::communicator
 #include "plssvm/verbosity_levels.hpp"       // plssvm::verbosity
 
 #include "tests/custom_test_macros.hpp"      // EXPECT_CONVERSION_TO_STRING, EXPECT_THROW_WHAT
@@ -35,7 +34,7 @@
 
 class ParserScale : public util::ParameterBase { };
 
-TEST_F(ParserScale, minimal) {
+TEST_F(ParserScale, Minimal) {
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", "data.libsvm" });
 
@@ -56,7 +55,7 @@ TEST_F(ParserScale, minimal) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::full);
 }
 
-TEST_F(ParserScale, minimal_output) {
+TEST_F(ParserScale, MinimalOutput) {
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", "data.libsvm" });
 
@@ -81,7 +80,7 @@ TEST_F(ParserScale, minimal_output) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::full);
 }
 
-TEST_F(ParserScale, all_arguments) {
+TEST_F(ParserScale, AllArguments) {
     // create artificial command line arguments in test fixture
     std::vector<std::string> cmd_args = { "./plssvm-scale", "-l", "-2.0", "-u", "2.5", "-f", "arff", "-s", "data.libsvm.save", "--use_strings_as_labels", "--verbosity", "libsvm" };
 #if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
@@ -109,7 +108,7 @@ TEST_F(ParserScale, all_arguments) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::libsvm);
 }
 
-TEST_F(ParserScale, all_arguments_output) {
+TEST_F(ParserScale, AllArgumentsOutput) {
     // create artificial command line arguments in test fixture
     std::vector<std::string> cmd_args = { "./plssvm-scale", "-l", "-2.0", "-u", "2.5", "-f", "arff", "-s", "data.libsvm.save", "--use_strings_as_labels", "--verbosity", "libsvm" };
 #if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
@@ -122,6 +121,7 @@ TEST_F(ParserScale, all_arguments_output) {
     const plssvm::detail::cmd::parser_scale parser{ this->get_comm(), this->get_argc(), this->get_argv() };
 
     // test output string
+    // NOLINTNEXTLINE(misc-const-correctness): can't be const due to performance tracking
     std::string correct = fmt::format(
         "lower: -2\n"
         "upper: 2.5\n"
@@ -145,7 +145,7 @@ TEST_F(ParserScale, all_arguments_output) {
 class ParserScaleLower : public ParserScale,
                          public ::testing::WithParamInterface<std::tuple<std::string, plssvm::real_type>> { };
 
-TEST_P(ParserScaleLower, parsing) {
+TEST_P(ParserScaleLower, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", flag, fmt::format("{}", value), "data.libsvm" });
@@ -165,7 +165,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleLower, ::testing::Combine(
 class ParserScaleUpper : public ParserScale,
                          public ::testing::WithParamInterface<std::tuple<std::string, plssvm::real_type>> { };
 
-TEST_P(ParserScaleUpper, parsing) {
+TEST_P(ParserScaleUpper, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", flag, fmt::format("{}", value), "data.libsvm" });
@@ -185,7 +185,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleUpper,
 class ParserScaleFileFormat : public ParserScale,
                               public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserScaleFileFormat, parsing) {
+TEST_P(ParserScaleFileFormat, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to backend
     const auto backend = util::convert_from_string<plssvm::file_format_type>(value);
@@ -207,7 +207,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleFileFormat, ::testing::Combine(
 class ParserScaleSaveFilename : public ParserScale,
                                 public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserScaleSaveFilename, parsing) {
+TEST_P(ParserScaleSaveFilename, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", flag, value, "data.libsvm" });
@@ -227,7 +227,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleSaveFilename, ::testing::Combin
 class ParserScaleRestoreFilename : public ParserScale,
                                    public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserScaleRestoreFilename, parsing) {
+TEST_P(ParserScaleRestoreFilename, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", flag, value, "data.libsvm" });
@@ -247,7 +247,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleRestoreFilename, ::testing::Com
 class ParserScaleRestoreFilenameLowerUpper : public ParserScale,
                                              public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserScaleRestoreFilenameLowerUpper, parsing) {
+TEST_P(ParserScaleRestoreFilenameLowerUpper, Parsing) {
     util::redirect_output<&std::clog> clog_capture{};
 
     // explicitly enable logging
@@ -277,7 +277,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleRestoreFilenameLowerUpper, ::te
 class ParserScalePerformanceTrackingFilename : public ParserScale,
                                                public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserScalePerformanceTrackingFilename, parsing) {
+TEST_P(ParserScalePerformanceTrackingFilename, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", flag, value, "data.libsvm" });
@@ -299,7 +299,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScalePerformanceTrackingFilename, ::
 class ParserScaleUseStringsAsLabels : public ParserScale,
                                       public ::testing::WithParamInterface<std::tuple<std::string, bool>> { };
 
-TEST_P(ParserScaleUseStringsAsLabels, parsing) {
+TEST_P(ParserScaleUseStringsAsLabels, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", fmt::format("{}={}", flag, value), "data.libsvm" });
@@ -319,7 +319,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleUseStringsAsLabels, ::testing::
 class ParserScaleVerbosity : public ParserScale,
                              public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserScaleVerbosity, parsing) {
+TEST_P(ParserScaleVerbosity, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", flag, value, "data.libsvm" });
@@ -339,7 +339,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleVerbosity, ::testing::Combine(
 class ParserScaleQuiet : public ParserScale,
                          public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserScaleQuiet, parsing) {
+TEST_P(ParserScaleQuiet, Parsing) {
     const plssvm::verbosity_level old_verbosity = plssvm::verbosity;
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
@@ -355,7 +355,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleQuiet, ::testing::Values("-q",
 class ParserScaleVerbosityAndQuiet : public ParserScale,
                                      private util::redirect_output<&std::clog> { };
 
-TEST_F(ParserScaleVerbosityAndQuiet, parsing) {
+TEST_F(ParserScaleVerbosityAndQuiet, Parsing) {
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", "--quiet", "--verbosity", "full", "data.libsvm" });
     // create parameter object
@@ -367,7 +367,7 @@ TEST_F(ParserScaleVerbosityAndQuiet, parsing) {
 class ParserScaleHelp : public ParserScale,
                         public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserScaleHelp, parsing) {
+TEST_P(ParserScaleHelp, Parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", flag });
@@ -380,7 +380,7 @@ INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleHelp, ::testing::Values("-h", "
 class ParserScaleVersion : public ParserScale,
                            public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserScaleVersion, parsing) {
+TEST_P(ParserScaleVersion, Parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", flag });
@@ -390,28 +390,28 @@ TEST_P(ParserScaleVersion, parsing) {
 
 INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleVersion, ::testing::Values("-v", "--version"), naming::pretty_print_parameter_flag<ParserScaleVersion>);
 
-TEST_F(ParserScale, no_positional_argument) {
+TEST_F(ParserScale, NoPositionalArgument) {
     this->CreateCMDArgs({ "./plssvm-scale" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_scale{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
 
-TEST_F(ParserScale, save_and_restore) {
+TEST_F(ParserScale, SaveAndRestore) {
     this->CreateCMDArgs({ "./plssvm-scale", "-s", "data.libsvm.save", "-r", "data.libsvm.restore", "data.libsvm" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_scale{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
 
-TEST_F(ParserScale, too_many_positional_arguments) {
+TEST_F(ParserScale, TooManyPositionalArguments) {
     this->CreateCMDArgs({ "./plssvm-scale", "p1", "p2", "p3", "p4" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_scale{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
 
-TEST_F(ParserScale, illegal_scaling_range) {
+TEST_F(ParserScale, IllegalScalingRange) {
     // illegal [lower, upper] bound range
     this->CreateCMDArgs({ "./plssvm-scale", "-l", "1.0", "-u", "-1.0", "data.libsvm" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_scale{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
 
-TEST_F(ParserScale, unrecognized_option) {
+TEST_F(ParserScale, UnrecognizedOption) {
     this->CreateCMDArgs({ "./plssvm-scale", "--foo", "bar" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_scale{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
@@ -419,12 +419,12 @@ TEST_F(ParserScale, unrecognized_option) {
 class ParserScaleDeathTest : public ParserScale { };
 
 // test whether nonsensical cmd arguments trigger the assertions
-TEST_F(ParserScaleDeathTest, too_few_argc) {
+TEST_F(ParserScaleDeathTest, TooFewArgc) {
     EXPECT_DEATH((plssvm::detail::cmd::parser_scale{ this->get_comm(), 0, nullptr }),
                  ::testing::HasSubstr("At least one argument is always given (the executable name), but argc is 0!"));
 }
 
-TEST_F(ParserScaleDeathTest, nullptr_argv) {
+TEST_F(ParserScaleDeathTest, NullptrArgv) {
     EXPECT_DEATH((plssvm::detail::cmd::parser_scale{ this->get_comm(), 1, nullptr }),
                  ::testing::HasSubstr("At least one argument is always given (the executable name), but argv is a nullptr!"));
 }
diff --git a/tests/detail/cmd/parser_train.cpp b/tests/detail/cmd/parser_train.cpp
index 36e70228c..c048bcf8a 100644
--- a/tests/detail/cmd/parser_train.cpp
+++ b/tests/detail/cmd/parser_train.cpp
@@ -10,19 +10,19 @@
 
 #include "plssvm/detail/cmd/parser_train.hpp"
 
-#include "plssvm/backend_types.hpp"                          // plssvm::backend_type
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::execution_space
-#include "plssvm/backends/SYCL/implementation_types.hpp"     // plssvm::sycl::implementation_type
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/classification_types.hpp"                   // plssvm::classification_type
-#include "plssvm/constants.hpp"                              // plssvm::real_type
-#include "plssvm/exceptions/exceptions.hpp"                  // plssvm::cmd_parser_exit
-#include "plssvm/gamma.hpp"                                  // plssvm::gamma_type
-#include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
-#include "plssvm/solver_types.hpp"                           // plssvm::solver_type
-#include "plssvm/svm_types.hpp"                              // plssvm::svm_type
-#include "plssvm/target_platforms.hpp"                       // plssvm::target_platform
-#include "plssvm/verbosity_levels.hpp"                       // plssvm::verbosity
+#include "plssvm/backend_types.hpp"                        // plssvm::backend_type
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"     // plssvm::kokkos::execution_space
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::implementation_type
+#include "plssvm/classification_types.hpp"                 // plssvm::classification_type
+#include "plssvm/constants.hpp"                            // plssvm::real_type
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::cmd_parser_exit
+#include "plssvm/gamma.hpp"                                // plssvm::gamma_type
+#include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
+#include "plssvm/solver_types.hpp"                         // plssvm::solver_type
+#include "plssvm/svm_types.hpp"                            // plssvm::svm_type
+#include "plssvm/target_platforms.hpp"                     // plssvm::target_platform
+#include "plssvm/verbosity_levels.hpp"                     // plssvm::verbosity
 
 #include "tests/custom_test_macros.hpp"      // EXPECT_CONVERSION_TO_STRING, EXPECT_THROW_WHAT
 #include "tests/detail/cmd/cmd_utility.hpp"  // util::ParameterBase
@@ -45,7 +45,7 @@
 
 class ParserTrain : public util::ParameterBase { };
 
-TEST_F(ParserTrain, minimal) {
+TEST_F(ParserTrain, Minimal) {
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", "data.libsvm" });
 
@@ -61,7 +61,7 @@ TEST_F(ParserTrain, minimal) {
     EXPECT_EQ(parser.backend, plssvm::backend_type::automatic);
     EXPECT_EQ(parser.target, plssvm::target_platform::automatic);
     EXPECT_EQ(parser.solver, plssvm::solver_type::automatic);
-    EXPECT_EQ(parser.sycl_kernel_invocation_type, plssvm::sycl::kernel_invocation_type::automatic);
+    EXPECT_EQ(parser.sycl_data_parallel_kernel, plssvm::sycl::data_parallel_kernel::automatic);
     EXPECT_EQ(parser.sycl_implementation_type, plssvm::sycl::implementation_type::automatic);
     EXPECT_EQ(parser.kokkos_execution_space, plssvm::kokkos::execution_space::automatic);
     EXPECT_FALSE(parser.strings_as_labels);
@@ -72,7 +72,7 @@ TEST_F(ParserTrain, minimal) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::full);
 }
 
-TEST_F(ParserTrain, minimal_output) {
+TEST_F(ParserTrain, MinimalOutput) {
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", "data.libsvm" });
 
@@ -91,7 +91,7 @@ TEST_F(ParserTrain, minimal_output) {
         "target platform: automatic\n"
         "solver: automatic\n"
         "SYCL implementation type: automatic\n"
-        "SYCL kernel invocation type: automatic\n"
+        "SYCL data parallel kernel: automatic\n"
         "Kokkos execution space: automatic\n"
         "classification_type: one vs. all\n"
         "label_type: int\n"
@@ -104,11 +104,11 @@ TEST_F(ParserTrain, minimal_output) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::full);
 }
 
-TEST_F(ParserTrain, all_arguments) {
+TEST_F(ParserTrain, AllArguments) {
     // create artificial command line arguments in test fixture
     std::vector<std::string> cmd_args = { "./plssvm-train", "--svm_type", "1", "--kernel_type", "1", "--degree", "2", "--gamma", "1.5", "--coef0", "-1.5", "--cost", "2", "--epsilon", "1e-12", "--max_iter", "100", "--classification", "oao", "--solver", "cg_implicit", "--backend", "cuda", "--target_platform", "gpu_nvidia", "--use_strings_as_labels", "--verbosity", "libsvm" };
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
-    cmd_args.insert(cmd_args.end(), { "--sycl_kernel_invocation_type", "work_group", "--sycl_implementation_type", "dpcpp" });
+    cmd_args.insert(cmd_args.end(), { "--sycl_data_parallel_kernel", "work_group", "--sycl_implementation_type", "dpcpp" });
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
     const plssvm::kokkos::execution_space space = plssvm::kokkos::list_available_execution_spaces()[1];  // [0] would be automatic
@@ -142,10 +142,10 @@ TEST_F(ParserTrain, all_arguments) {
     EXPECT_EQ(parser.target, plssvm::target_platform::gpu_nvidia);
     EXPECT_EQ(parser.solver, plssvm::solver_type::cg_implicit);
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
-    EXPECT_EQ(parser.sycl_kernel_invocation_type, plssvm::sycl::kernel_invocation_type::work_group);
+    EXPECT_EQ(parser.sycl_data_parallel_kernel, plssvm::sycl::data_parallel_kernel::work_group);
     EXPECT_EQ(parser.sycl_implementation_type, plssvm::sycl::implementation_type::dpcpp);
 #else
-    EXPECT_EQ(parser.sycl_kernel_invocation_type, plssvm::sycl::kernel_invocation_type::automatic);
+    EXPECT_EQ(parser.sycl_data_parallel_kernel, plssvm::sycl::data_parallel_kernel::automatic);
     EXPECT_EQ(parser.sycl_implementation_type, plssvm::sycl::implementation_type::automatic);
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
@@ -166,11 +166,11 @@ TEST_F(ParserTrain, all_arguments) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::libsvm);
 }
 
-TEST_F(ParserTrain, all_arguments_output) {
+TEST_F(ParserTrain, AllArgumentsOutput) {
     // create artificial command line arguments in test fixture
     std::vector<std::string> cmd_args = { "./plssvm-train", "--svm_type", "1", "--kernel_type", "1", "--degree", "2", "--gamma", "1.5", "--coef0", "-1.5", "--cost", "2", "--epsilon", "1e-12", "--max_iter", "100", "--classification", "oao", "--solver", "cg_implicit", "--backend", "automatic", "--target_platform", "gpu_nvidia", "--use_strings_as_labels", "--verbosity", "libsvm" };
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
-    cmd_args.insert(cmd_args.end(), { "--sycl_kernel_invocation_type", "work_group", "--sycl_implementation_type", "dpcpp" });
+    cmd_args.insert(cmd_args.end(), { "--sycl_data_parallel_kernel", "work_group", "--sycl_implementation_type", "dpcpp" });
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
     const std::string space = fmt::format("{}", plssvm::kokkos::list_available_execution_spaces()[1]);  // [0] would be automatic
@@ -203,10 +203,10 @@ TEST_F(ParserTrain, all_arguments_output) {
         "solver: cg_implicit\n";
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
     correct += "SYCL implementation type: dpcpp\n"
-               "SYCL kernel invocation type: work_group\n";
+               "SYCL data parallel kernel: work_group\n";
 #else
     correct += "SYCL implementation type: automatic\n"
-               "SYCL kernel invocation type: automatic\n";
+               "SYCL data parallel kernel: automatic\n";
 #endif
 #if defined(PLSSVM_HAS_KOKKOS_BACKEND)
     correct += fmt::format("Kokkos execution space: {}\n", space);
@@ -235,7 +235,7 @@ TEST_F(ParserTrain, all_arguments_output) {
 class ParserTrainSvm : public ParserTrain,
                        public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainSvm, parsing) {
+TEST_P(ParserTrainSvm, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to svm_type
     const auto svm_type = util::convert_from_string<plssvm::svm_type>(value);
@@ -257,7 +257,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainSvm, ::testing::Combine(
 class ParserTrainKernel : public ParserTrain,
                           public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainKernel, parsing) {
+TEST_P(ParserTrainKernel, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to kernel_type
     const auto kernel_type = util::convert_from_string<plssvm::kernel_function_type>(value);
@@ -279,7 +279,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainKernel, ::testing::Combine(
 class ParserTrainDegree : public ParserTrain,
                           public ::testing::WithParamInterface<std::tuple<std::string, int>> { };
 
-TEST_P(ParserTrainDegree, parsing) {
+TEST_P(ParserTrainDegree, Parsing) {
     const auto &[flag, degree] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, fmt::format("{}", degree), "data.libsvm" });
@@ -300,7 +300,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainDegree, ::testing::Combine(
 class ParserTrainGamma : public ParserTrain,
                          public ::testing::WithParamInterface<std::tuple<std::string, plssvm::gamma_type>> { };
 
-TEST_P(ParserTrainGamma, parsing) {
+TEST_P(ParserTrainGamma, Parsing) {
     const auto &[flag, gamma] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, fmt::format("{}", gamma), "data.libsvm" });
@@ -328,7 +328,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainGamma,
 class ParserTrainGammaInvalid : public ParserTrain,
                                 public ::testing::WithParamInterface<std::tuple<std::string, plssvm::real_type>> { };
 
-TEST_P(ParserTrainGammaInvalid, gamma_explicit_less_or_equal_to_zero) {
+TEST_P(ParserTrainGammaInvalid, GammaExplicitLessOrEqualToZero) {
     const auto &[flag, gamma] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, fmt::format("{}", gamma), "data.libsvm" });
@@ -346,7 +346,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainGammaInvalid, ::testing::Combin
 class ParserTrainCoef0 : public ParserTrain,
                          public ::testing::WithParamInterface<std::tuple<std::string, plssvm::real_type>> { };
 
-TEST_P(ParserTrainCoef0, parsing) {
+TEST_P(ParserTrainCoef0, Parsing) {
     const auto &[flag, coef0] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, fmt::format("{}", coef0), "data.libsvm" });
@@ -368,7 +368,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainCoef0, ::testing::Combine(
 class ParserTrainCost : public ParserTrain,
                         public ::testing::WithParamInterface<std::tuple<std::string, plssvm::real_type>> { };
 
-TEST_P(ParserTrainCost, parsing) {
+TEST_P(ParserTrainCost, Parsing) {
     const auto &[flag, cost] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, fmt::format("{}", cost), "data.libsvm" });
@@ -388,7 +388,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainCost, ::testing::Combine(
 class ParserTrainEpsilon : public ParserTrain,
                            public ::testing::WithParamInterface<std::tuple<std::string, plssvm::real_type>> { };
 
-TEST_P(ParserTrainEpsilon, parsing) {
+TEST_P(ParserTrainEpsilon, Parsing) {
     const auto &[flag, eps] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, fmt::format("{}", eps), "data.libsvm" });
@@ -409,7 +409,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainEpsilon, ::testing::Combine(
 class ParserTrainMaxIter : public ParserTrain,
                            public ::testing::WithParamInterface<std::tuple<std::string, std::size_t>> { };
 
-TEST_P(ParserTrainMaxIter, parsing) {
+TEST_P(ParserTrainMaxIter, Parsing) {
     const auto &[flag, max_iter] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, fmt::format("{}", max_iter), "data.libsvm" });
@@ -429,7 +429,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainMaxIter, ::testing::Combine(
 class ParserTrainMaxIterInvalid : public ParserTrain,
                                   public ::testing::WithParamInterface<std::tuple<std::string, long long int>> { };
 
-TEST_P(ParserTrainMaxIterInvalid, max_iter_explicit_less_or_equal_to_zero) {
+TEST_P(ParserTrainMaxIterInvalid, MaxIterExplicitLessOrEqualToZero) {
     const auto &[flag, max_iter] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, fmt::format("{}", max_iter), "data.libsvm" });
@@ -447,7 +447,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainMaxIterInvalid, ::testing::Comb
 class ParserTrainSolver : public ParserTrain,
                           public ::testing::WithParamInterface<std::tuple<std::string, plssvm::solver_type>> { };
 
-TEST_P(ParserTrainSolver, parsing) {
+TEST_P(ParserTrainSolver, Parsing) {
     const auto &[flag, solver] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, fmt::format("{}", solver), "data.libsvm" });
@@ -467,7 +467,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainSolver, ::testing::Combine(
 class ParserTrainClassification : public ParserTrain,
                                   public ::testing::WithParamInterface<std::tuple<std::string, plssvm::classification_type>> { };
 
-TEST_P(ParserTrainClassification, parsing) {
+TEST_P(ParserTrainClassification, Parsing) {
     const auto &[flag, classification] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, fmt::format("{}", classification), "data.libsvm" });
@@ -487,7 +487,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainClassification, ::testing::Comb
 class ParserTrainBackend : public ParserTrain,
                            public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainBackend, parsing) {
+TEST_P(ParserTrainBackend, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to backend
     const auto backend = util::convert_from_string<plssvm::backend_type>(value);
@@ -509,7 +509,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainBackend, ::testing::Combine(
 class ParserTrainTargetPlatform : public ParserTrain,
                                   public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainTargetPlatform, parsing) {
+TEST_P(ParserTrainTargetPlatform, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to target_platform
     const auto target_platform = util::convert_from_string<plssvm::target_platform>(value);
@@ -530,32 +530,32 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainTargetPlatform, ::testing::Comb
 
 #if defined(PLSSVM_HAS_SYCL_BACKEND)
 
-class ParserTrainSYCLKernelInvocation : public ParserTrain,
-                                        public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
+class ParserTrainSYCLDataParallelKernel : public ParserTrain,
+                                          public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainSYCLKernelInvocation, parsing) {
+TEST_P(ParserTrainSYCLDataParallelKernel, Parsing) {
     const auto &[flag, value] = GetParam();
-    // convert string to sycl::kernel_invocation_type
-    const auto sycl_kernel_invocation_type = util::convert_from_string<plssvm::sycl::kernel_invocation_type>(value);
+    // convert string to sycl::data_parallel_kernel
+    const auto sycl_data_parallel_kernel = util::convert_from_string<plssvm::sycl::data_parallel_kernel>(value);
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, value, "data.libsvm" });
     // create parameter object
     const plssvm::detail::cmd::parser_train parser{ this->get_comm(), this->get_argc(), this->get_argv() };
     // test for correctness
-    EXPECT_EQ(parser.sycl_kernel_invocation_type, sycl_kernel_invocation_type);
+    EXPECT_EQ(parser.sycl_data_parallel_kernel, sycl_data_parallel_kernel);
 }
 
 // clang-format off
-INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainSYCLKernelInvocation, ::testing::Combine(
-                ::testing::Values("--sycl_kernel_invocation_type"),
+INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainSYCLDataParallelKernel, ::testing::Combine(
+                ::testing::Values("--sycl_data_parallel_kernel"),
                 ::testing::Values("automatic", "auto", "basic", "nd_range", "work_group", "hierarchical", "scoped")),
-                naming::pretty_print_parameter_flag_and_value<ParserTrainSYCLKernelInvocation>);
+                naming::pretty_print_parameter_flag_and_value<ParserTrainSYCLDataParallelKernel>);
 // clang-format on
 
 class ParserTrainSYCLImplementation : public ParserTrain,
                                       public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainSYCLImplementation, parsing) {
+TEST_P(ParserTrainSYCLImplementation, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to sycl::implementation_type
     const auto sycl_implementation_type = util::convert_from_string<plssvm::sycl::implementation_type>(value);
@@ -581,7 +581,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainSYCLImplementation, ::testing::
 class ParserTrainKokkosExecutionSpace : public ParserTrain,
                                         public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainKokkosExecutionSpace, parsing) {
+TEST_P(ParserTrainKokkosExecutionSpace, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to kokkos::execution_space
     const auto kokkos_execution_space = util::convert_from_string<plssvm::kokkos::execution_space>(value);
@@ -607,7 +607,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainKokkosExecutionSpace, ::testing
 class ParserTrainPerformanceTrackingFilename : public ParserTrain,
                                                public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainPerformanceTrackingFilename, parsing) {
+TEST_P(ParserTrainPerformanceTrackingFilename, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, value, "data.libsvm" });
@@ -631,7 +631,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainPerformanceTrackingFilename, ::
 class ParserTrainMPILoadBalancingWeights : public ParserTrain,
                                            public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainMPILoadBalancingWeights, parsing) {
+TEST_P(ParserTrainMPILoadBalancingWeights, Parsing) {
     const auto &[flag, value] = GetParam();
     // convert string to std::vector
     const std::vector<std::size_t> weights{ util::convert_from_string<std::size_t>(value) };
@@ -653,7 +653,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainMPILoadBalancingWeights, ::test
 class ParserTrainMPILoadBalancingWeightsInvalid : public ParserTrain,
                                                   public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainMPILoadBalancingWeightsInvalid, parsing) {
+TEST_P(ParserTrainMPILoadBalancingWeightsInvalid, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, value, "data.libsvm" });
@@ -673,7 +673,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainMPILoadBalancingWeightsInvalid,
 class ParserTrainUseStringsAsLabels : public ParserTrain,
                                       public ::testing::WithParamInterface<std::tuple<std::string, bool>> { };
 
-TEST_P(ParserTrainUseStringsAsLabels, parsing) {
+TEST_P(ParserTrainUseStringsAsLabels, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", fmt::format("{}={}", flag, value), "data.libsvm" });
@@ -693,7 +693,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainUseStringsAsLabels, ::testing::
 class ParserTrainVerbosity : public ParserTrain,
                              public ::testing::WithParamInterface<std::tuple<std::string, std::string>> { };
 
-TEST_P(ParserTrainVerbosity, parsing) {
+TEST_P(ParserTrainVerbosity, Parsing) {
     const auto &[flag, value] = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag, value, "data.libsvm" });
@@ -713,7 +713,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainVerbosity, ::testing::Combine(
 class ParserTrainQuiet : public ParserTrain,
                          public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserTrainQuiet, parsing) {
+TEST_P(ParserTrainQuiet, Parsing) {
     const plssvm::verbosity_level old_verbosity = plssvm::verbosity;
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
@@ -729,7 +729,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainQuiet, ::testing::Values("-q",
 class ParserTrainVerbosityAndQuiet : public ParserTrain,
                                      private util::redirect_output<&std::clog> { };
 
-TEST_F(ParserTrainVerbosityAndQuiet, parsing) {
+TEST_F(ParserTrainVerbosityAndQuiet, Parsing) {
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", "--quiet", "--verbosity", "full", "data.libsvm" });
     // create parameter object
@@ -741,7 +741,7 @@ TEST_F(ParserTrainVerbosityAndQuiet, parsing) {
 class ParserTrainHelp : public ParserTrain,
                         public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserTrainHelp, parsing) {
+TEST_P(ParserTrainHelp, Parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag });
@@ -754,7 +754,7 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainHelp, ::testing::Values("-h", "
 class ParserTrainVersion : public ParserTrain,
                            public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserTrainVersion, parsing) {
+TEST_P(ParserTrainVersion, Parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag });
@@ -764,17 +764,17 @@ TEST_P(ParserTrainVersion, parsing) {
 
 INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainVersion, ::testing::Values("-v", "--version"), naming::pretty_print_parameter_flag<ParserTrainVersion>);
 
-TEST_F(ParserTrain, no_positional_argument) {
+TEST_F(ParserTrain, NoPositionalArgument) {
     this->CreateCMDArgs({ "./plssvm-train" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_train{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
 
-TEST_F(ParserTrain, too_many_positional_arguments) {
+TEST_F(ParserTrain, TooManyPositionalArguments) {
     this->CreateCMDArgs({ "./plssvm-train", "p1", "p2", "p3", "p4" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_train{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
 
-TEST_F(ParserTrain, unrecognized_option) {
+TEST_F(ParserTrain, UnrecognizedOption) {
     this->CreateCMDArgs({ "./plssvm-train", "--foo", "bar" });
     EXPECT_THROW_WHAT((plssvm::detail::cmd::parser_train{ this->get_comm(), this->get_argc(), this->get_argv() }), plssvm::cmd_parser_exit, fmt::format("exit code: {}", EXIT_FAILURE));
 }
@@ -782,7 +782,7 @@ TEST_F(ParserTrain, unrecognized_option) {
 class ParserTrainOutput : public ParserTrain,
                           public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserTrainOutput, parsing) {
+TEST_P(ParserTrainOutput, Parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", "--kernel_type", flag, "data.libsvm" });
@@ -816,7 +816,7 @@ TEST_P(ParserTrainOutput, parsing) {
     };
 
     // test output string
-    std::string correct = fmt::format(
+    const std::string correct = fmt::format(
         "svm_type: csvc\n"
         "{}"
         "cost: 1\n"
@@ -826,7 +826,7 @@ TEST_P(ParserTrainOutput, parsing) {
         "target platform: automatic\n"
         "solver: automatic\n"
         "SYCL implementation type: automatic\n"
-        "SYCL kernel invocation type: automatic\n"
+        "SYCL data parallel kernel: automatic\n"
         "Kokkos execution space: automatic\n"
         "classification_type: one vs. all\n"
         "label_type: int\n"
@@ -844,12 +844,12 @@ INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainOutput, ::testing::Values("line
 class ParserTrainDeathTest : public ParserTrain { };
 
 // test whether nonsensical cmd arguments trigger the assertions
-TEST_F(ParserTrainDeathTest, too_few_argc) {
+TEST_F(ParserTrainDeathTest, TooFewArgc) {
     EXPECT_DEATH((plssvm::detail::cmd::parser_train{ this->get_comm(), 0, nullptr }),
                  ::testing::HasSubstr("At least one argument is always given (the executable name), but argc is 0!"));
 }
 
-TEST_F(ParserTrainDeathTest, nullptr_argv) {
+TEST_F(ParserTrainDeathTest, NullptrArgv) {
     EXPECT_DEATH((plssvm::detail::cmd::parser_train{ this->get_comm(), 1, nullptr }),
                  ::testing::HasSubstr("At least one argument is always given (the executable name), but argv is a nullptr!"));
 }
diff --git a/tests/detail/data_distribution.cpp b/tests/detail/data_distribution.cpp
index c3e488c21..8fcc3d025 100644
--- a/tests/detail/data_distribution.cpp
+++ b/tests/detail/data_distribution.cpp
@@ -24,18 +24,18 @@
 #include <iostream>   // std::cout, std::endl
 #include <vector>     // std::vector
 
-using namespace plssvm::detail::literals;
+using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
 
 //*************************************************************************************************************************************//
 //                                                    triangular data distributions                                                    //
 //*************************************************************************************************************************************//
 
-TEST(TriangularDataDistribution, construct) {
+TEST(TriangularDataDistribution, Construct) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
     // test getter
-    const std::vector<std::size_t> dist_vec = dist.distribution();
+    const std::vector<std::size_t> &dist_vec = dist.distribution();
     EXPECT_EQ(dist_vec.size(), 5);
     EXPECT_EQ(dist_vec.front(), 0);                                   // the distribution must start with 0
     EXPECT_EQ(dist_vec.back(), 1024);                                 // the distribution must end with the number of rows
@@ -44,12 +44,12 @@ TEST(TriangularDataDistribution, construct) {
     EXPECT_EQ(dist.num_places(), 4);
 }
 
-TEST(TriangularDataDistribution, construct_with_weights) {
+TEST(TriangularDataDistribution, ConstructWithWeights) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{ std::vector<std::size_t>{ std::size_t{ 2 } } }, 1024, 4 };
 
     // test getter
-    const std::vector<std::size_t> dist_vec = dist.distribution();
+    const std::vector<std::size_t> &dist_vec = dist.distribution();
     EXPECT_EQ(dist_vec.size(), 5);
     EXPECT_EQ(dist_vec.front(), 0);                                   // the distribution must start with 0
     EXPECT_EQ(dist_vec.back(), 1024);                                 // the distribution must end with the number of rows
@@ -58,7 +58,7 @@ TEST(TriangularDataDistribution, construct_with_weights) {
     EXPECT_EQ(dist.num_places(), 4);
 }
 
-TEST(TriangularDataDistribution, place_specific_num_rows) {
+TEST(TriangularDataDistribution, PlaceSpecificNumRows) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -68,7 +68,7 @@ TEST(TriangularDataDistribution, place_specific_num_rows) {
     }
 }
 
-TEST(TriangularDataDistribution, place_row_offset) {
+TEST(TriangularDataDistribution, PlaceRowOffset) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -79,42 +79,42 @@ TEST(TriangularDataDistribution, place_row_offset) {
     }
 }
 
-TEST(TriangularDataDistribution, distribution) {
+TEST(TriangularDataDistribution, Distribution) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
     // check the distribution for sanity
-    const std::vector<std::size_t> dist_vec = dist.distribution();
+    const std::vector<std::size_t> &dist_vec = dist.distribution();
     EXPECT_EQ(dist_vec.size(), 5);
     EXPECT_EQ(dist_vec.front(), 0);                                   // the distribution must start with 0
     EXPECT_EQ(dist_vec.back(), 1024);                                 // the distribution must end with the number of rows
     EXPECT_TRUE(std::is_sorted(dist_vec.cbegin(), dist_vec.cend()));  // the distribution values must be sorted in ascending order
 }
 
-TEST(TriangularDataDistribution, distribution_one_place) {
+TEST(TriangularDataDistribution, DistributionOnePlace) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 1 };
 
     // check the distribution for sanity
-    const std::vector<std::size_t> dist_vec = dist.distribution();
+    const std::vector<std::size_t> &dist_vec = dist.distribution();
     EXPECT_EQ(dist_vec.size(), 2);
     EXPECT_EQ(dist_vec.front(), 0);    // the distribution must start with 0
     EXPECT_EQ(dist_vec.back(), 1024);  // the distribution must end with the number of rows
 }
 
-TEST(TriangularDataDistribution, distribution_fewer_rows_than_places) {
+TEST(TriangularDataDistribution, DistributionFewerRowsThanPlaces) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 6, 8 };
 
     // check the distribution for sanity
-    const std::vector<std::size_t> dist_vec = dist.distribution();
+    const std::vector<std::size_t> &dist_vec = dist.distribution();
     EXPECT_EQ(dist_vec.size(), 9);
     EXPECT_EQ(dist_vec.front(), 0);                                   // the distribution must start with 0
     EXPECT_EQ(dist_vec.back(), 6);                                    // the distribution must end with the number of rows
     EXPECT_TRUE(std::is_sorted(dist_vec.cbegin(), dist_vec.cend()));  // the distribution values must be sorted in ascending order
 }
 
-TEST(TriangularDataDistribution, num_rows) {
+TEST(TriangularDataDistribution, NumRows) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -122,7 +122,7 @@ TEST(TriangularDataDistribution, num_rows) {
     EXPECT_EQ(dist.num_rows(), 1024);
 }
 
-TEST(TriangularDataDistribution, total_num_places) {
+TEST(TriangularDataDistribution, TotalNumPlaces) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -130,7 +130,7 @@ TEST(TriangularDataDistribution, total_num_places) {
     EXPECT_EQ(dist.total_num_places(), 4);
 }
 
-TEST(TriangularDataDistribution, num_places) {
+TEST(TriangularDataDistribution, NumPlaces) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -138,7 +138,7 @@ TEST(TriangularDataDistribution, num_places) {
     EXPECT_EQ(dist.num_places(), 4);
 }
 
-TEST(TriangularDataDistribution, calculate_explicit_kernel_matrix_num_entries_padded) {
+TEST(TriangularDataDistribution, CalculateExplicitKernelMatrixNumEntriesPadded) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -149,7 +149,7 @@ TEST(TriangularDataDistribution, calculate_explicit_kernel_matrix_num_entries_pa
     }
 }
 
-TEST(TriangularDataDistribution, calculate_maximum_explicit_kernel_matrix_memory_needed_per_place) {
+TEST(TriangularDataDistribution, CalculateMaximumExplicitKernelMatrixMemoryNeededPerPlace) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -160,7 +160,7 @@ TEST(TriangularDataDistribution, calculate_maximum_explicit_kernel_matrix_memory
     }
 }
 
-TEST(TriangularDataDistribution, calculate_maximum_explicit_kernel_matrix_memory_allocation_size_per_place) {
+TEST(TriangularDataDistribution, CalculateMaximumExplicitKernelMatrixMemoryAllocationSizePerPlace) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -171,7 +171,7 @@ TEST(TriangularDataDistribution, calculate_maximum_explicit_kernel_matrix_memory
     }
 }
 
-TEST(TriangularDataDistribution, calculate_maximum_implicit_kernel_matrix_memory_needed_per_place) {
+TEST(TriangularDataDistribution, CalculateMaximumImplicitKernelMatrixMemoryNeededPerPlace) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -182,7 +182,7 @@ TEST(TriangularDataDistribution, calculate_maximum_implicit_kernel_matrix_memory
     }
 }
 
-TEST(TriangularDataDistribution, calculate_maximum_implicit_kernel_matrix_memory_allocation_size_per_place) {
+TEST(TriangularDataDistribution, CalculateMaximumImplicitKernelMatrixMemoryAllocationSizePerPlace) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -196,7 +196,7 @@ TEST(TriangularDataDistribution, calculate_maximum_implicit_kernel_matrix_memory
 class TriangularDataDistributionCapture : public ::testing::Test,
                                           public util::redirect_output<> { };
 
-TEST_F(TriangularDataDistributionCapture, output_operator) {
+TEST_F(TriangularDataDistributionCapture, OutputOperator) {
     // create a triangular data distribution
     const plssvm::detail::triangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -211,12 +211,12 @@ TEST_F(TriangularDataDistributionCapture, output_operator) {
 //                                                    rectangular data distributions                                                   //
 //*************************************************************************************************************************************//
 
-TEST(RectangularDataDistribution, construct) {
+TEST(RectangularDataDistribution, Construct) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
     // test getter
-    const std::vector<std::size_t> dist_vec = dist.distribution();
+    const std::vector<std::size_t> &dist_vec = dist.distribution();
     EXPECT_EQ(dist_vec.size(), 5);
     EXPECT_EQ(dist_vec.front(), 0);                                   // the distribution must start with 0
     EXPECT_EQ(dist_vec.back(), 1024);                                 // the distribution must end with the number of rows
@@ -225,12 +225,12 @@ TEST(RectangularDataDistribution, construct) {
     EXPECT_EQ(dist.num_places(), 4);
 }
 
-TEST(RectangularDataDistribution, construct_with_weights) {
+TEST(RectangularDataDistribution, ConstructWithWeights) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{ std::vector<std::size_t>{ std::size_t{ 3 } } }, 1024, 4 };
 
     // test getter
-    const std::vector<std::size_t> dist_vec = dist.distribution();
+    const std::vector<std::size_t> &dist_vec = dist.distribution();
     EXPECT_EQ(dist_vec.size(), 5);
     EXPECT_EQ(dist_vec.front(), 0);                                   // the distribution must start with 0
     EXPECT_EQ(dist_vec.back(), 1024);                                 // the distribution must end with the number of rows
@@ -239,7 +239,7 @@ TEST(RectangularDataDistribution, construct_with_weights) {
     EXPECT_EQ(dist.num_places(), 4);
 }
 
-TEST(RectangularDataDistribution, place_specific_num_rows) {
+TEST(RectangularDataDistribution, PlaceSpecificNumRows) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -249,7 +249,7 @@ TEST(RectangularDataDistribution, place_specific_num_rows) {
     }
 }
 
-TEST(RectangularDataDistribution, place_row_offset) {
+TEST(RectangularDataDistribution, PlaceRowOffset) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -260,42 +260,42 @@ TEST(RectangularDataDistribution, place_row_offset) {
     }
 }
 
-TEST(RectangularDataDistribution, distribution) {
+TEST(RectangularDataDistribution, Distribution) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
     // check the distribution for sanity
-    const std::vector<std::size_t> dist_vec = dist.distribution();
+    const std::vector<std::size_t> &dist_vec = dist.distribution();
     EXPECT_EQ(dist_vec.size(), 5);
     EXPECT_EQ(dist_vec.front(), 0);                                   // the distribution must start with 0
     EXPECT_EQ(dist_vec.back(), 1024);                                 // the distribution must end with the number of rows
     EXPECT_TRUE(std::is_sorted(dist_vec.cbegin(), dist_vec.cend()));  // the distribution values must be sorted in ascending order
 }
 
-TEST(RectangularDataDistribution, distribution_one_place) {
+TEST(RectangularDataDistribution, DistributionOnePlace) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 1 };
 
     // check the distribution for sanity
-    const std::vector<std::size_t> dist_vec = dist.distribution();
+    const std::vector<std::size_t> &dist_vec = dist.distribution();
     EXPECT_EQ(dist_vec.size(), 2);
     EXPECT_EQ(dist_vec.front(), 0);    // the distribution must start with 0
     EXPECT_EQ(dist_vec.back(), 1024);  // the distribution must end with the number of rows
 }
 
-TEST(RectangularDataDistribution, distribution_fewer_rows_than_places) {
+TEST(RectangularDataDistribution, DistributionFewerRowsThanPlaces) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, 6, 8 };
 
     // check the distribution for sanity
-    const std::vector<std::size_t> dist_vec = dist.distribution();
+    const std::vector<std::size_t> &dist_vec = dist.distribution();
     EXPECT_EQ(dist_vec.size(), 9);
     EXPECT_EQ(dist_vec.front(), 0);                                   // the distribution must start with 0
     EXPECT_EQ(dist_vec.back(), 6);                                    // the distribution must end with the number of rows
     EXPECT_TRUE(std::is_sorted(dist_vec.cbegin(), dist_vec.cend()));  // the distribution values must be sorted in ascending order
 }
 
-TEST(RectangularDataDistribution, num_rows) {
+TEST(RectangularDataDistribution, NumRows) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -303,7 +303,7 @@ TEST(RectangularDataDistribution, num_rows) {
     EXPECT_EQ(dist.num_rows(), 1024);
 }
 
-TEST(RectangularDataDistribution, total_num_places) {
+TEST(RectangularDataDistribution, TotalNumPlaces) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -311,7 +311,7 @@ TEST(RectangularDataDistribution, total_num_places) {
     EXPECT_EQ(dist.total_num_places(), 4);
 }
 
-TEST(RectangularDataDistribution, num_places) {
+TEST(RectangularDataDistribution, NumPlaces) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
@@ -322,7 +322,7 @@ TEST(RectangularDataDistribution, num_places) {
 class RectangularDataDistributionCapture : public ::testing::Test,
                                            public util::redirect_output<> { };
 
-TEST_F(RectangularDataDistributionCapture, output_operator) {
+TEST_F(RectangularDataDistributionCapture, OutputOperator) {
     // create a rectangular data distribution
     const plssvm::detail::rectangular_data_distribution dist{ plssvm::mpi::communicator{}, 1024, 4 };
 
diff --git a/tests/detail/io/arff_parsing.cpp b/tests/detail/io/arff_parsing.cpp
index af36ec3e2..fbe1ad85b 100644
--- a/tests/detail/io/arff_parsing.cpp
+++ b/tests/detail/io/arff_parsing.cpp
@@ -23,7 +23,7 @@
 #include "tests/utility.hpp"             // util::{temporary_file, instantiate_template_file, get_correct_data_file_labels, get_distinct_label, generate_specific_matrix}
 
 #include "fmt/format.h"   // fmt::format
-#include "fmt/std.h"      // format std::vector<bool>::operator[] proxy type
+#include "fmt/std.h"      // NOLINT: format std::vector<bool>::operator[] proxy type
 #include "gmock/gmock.h"  // ::testing::HasSubstr
 #include "gtest/gtest.h"  // TEST, TEST_P, TYPED_TEST, TYPED_TEST_SUITE, INSTANTIATE_TEST_SUITE_P, EXPECT_EQ, EXPECT_TRUE, EXPECT_DEATH, ASSERT_EQ, FAIL
                           // ::testing::{Test, Types, TestWithParam, Values}
@@ -39,7 +39,7 @@ class ARFFParseHeader : public ::testing::Test { };
 
 class ARFFParseHeaderValid : public ::testing::TestWithParam<std::tuple<std::string, std::size_t, std::size_t, bool, std::size_t>> { };
 
-TEST_P(ARFFParseHeaderValid, header) {
+TEST_P(ARFFParseHeaderValid, Header) {
     const auto &[filename_part, num_features, header_skip, has_label, label_idx] = GetParam();
 
     // parse the ARFF file
@@ -65,7 +65,7 @@ INSTANTIATE_TEST_SUITE_P(ARFFParse, ARFFParseHeaderValid, ::testing::Values(
                                                      std::make_tuple("/data/arff/3x2_without_label.arff", 2, 4, false, 0)));
 // clang-format on
 
-TEST(ARFFParseHeader, class_unquoted_nominal_attribute) {
+TEST(ARFFParseHeader, ClassUnquotedNominalAttribute) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/class_unquoted_nominal_attribute.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -75,7 +75,7 @@ TEST(ARFFParseHeader, class_unquoted_nominal_attribute) {
                       R"(The "@ATTRIBUTE class    0,1" nominal attribute must be enclosed with {}!)");
 }
 
-TEST(ARFFParseHeader, class_without_label) {
+TEST(ARFFParseHeader, ClassWithoutLabel) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/class_without_label.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -85,7 +85,7 @@ TEST(ARFFParseHeader, class_without_label) {
                       R"(The "@ATTRIBUTE class" field must contain class labels!)");
 }
 
-TEST(ARFFParseHeader, multiple_classes) {
+TEST(ARFFParseHeader, MultipleClasses) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/multiple_classes.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -95,7 +95,7 @@ TEST(ARFFParseHeader, multiple_classes) {
                       "A nominal attribute with the name CLASS may only be provided once!");
 }
 
-TEST(ARFFParseHeader, no_features) {
+TEST(ARFFParseHeader, NoFeatures) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/no_features.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -105,7 +105,7 @@ TEST(ARFFParseHeader, no_features) {
                       "Can't parse file: no feature ATTRIBUTES are defined!");
 }
 
-TEST(ARFFParseHeader, no_data_attribute) {
+TEST(ARFFParseHeader, NoDataAttribute) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/no_data_attribute.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -115,7 +115,7 @@ TEST(ARFFParseHeader, no_data_attribute) {
                       "Can't parse file: @DATA is missing!");
 }
 
-TEST(ARFFParseHeader, nominal_attribute_with_wrong_name) {
+TEST(ARFFParseHeader, NominalAttributeWithWrongName) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/nominal_attribute_with_wrong_name.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -125,7 +125,7 @@ TEST(ARFFParseHeader, nominal_attribute_with_wrong_name) {
                       R"(Read an invalid header entry: "@ATTRIBUTE foo    {0,1}"!)");
 }
 
-TEST(ARFFParseHeader, numeric_unquoted) {
+TEST(ARFFParseHeader, NumericUnquoted) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/numeric_unquoted.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -135,7 +135,7 @@ TEST(ARFFParseHeader, numeric_unquoted) {
                       R"(A "@ATTRIBUTE second entry   numeric" name that contains a whitespace must be quoted!)");
 }
 
-TEST(ARFFParseHeader, numeric_without_name) {
+TEST(ARFFParseHeader, NumericWithoutName) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/numeric_without_name.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -145,7 +145,7 @@ TEST(ARFFParseHeader, numeric_without_name) {
                       R"(The "@ATTRIBUTE   numeric" field must contain a name!)");
 }
 
-TEST(ARFFParseHeader, relation_not_at_beginning) {
+TEST(ARFFParseHeader, RelationNotAtBeginning) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/relation_not_at_beginning.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -155,7 +155,7 @@ TEST(ARFFParseHeader, relation_not_at_beginning) {
                       "The @RELATION attribute must be set before any other @ATTRIBUTE!");
 }
 
-TEST(ARFFParseHeader, relation_unquoted) {
+TEST(ARFFParseHeader, RelationUnquoted) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/relation_unquoted.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -165,7 +165,7 @@ TEST(ARFFParseHeader, relation_unquoted) {
                       R"(A "@RELATION  name with whitespaces" name that contains a whitespace must be quoted!)");
 }
 
-TEST(ARFFParseHeader, relation_without_name) {
+TEST(ARFFParseHeader, RelationWithoutName) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/relation_without_name.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -175,7 +175,7 @@ TEST(ARFFParseHeader, relation_without_name) {
                       R"(The "@RELATION" field must contain a name!)");
 }
 
-TEST(ARFFParseHeader, wrong_line) {
+TEST(ARFFParseHeader, WrongLine) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/arff/invalid/wrong_line.arff";
     plssvm::detail::io::file_reader reader{ filename };
@@ -185,7 +185,7 @@ TEST(ARFFParseHeader, wrong_line) {
                       R"(Read an invalid header entry: "@THIS IS NOT A CORRECT LINE!"!)");
 }
 
-TEST(ARFFParseHeader, empty) {
+TEST(ARFFParseHeader, Empty) {
     // parse the ARFF file
     const std::string filename = PLSSVM_TEST_PATH "/data/empty.txt";
     plssvm::detail::io::file_reader reader{ filename };
@@ -279,7 +279,7 @@ class ARFFParseSparse : public ARFFParse<T>,
 
 TYPED_TEST_SUITE(ARFFParseSparse, util::label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ARFFParseDense, read) {
+TYPED_TEST(ARFFParseDense, Read) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -297,7 +297,7 @@ TYPED_TEST(ARFFParseDense, read) {
     EXPECT_EQ(label, this->get_correct_label());
 }
 
-TYPED_TEST(ARFFParseSparse, read) {
+TYPED_TEST(ARFFParseSparse, Read) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -314,7 +314,7 @@ TYPED_TEST(ARFFParseSparse, read) {
     EXPECT_EQ(label, this->get_correct_label());
 }
 
-TYPED_TEST(ARFFParse, read_without_label) {
+TYPED_TEST(ARFFParse, ReadWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -336,7 +336,7 @@ TYPED_TEST(ARFFParse, read_without_label) {
     EXPECT_TRUE(label.empty());
 }
 
-TYPED_TEST(ARFFParse, at_inside_data_section) {
+TYPED_TEST(ARFFParse, AtInsideDataSection) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -348,7 +348,7 @@ TYPED_TEST(ARFFParse, at_inside_data_section) {
                       R"(Read @ inside data section!: "@ATTRIBUTE invalid numeric"!)");
 }
 
-TYPED_TEST(ARFFParse, sparse_missing_closing_brace) {
+TYPED_TEST(ARFFParse, SparseMissingClosingBrace) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -360,7 +360,7 @@ TYPED_TEST(ARFFParse, sparse_missing_closing_brace) {
                       R"(Missing closing '}' for sparse data point "{2 0.51687296029754564,3 0.54604461446026,4 1" description!)");
 }
 
-TYPED_TEST(ARFFParse, sparse_missing_opening_brace) {
+TYPED_TEST(ARFFParse, SparseMissingOpeningBrace) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -372,7 +372,7 @@ TYPED_TEST(ARFFParse, sparse_missing_opening_brace) {
                       R"(Missing opening '{' for sparse data point "1 0.60276937379453293,2 -0.13086851759108944,4 0}" description!)");
 }
 
-TYPED_TEST(ARFFParse, sparse_invalid_feature_index) {
+TYPED_TEST(ARFFParse, SparseInvalidFeatureIndex) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -384,7 +384,7 @@ TYPED_TEST(ARFFParse, sparse_invalid_feature_index) {
                       "Trying to add feature/label at index 5 but the maximum index is 4!");
 }
 
-TYPED_TEST(ARFFParse, sparse_missing_label) {
+TYPED_TEST(ARFFParse, SparseMissingLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -396,7 +396,7 @@ TYPED_TEST(ARFFParse, sparse_missing_label) {
                       R"(Missing label for data point "{0 1.88494043717792,1 1.00518564317278263,2 0.298499933047586044,3 1.6464627048813514}"!)");
 }
 
-TYPED_TEST(ARFFParse, dense_missing_value) {
+TYPED_TEST(ARFFParse, DenseMissingValue) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -408,7 +408,7 @@ TYPED_TEST(ARFFParse, dense_missing_value) {
                       "Invalid number of features and labels! Found 3 but should be 5!");
 }
 
-TYPED_TEST(ARFFParse, dense_too_many_values) {
+TYPED_TEST(ARFFParse, DenseTooManyValues) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -420,7 +420,7 @@ TYPED_TEST(ARFFParse, dense_too_many_values) {
                       "Invalid number of features and labels! Found 6 but should be 5!");
 }
 
-TYPED_TEST(ARFFParse, class_same_label_multiple_times) {
+TYPED_TEST(ARFFParse, ClassSameLabelMultipleTimes) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -432,7 +432,7 @@ TYPED_TEST(ARFFParse, class_same_label_multiple_times) {
                       "Provided 2 labels but only 1 of them was/where unique!");
 }
 
-TYPED_TEST(ARFFParse, class_with_only_one_label) {
+TYPED_TEST(ARFFParse, ClassWithOnlyOneLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -444,7 +444,7 @@ TYPED_TEST(ARFFParse, class_with_only_one_label) {
                       "Only a single label has been provided!");
 }
 
-TYPED_TEST(ARFFParse, usage_of_undefined_label) {
+TYPED_TEST(ARFFParse, UsageOfUndefinedLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -461,7 +461,7 @@ TYPED_TEST(ARFFParse, usage_of_undefined_label) {
     }
 }
 
-TYPED_TEST(ARFFParse, string_label_with_whitespace) {
+TYPED_TEST(ARFFParse, StringLabelWithWhitespace) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -478,7 +478,7 @@ TYPED_TEST(ARFFParse, string_label_with_whitespace) {
     }
 }
 
-TYPED_TEST(ARFFParse, libsvm_file) {
+TYPED_TEST(ARFFParse, LIBSVMFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -493,7 +493,7 @@ class ARFFParseDeathTest : public ::testing::Test { };
 
 TYPED_TEST_SUITE(ARFFParseDeathTest, util::label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ARFFParseDeathTest, invalid_file_reader) {
+TYPED_TEST(ARFFParseDeathTest, InvalidFileReader) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // open file_reader without associating it to a file
@@ -516,7 +516,7 @@ class ARFFWriteDeathTest : public ARFFWrite<T> { };
 
 TYPED_TEST_SUITE(ARFFWriteDeathTest, util::label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ARFFWrite, write_with_label) {
+TYPED_TEST(ARFFWrite, WriteWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
@@ -554,7 +554,7 @@ TYPED_TEST(ARFFWrite, write_with_label) {
     }
 }
 
-TYPED_TEST(ARFFWrite, write_without_label) {
+TYPED_TEST(ARFFWrite, WriteWithoutLabel) {
     // define data to write
     const auto data = util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ 3, 3 });
 
@@ -588,7 +588,7 @@ TYPED_TEST(ARFFWrite, write_without_label) {
     }
 }
 
-TYPED_TEST(ARFFWrite, empty_data) {
+TYPED_TEST(ARFFWrite, EmptyData) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
@@ -606,7 +606,7 @@ TYPED_TEST(ARFFWrite, empty_data) {
     EXPECT_TRUE(reader.lines().empty());
 }
 
-TYPED_TEST(ARFFWriteDeathTest, data_with_provided_empty_labels) {
+TYPED_TEST(ARFFWriteDeathTest, DataWithProvidedEmptyLabels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
@@ -617,7 +617,7 @@ TYPED_TEST(ARFFWriteDeathTest, data_with_provided_empty_labels) {
     EXPECT_DEATH(plssvm::detail::io::write_arff_data(this->filename, data, label), "has_label is 'true' but no labels were provided!");
 }
 
-TYPED_TEST(ARFFWriteDeathTest, data_and_label_size_mismatch) {
+TYPED_TEST(ARFFWriteDeathTest, DataAndLabelSizeMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
@@ -629,7 +629,7 @@ TYPED_TEST(ARFFWriteDeathTest, data_and_label_size_mismatch) {
                  ::testing::HasSubstr("Number of data points (2) and number of labels (1) mismatch!"));
 }
 
-TYPED_TEST(ARFFWriteDeathTest, labels_provided_but_not_written) {
+TYPED_TEST(ARFFWriteDeathTest, LabelsProvidedButNotWritten) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
diff --git a/tests/detail/io/classification_libsvm_model_parsing/data_parse_invalid.cpp b/tests/detail/io/classification_libsvm_model_parsing/data_parse_invalid.cpp
index b0624a769..8a8ce2cb5 100644
--- a/tests/detail/io/classification_libsvm_model_parsing/data_parse_invalid.cpp
+++ b/tests/detail/io/classification_libsvm_model_parsing/data_parse_invalid.cpp
@@ -31,7 +31,7 @@ class LIBSVMClassificationModelDataParseInvalid : public ::testing::Test { };
 
 TYPED_TEST_SUITE(LIBSVMClassificationModelDataParseInvalid, util::classification_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, zero_based_features) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, ZeroBasedFeatures) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/zero_based_features.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -41,7 +41,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, zero_based_features) {
                       "LIBSVM assumes a 1-based feature indexing scheme, but 0 was given!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, empty_data) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, EmptyData) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/empty_data.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -51,7 +51,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, empty_data) {
                       "Can't parse file: no data points are given!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, too_few_alpha_values) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, TooFewAlphaValues) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/too_few_alpha_values.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -61,7 +61,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, too_few_alpha_values) {
                       "Can't parse file: needed at least 1 alpha values, but fewer (0) were provided!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, too_many_alpha_values) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, TooManyAlphaValues) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/too_many_alpha_values.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -71,7 +71,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, too_many_alpha_values) {
                       "Can't parse file: needed at most 2 alpha values, but more (3) were provided!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, feature_with_alpha_char_at_the_beginning) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, FeatureWithAlphaCharAtTheBeginning) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/feature_with_alpha_char_at_the_beginning.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -81,7 +81,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, feature_with_alpha_char_at
                       fmt::format("Can't convert 'a-1.1178275006e+00' to a value of type {}!", plssvm::detail::arithmetic_type_name<plssvm::real_type>()));
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, index_with_alpha_char_at_the_beginning) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, IndexWithAlphaCharAtTheBeginning) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/index_with_alpha_char_at_the_beginning.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -91,7 +91,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, index_with_alpha_char_at_t
                       "Can't convert ' !2' to a value of type unsigned long!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, invalid_colon_at_the_beginning) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, InvalidColonAtTheBeginning) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/invalid_colon_at_the_beginning.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -101,7 +101,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, invalid_colon_at_the_begin
                       "Can't parse file: needed at least 1 alpha values, but fewer (0) were provided!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, invalid_colon_in_the_middle) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, InvalidColonInTheMiddle) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/invalid_colon_in_the_middle.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -111,7 +111,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, invalid_colon_in_the_middl
                       "Can't convert ' ' to a value of type unsigned long!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, missing_feature_value) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, MissingFeatureValue) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/missing_feature_value.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -121,7 +121,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, missing_feature_value) {
                       fmt::format("Can't convert '' to a value of type {}!", plssvm::detail::arithmetic_type_name<plssvm::real_type>()));
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, missing_index_value) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, MissingIndexValue) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/missing_index_value.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -131,7 +131,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, missing_index_value) {
                       "Can't convert ' ' to a value of type unsigned long!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, non_increasing_indices) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, NonIncreasingIndices) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/non_increasing_indices.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -141,7 +141,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, non_increasing_indices) {
                       "The features indices must be strictly increasing, but 3 is smaller or equal than 3!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, non_strictly_increasing_indices) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, NonStrictlyIncreasingIndices) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/non_strictly_increasing_indices.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -151,7 +151,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, non_strictly_increasing_in
                       "The features indices must be strictly increasing, but 2 is smaller or equal than 3!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, oaa_and_oao) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, OaAAndOaO) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/oaa_and_oao.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -161,7 +161,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, oaa_and_oao) {
                       "Can't distinguish between OAA and OAO in the given model file!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, too_many_num_sv_per_class) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, TooManyNumSvPerClass) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/too_many_num_sv_per_class.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -171,7 +171,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, too_many_num_sv_per_class)
                       "Can't parse file: needed at least 3 alpha values, but fewer (2) were provided!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, too_few_sv_according_to_header) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, TooFewSvAccordingToHeader) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/too_few_sv_according_to_header.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -181,7 +181,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, too_few_sv_according_to_he
                       "Found 5 support vectors, but it should be 6!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, too_many_sv_according_to_header) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalid, TooManySvAccordingToHeader) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/invalid/too_many_sv_according_to_header.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -196,14 +196,14 @@ class LIBSVMClassificationModelDataParseInvalidDeathTest : public LIBSVMClassifi
 
 TYPED_TEST_SUITE(LIBSVMClassificationModelDataParseInvalidDeathTest, util::classification_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalidDeathTest, invalid_file_reader) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalidDeathTest, InvalidFileReader) {
     // open file_reader without associating it to a file
     const plssvm::detail::io::file_reader reader{};
     EXPECT_DEATH(std::ignore = (plssvm::detail::io::parse_libsvm_model_data_classification(reader, std::vector<std::size_t>{ 3, 3 }, 0)),
                  "The file_reader is currently not associated with a file!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalidDeathTest, too_few_num_sv_per_class) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalidDeathTest, TooFewNumSvPerClass) {
     // parse LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/libsvm/classification/5x4.libsvm";
     plssvm::detail::io::file_reader reader{ filename };
@@ -213,7 +213,7 @@ TYPED_TEST(LIBSVMClassificationModelDataParseInvalidDeathTest, too_few_num_sv_pe
                  "At least two classes must be present!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataParseInvalidDeathTest, skip_too_many_lines) {
+TYPED_TEST(LIBSVMClassificationModelDataParseInvalidDeathTest, SkipTooManyLines) {
     // parse LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/classification/6x4.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
diff --git a/tests/detail/io/classification_libsvm_model_parsing/data_parse_valid.cpp b/tests/detail/io/classification_libsvm_model_parsing/data_parse_valid.cpp
index fdb735e37..f21bfdffe 100644
--- a/tests/detail/io/classification_libsvm_model_parsing/data_parse_valid.cpp
+++ b/tests/detail/io/classification_libsvm_model_parsing/data_parse_valid.cpp
@@ -83,7 +83,7 @@ class LIBSVMClassificationModelDataParseValid : public ::testing::Test,
 
 TYPED_TEST_SUITE(LIBSVMClassificationModelDataParseValid, util::classification_label_type_classification_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMClassificationModelDataParseValid, read) {
+TYPED_TEST(LIBSVMClassificationModelDataParseValid, Read) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::classification_type expected_classification = TestFixture::fixture_classification;
 
diff --git a/tests/detail/io/classification_libsvm_model_parsing/data_write.cpp b/tests/detail/io/classification_libsvm_model_parsing/data_write.cpp
index 295daa5e7..2ad768bee 100644
--- a/tests/detail/io/classification_libsvm_model_parsing/data_write.cpp
+++ b/tests/detail/io/classification_libsvm_model_parsing/data_write.cpp
@@ -15,6 +15,7 @@
 #include "plssvm/detail/io/file_reader.hpp"                          // plssvm::detail::io::file_reader
 #include "plssvm/kernel_function_types.hpp"                          // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                                         // plssvm::aos_matrix
+#include "plssvm/mpi/communicator.hpp"                               // plssvm::mpi::communicator
 #include "plssvm/parameter.hpp"                                      // plssvm::parameter
 #include "plssvm/shape.hpp"                                          // plssvm::shape
 
@@ -42,16 +43,16 @@ class LIBSVMClassificationModelDataWrite : public ::testing::Test,
      * @brief Return the used MPI communicator.
      * @return the MPI communicator (`[[nodiscard]]`)
      */
-    [[nodiscard]] const plssvm::mpi::communicator get_comm() const noexcept { return comm_; }
+    [[nodiscard]] const plssvm::mpi::communicator &get_comm() const noexcept { return comm_; }
 
   private:
     /// The MPI communicator (unused during testing since we do not support MPI runtime tests).
-    plssvm::mpi::communicator comm_{};
+    plssvm::mpi::communicator comm_;
 };
 
 TYPED_TEST_SUITE(LIBSVMClassificationModelDataWrite, util::classification_label_type_classification_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMClassificationModelDataWrite, write) {
+TYPED_TEST(LIBSVMClassificationModelDataWrite, Write) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
     constexpr plssvm::classification_type classification = util::test_parameter_value_at_v<0, TypeParam>;
 
@@ -66,7 +67,7 @@ TYPED_TEST(LIBSVMClassificationModelDataWrite, write) {
     // create necessary parameter
     const plssvm::parameter params{ plssvm::kernel_type = plssvm::kernel_function_type::linear };
     const std::vector<plssvm::real_type> rho(num_classifiers, plssvm::real_type{ 3.1415 });
-    std::vector<std::vector<std::size_t>> index_sets{};
+    std::vector<std::vector<std::size_t>> index_sets{};  // NOLINT(misc-const-correctness): is modified in case of OAO
     if constexpr (classification == plssvm::classification_type::oao) {
         switch (num_classes) {
             case 2:
@@ -138,6 +139,7 @@ TYPED_TEST(LIBSVMClassificationModelDataWrite, write) {
                     // iterate over all support vectors for one class IN THE ORIGINAL DATA
                     // assemble the alpha vector
                     std::vector<plssvm::real_type> alpha_vec{};
+                    alpha_vec.reserve(num_classifiers);
                     for (std::size_t l = 0; l < num_classifiers; ++l) {
                         alpha_vec.push_back(alpha.front()(l, idx + k));
                     }
@@ -207,7 +209,8 @@ TYPED_TEST(LIBSVMClassificationModelDataWrite, write) {
             // check, how often the line in the file was found in the original data
             if (line_found == 0) {
                 FAIL() << fmt::format("Couldn't find the line '{}' ({}) from the output file in the provided data set.", read_line, idx);
-            } else if (line_found > 1) {
+            }
+            if (line_found > 1) {
                 FAIL() << fmt::format("Could find the line '{}' ({}) from the output file in the provided data set multiple times.", read_line, idx);
             }
         }
@@ -309,20 +312,20 @@ class LIBSVMClassificationModelDataWriteDeathTest : public LIBSVMClassificationM
 
   private:
     /// The default parameters.
-    plssvm::parameter params_{};
+    plssvm::parameter params_;
     /// The rho vector; size depending on used classification type and number of classes.
-    std::vector<plssvm::real_type> rho_{};
+    std::vector<plssvm::real_type> rho_;
     /// The weights; shape of the vector and the containing matrices depending on used classification type and number of classes.
-    std::vector<plssvm::aos_matrix<plssvm::real_type>> alpha_{};
+    std::vector<plssvm::aos_matrix<plssvm::real_type>> alpha_;
     /// The index sets indicating which data point is a support vector for which class.
-    std::vector<std::vector<std::size_t>> index_sets_{};
+    std::vector<std::vector<std::size_t>> index_sets_;
     /// The support vectors.
     plssvm::classification_data_set<fixture_label_type> data_set_{ util::generate_random_matrix<plssvm::aos_matrix<plssvm::real_type>>(plssvm::shape{ 6, 2 }), util::get_correct_model_file_labels<fixture_label_type>() };
 };
 
 TYPED_TEST_SUITE(LIBSVMClassificationModelDataWriteDeathTest, util::classification_label_type_classification_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, empty_filename) {
+TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, EmptyFilename) {
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
     // try writing the LIBSVM model header
@@ -330,7 +333,7 @@ TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, empty_filename) {
                  "The provided model filename must not be empty!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, missing_labels) {
+TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, MissingLabels) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
@@ -342,7 +345,7 @@ TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, missing_labels) {
                  "Cannot write a model file that does not include labels!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, invalid_number_of_rho_values) {
+TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, InvalidNumberOfRhoValues) {
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
     // create invalid parameter
@@ -353,7 +356,7 @@ TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, invalid_number_of_rho_va
                  ::testing::HasSubstr(fmt::format("The number of rho values is 42 but must be {} ({})!", this->num_classifiers(), classification)));
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, invalid_alpha_vector) {
+TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, InvalidAlphaVector) {
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
     if constexpr (classification == plssvm::classification_type::oaa) {
@@ -394,7 +397,7 @@ TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, invalid_alpha_vector) {
     }
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, invalid_number_of_index_sets) {
+TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, InvalidNumberOfIndexSets) {
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
     // create invalid parameter
@@ -413,7 +416,7 @@ TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, invalid_number_of_index_
     }
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, invalid_number_of_indices) {
+TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, InvalidNumberOfIndices) {
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
     // create invalid parameter
@@ -432,7 +435,7 @@ TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, invalid_number_of_indice
     }
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, indices_not_sorted) {
+TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, IndicesNotSorted) {
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
     // create invalid parameter
@@ -451,7 +454,7 @@ TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, indices_not_sorted) {
     }
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, indices_in_one_index_set_not_unique) {
+TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, IndicesInOneIndexSetNotUnique) {
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
     // create invalid parameter
@@ -470,7 +473,7 @@ TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, indices_in_one_index_set
     }
 }
 
-TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, index_sets_not_disjoint) {
+TYPED_TEST(LIBSVMClassificationModelDataWriteDeathTest, IndexSetsNotDisjoint) {
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
     // create invalid parameter
diff --git a/tests/detail/io/classification_libsvm_model_parsing/header_parse_invalid.cpp b/tests/detail/io/classification_libsvm_model_parsing/header_parse_invalid.cpp
index b2e83b861..e424fff0f 100644
--- a/tests/detail/io/classification_libsvm_model_parsing/header_parse_invalid.cpp
+++ b/tests/detail/io/classification_libsvm_model_parsing/header_parse_invalid.cpp
@@ -28,7 +28,7 @@ class LIBSVMClassificationModelHeaderParseInvalid : public ::testing::Test { };
 
 TYPED_TEST_SUITE(LIBSVMClassificationModelHeaderParseInvalid, util::classification_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, wrong_svm_type) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, WrongSvmType) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -40,7 +40,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, wrong_svm_type) {
                       "Can only use c_svc as svm_type, but 'nu_svc' was given!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, wrong_kernel_type) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, WrongKernelType) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -52,7 +52,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, wrong_kernel_type) {
                       "Unrecognized kernel type 'foo'!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, wrong_total_sv) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, WrongTotalSv) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -64,7 +64,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, wrong_total_sv) {
                       "The number of support vectors must be greater than 0!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, too_few_label) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, TooFewLabel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -76,7 +76,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, too_few_label) {
                       "At least two labels must be set, but only one label was given!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, too_few_nr_sv) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, TooFewNrSv) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -88,7 +88,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, too_few_nr_sv) {
                       "At least two nr_sv must be set, but only one was given!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, empty_rho) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, EmptyRho) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -100,7 +100,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, empty_rho) {
                       "At least one rho value must be set, but none was given!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, too_few_rho) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, TooFewRho) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     if (util::get_num_classes<label_type>() == 2) {
@@ -116,7 +116,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, too_few_rho) {
     }
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, unrecognized_header_entry) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, UnrecognizedHeaderEntry) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -128,7 +128,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, unrecognized_header_entr
                       "Unrecognized header entry 'invalid entry'! Maybe SV is missing?");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_svm_type) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, MissingSvmType) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -140,7 +140,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_svm_type) {
                       "Missing svm_type!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_kernel_type) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, MissingKernelType) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -152,7 +152,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_kernel_type) {
                       "Missing kernel_type!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_degree_in_linear_kernel) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, ExplicitDegreeInLinearKernel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -164,7 +164,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_degree_in_linea
                       "Explicitly provided a value for the degree parameter which is not used in the linear kernel!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_gamma_in_linear_kernel) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, ExplicitGammaInLinearKernel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -176,7 +176,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_gamma_in_linear
                       "Explicitly provided a value for the gamma parameter which is not used in the linear kernel!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_coef0_in_linear_kernel) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, ExplicitCoef0InLinearKernel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -188,7 +188,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_coef0_in_linear
                       "Explicitly provided a value for the coef0 parameter which is not used in the linear kernel!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_degree_in_rbf_kernel) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, ExplicitDegreeInRadialBasisFunctionKernel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -200,7 +200,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_degree_in_rbf_k
                       "Explicitly provided a value for the degree parameter which is not used in the rbf kernel!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_coef0_in_rbf_kernel) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, ExplicitCoef0InRadialBasisFunctionKernel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -212,7 +212,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_coef0_in_rbf_ke
                       "Explicitly provided a value for the coef0 parameter which is not used in the rbf kernel!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_degree_in_sigmoid_kernel) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, ExplicitDegreeInSigmoidKernel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -224,7 +224,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_degree_in_sigmo
                       "Explicitly provided a value for the degree parameter which is not used in the sigmoid kernel!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_degree_in_laplacian_kernel) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, ExplicitDegreeInLaplacianKernel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -236,7 +236,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_degree_in_lapla
                       "Explicitly provided a value for the degree parameter which is not used in the laplacian kernel!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_coef0_in_laplacian_kernel) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, ExplicitCoef0InLaplacianKernel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -248,7 +248,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_coef0_in_laplac
                       "Explicitly provided a value for the coef0 parameter which is not used in the laplacian kernel!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_degree_in_chi_squared_kernel) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, ExplicitDegreeInChiSquaredKernel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -260,7 +260,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_degree_in_chi_s
                       "Explicitly provided a value for the degree parameter which is not used in the chi_squared kernel!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_coef0_in_chi_squared_kernel) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, ExplicitCoef0InChiSquaredKernel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -272,7 +272,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, explicit_coef0_in_chi_sq
                       "Explicitly provided a value for the coef0 parameter which is not used in the chi_squared kernel!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_nr_class) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, MissingNrClass) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -284,7 +284,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_nr_class) {
                       "Missing number of different classes nr_class!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_total_sv) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, MissingTotalSv) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -296,7 +296,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_total_sv) {
                       "Missing total number of support vectors total_sv!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_rho) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, MissingRho) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -308,7 +308,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_rho) {
                       "Missing rho values!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_label) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, MissingLabel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -320,7 +320,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_label) {
                       "Missing class label specification!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, nr_class_and_label_mismatch) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, NrClassAndLabelMismatch) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -332,7 +332,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, nr_class_and_label_misma
                       "The number of classes (nr_class) is 3, but the provided number of different labels is 2 (label)!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_nr_sv) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, MissingNrSv) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -344,7 +344,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_nr_sv) {
                       "Missing number of support vectors per class nr_sv!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, nr_class_and_nr_sv_mismatch) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, NrClassAndNrSvMismatch) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -356,7 +356,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, nr_class_and_nr_sv_misma
                       "The number of classes (nr_class) is 2, but the provided number of different labels is 3 (nr_sv)!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, total_sv_and_nr_sv_mismatch) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, TotalSvAndNrSvMismatch) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -368,7 +368,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, total_sv_and_nr_sv_misma
                       "The total number of support vectors is 5, but the sum of nr_sv is 6!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_sv) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, MissingSv) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -380,7 +380,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_sv) {
                       "Unrecognized header entry '-1.8568721894e-01 1:-1.1178275006e+00 2:-2.9087188881e+00 3:6.6638344270e-01 4:1.0978832704e+00'! Maybe SV is missing?");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_support_vectors) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, MissingSupportVectors) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -392,7 +392,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, missing_support_vectors)
                       "Can't parse file: no support vectors are given or SV is missing!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, same_class_multiple_times) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, SameClassMultipleTimes) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
@@ -404,7 +404,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, same_class_multiple_time
                       "Provided 2 labels but only 1 of them was/where unique!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, empty) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseInvalid, Empty) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // parse the LIBSVM model file
diff --git a/tests/detail/io/classification_libsvm_model_parsing/header_parse_valid.cpp b/tests/detail/io/classification_libsvm_model_parsing/header_parse_valid.cpp
index c5cd6da7b..2b53dae3d 100644
--- a/tests/detail/io/classification_libsvm_model_parsing/header_parse_valid.cpp
+++ b/tests/detail/io/classification_libsvm_model_parsing/header_parse_valid.cpp
@@ -25,7 +25,6 @@
 
 #include <cstddef>  // std::size_t
 #include <string>   // std::string
-#include <variant>  // std::get
 #include <vector>   // std::vector
 
 template <typename T>
@@ -82,7 +81,7 @@ class LIBSVMClassificationModelHeaderParseValid : public ::testing::Test {
 
 TYPED_TEST_SUITE(LIBSVMClassificationModelHeaderParseValid, util::classification_label_type_kernel_function_and_classification_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMClassificationModelHeaderParseValid, read) {
+TYPED_TEST(LIBSVMClassificationModelHeaderParseValid, Read) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
diff --git a/tests/detail/io/classification_libsvm_model_parsing/header_write.cpp b/tests/detail/io/classification_libsvm_model_parsing/header_write.cpp
index 1f6794aad..9a19b3e87 100644
--- a/tests/detail/io/classification_libsvm_model_parsing/header_write.cpp
+++ b/tests/detail/io/classification_libsvm_model_parsing/header_write.cpp
@@ -14,6 +14,7 @@
 #include "plssvm/detail/io/file_reader.hpp"                          // plssvm::detail::io::file_reader
 #include "plssvm/kernel_function_types.hpp"                          // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                                         // plssvm::aos_matrix
+#include "plssvm/mpi/communicator.hpp"                               // plssvm::mpi::communicator
 #include "plssvm/parameter.hpp"                                      // plssvm::parameter
 #include "plssvm/shape.hpp"                                          // plssvm::shape
 
@@ -40,16 +41,16 @@ class LIBSVMClassificationModelHeaderWrite : public ::testing::Test,
      * @brief Return the used MPI communicator.
      * @return the MPI communicator (`[[nodiscard]]`)
      */
-    [[nodiscard]] const plssvm::mpi::communicator get_comm() const noexcept { return comm_; }
+    [[nodiscard]] const plssvm::mpi::communicator &get_comm() const noexcept { return comm_; }
 
   private:
     /// The MPI communicator (unused during testing since we do not support MPI runtime tests).
-    plssvm::mpi::communicator comm_{};
+    plssvm::mpi::communicator comm_;
 };
 
 TYPED_TEST_SUITE(LIBSVMClassificationModelHeaderWrite, util::classification_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_linear) {
+TYPED_TEST(LIBSVMClassificationModelHeaderWrite, WriteLinear) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -88,7 +89,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_linear) {
     EXPECT_EQ(reader.line(7), "SV");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_polynomial) {
+TYPED_TEST(LIBSVMClassificationModelHeaderWrite, WritePolynomial) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -130,7 +131,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_polynomial) {
     EXPECT_EQ(reader.line(10), "SV");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_rbf) {
+TYPED_TEST(LIBSVMClassificationModelHeaderWrite, WriteRadialBasisFunction) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -170,7 +171,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_rbf) {
     EXPECT_EQ(reader.line(8), "SV");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_sigmoid) {
+TYPED_TEST(LIBSVMClassificationModelHeaderWrite, WriteSigmoid) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -211,7 +212,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_sigmoid) {
     EXPECT_EQ(reader.line(9), "SV");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_laplacian) {
+TYPED_TEST(LIBSVMClassificationModelHeaderWrite, WriteLaplacian) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -251,7 +252,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_laplacian) {
     EXPECT_EQ(reader.line(8), "SV");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderWrite, write_chi_squared) {
+TYPED_TEST(LIBSVMClassificationModelHeaderWrite, WriteChiSquared) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -297,7 +298,7 @@ class LIBSVMClassificationModelHeaderWriteDeathTest : public LIBSVMClassificatio
 
 TYPED_TEST_SUITE(LIBSVMClassificationModelHeaderWriteDeathTest, util::classification_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMClassificationModelHeaderWriteDeathTest, write_header_without_label) {
+TYPED_TEST(LIBSVMClassificationModelHeaderWriteDeathTest, WriteHeaderWithoutLabel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // create necessary parameter
@@ -314,7 +315,7 @@ TYPED_TEST(LIBSVMClassificationModelHeaderWriteDeathTest, write_header_without_l
                  "Cannot write a model file that does not include labels!");
 }
 
-TYPED_TEST(LIBSVMClassificationModelHeaderWriteDeathTest, write_header_invalid_number_of_rho_values) {
+TYPED_TEST(LIBSVMClassificationModelHeaderWriteDeathTest, WriteHeaderInvalidNumberOfRhoValues) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // create necessary parameter
diff --git a/tests/detail/io/classification_libsvm_model_parsing/utility_functions.cpp b/tests/detail/io/classification_libsvm_model_parsing/utility_functions.cpp
index b5c3c1595..7dbae32be 100644
--- a/tests/detail/io/classification_libsvm_model_parsing/utility_functions.cpp
+++ b/tests/detail/io/classification_libsvm_model_parsing/utility_functions.cpp
@@ -22,7 +22,7 @@
 
 class LIBSVMClassificationModelUtilityXvsY : public ::testing::TestWithParam<std::tuple<std::size_t, std::size_t, std::size_t, std::size_t>> { };
 
-TEST_P(LIBSVMClassificationModelUtilityXvsY, oao_x_vs_y_to_idx) {
+TEST_P(LIBSVMClassificationModelUtilityXvsY, OaoXvsYToIdx) {
     const auto [x, y, num_classes, expected_idx] = GetParam();
 
     EXPECT_EQ(plssvm::detail::io::oao_x_vs_y_to_idx(x, y, num_classes), expected_idx);
@@ -37,19 +37,19 @@ INSTANTIATE_TEST_SUITE_P(LIBSVMClassificationModelUtilityXvsY, LIBSVMClassificat
         naming::pretty_print_x_vs_y<LIBSVMClassificationModelUtilityXvsY>);
 // clang-format on
 
-TEST(LIBSVMClassificationModelUtilityXvsYDeathTest, x_equal_to_y) {
+TEST(LIBSVMClassificationModelUtilityXvsYDeathTest, XEqualToY) {
     EXPECT_DEATH(std::ignore = plssvm::detail::io::oao_x_vs_y_to_idx(0, 0, 2), "Can't compute the index for the binary classification of 0vs0!");
 }
 
-TEST(LIBSVMClassificationModelUtilityXvsYDeathTest, too_few_classes) {
+TEST(LIBSVMClassificationModelUtilityXvsYDeathTest, TooFewClasses) {
     EXPECT_DEATH(std::ignore = plssvm::detail::io::oao_x_vs_y_to_idx(0, 1, 1), "There must be at least two classes!");
 }
 
-TEST(LIBSVMClassificationModelUtilityXvsYDeathTest, x_greater_or_equal_than_num_classes) {
+TEST(LIBSVMClassificationModelUtilityXvsYDeathTest, XGreaterOrEqualThanNumClasses) {
     EXPECT_DEATH(std::ignore = plssvm::detail::io::oao_x_vs_y_to_idx(3, 0, 2), ::testing::HasSubstr("The class x (3) must be smaller than the total number of classes (2)!"));
 }
 
-TEST(LIBSVMClassificationModelUtilityXvsYDeathTest, y_greater_or_equal_than_num_classes) {
+TEST(LIBSVMClassificationModelUtilityXvsYDeathTest, YGreaterOrEqualThanNumClasses) {
     EXPECT_DEATH(std::ignore = plssvm::detail::io::oao_x_vs_y_to_idx(0, 3, 3), ::testing::HasSubstr("The class y (3) must be smaller than the total number of classes (3)!"));
 }
 
@@ -72,10 +72,10 @@ class LIBSVMClassificationModelUtilityAlphaIdx : public ::testing::TestWithParam
 
   private:
     /// The support vector index sets per class.
-    std::vector<std::vector<std::size_t>> index_sets_{};
+    std::vector<std::vector<std::size_t>> index_sets_;
 };
 
-TEST_P(LIBSVMClassificationModelUtilityAlphaIdx, calculate_alpha_idx) {
+TEST_P(LIBSVMClassificationModelUtilityAlphaIdx, CalculateAlphaIdx) {
     const auto [i, j, idx_to_find, expected_global_idx] = GetParam();
 
     EXPECT_EQ(plssvm::detail::io::calculate_alpha_idx(i, j, this->get_index_sets(), idx_to_find), expected_global_idx);
@@ -90,37 +90,37 @@ INSTANTIATE_TEST_SUITE_P(LIBSVMClassificationModelUtilityAlphaIdx, LIBSVMClassif
         naming::pretty_print_calc_alpha_idx<LIBSVMClassificationModelUtilityAlphaIdx>);
 // clang-format on
 
-TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, i_equal_to_j) {
+TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, IEqualToJ) {
     const std::vector<std::vector<std::size_t>> index_sets{ { 0, 1 }, { 2, 3 } };
     EXPECT_DEATH(std::ignore = plssvm::detail::io::calculate_alpha_idx(0, 0, index_sets, 0), "Can't compute the index for 0 == 0!");
 }
 
-TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, too_few_index_sets) {
+TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, TooFewIndexSets) {
     const std::vector<std::vector<std::size_t>> index_sets{ { 0, 1 } };
     EXPECT_DEATH(std::ignore = plssvm::detail::io::calculate_alpha_idx(0, 1, index_sets, 0), "At least two index sets must be provided!");
 }
 
-TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, i_greater_or_equal_than_num_indices) {
+TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, IGreaterOrEqualThanNumIndices) {
     const std::vector<std::vector<std::size_t>> index_sets{ { 0, 1 }, { 2, 3 } };
     EXPECT_DEATH(std::ignore = plssvm::detail::io::calculate_alpha_idx(3, 0, index_sets, 0), ::testing::HasSubstr("The index i (3) must be smaller than the total number of indices (2)!"));
 }
 
-TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, j_greater_or_equal_than_num_indices) {
+TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, JGreaterOrEqualThanNumIndices) {
     const std::vector<std::vector<std::size_t>> index_sets{ { 0, 1 }, { 2, 3 } };
     EXPECT_DEATH(std::ignore = plssvm::detail::io::calculate_alpha_idx(0, 2, index_sets, 0), ::testing::HasSubstr("The index j (2) must be smaller than the total number of indices (2)!"));
 }
 
-TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, index_sets_not_sorted) {
+TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, IndexSetsNotSorted) {
     const std::vector<std::vector<std::size_t>> index_sets{ { 0, 2, 1 }, { 3, 5, 4 } };
     EXPECT_DEATH(std::ignore = plssvm::detail::io::calculate_alpha_idx(0, 1, index_sets, 0), "The index sets must be sorted in ascending order!");
 }
 
-TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, indices_in_one_index_set_not_unique) {
+TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, IndicesInOneIndexSetNotUnique) {
     const std::vector<std::vector<std::size_t>> index_sets{ { 0, 0 }, { 2, 3 } };
     EXPECT_DEATH(std::ignore = plssvm::detail::io::calculate_alpha_idx(0, 1, index_sets, 1), "All indices in one index set must be unique!");
 }
 
-TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, index_sets_not_disjoint) {
+TEST(LIBSVMClassificationModelUtilityAlphaIdxDeathTest, IndexSetsNotDisjoint) {
     const std::vector<std::vector<std::size_t>> index_sets{ { 0, 1 }, { 1, 3 } };
     EXPECT_DEATH(std::ignore = plssvm::detail::io::calculate_alpha_idx(0, 1, index_sets, 1), "The content of both index sets must be disjoint!");
 }
diff --git a/tests/detail/io/file_reader.cpp b/tests/detail/io/file_reader.cpp
index d2ae85ff0..631844f8d 100644
--- a/tests/detail/io/file_reader.cpp
+++ b/tests/detail/io/file_reader.cpp
@@ -30,7 +30,7 @@
 #include <utility>      // std::move, std::swap
 #include <vector>       // std::vector
 
-TEST(FileReader, default_construct) {
+TEST(FileReader, DefaultConstruct) {
     // default construct file_reader
     const plssvm::detail::io::file_reader reader{};
 
@@ -42,7 +42,7 @@ TEST(FileReader, default_construct) {
     EXPECT_EQ(reader.buffer(), nullptr);
 }
 
-TEST(FileReader, move_construct) {
+TEST(FileReader, MoveConstruct) {
     // construct first file_reader
     plssvm::detail::io::file_reader reader1{ PLSSVM_TEST_PATH "/data/libsvm/classification/5x4.libsvm" };
     reader1.read_lines('#');
@@ -57,13 +57,15 @@ TEST(FileReader, move_construct) {
     EXPECT_NE(reader2.buffer(), nullptr);
 
     // check whether the first file_reader is in a valid moved-from state
+    // NOLINTBEGIN: use after move wanted since this is tested here
     EXPECT_FALSE(reader1.is_open());
     EXPECT_EQ(reader1.num_lines(), 0);
     EXPECT_TRUE(reader1.lines().empty());
     EXPECT_EQ(reader1.buffer(), nullptr);
+    // NOLINTEND
 }
 
-TEST(FileReader, move_assign) {
+TEST(FileReader, MoveAssign) {
     // construct first file_reader
     plssvm::detail::io::file_reader reader1{ PLSSVM_TEST_PATH "/data/libsvm/classification/5x4.libsvm" };
     reader1.read_lines('#');
@@ -79,10 +81,12 @@ TEST(FileReader, move_assign) {
     EXPECT_NE(reader2.buffer(), nullptr);
 
     // check whether the first file_reader is in a valid moved-from state
+    // NOLINTBEGIN: use after move wanted since this is tested here
     EXPECT_FALSE(reader1.is_open());
     EXPECT_EQ(reader1.num_lines(), 0);
     EXPECT_TRUE(reader1.lines().empty());
     EXPECT_EQ(reader1.buffer(), nullptr);
+    // NOLINTEND
 }
 
 // the input filename types to test
@@ -97,7 +101,7 @@ class FileReaderConstructWithOpen : public ::testing::Test {
 
 TYPED_TEST_SUITE(FileReaderConstructWithOpen, open_parameter_types_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(FileReaderConstructWithOpen, non_empty_file) {
+TYPED_TEST(FileReaderConstructWithOpen, NonEmptyFile) {
     using open_type = typename TestFixture::fixture_open_type;
 
     // create file name depending on the current test type
@@ -112,7 +116,7 @@ TYPED_TEST(FileReaderConstructWithOpen, non_empty_file) {
     EXPECT_NE(reader.buffer(), nullptr);
 }
 
-TYPED_TEST(FileReaderConstructWithOpen, empty_file) {
+TYPED_TEST(FileReaderConstructWithOpen, EmptyFile) {
     using open_type = typename TestFixture::fixture_open_type;
 
     // create file name depending on the current test type
@@ -127,7 +131,7 @@ TYPED_TEST(FileReaderConstructWithOpen, empty_file) {
     EXPECT_EQ(reader.buffer(), nullptr);
 }
 
-TYPED_TEST(FileReaderConstructWithOpen, file_not_found) {
+TYPED_TEST(FileReaderConstructWithOpen, FileNotFound) {
     using open_type = typename TestFixture::fixture_open_type;
 
     // create file name depending on the current test type
@@ -145,7 +149,7 @@ class FileReaderOpen : public ::testing::Test {
 
 TYPED_TEST_SUITE(FileReaderOpen, open_parameter_types_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(FileReaderOpen, non_empty_file) {
+TYPED_TEST(FileReaderOpen, NonEmptyFile) {
     using open_type = typename TestFixture::fixture_open_type;
 
     // create default constructed file reader and open it using the file name depending on the current test type
@@ -161,7 +165,7 @@ TYPED_TEST(FileReaderOpen, non_empty_file) {
     EXPECT_NE(reader.buffer(), nullptr);
 }
 
-TYPED_TEST(FileReaderOpen, empty_file) {
+TYPED_TEST(FileReaderOpen, EmptyFile) {
     using open_type = typename TestFixture::fixture_open_type;
 
     // create default constructed file reader and open it using the file name depending on the current test type
@@ -177,7 +181,7 @@ TYPED_TEST(FileReaderOpen, empty_file) {
     EXPECT_EQ(reader.buffer(), nullptr);
 }
 
-TYPED_TEST(FileReaderOpen, file_not_found) {
+TYPED_TEST(FileReaderOpen, FileNotFound) {
     using open_type = typename TestFixture::fixture_open_type;
 
     // create default constructed file reader and open it using the file name depending on the current test type
@@ -189,7 +193,7 @@ TYPED_TEST(FileReaderOpen, file_not_found) {
                       "Couldn't find file: '" PLSSVM_TEST_PATH "/data/file_not_found'!");
 }
 
-TYPED_TEST(FileReaderOpen, multiple_open) {
+TYPED_TEST(FileReaderOpen, MultipleOpen) {
     using open_type = typename TestFixture::fixture_open_type;
 
     // create default constructed file reader and open it using the file name depending on the current test type
@@ -205,7 +209,7 @@ TYPED_TEST(FileReaderOpen, multiple_open) {
                       "This file_reader is already associated to a file!");
 }
 
-TEST(FileReader, close) {
+TEST(FileReader, Close) {
     // create a new file_reader and associate it to a file
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/libsvm/classification/5x4.libsvm" };
     ASSERT_TRUE(reader.is_open());
@@ -220,7 +224,7 @@ TEST(FileReader, close) {
     EXPECT_EQ(reader.buffer(), nullptr);
 }
 
-TEST(FileReader, close_twice) {
+TEST(FileReader, CloseTwice) {
     // create a new file_reader and associate it to a file
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/libsvm/classification/5x4.libsvm" };
     ASSERT_TRUE(reader.is_open());
@@ -236,7 +240,7 @@ TEST(FileReader, close_twice) {
     EXPECT_EQ(reader.buffer(), nullptr);
 }
 
-TEST(FileReader, is_open) {
+TEST(FileReader, IsOpen) {
     // create a new default constructed file_reader
     plssvm::detail::io::file_reader reader{};
     // noe file must be open
@@ -249,7 +253,7 @@ TEST(FileReader, is_open) {
     EXPECT_FALSE(reader.is_open());
 }
 
-TEST(FileReader, swap_member_function) {
+TEST(FileReader, SwapMemberFunction) {
     // create two file readers
     plssvm::detail::io::file_reader reader1{};
     plssvm::detail::io::file_reader reader2{ PLSSVM_TEST_PATH "/data/libsvm/classification/5x4.libsvm" };
@@ -270,6 +274,8 @@ TEST(FileReader, swap_member_function) {
     EXPECT_EQ(reader2.buffer(), nullptr);
 }
 
+namespace {
+
 // clang-format off
 const auto & get_file_lines() {
     static const std::array<std::tuple<std::basic_string<char>, char, std::vector<std::basic_string_view<char>>>, 3> lines{
@@ -315,9 +321,11 @@ std::vector<std::string_view> filter_lines(const std::vector<std::string_view> &
     return filtered_lines;
 }
 
+}  // namespace
+
 class FileReaderLines : public ::testing::TestWithParam<std::tuple<std::string, char, std::vector<std::string_view>>> { };
 
-TEST_P(FileReaderLines, parse_lines_with_comments) {
+TEST_P(FileReaderLines, ParseLinesWithComments) {
     const auto &[filename, comment, lines] = GetParam();
     // create and read file
     plssvm::detail::io::file_reader reader{ filename };
@@ -327,7 +335,7 @@ TEST_P(FileReaderLines, parse_lines_with_comments) {
     EXPECT_EQ(reader.lines(), lines);
 }
 
-TEST_P(FileReaderLines, parse_lines_without_char_comments) {
+TEST_P(FileReaderLines, ParseLinesWithoutCharComments) {
     const auto &[filename, comment, lines] = GetParam();
     // create and read file
     plssvm::detail::io::file_reader reader{ filename };
@@ -337,7 +345,7 @@ TEST_P(FileReaderLines, parse_lines_without_char_comments) {
     EXPECT_EQ(reader.lines(), filter_lines(lines, comment));
 }
 
-TEST_P(FileReaderLines, parse_lines_without_string_comments) {
+TEST_P(FileReaderLines, ParseLinesWithoutStringComments) {
     const auto &[filename, comment, lines] = GetParam();
     // create and read file
     plssvm::detail::io::file_reader reader{ filename };
@@ -347,7 +355,7 @@ TEST_P(FileReaderLines, parse_lines_without_string_comments) {
     EXPECT_EQ(reader.lines(), filter_lines(lines, "@ATTRIBUTE"));
 }
 
-TEST_P(FileReaderLines, num_lines) {
+TEST_P(FileReaderLines, NumLines) {
     const auto &[filename, comment, lines] = GetParam();
     // create and read file
     plssvm::detail::io::file_reader reader{ filename };
@@ -357,7 +365,7 @@ TEST_P(FileReaderLines, num_lines) {
     EXPECT_EQ(reader.num_lines(), filter_lines(lines, comment).size());
 }
 
-TEST_P(FileReaderLines, line) {
+TEST_P(FileReaderLines, Line) {
     const auto &[filename, comment, lines] = GetParam();
     // create and read file
     plssvm::detail::io::file_reader reader{ filename };
@@ -371,7 +379,7 @@ TEST_P(FileReaderLines, line) {
     }
 }
 
-TEST_P(FileReaderLines, lines) {
+TEST_P(FileReaderLines, Lines) {
     const auto &[filename, comment, lines] = GetParam();
     // create and read file
     plssvm::detail::io::file_reader reader{ filename };
@@ -381,7 +389,7 @@ TEST_P(FileReaderLines, lines) {
     EXPECT_EQ(reader.lines(), filter_lines(lines, comment));
 }
 
-TEST_P(FileReaderLines, buffer_valid) {
+TEST_P(FileReaderLines, BufferValid) {
     const auto &[filename, comment, lines] = GetParam();
     // create and read file
     plssvm::detail::io::file_reader reader{ filename };
@@ -397,7 +405,7 @@ TEST_P(FileReaderLines, buffer_valid) {
 
 INSTANTIATE_TEST_SUITE_P(FileReader, FileReaderLines, ::testing::ValuesIn(get_file_lines()), naming::pretty_print_escaped_string<FileReaderLines>);
 
-TEST(FileReaderLines, parse_lines_without_associated_file) {
+TEST(FileReaderLines, ParseLinesWithoutAssociatedFile) {
     // create file_reader without associating it to a file
     plssvm::detail::io::file_reader reader{};
 
@@ -409,7 +417,7 @@ TEST(FileReaderLines, parse_lines_without_associated_file) {
 
 class FileReaderLinesDeathTest : public ::testing::TestWithParam<std::tuple<std::string, char, std::vector<std::string_view>>> { };
 
-TEST_P(FileReaderLinesDeathTest, line_out_of_bounce) {
+TEST_P(FileReaderLinesDeathTest, LineOutOfBounce) {
     const auto &[filename, comment, lines] = GetParam();
     // create and read file
     plssvm::detail::io::file_reader reader{ filename };
@@ -422,7 +430,7 @@ TEST_P(FileReaderLinesDeathTest, line_out_of_bounce) {
 
 INSTANTIATE_TEST_SUITE_P(FileReader, FileReaderLinesDeathTest, ::testing::ValuesIn(get_file_lines()), naming::pretty_print_escaped_string<FileReaderLinesDeathTest>);
 
-TEST(FileReader, swap_free_function) {
+TEST(FileReader, SwapFreeFunction) {
     // create two file readers
     plssvm::detail::io::file_reader reader1{};
     plssvm::detail::io::file_reader reader2{ PLSSVM_TEST_PATH "/data/libsvm/classification/5x4.libsvm" };
diff --git a/tests/detail/io/libsvm_parsing.cpp b/tests/detail/io/libsvm_parsing.cpp
index 85c4a2e43..d121f32dd 100644
--- a/tests/detail/io/libsvm_parsing.cpp
+++ b/tests/detail/io/libsvm_parsing.cpp
@@ -23,7 +23,7 @@
 #include "tests/utility.hpp"             // util::{temporary_file, instantiate_template_file, get_correct_data_file_labels, get_distinct_label, generate_specific_matrix, generate_specific_sparse_matrix}
 
 #include "fmt/format.h"   // fmt::format
-#include "fmt/std.h"      // format std::vector<bool>::operator[] proxy type
+#include "fmt/std.h"      // NOLINT: format std::vector<bool>::operator[] proxy type
 #include "gmock/gmock.h"  // ::testing::HasSubstr
 #include "gtest/gtest.h"  // TEST, TEST_P, TYPED_TEST, TYPED_TEST_SUITE, INSTANTIATE_TEST_SUITE_P, EXPECT_EQ, EXPECT_TRUE, EXPECT_DEATH, ASSERT_EQ, FAIL
                           // ::testing::{Test, TestWithParam, Values}
@@ -36,7 +36,7 @@
 
 class LIBSVMParseNumFeatures : public ::testing::TestWithParam<std::pair<std::string, std::size_t>> { };
 
-TEST_P(LIBSVMParseNumFeatures, num_features) {
+TEST_P(LIBSVMParseNumFeatures, NumFeatures) {
     const auto &[filename_part, num_features] = GetParam();
 
     // parse the LIBSVM file
@@ -55,7 +55,7 @@ INSTANTIATE_TEST_SUITE_P(LIBSVMParse, LIBSVMParseNumFeatures, ::testing::Values(
                                                       std::make_pair("/data/empty.txt", 0)));
 // clang-format on
 
-TEST(LIBSVMParseNumFeatures, index_with_alpha_char_at_the_beginning) {
+TEST(LIBSVMParseNumFeatures, IndexWithAlphaCharAtTheBeginning) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/libsvm/invalid/index_with_alpha_char_at_the_beginning.libsvm";
     plssvm::detail::io::file_reader reader{ filename };
@@ -149,7 +149,7 @@ class LIBSVMParse : public ::testing::Test {
 
 TYPED_TEST_SUITE(LIBSVMParse, util::label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMParseDense, read) {
+TYPED_TEST(LIBSVMParseDense, Read) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -166,7 +166,7 @@ TYPED_TEST(LIBSVMParseDense, read) {
     EXPECT_EQ(label, this->get_correct_label());
 }
 
-TYPED_TEST(LIBSVMParseSparse, read) {
+TYPED_TEST(LIBSVMParseSparse, Read) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -183,7 +183,7 @@ TYPED_TEST(LIBSVMParseSparse, read) {
     EXPECT_EQ(label, this->get_correct_label());
 }
 
-TYPED_TEST(LIBSVMParse, read_without_label) {
+TYPED_TEST(LIBSVMParse, ReadWithoutLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -205,7 +205,7 @@ TYPED_TEST(LIBSVMParse, read_without_label) {
     EXPECT_TRUE(label.empty());
 }
 
-TYPED_TEST(LIBSVMParse, zero_based_features) {
+TYPED_TEST(LIBSVMParse, ZeroBasedFeatures) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -217,7 +217,7 @@ TYPED_TEST(LIBSVMParse, zero_based_features) {
                       "LIBSVM assumes a 1-based feature indexing scheme, but 0 was given!");
 }
 
-TYPED_TEST(LIBSVMParse, arff_file) {
+TYPED_TEST(LIBSVMParse, ARFFFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the ARFF file
@@ -227,7 +227,7 @@ TYPED_TEST(LIBSVMParse, arff_file) {
     EXPECT_THROW(std::ignore = (plssvm::detail::io::parse_libsvm_data<label_type>(reader)), plssvm::invalid_file_format_exception);
 }
 
-TYPED_TEST(LIBSVMParse, empty) {
+TYPED_TEST(LIBSVMParse, Empty) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -239,7 +239,7 @@ TYPED_TEST(LIBSVMParse, empty) {
                       "Can't parse file: no data points are given!");
 }
 
-TYPED_TEST(LIBSVMParse, feature_with_alpha_char_at_the_beginning) {
+TYPED_TEST(LIBSVMParse, FeatureWithAlphaCharAtTheBeginning) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -251,7 +251,7 @@ TYPED_TEST(LIBSVMParse, feature_with_alpha_char_at_the_beginning) {
                       fmt::format("Can't convert 'a-1.11' to a value of type {}!", plssvm::detail::arithmetic_type_name<plssvm::real_type>()));
 }
 
-TYPED_TEST(LIBSVMParse, index_with_alpha_char_at_the_beginning) {
+TYPED_TEST(LIBSVMParse, IndexWithAlphaCharAtTheBeginning) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -263,7 +263,7 @@ TYPED_TEST(LIBSVMParse, index_with_alpha_char_at_the_beginning) {
                       "Can't convert ' !2' to a value of type unsigned long!");
 }
 
-TYPED_TEST(LIBSVMParse, invalid_colon_at_the_beginning) {
+TYPED_TEST(LIBSVMParse, InvalidColonAtTheBeginning) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -275,7 +275,7 @@ TYPED_TEST(LIBSVMParse, invalid_colon_at_the_beginning) {
                       "Can't convert '' to a value of type unsigned long!");
 }
 
-TYPED_TEST(LIBSVMParse, invalid_colon_in_the_middle) {
+TYPED_TEST(LIBSVMParse, InvalidColonInTheMiddle) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -287,7 +287,7 @@ TYPED_TEST(LIBSVMParse, invalid_colon_in_the_middle) {
                       "Can't convert ' :2' to a value of type unsigned long!");
 }
 
-TYPED_TEST(LIBSVMParse, missing_feature_value) {
+TYPED_TEST(LIBSVMParse, MissingFeatureValue) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -299,7 +299,7 @@ TYPED_TEST(LIBSVMParse, missing_feature_value) {
                       fmt::format("Can't convert '' to a value of type {}!", plssvm::detail::arithmetic_type_name<plssvm::real_type>()));
 }
 
-TYPED_TEST(LIBSVMParse, missing_index_value) {
+TYPED_TEST(LIBSVMParse, MissingIndexValue) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -311,7 +311,7 @@ TYPED_TEST(LIBSVMParse, missing_index_value) {
                       "Can't convert ' ' to a value of type unsigned long!");
 }
 
-TYPED_TEST(LIBSVMParse, inconsistent_label_specification) {
+TYPED_TEST(LIBSVMParse, InconsistentLabelSpecification) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -323,7 +323,7 @@ TYPED_TEST(LIBSVMParse, inconsistent_label_specification) {
                       "Inconsistent label specification found (some data points are labeled, others are not)!");
 }
 
-TYPED_TEST(LIBSVMParse, non_increasing_indices) {
+TYPED_TEST(LIBSVMParse, NonIncreasingIndices) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -335,7 +335,7 @@ TYPED_TEST(LIBSVMParse, non_increasing_indices) {
                       "The features indices must be strictly increasing, but 3 is smaller or equal than 3!");
 }
 
-TYPED_TEST(LIBSVMParse, non_strictly_increasing_indices) {
+TYPED_TEST(LIBSVMParse, NonStrictlyIncreasingIndices) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // parse the LIBSVM file
@@ -355,7 +355,7 @@ class LIBSVMParseDeathTest : public ::testing::Test {
 
 TYPED_TEST_SUITE(LIBSVMParseDeathTest, util::label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMParseDeathTest, invalid_file_reader) {
+TYPED_TEST(LIBSVMParseDeathTest, InvalidFileReader) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // open file_reader without associating it to a file
@@ -378,7 +378,7 @@ class LIBSVMWriteDeathTest : public LIBSVMWrite<T> { };
 
 TYPED_TEST_SUITE(LIBSVMWriteDeathTest, util::label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMWrite, write_dense_with_label) {
+TYPED_TEST(LIBSVMWrite, WriteDenseWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
@@ -409,7 +409,7 @@ TYPED_TEST(LIBSVMWrite, write_dense_with_label) {
     }
 }
 
-TYPED_TEST(LIBSVMWrite, write_dense_without_label) {
+TYPED_TEST(LIBSVMWrite, WriteDenseWithoutLabel) {
     // define data to write
     const auto data = util::generate_specific_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ 3, 3 });
 
@@ -437,7 +437,7 @@ TYPED_TEST(LIBSVMWrite, write_dense_without_label) {
     }
 }
 
-TYPED_TEST(LIBSVMWrite, write_sparse_with_label) {
+TYPED_TEST(LIBSVMWrite, WriteSparseWithLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
@@ -475,7 +475,7 @@ TYPED_TEST(LIBSVMWrite, write_sparse_with_label) {
     }
 }
 
-TYPED_TEST(LIBSVMWrite, write_sparse_without_label) {
+TYPED_TEST(LIBSVMWrite, WriteSparseWithoutLabel) {
     // define data to write
     const auto data = util::generate_specific_sparse_matrix<plssvm::soa_matrix<plssvm::real_type>>(plssvm::shape{ 3, 3 });
 
@@ -510,7 +510,7 @@ TYPED_TEST(LIBSVMWrite, write_sparse_without_label) {
     }
 }
 
-TYPED_TEST(LIBSVMWrite, empty_data) {
+TYPED_TEST(LIBSVMWrite, EmptyData) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
@@ -528,7 +528,7 @@ TYPED_TEST(LIBSVMWrite, empty_data) {
     EXPECT_TRUE(reader.lines().empty());
 }
 
-TYPED_TEST(LIBSVMWriteDeathTest, data_with_provided_empty_labels) {
+TYPED_TEST(LIBSVMWriteDeathTest, DataWithProvidedEmptyLabels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
@@ -539,7 +539,7 @@ TYPED_TEST(LIBSVMWriteDeathTest, data_with_provided_empty_labels) {
     EXPECT_DEATH(plssvm::detail::io::write_libsvm_data(this->filename, data, label), "has_label is 'true' but no labels were provided!");
 }
 
-TYPED_TEST(LIBSVMWriteDeathTest, data_and_label_size_mismatch) {
+TYPED_TEST(LIBSVMWriteDeathTest, DataAndLabelSizeMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
@@ -551,7 +551,7 @@ TYPED_TEST(LIBSVMWriteDeathTest, data_and_label_size_mismatch) {
                  ::testing::HasSubstr("Number of data points (2) and number of labels (1) mismatch!"));
 }
 
-TYPED_TEST(LIBSVMWriteDeathTest, labels_provided_but_not_written) {
+TYPED_TEST(LIBSVMWriteDeathTest, LabelsProvidedButNotWritten) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // define data to write
diff --git a/tests/detail/io/regression_libsvm_model_parsing/data_parse_invalid.cpp b/tests/detail/io/regression_libsvm_model_parsing/data_parse_invalid.cpp
index 187fbbf9b..0f4e52482 100644
--- a/tests/detail/io/regression_libsvm_model_parsing/data_parse_invalid.cpp
+++ b/tests/detail/io/regression_libsvm_model_parsing/data_parse_invalid.cpp
@@ -21,17 +21,15 @@
 #include "fmt/format.h"   // fmt::format
 #include "gtest/gtest.h"  // TYPED_TEST, TYPED_TEST_SUITE, ::testing::Test
 
-#include <cstddef>  // std::size_t
-#include <string>   // std::string
-#include <tuple>    // std::ignore
-#include <vector>   // std::vector
+#include <string>  // std::string
+#include <tuple>   // std::ignore
 
 template <typename T>
 class LIBSVMRegressionModelDataParseInvalid : public ::testing::Test { };
 
 TYPED_TEST_SUITE(LIBSVMRegressionModelDataParseInvalid, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, zero_based_features) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, ZeroBasedFeatures) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/zero_based_features.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -41,7 +39,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, zero_based_features) {
                       "LIBSVM assumes a 1-based feature indexing scheme, but 0 was given!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, empty_data) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, EmptyData) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/empty_data.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -51,7 +49,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, empty_data) {
                       "Can't parse file: no data points are given!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, missing_alpha_values) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, MissingAlphaValues) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/missing_alpha_values.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -61,7 +59,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, missing_alpha_values) {
                       "Can't parse file: needed exactly one alpha value, but none were provided!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, too_many_alpha_values) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, TooManyAlphaValues) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/too_many_alpha_values.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -71,7 +69,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, too_many_alpha_values) {
                       "Can't parse file: needed exactly one alpha value, but more were provided!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, feature_with_alpha_char_at_the_beginning) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, FeatureWithAlphaCharAtTheBeginning) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/feature_with_alpha_char_at_the_beginning.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -81,7 +79,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, feature_with_alpha_char_at_the
                       fmt::format("Can't convert 'a-1.1178275006e+00' to a value of type {}!", plssvm::detail::arithmetic_type_name<plssvm::real_type>()));
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, index_with_alpha_char_at_the_beginning) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, IndexWithAlphaCharAtTheBeginning) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/index_with_alpha_char_at_the_beginning.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -91,7 +89,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, index_with_alpha_char_at_the_b
                       "Can't convert ' !2' to a value of type unsigned long!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, invalid_colon_at_the_beginning) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, InvalidColonAtTheBeginning) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/invalid_colon_at_the_beginning.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -101,7 +99,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, invalid_colon_at_the_beginning
                       "Can't parse file: needed exactly one alpha value, but none were provided!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, invalid_colon_in_the_middle) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, InvalidColonInTheMiddle) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/invalid_colon_in_the_middle.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -111,7 +109,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, invalid_colon_in_the_middle) {
                       "Can't convert ' ' to a value of type unsigned long!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, missing_feature_value) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, MissingFeatureValue) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/missing_feature_value.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -121,7 +119,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, missing_feature_value) {
                       fmt::format("Can't convert '' to a value of type {}!", plssvm::detail::arithmetic_type_name<plssvm::real_type>()));
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, missing_index_value) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, MissingIndexValue) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/missing_index_value.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -131,7 +129,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, missing_index_value) {
                       "Can't convert ' ' to a value of type unsigned long!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, non_increasing_indices) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, NonIncreasingIndices) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/non_increasing_indices.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -141,7 +139,7 @@ TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, non_increasing_indices) {
                       "The features indices must be strictly increasing, but 3 is smaller or equal than 3!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, non_strictly_increasing_indices) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalid, NonStrictlyIncreasingIndices) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/non_strictly_increasing_indices.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -156,14 +154,14 @@ class LIBSVMRegressionModelDataParseInvalidDeathTest : public LIBSVMRegressionMo
 
 TYPED_TEST_SUITE(LIBSVMRegressionModelDataParseInvalidDeathTest, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalidDeathTest, invalid_file_reader) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalidDeathTest, InvalidFileReader) {
     // open file_reader without associating it to a file
     const plssvm::detail::io::file_reader reader{};
     EXPECT_DEATH(std::ignore = (plssvm::detail::io::parse_libsvm_model_data_regression(reader, 0)),
                  "The file_reader is currently not associated with a file!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataParseInvalidDeathTest, skip_too_many_lines) {
+TYPED_TEST(LIBSVMRegressionModelDataParseInvalidDeathTest, SkipTooManyLines) {
     // parse LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/6x4.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
diff --git a/tests/detail/io/regression_libsvm_model_parsing/data_parse_valid.cpp b/tests/detail/io/regression_libsvm_model_parsing/data_parse_valid.cpp
index 004086cb6..16e387939 100644
--- a/tests/detail/io/regression_libsvm_model_parsing/data_parse_valid.cpp
+++ b/tests/detail/io/regression_libsvm_model_parsing/data_parse_valid.cpp
@@ -19,8 +19,7 @@
 
 #include "gtest/gtest.h"  // TEST_F, EXPECT_EQ, ASSERT_EQ, FAIL, ::testing::Test
 
-#include <cstddef>  // std::size_t
-#include <vector>   // std::vector
+#include <vector>  // std::vector
 
 class LIBSVMRegressionModelDataParseValid : public ::testing::Test,
                                             protected util::temporary_file {
@@ -57,7 +56,7 @@ class LIBSVMRegressionModelDataParseValid : public ::testing::Test,
                                                             plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } };
 };
 
-TEST_F(LIBSVMRegressionModelDataParseValid, read) {
+TEST_F(LIBSVMRegressionModelDataParseValid, Read) {
     // parse the LIBSVM file
     plssvm::detail::io::file_reader reader{ this->filename };
     reader.read_lines('#');
diff --git a/tests/detail/io/regression_libsvm_model_parsing/data_write.cpp b/tests/detail/io/regression_libsvm_model_parsing/data_write.cpp
index adc49c81e..61a9fca55 100644
--- a/tests/detail/io/regression_libsvm_model_parsing/data_write.cpp
+++ b/tests/detail/io/regression_libsvm_model_parsing/data_write.cpp
@@ -14,6 +14,7 @@
 #include "plssvm/detail/io/regression_libsvm_model_parsing.hpp"  // functions to test
 #include "plssvm/kernel_function_types.hpp"                      // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                                     // plssvm::aos_matrix
+#include "plssvm/mpi/communicator.hpp"                           // plssvm::mpi::communicator
 #include "plssvm/parameter.hpp"                                  // plssvm::parameter
 #include "plssvm/shape.hpp"                                      // plssvm::shape
 
@@ -40,16 +41,16 @@ class LIBSVMRegressionModelDataWrite : public ::testing::Test,
      * @brief Return the used MPI communicator.
      * @return the MPI communicator (`[[nodiscard]]`)
      */
-    [[nodiscard]] const plssvm::mpi::communicator get_comm() const noexcept { return comm_; }
+    [[nodiscard]] const plssvm::mpi::communicator &get_comm() const noexcept { return comm_; }
 
   private:
     /// The MPI communicator (unused during testing since we do not support MPI runtime tests).
-    plssvm::mpi::communicator comm_{};
+    plssvm::mpi::communicator comm_;
 };
 
 TYPED_TEST_SUITE(LIBSVMRegressionModelDataWrite, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMRegressionModelDataWrite, write) {
+TYPED_TEST(LIBSVMRegressionModelDataWrite, Write) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -98,14 +99,15 @@ TYPED_TEST(LIBSVMRegressionModelDataWrite, write) {
         // check, how often the line in the file was found in the original data
         if (line_found == 0) {
             FAIL() << fmt::format("Couldn't find the line '{}' ({}) from the output file in the provided data set.", read_line, i);
-        } else if (line_found > 1) {
+        }
+        if (line_found > 1) {
             FAIL() << fmt::format("Could find the line '{}' ({}) from the output file in the provided data set multiple times.", read_line, i);
         }
     }
     SUCCEED();
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataWrite, write_without_label) {
+TYPED_TEST(LIBSVMRegressionModelDataWrite, WriteWithoutLabel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -153,7 +155,8 @@ TYPED_TEST(LIBSVMRegressionModelDataWrite, write_without_label) {
         // check, how often the line in the file was found in the original data
         if (line_found == 0) {
             FAIL() << fmt::format("Couldn't find the line '{}' ({}) from the output file in the provided data set.", read_line, i);
-        } else if (line_found > 1) {
+        }
+        if (line_found > 1) {
             FAIL() << fmt::format("Could find the line '{}' ({}) from the output file in the provided data set multiple times.", read_line, i);
         }
     }
@@ -193,7 +196,7 @@ class LIBSVMRegressionModelDataWriteDeathTest : public LIBSVMRegressionModelData
 
   private:
     /// The default parameters.
-    plssvm::parameter params_{};
+    plssvm::parameter params_;
     /// The rho vector; size depending on used classification type and number of classes.
     std::vector<plssvm::real_type> rho_{ plssvm::real_type{ 3.1415 } };
     /// The weights; shape of the vector and the containing matrices depending on used classification type and number of classes.
@@ -204,13 +207,13 @@ class LIBSVMRegressionModelDataWriteDeathTest : public LIBSVMRegressionModelData
 
 TYPED_TEST_SUITE(LIBSVMRegressionModelDataWriteDeathTest, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMRegressionModelDataWriteDeathTest, empty_filename) {
+TYPED_TEST(LIBSVMRegressionModelDataWriteDeathTest, EmptyFilename) {
     // try writing the LIBSVM model header
     EXPECT_DEATH((plssvm::detail::io::write_libsvm_model_data_regression("", this->get_comm(), this->get_params(), this->get_rho(), this->get_alpha(), this->get_data_set())),
                  "The provided model filename must not be empty!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataWriteDeathTest, invalid_number_of_rho_values) {
+TYPED_TEST(LIBSVMRegressionModelDataWriteDeathTest, InvalidNumberOfRhoValues) {
     // create invalid parameter
     const std::vector<plssvm::real_type> rho = util::generate_random_vector<plssvm::real_type>(42);
 
@@ -219,7 +222,7 @@ TYPED_TEST(LIBSVMRegressionModelDataWriteDeathTest, invalid_number_of_rho_values
                  "The number of rho values is 42 but must be exactly 1!");
 }
 
-TYPED_TEST(LIBSVMRegressionModelDataWriteDeathTest, invalid_alpha_vector) {
+TYPED_TEST(LIBSVMRegressionModelDataWriteDeathTest, InvalidAlphaVector) {
     {
         // alpha vector too large
         const std::vector<plssvm::aos_matrix<plssvm::real_type>> alpha(2);
diff --git a/tests/detail/io/regression_libsvm_model_parsing/header_parse_invalid.cpp b/tests/detail/io/regression_libsvm_model_parsing/header_parse_invalid.cpp
index 8deaccd06..fd1c56ea1 100644
--- a/tests/detail/io/regression_libsvm_model_parsing/header_parse_invalid.cpp
+++ b/tests/detail/io/regression_libsvm_model_parsing/header_parse_invalid.cpp
@@ -20,7 +20,7 @@
 #include <string>  // std::string
 #include <tuple>   // std::ignore
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, wrong_svm_type) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, WrongSvmType) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/wrong_svm_type.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -30,7 +30,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, wrong_svm_type) {
                       "Can only use c_svr as svm_type, but 'epsilon_svr' was given!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, wrong_kernel_type) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, WrongKernelType) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/wrong_kernel_type.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -40,7 +40,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, wrong_kernel_type) {
                       "Unrecognized kernel type 'foo'!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, wrong_total_sv) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, WrongTotalSv) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/wrong_total_sv.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -50,7 +50,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, wrong_total_sv) {
                       "The number of support vectors must be greater than 0!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, empty_rho) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, EmptyRho) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/empty_rho.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -60,7 +60,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, empty_rho) {
                       "At least one rho value must be set, but none was given!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, unrecognized_header_entry) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, UnrecognizedHeaderEntry) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/unrecognized_header_entry.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -70,7 +70,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, unrecognized_header_entry) {
                       "Unrecognized header entry 'invalid entry'! Maybe SV is missing?");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_svm_type) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, MissingSvmType) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/missing_svm_type.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -80,7 +80,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_svm_type) {
                       "Missing svm_type!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_kernel_type) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, MissingKernelType) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/missing_kernel_type.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -90,7 +90,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_kernel_type) {
                       "Missing kernel_type!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_degree_in_linear_kernel) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, ExplicitDegreeInLinearKernel) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/explicit_degree_in_linear_kernel.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -100,7 +100,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_degree_in_linear_kernel)
                       "Explicitly provided a value for the degree parameter which is not used in the linear kernel!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_gamma_in_linear_kernel) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, ExplicitGammaInLinearKernel) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/explicit_gamma_in_linear_kernel.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -110,7 +110,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_gamma_in_linear_kernel) {
                       "Explicitly provided a value for the gamma parameter which is not used in the linear kernel!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_coef0_in_linear_kernel) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, ExplicitCoef0InLinearKernel) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/explicit_coef0_in_linear_kernel.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -120,7 +120,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_coef0_in_linear_kernel) {
                       "Explicitly provided a value for the coef0 parameter which is not used in the linear kernel!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_degree_in_rbf_kernel) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, ExplicitDegreeInRadialBasisFunctionKernel) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/explicit_degree_in_rbf_kernel.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -130,7 +130,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_degree_in_rbf_kernel) {
                       "Explicitly provided a value for the degree parameter which is not used in the rbf kernel!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_coef0_in_rbf_kernel) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, ExplicitCoef0InRadialBasisFunctionKernel) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/explicit_coef0_in_rbf_kernel.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -140,7 +140,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_coef0_in_rbf_kernel) {
                       "Explicitly provided a value for the coef0 parameter which is not used in the rbf kernel!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_degree_in_sigmoid_kernel) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, ExplicitDegreeInSigmoidKernel) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/explicit_degree_in_sigmoid_kernel.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -150,7 +150,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_degree_in_sigmoid_kernel)
                       "Explicitly provided a value for the degree parameter which is not used in the sigmoid kernel!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_degree_in_laplacian_kernel) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, ExplicitDegreeInLaplacianKernel) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/explicit_degree_in_laplacian_kernel.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -160,7 +160,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_degree_in_laplacian_kerne
                       "Explicitly provided a value for the degree parameter which is not used in the laplacian kernel!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_coef0_in_laplacian_kernel) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, ExplicitCoef0InLaplacianKernel) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/explicit_coef0_in_laplacian_kernel.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -170,7 +170,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_coef0_in_laplacian_kernel
                       "Explicitly provided a value for the coef0 parameter which is not used in the laplacian kernel!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_degree_in_chi_squared_kernel) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, ExplicitDegreeInChiSquaredKernel) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/explicit_degree_in_chi_squared_kernel.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -180,7 +180,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_degree_in_chi_squared_ker
                       "Explicitly provided a value for the degree parameter which is not used in the chi_squared kernel!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_coef0_in_chi_squared_kernel) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, ExplicitCoef0InChiSquaredKernel) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/explicit_coef0_in_chi_squared_kernel.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -190,7 +190,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, explicit_coef0_in_chi_squared_kern
                       "Explicitly provided a value for the coef0 parameter which is not used in the chi_squared kernel!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_nr_class) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, MissingNrClass) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/missing_nr_class.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -200,7 +200,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_nr_class) {
                       "Missing number of different classes nr_class!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_total_sv) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, MissingTotalSv) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/missing_total_sv.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -210,7 +210,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_total_sv) {
                       "Missing total number of support vectors total_sv!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_rho) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, MissingRho) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/missing_rho.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -220,7 +220,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_rho) {
                       "Missing rho values!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_sv) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, MissingSv) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/missing_sv.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -230,7 +230,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_sv) {
                       "Unrecognized header entry '-1.8568721894e-01 1:-1.1178275006e+00 2:-2.9087188881e+00 3:6.6638344270e-01 4:1.0978832704e+00'! Maybe SV is missing?");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_support_vectors) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, MissingSupportVectors) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/missing_support_vectors.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -240,7 +240,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, missing_support_vectors) {
                       "Can't parse file: no support vectors are given or SV is missing!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, empty) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, Empty) {
     // parse the LIBSVM model file
     const std::string filename = PLSSVM_TEST_PATH "/data/empty.txt";
     plssvm::detail::io::file_reader reader{ filename };
@@ -250,7 +250,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, empty) {
                       "Missing svm_type!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, too_few_sv_according_to_header) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, TooFewSvAccordingToHeader) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/too_few_sv_according_to_header.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -260,7 +260,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, too_few_sv_according_to_header) {
                       "Found 5 support vectors, but it should be 6!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, too_many_sv_according_to_header) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, TooManySvAccordingToHeader) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/too_many_sv_according_to_header.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -270,7 +270,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, too_many_sv_according_to_header) {
                       "Found 7 support vectors, but it should be 6!");
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, wrong_nr_class) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, WrongNrClass) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/wrong_nr_class.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
@@ -280,7 +280,7 @@ TEST(LIBSVMRegressionModelHeaderParseInvalid, wrong_nr_class) {
                               ::testing::HasSubstr("The number of classes (nr_class) is 3, but must be 2!"));
 }
 
-TEST(LIBSVMRegressionModelHeaderParseInvalid, wrong_num_rho) {
+TEST(LIBSVMRegressionModelHeaderParseInvalid, WrongNumRho) {
     // parse the LIBSVM file
     const std::string filename = PLSSVM_TEST_PATH "/data/model/regression/invalid/wrong_num_rho.libsvm.model";
     plssvm::detail::io::file_reader reader{ filename };
diff --git a/tests/detail/io/regression_libsvm_model_parsing/header_parse_valid.cpp b/tests/detail/io/regression_libsvm_model_parsing/header_parse_valid.cpp
index e69062f87..a5ba6bc69 100644
--- a/tests/detail/io/regression_libsvm_model_parsing/header_parse_valid.cpp
+++ b/tests/detail/io/regression_libsvm_model_parsing/header_parse_valid.cpp
@@ -21,7 +21,7 @@
 #include "gtest/gtest.h"  // TYPED_TEST, TYPED_TEST_SUITE, EXPECT_EQ, ASSERT_EQ, ::testing::Test
 
 #include <cstddef>  // std::size_t
-#include <variant>  // std::get
+#include <utility>  // std::get
 
 template <typename T>
 class LIBSVMRegressionModelHeaderParseValid : public ::testing::Test {
@@ -76,7 +76,7 @@ class LIBSVMRegressionModelHeaderParseValid : public ::testing::Test {
 
 TYPED_TEST_SUITE(LIBSVMRegressionModelHeaderParseValid, util::regression_label_type_kernel_function_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMRegressionModelHeaderParseValid, read) {
+TYPED_TEST(LIBSVMRegressionModelHeaderParseValid, Read) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
 
diff --git a/tests/detail/io/regression_libsvm_model_parsing/header_write.cpp b/tests/detail/io/regression_libsvm_model_parsing/header_write.cpp
index 114aca439..9cd573ab7 100644
--- a/tests/detail/io/regression_libsvm_model_parsing/header_write.cpp
+++ b/tests/detail/io/regression_libsvm_model_parsing/header_write.cpp
@@ -14,6 +14,7 @@
 #include "plssvm/detail/io/regression_libsvm_model_parsing.hpp"  // functions to test
 #include "plssvm/kernel_function_types.hpp"                      // plssvm::kernel_function_type
 #include "plssvm/matrix.hpp"                                     // plssvm::aos_matrix
+#include "plssvm/mpi/communicator.hpp"                           // plssvm::mpi::communicator
 #include "plssvm/parameter.hpp"                                  // plssvm::parameter
 #include "plssvm/shape.hpp"                                      // plssvm::shape
 
@@ -36,16 +37,16 @@ class LIBSVMRegressionModelHeaderWrite : public ::testing::Test,
      * @brief Return the used MPI communicator.
      * @return the MPI communicator (`[[nodiscard]]`)
      */
-    [[nodiscard]] const plssvm::mpi::communicator get_comm() const noexcept { return comm_; }
+    [[nodiscard]] const plssvm::mpi::communicator &get_comm() const noexcept { return comm_; }
 
   private:
     /// The MPI communicator (unused during testing since we do not support MPI runtime tests).
-    plssvm::mpi::communicator comm_{};
+    plssvm::mpi::communicator comm_;
 };
 
 TYPED_TEST_SUITE(LIBSVMRegressionModelHeaderWrite, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_linear) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WriteLinear) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -76,7 +77,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_linear) {
     EXPECT_EQ(reader.line(5), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_linear_without_label) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WriteLinearWithoutLabel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -106,7 +107,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_linear_without_label) {
     EXPECT_EQ(reader.line(5), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_polynomial) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WritePolynomial) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -140,7 +141,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_polynomial) {
     EXPECT_EQ(reader.line(8), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_polynomial_without_label) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WritePolynomialWithoutLabel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -173,7 +174,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_polynomial_without_label) {
     EXPECT_EQ(reader.line(8), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_rbf) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WriteRadialBasisFunction) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -205,7 +206,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_rbf) {
     EXPECT_EQ(reader.line(6), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_rbf_without_label) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WriteRadialBasisFunctionWithoutLabel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -236,7 +237,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_rbf_without_label) {
     EXPECT_EQ(reader.line(6), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_sigmoid) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WriteSigmoid) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -269,7 +270,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_sigmoid) {
     EXPECT_EQ(reader.line(7), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_sigmoid_without_label) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WriteSigmoidWithoutLabel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -301,7 +302,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_sigmoid_without_label) {
     EXPECT_EQ(reader.line(7), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_laplacian) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WriteLaplacian) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -333,7 +334,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_laplacian) {
     EXPECT_EQ(reader.line(6), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_laplacian_without_label) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WriteLaplacianWithoutLabel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -364,7 +365,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_laplacian_without_label) {
     EXPECT_EQ(reader.line(6), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_chi_squared) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WriteChiSquared) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -396,7 +397,7 @@ TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_chi_squared) {
     EXPECT_EQ(reader.line(6), "SV");
 }
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWrite, write_chi_squared_without_label) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWrite, WriteChiSquaredWithoutLabel) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // define data to write
@@ -433,7 +434,7 @@ class LIBSVMRegressionModelHeaderWriteDeathTest : public LIBSVMRegressionModelHe
 
 TYPED_TEST_SUITE(LIBSVMRegressionModelHeaderWriteDeathTest, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(LIBSVMRegressionModelHeaderWriteDeathTest, write_header_invalid_number_of_rho_values) {
+TYPED_TEST(LIBSVMRegressionModelHeaderWriteDeathTest, WriteHeaderInvalidNumberOfRhoValues) {
     using label_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     // create necessary parameter
diff --git a/tests/detail/io/scaling_factors_parsing.cpp b/tests/detail/io/scaling_factors_parsing.cpp
index 8f4965e4b..61899d8c9 100644
--- a/tests/detail/io/scaling_factors_parsing.cpp
+++ b/tests/detail/io/scaling_factors_parsing.cpp
@@ -32,7 +32,7 @@
 // typedef nested struct -> the same for classification and regression -> not necessary to test it twice
 using factors_type = plssvm::min_max_scaler::factors;
 
-TEST(ScalingFactorsRead, read) {
+TEST(ScalingFactorsRead, Read) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/scaling_factors.txt" };
     reader.read_lines('#');
@@ -58,7 +58,7 @@ TEST(ScalingFactorsRead, read) {
     }
 }
 
-TEST(ScalingFactorsRead, read_no_scaling_factors) {
+TEST(ScalingFactorsRead, ReadNoScalingFactors) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/no_scaling_factors.txt" };
     reader.read_lines('#');
@@ -72,7 +72,7 @@ TEST(ScalingFactorsRead, read_no_scaling_factors) {
     EXPECT_TRUE(scaling_factors.empty());
 }
 
-TEST(ScalingFactorsRead, too_many_scaling_interval_values) {
+TEST(ScalingFactorsRead, TooManyScalingIntervalValues) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/invalid/too_many_scaling_interval_values.txt" };
     reader.read_lines('#');
@@ -81,7 +81,7 @@ TEST(ScalingFactorsRead, too_many_scaling_interval_values) {
                       "The interval to which the data points should be scaled must exactly have two values, but 3 were given!");
 }
 
-TEST(ScalingFactorsRead, too_few_scaling_interval_values) {
+TEST(ScalingFactorsRead, TooFewScalingIntervalValues) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/invalid/too_few_scaling_interval_values.txt" };
     reader.read_lines('#');
@@ -90,7 +90,7 @@ TEST(ScalingFactorsRead, too_few_scaling_interval_values) {
                       "The interval to which the data points should be scaled must exactly have two values, but 1 were given!");
 }
 
-TEST(ScalingFactorsRead, inconsistent_scaling_interval_values) {
+TEST(ScalingFactorsRead, InconsistentScalingIntervalValues) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/invalid/inconsistent_scaling_interval_values.txt" };
     reader.read_lines('#');
@@ -99,7 +99,7 @@ TEST(ScalingFactorsRead, inconsistent_scaling_interval_values) {
                       "Inconsistent scaling interval specification: lower (1.4) must be less than upper (-2.6)!");
 }
 
-TEST(ScalingFactorsRead, no_header) {
+TEST(ScalingFactorsRead, NoHeader) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/invalid/no_header.txt" };
     reader.read_lines('#');
@@ -108,7 +108,7 @@ TEST(ScalingFactorsRead, no_header) {
                       R"(The first line must only contain an 'x', but is "-1.4 2.6"!)");
 }
 
-TEST(ScalingFactorsRead, too_few_lines) {
+TEST(ScalingFactorsRead, TooFewLines) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/invalid/too_few_lines.txt" };
     reader.read_lines('#');
@@ -117,7 +117,7 @@ TEST(ScalingFactorsRead, too_few_lines) {
                       "At least two lines must be present, but only 1 were given!");
 }
 
-TEST(ScalingFactorsRead, empty) {
+TEST(ScalingFactorsRead, Empty) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/empty.txt" };
     reader.read_lines('#');
@@ -126,7 +126,7 @@ TEST(ScalingFactorsRead, empty) {
                       "At least two lines must be present, but only 0 were given!");
 }
 
-TEST(ScalingFactorsRead, too_few_scaling_factor_values) {
+TEST(ScalingFactorsRead, TooFewScalingFactorValues) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/invalid/too_few_scaling_factor_values.txt" };
     reader.read_lines('#');
@@ -135,7 +135,7 @@ TEST(ScalingFactorsRead, too_few_scaling_factor_values) {
                       "Each line must contain exactly three values, but 2 were given!");
 }
 
-TEST(ScalingFactorsRead, too_many_scaling_factor_values) {
+TEST(ScalingFactorsRead, TooManyScalingFactorValues) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/invalid/too_many_scaling_factor_values.txt" };
     reader.read_lines('#');
@@ -144,7 +144,7 @@ TEST(ScalingFactorsRead, too_many_scaling_factor_values) {
                       "Each line must contain exactly three values, but 4 were given!");
 }
 
-TEST(ScalingFactorsRead, zero_based_scaling_factors) {
+TEST(ScalingFactorsRead, ZeroBasedScalingFactors) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/invalid/zero_based_scaling_factors.txt" };
     reader.read_lines('#');
@@ -153,7 +153,7 @@ TEST(ScalingFactorsRead, zero_based_scaling_factors) {
                       "The scaling factors must be provided one-based, but are zero-based!");
 }
 
-TEST(ScalingFactorsRead, invalid_number) {
+TEST(ScalingFactorsRead, InvalidNumber) {
     // parse scaling factors!
     plssvm::detail::io::file_reader reader{ PLSSVM_TEST_PATH "/data/scaling_factors/invalid/invalid_number.txt" };
     reader.read_lines('#');
@@ -162,7 +162,7 @@ TEST(ScalingFactorsRead, invalid_number) {
                       fmt::format("Can't convert 'a' to a value of type {}!", plssvm::detail::arithmetic_type_name<plssvm::real_type>()));
 }
 
-TEST(ScalingFactorsReadDeathTest, invalid_file_reader) {
+TEST(ScalingFactorsReadDeathTest, InvalidFileReader) {
     // create temporary file containing the scaling factors
     const plssvm::detail::io::file_reader reader{};
     EXPECT_DEATH(std::ignore = (plssvm::detail::io::parse_scaling_factors<factors_type>(reader)),
@@ -174,7 +174,7 @@ class ScalingFactorsWrite : public ::testing::Test,
 
 class ScalingFactorsWriteDeathTest : public ScalingFactorsWrite { };
 
-TEST_F(ScalingFactorsWrite, write) {
+TEST_F(ScalingFactorsWrite, Write) {
     // define data to write
     const std::pair<plssvm::real_type, plssvm::real_type> interval{ plssvm::real_type{ -2.0 }, plssvm::real_type{ 2.0 } };
     std::vector<factors_type> scaling_factors{
@@ -202,7 +202,7 @@ TEST_F(ScalingFactorsWrite, write) {
     }
 }
 
-TEST_F(ScalingFactorsWrite, write_empty_scaling_factors) {
+TEST_F(ScalingFactorsWrite, WriteEmptyScalingFactors) {
     // define data to write
     const std::pair<plssvm::real_type, plssvm::real_type> interval{ plssvm::real_type{ -1.5 }, plssvm::real_type{ 1.5 } };
     const std::vector<factors_type> scaling_factors{};  // write no scaling factors to the file (allowed, but nonsensical)
@@ -222,7 +222,7 @@ TEST_F(ScalingFactorsWrite, write_empty_scaling_factors) {
     EXPECT_EQ(reader.line(1), fmt::format("{} {}", -1.5, 1.5));
 }
 
-TEST_F(ScalingFactorsWriteDeathTest, write_illegal_interval) {
+TEST_F(ScalingFactorsWriteDeathTest, WriteIllegalInterval) {
     // define data to write
     const std::pair<plssvm::real_type, plssvm::real_type> interval{ plssvm::real_type{ 1 }, plssvm::real_type{ -1 } };  // illegal interval!
     const std::vector<factors_type> scaling_factors(1);
diff --git a/tests/detail/logging/log.cpp b/tests/detail/logging/log.cpp
index 57930d587..c7ef3fa94 100644
--- a/tests/detail/logging/log.cpp
+++ b/tests/detail/logging/log.cpp
@@ -10,15 +10,19 @@
 
 #include "plssvm/detail/logging/log.hpp"
 
+#include "plssvm/verbosity_levels.hpp"  // plssvm::verbosity, plssvm::verbosity_level
+
 #include "tests/utility.hpp"  // util::redirect_output
 
 #include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
 #include "gtest/gtest.h"  // TEST_F, EXPECT_EQ, EXPECT_TRUE, ::testing::Test
 
+#include <iostream>  // std::clog
+
 class Logger : public ::testing::Test,
                public util::redirect_output<> { };
 
-TEST_F(Logger, enabled_logging) {
+TEST_F(Logger, EnabledLogging) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
@@ -29,7 +33,7 @@ TEST_F(Logger, enabled_logging) {
     EXPECT_EQ(this->get_capture(), "Hello, World!");
 }
 
-TEST_F(Logger, enabled_logging_with_args) {
+TEST_F(Logger, EnabledLoggingWithArgs) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
@@ -40,7 +44,7 @@ TEST_F(Logger, enabled_logging_with_args) {
     EXPECT_EQ(this->get_capture(), "int: 42, float: 1.5, str: abc");
 }
 
-TEST_F(Logger, disabled_logging) {
+TEST_F(Logger, DisabledLogging) {
     // explicitly disable logging
     plssvm::verbosity = plssvm::verbosity_level::quiet;
 
@@ -51,7 +55,7 @@ TEST_F(Logger, disabled_logging) {
     EXPECT_TRUE(this->get_capture().empty());
 }
 
-TEST_F(Logger, disabled_logging_with_args) {
+TEST_F(Logger, DisabledLoggingWithArgs) {
     // explicitly disable logging
     plssvm::verbosity = plssvm::verbosity_level::quiet;
 
@@ -62,7 +66,7 @@ TEST_F(Logger, disabled_logging_with_args) {
     EXPECT_TRUE(this->get_capture().empty());
 }
 
-TEST_F(Logger, mismatching_verbosity_level) {
+TEST_F(Logger, MismatchingVerbosityLevel) {
     // set verbosity_level to libsvm
     plssvm::verbosity = plssvm::verbosity_level::libsvm;
 
@@ -77,7 +81,7 @@ TEST_F(Logger, mismatching_verbosity_level) {
 class WarningLogger : public ::testing::Test,
                       public util::redirect_output<&std::clog> { };
 
-TEST_F(WarningLogger, enabled_logging_warning) {
+TEST_F(WarningLogger, EnabledLoggingWarning) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
diff --git a/tests/detail/logging/log_untracked.cpp b/tests/detail/logging/log_untracked.cpp
index e32335b8a..06bf3c426 100644
--- a/tests/detail/logging/log_untracked.cpp
+++ b/tests/detail/logging/log_untracked.cpp
@@ -17,10 +17,12 @@
 #include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
 #include "gtest/gtest.h"  // TEST_F, EXPECT_EQ, EXPECT_TRUE, ::testing::Test
 
+#include <iostream>  // std::clog
+
 class LoggerUntracked : public ::testing::Test,
                         public util::redirect_output<> { };
 
-TEST_F(LoggerUntracked, enabled_logging) {
+TEST_F(LoggerUntracked, EnabledLogging) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
@@ -31,7 +33,7 @@ TEST_F(LoggerUntracked, enabled_logging) {
     EXPECT_EQ(this->get_capture(), "Hello, World!");
 }
 
-TEST_F(LoggerUntracked, enabled_logging_with_args) {
+TEST_F(LoggerUntracked, EnabledLoggingWithArgs) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
@@ -42,7 +44,7 @@ TEST_F(LoggerUntracked, enabled_logging_with_args) {
     EXPECT_EQ(this->get_capture(), "int: 42, float: 1.5, str: abc");
 }
 
-TEST_F(LoggerUntracked, disabled_logging) {
+TEST_F(LoggerUntracked, DisabledLogging) {
     // explicitly disable logging
     plssvm::verbosity = plssvm::verbosity_level::quiet;
 
@@ -53,7 +55,7 @@ TEST_F(LoggerUntracked, disabled_logging) {
     EXPECT_TRUE(this->get_capture().empty());
 }
 
-TEST_F(LoggerUntracked, disabled_logging_with_args) {
+TEST_F(LoggerUntracked, DisabledLoggingWithArgs) {
     // explicitly disable logging
     plssvm::verbosity = plssvm::verbosity_level::quiet;
 
@@ -64,7 +66,7 @@ TEST_F(LoggerUntracked, disabled_logging_with_args) {
     EXPECT_TRUE(this->get_capture().empty());
 }
 
-TEST_F(LoggerUntracked, mismatching_verbosity_level) {
+TEST_F(LoggerUntracked, MismatchingVerbosityLevel) {
     // set verbosity_level to libsvm
     plssvm::verbosity = plssvm::verbosity_level::libsvm;
 
@@ -79,7 +81,7 @@ TEST_F(LoggerUntracked, mismatching_verbosity_level) {
 class WarningLoggerUntracked : public ::testing::Test,
                                public util::redirect_output<&std::clog> { };
 
-TEST_F(WarningLoggerUntracked, enabled_logging_warning) {
+TEST_F(WarningLoggerUntracked, EnabledLoggingWarning) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
diff --git a/tests/detail/logging/mpi_log.cpp b/tests/detail/logging/mpi_log.cpp
index dc5d2d5a8..dbcad20c5 100644
--- a/tests/detail/logging/mpi_log.cpp
+++ b/tests/detail/logging/mpi_log.cpp
@@ -11,16 +11,19 @@
 #include "plssvm/detail/logging/mpi_log.hpp"
 
 #include "plssvm/mpi/communicator.hpp"  // plssvm::mpi::communicator
+#include "plssvm/verbosity_levels.hpp"  // plssvm::verbosity, plssvm::verbosity_level
 
 #include "tests/utility.hpp"  // util::redirect_output
 
 #include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
 #include "gtest/gtest.h"  // TEST_F, EXPECT_EQ, EXPECT_TRUE, ::testing::Test
 
+#include <iostream>  // std::clog
+
 class MPILogger : public ::testing::Test,
                   public util::redirect_output<> { };
 
-TEST_F(MPILogger, enabled_logging) {
+TEST_F(MPILogger, EnabledLogging) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
@@ -31,7 +34,7 @@ TEST_F(MPILogger, enabled_logging) {
     EXPECT_EQ(this->get_capture(), "Hello, World!");
 }
 
-TEST_F(MPILogger, enabled_logging_with_args) {
+TEST_F(MPILogger, EnabledLoggingWithArgs) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
@@ -42,7 +45,7 @@ TEST_F(MPILogger, enabled_logging_with_args) {
     EXPECT_EQ(this->get_capture(), "int: 42, float: 1.5, str: abc");
 }
 
-TEST_F(MPILogger, disabled_logging) {
+TEST_F(MPILogger, DisabledLogging) {
     // explicitly disable logging
     plssvm::verbosity = plssvm::verbosity_level::quiet;
 
@@ -53,7 +56,7 @@ TEST_F(MPILogger, disabled_logging) {
     EXPECT_TRUE(this->get_capture().empty());
 }
 
-TEST_F(MPILogger, disabled_logging_with_args) {
+TEST_F(MPILogger, DisabledLoggingWithArgs) {
     // explicitly disable logging
     plssvm::verbosity = plssvm::verbosity_level::quiet;
 
@@ -64,7 +67,7 @@ TEST_F(MPILogger, disabled_logging_with_args) {
     EXPECT_TRUE(this->get_capture().empty());
 }
 
-TEST_F(MPILogger, mismatching_verbosity_level) {
+TEST_F(MPILogger, MismatchingVerbosityLevel) {
     // set verbosity_level to libsvm
     plssvm::verbosity = plssvm::verbosity_level::libsvm;
 
@@ -79,7 +82,7 @@ TEST_F(MPILogger, mismatching_verbosity_level) {
 class WarningMPILogger : public ::testing::Test,
                          public util::redirect_output<&std::clog> { };
 
-TEST_F(WarningMPILogger, enabled_logging_warning) {
+TEST_F(WarningMPILogger, EnabledLoggingWarning) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
diff --git a/tests/detail/logging/mpi_log_untracked.cpp b/tests/detail/logging/mpi_log_untracked.cpp
index ec1be7a5d..5f005948b 100644
--- a/tests/detail/logging/mpi_log_untracked.cpp
+++ b/tests/detail/logging/mpi_log_untracked.cpp
@@ -18,10 +18,12 @@
 #include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
 #include "gtest/gtest.h"  // TEST_F, EXPECT_EQ, EXPECT_TRUE, ::testing::Test
 
+#include <iostream>  // std::clog
+
 class MPILoggerUntracked : public ::testing::Test,
                            public util::redirect_output<> { };
 
-TEST_F(MPILoggerUntracked, enabled_logging) {
+TEST_F(MPILoggerUntracked, EnabledLogging) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
@@ -32,7 +34,7 @@ TEST_F(MPILoggerUntracked, enabled_logging) {
     EXPECT_EQ(this->get_capture(), "Hello, World!");
 }
 
-TEST_F(MPILoggerUntracked, enabled_logging_with_args) {
+TEST_F(MPILoggerUntracked, EnabledLoggingWithArgs) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
@@ -43,7 +45,7 @@ TEST_F(MPILoggerUntracked, enabled_logging_with_args) {
     EXPECT_EQ(this->get_capture(), "int: 42, float: 1.5, str: abc");
 }
 
-TEST_F(MPILoggerUntracked, disabled_logging) {
+TEST_F(MPILoggerUntracked, DisabledLogging) {
     // explicitly disable logging
     plssvm::verbosity = plssvm::verbosity_level::quiet;
 
@@ -54,7 +56,7 @@ TEST_F(MPILoggerUntracked, disabled_logging) {
     EXPECT_TRUE(this->get_capture().empty());
 }
 
-TEST_F(MPILoggerUntracked, disabled_logging_with_args) {
+TEST_F(MPILoggerUntracked, DisabledLoggingWithArgs) {
     // explicitly disable logging
     plssvm::verbosity = plssvm::verbosity_level::quiet;
 
@@ -65,7 +67,7 @@ TEST_F(MPILoggerUntracked, disabled_logging_with_args) {
     EXPECT_TRUE(this->get_capture().empty());
 }
 
-TEST_F(MPILoggerUntracked, mismatching_verbosity_level) {
+TEST_F(MPILoggerUntracked, MismatchingVerbosityLevel) {
     // set verbosity_level to libsvm
     plssvm::verbosity = plssvm::verbosity_level::libsvm;
 
@@ -80,7 +82,7 @@ TEST_F(MPILoggerUntracked, mismatching_verbosity_level) {
 class WarningMPILoggerUntracked : public ::testing::Test,
                                   public util::redirect_output<&std::clog> { };
 
-TEST_F(WarningMPILoggerUntracked, enabled_logging_warning) {
+TEST_F(WarningMPILoggerUntracked, EnabledLoggingWarning) {
     // explicitly enable logging
     plssvm::verbosity = plssvm::verbosity_level::full;
 
diff --git a/tests/detail/memory_size.cpp b/tests/detail/memory_size.cpp
index 66879b3a5..15d3c1ec8 100644
--- a/tests/detail/memory_size.cpp
+++ b/tests/detail/memory_size.cpp
@@ -20,7 +20,7 @@
 #include <sstream>     // std::istringstream
 #include <string>      // std::string
 
-TEST(MemorySize, default_construct) {
+TEST(MemorySize, DefaultConstruct) {
     // default construct a memory size object
     const plssvm::detail::memory_size mem{};
 
@@ -28,20 +28,20 @@ TEST(MemorySize, default_construct) {
     EXPECT_EQ(mem.num_bytes(), 0ULL);
 }
 
-TEST(MemorySize, construct_from_ull) {
+TEST(MemorySize, ConstructFromUll) {
     // construct a memory size object using an unsigned long long
     const plssvm::detail::memory_size mem{ 1024ULL };
     EXPECT_EQ(mem.num_bytes(), 1024ULL);
 }
 
-TEST(MemorySize, num_bytes) {
+TEST(MemorySize, NumBytes) {
     // create memory size object
     const plssvm::detail::memory_size mem{ 512 };
     // check getter
     EXPECT_EQ(mem.num_bytes(), 512ULL);
 }
 
-TEST(MemorySize, member_swap) {
+TEST(MemorySize, MemberSwap) {
     // construct two memory sizes
     plssvm::detail::memory_size mem1{ 1024ULL };
     plssvm::detail::memory_size mem2{ 500ULL };
@@ -54,7 +54,7 @@ TEST(MemorySize, member_swap) {
     EXPECT_EQ(mem2.num_bytes(), 1024ULL);
 }
 
-TEST(MemorySize, free_swap) {
+TEST(MemorySize, FreeSwap) {
     // construct two memory sizes
     plssvm::detail::memory_size mem1{ 1024ULL };
     plssvm::detail::memory_size mem2{ 500ULL };
@@ -68,7 +68,7 @@ TEST(MemorySize, free_swap) {
     EXPECT_EQ(mem2.num_bytes(), 1024ULL);
 }
 
-TEST(MemorySize, operator_compound_add) {
+TEST(MemorySize, OperatorCompoundAdd) {
     // create two memory size objects
     plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -80,7 +80,7 @@ TEST(MemorySize, operator_compound_add) {
     EXPECT_EQ(mem2.num_bytes(), 512ULL);
 }
 
-TEST(MemorySize, operator_add) {
+TEST(MemorySize, OperatorAdd) {
     // create two memory size objects
     const plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -92,7 +92,7 @@ TEST(MemorySize, operator_add) {
     EXPECT_EQ(mem2.num_bytes(), 512ULL);
 }
 
-TEST(MemorySize, operator_compound_subtract) {
+TEST(MemorySize, OperatorCompoundSubtract) {
     // create two memory size objects
     plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -104,7 +104,7 @@ TEST(MemorySize, operator_compound_subtract) {
     EXPECT_EQ(mem2.num_bytes(), 512ULL);
 }
 
-TEST(MemorySize, operator_subtract) {
+TEST(MemorySize, OperatorSubtract) {
     // create two memory size objects
     const plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -116,7 +116,7 @@ TEST(MemorySize, operator_subtract) {
     EXPECT_EQ(mem2.num_bytes(), 512ULL);
 }
 
-TEST(MemorySize, operator_compound_scale_mul) {
+TEST(MemorySize, OperatorCompoundScaleMultiply) {
     // create a memory size object
     plssvm::detail::memory_size mem{ 1024ULL };
 
@@ -125,7 +125,7 @@ TEST(MemorySize, operator_compound_scale_mul) {
     EXPECT_EQ(mem.num_bytes(), 512ULL);
 }
 
-TEST(MemorySize, operator_scale_mul) {
+TEST(MemorySize, OperatorScaleMultiply) {
     // create a memory size object
     const plssvm::detail::memory_size mem{ 1024ULL };
 
@@ -138,7 +138,7 @@ TEST(MemorySize, operator_scale_mul) {
     EXPECT_EQ(mem.num_bytes(), 1024ULL);
 }
 
-TEST(MemorySize, operator_compound_scale_div) {
+TEST(MemorySize, OperatorCompoundScaleDivide) {
     // create a memory size object
     plssvm::detail::memory_size mem{ 1024ULL };
 
@@ -147,7 +147,7 @@ TEST(MemorySize, operator_compound_scale_div) {
     EXPECT_EQ(mem.num_bytes(), 512ULL);
 }
 
-TEST(MemorySize, operator_scale_div) {
+TEST(MemorySize, OperatorScaleDivide) {
     // create a memory size object
     const plssvm::detail::memory_size mem{ 1024ULL };
 
@@ -157,7 +157,7 @@ TEST(MemorySize, operator_scale_div) {
     EXPECT_EQ(mem.num_bytes(), 1024ULL);
 }
 
-TEST(MemorySize, operator_factor) {
+TEST(MemorySize, OperatorDivide) {
     // create two memory size objects
     const plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -167,7 +167,7 @@ TEST(MemorySize, operator_factor) {
     EXPECT_EQ(factor, 2.0L);
 }
 
-TEST(MemorySize, relational_equal) {
+TEST(MemorySize, Equal) {
     // create memory objects
     const plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -179,7 +179,7 @@ TEST(MemorySize, relational_equal) {
     EXPECT_FALSE(mem3 == mem1);
 }
 
-TEST(MemorySize, relational_inequal) {
+TEST(MemorySize, Unequal) {
     // create memory objects
     const plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -191,7 +191,7 @@ TEST(MemorySize, relational_inequal) {
     EXPECT_TRUE(mem3 != mem1);
 }
 
-TEST(MemorySize, relational_less) {
+TEST(MemorySize, LessThan) {
     // create memory objects
     const plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -203,7 +203,7 @@ TEST(MemorySize, relational_less) {
     EXPECT_TRUE(mem3 < mem1);
 }
 
-TEST(MemorySize, relational_greater) {
+TEST(MemorySize, GreaterThan) {
     // create memory objects
     const plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -215,7 +215,7 @@ TEST(MemorySize, relational_greater) {
     EXPECT_FALSE(mem3 > mem1);
 }
 
-TEST(MemorySize, relational_less_or_equal) {
+TEST(MemorySize, LessOrEqualThan) {
     // create memory objects
     const plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -227,7 +227,7 @@ TEST(MemorySize, relational_less_or_equal) {
     EXPECT_TRUE(mem3 <= mem1);
 }
 
-TEST(MemorySize, relational_greater_or_equal) {
+TEST(MemorySize, GreaterOrEqualThan) {
     // create memory objects
     const plssvm::detail::memory_size mem1{ 1024ULL };
     const plssvm::detail::memory_size mem2{ 512ULL };
@@ -239,7 +239,7 @@ TEST(MemorySize, relational_greater_or_equal) {
     EXPECT_FALSE(mem3 >= mem1);
 }
 
-TEST(MemorySize, to_string) {
+TEST(MemorySize, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::detail::memory_size{ 0ULL }, "0 B");
     EXPECT_CONVERSION_TO_STRING(plssvm::detail::memory_size{ 8ULL }, "8 B");
@@ -254,7 +254,7 @@ TEST(MemorySize, to_string) {
     EXPECT_CONVERSION_TO_STRING(plssvm::detail::memory_size{ 1'125'899'906'842'624ULL }, "1024.00 TiB");
 }
 
-TEST(MemorySize, from_string) {
+TEST(MemorySize, FromString) {
     // check conversions to std::string
     EXPECT_CONVERSION_FROM_STRING("0 B", plssvm::detail::memory_size{ 0ULL });
     EXPECT_CONVERSION_FROM_STRING("8 B", plssvm::detail::memory_size{ 8ULL });
@@ -268,7 +268,7 @@ TEST(MemorySize, from_string) {
     EXPECT_CONVERSION_FROM_STRING("0.2TB", plssvm::detail::memory_size{ 200'000'000'000ULL });
 }
 
-TEST(MemorySize, from_string_unknown) {
+TEST(MemorySize, FromStringInvalid) {
     // foo isn't a valid backend_type
     std::istringstream input{ "0Bit" };
     plssvm::detail::memory_size mem{};
@@ -276,7 +276,7 @@ TEST(MemorySize, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(MemorySize, constexpr_pow) {
+TEST(MemorySize, ConstexprPow) {
     // check custom constexpr power function
     EXPECT_EQ(plssvm::detail::constexpr_pow(0, 1), 0);
     EXPECT_EQ(plssvm::detail::constexpr_pow(2, 0), 1);
@@ -284,7 +284,7 @@ TEST(MemorySize, constexpr_pow) {
     EXPECT_EQ(plssvm::detail::constexpr_pow(1024, 2), 1'048'576);
 }
 
-TEST(MemorySize, hash) {
+TEST(MemorySize, Hash) {
     // hash a memory size
     const plssvm::detail::memory_size mem{ 1024ULL };
     const std::size_t hash_value = std::hash<plssvm::detail::memory_size>{}(mem);
@@ -299,9 +299,9 @@ TEST(MemorySize, hash) {
 //*************************************************************************************************************************************//
 //                                                           custom literals                                                           //
 //*************************************************************************************************************************************//
-TEST(MemorySizeLiterals, base_ten_ull) {
+TEST(MemorySizeLiterals, BaseTenUnsignedLongLong) {
     // check if literals are correct
-    using namespace plssvm::detail::literals;
+    using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
 
     EXPECT_EQ(0_B, plssvm::detail::memory_size{ 0ULL });
     EXPECT_EQ(8_B, plssvm::detail::memory_size{ 8ULL });
@@ -316,9 +316,9 @@ TEST(MemorySizeLiterals, base_ten_ull) {
     EXPECT_EQ(1024_TiB, plssvm::detail::memory_size{ 1'125'899'906'842'624ULL });
 }
 
-TEST(MemorySizeLiterals, base_ten_l) {
+TEST(MemorySizeLiterals, BaseTenLongDouble) {
     // check if literals are correct
-    using namespace plssvm::detail::literals;
+    using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
 
     EXPECT_EQ(0.0_B, plssvm::detail::memory_size{ 0ULL });
     EXPECT_EQ(8.0_B, plssvm::detail::memory_size{ 8ULL });
@@ -333,9 +333,9 @@ TEST(MemorySizeLiterals, base_ten_l) {
     EXPECT_EQ(0.0009765625_TiB, plssvm::detail::memory_size{ 1'073'741'824ULL });
 }
 
-TEST(MemorySizeLiterals, base_two_ull) {
+TEST(MemorySizeLiterals, BaseTwoUnsignedLongLong) {
     // check if literals are correct
-    using namespace plssvm::detail::literals;
+    using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
 
     EXPECT_EQ(1_KB, plssvm::detail::memory_size{ 1000ULL });
     EXPECT_EQ(2_KB, plssvm::detail::memory_size{ 2000ULL });
@@ -348,9 +348,9 @@ TEST(MemorySizeLiterals, base_two_ull) {
     EXPECT_EQ(1024_TB, plssvm::detail::memory_size{ 1'024'000'000'000'000ULL });
 }
 
-TEST(MemorySizeLiterals, base_two_l) {
+TEST(MemorySizeLiterals, BaseTwoLongDouble) {
     // check if literals are correct
-    using namespace plssvm::detail::literals;
+    using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
 
     EXPECT_EQ(1.0_KB, plssvm::detail::memory_size{ 1000ULL });
     EXPECT_EQ(0.5_KB, plssvm::detail::memory_size{ 500ULL });
diff --git a/tests/detail/move_only_any.cpp b/tests/detail/move_only_any.cpp
index 0202b63e8..d336f3bbe 100644
--- a/tests/detail/move_only_any.cpp
+++ b/tests/detail/move_only_any.cpp
@@ -21,12 +21,12 @@
 #include <utility>    // std::in_place_type, std::move
 #include <vector>     // std::vector
 
-TEST(BadMoveOnlyCastException, exception) {
+TEST(BadMoveOnlyCastException, Exception) {
     const auto dummy = []() { throw plssvm::detail::bad_move_only_any_cast{}; };
     EXPECT_THROW_WHAT(dummy(), plssvm::detail::bad_move_only_any_cast, "plssvm::detail::bad_move_only_any_cast");
 }
 
-TEST(MoveOnlyAny, default_construct) {
+TEST(MoveOnlyAny, DefaultConstruct) {
     // default construct a move_only_any
     const plssvm::detail::move_only_any a{};
 
@@ -34,7 +34,7 @@ TEST(MoveOnlyAny, default_construct) {
     EXPECT_FALSE(a.has_value());
 }
 
-TEST(MoveOnlyAny, construct) {
+TEST(MoveOnlyAny, Construct) {
     // construct move_only_any objects
     const plssvm::detail::move_only_any a1{ 42 };
     EXPECT_EQ(plssvm::detail::move_only_any_cast<int>(a1), 42);
@@ -58,7 +58,7 @@ TEST(MoveOnlyAny, construct) {
     EXPECT_EQ(*plssvm::detail::move_only_any_cast<std::shared_ptr<float>>(a7), 1.0f);
 }
 
-TEST(MoveOnlyAny, construct_in_place) {
+TEST(MoveOnlyAny, ConstructInPlace) {
     // construct a move_only_any object using std::in_place_type
     const plssvm::detail::move_only_any a{ std::in_place_type<std::string>, std::string::size_type{ 10 }, 'a' };
 
@@ -66,7 +66,7 @@ TEST(MoveOnlyAny, construct_in_place) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<std::string>(a), std::string{ "aaaaaaaaaa" });
 }
 
-TEST(MoveOnlyAny, construct_in_place_with_initializer_list) {
+TEST(MoveOnlyAny, ConstructInPlaceWithInitializerList) {
     // construct a move_only_any object using std::in_place_type
     const plssvm::detail::move_only_any a{ std::in_place_type<std::vector<int>>, { 0, 1, 2, 3 } };
 
@@ -74,7 +74,7 @@ TEST(MoveOnlyAny, construct_in_place_with_initializer_list) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<std::vector<int>>(a), (std::vector<int>{ 0, 1, 2, 3 }));
 }
 
-TEST(MoveOnlyAny, assignment_operator) {
+TEST(MoveOnlyAny, AssignmentOperator) {
     // default construct a move_only_any
     plssvm::detail::move_only_any a{};
     // the constructed any should not contain an object
@@ -88,7 +88,7 @@ TEST(MoveOnlyAny, assignment_operator) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<std::string>(a), (std::string{ "Hello, World!" }));
 }
 
-TEST(MoveOnlyAny, emplace) {
+TEST(MoveOnlyAny, Emplace) {
     // default construct a move_only_any
     plssvm::detail::move_only_any a{};
     // the constructed any should not contain an object
@@ -101,7 +101,7 @@ TEST(MoveOnlyAny, emplace) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<std::string>(a), std::string{ "bbbbbbbbbb" });
 }
 
-TEST(MoveOnlyAny, emplace_with_initializer_list) {
+TEST(MoveOnlyAny, EmplaceWithInitializerList) {
     // default construct a move_only_any
     plssvm::detail::move_only_any a{};
     // the constructed any should not contain an object
@@ -114,7 +114,7 @@ TEST(MoveOnlyAny, emplace_with_initializer_list) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<std::vector<int>>(a), (std::vector<int>{ 0, 1, 2, 3 }));
 }
 
-TEST(MoveOnlyAny, reset) {
+TEST(MoveOnlyAny, Reset) {
     // create move_only_any object
     plssvm::detail::move_only_any a{ 42 };
     // the constructed any should contain an object
@@ -127,7 +127,7 @@ TEST(MoveOnlyAny, reset) {
     EXPECT_FALSE(a.has_value());
 }
 
-TEST(MoveOnlyAny, swap_member_function) {
+TEST(MoveOnlyAny, SwapMemberFunction) {
     // create two move_only_any objects
     plssvm::detail::move_only_any a1{ 42 };
     plssvm::detail::move_only_any a2{ 3.1415 };
@@ -140,7 +140,7 @@ TEST(MoveOnlyAny, swap_member_function) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<int>(a2), 42);
 }
 
-TEST(MoveOnlyAny, has_value) {
+TEST(MoveOnlyAny, HasValue) {
     // create move_only_any object that should contain an object
     const plssvm::detail::move_only_any a1{ 42 };
     EXPECT_TRUE(a1.has_value());
@@ -150,7 +150,7 @@ TEST(MoveOnlyAny, has_value) {
     EXPECT_FALSE(a2.has_value());
 }
 
-TEST(MoveOnlyAny, type) {
+TEST(MoveOnlyAny, Type) {
     // default constructed move_only_any should return the typeid(void) on a call to .type()
     const plssvm::detail::move_only_any a1{};
     EXPECT_EQ(a1.type(), typeid(void));
@@ -160,7 +160,7 @@ TEST(MoveOnlyAny, type) {
     EXPECT_EQ(a2.type(), typeid(int));
 }
 
-TEST(MoveOnlyAny, swap_free_function) {
+TEST(MoveOnlyAny, SwapFreeFunction) {
     // create two move_only_any objects
     plssvm::detail::move_only_any a1{ 42 };
     plssvm::detail::move_only_any a2{ 3.1415 };
@@ -174,7 +174,7 @@ TEST(MoveOnlyAny, swap_free_function) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<int>(a2), 42);
 }
 
-TEST(MoveOnlyAny, cast_const_lvalue_reference) {
+TEST(MoveOnlyAny, CastConstLvalueReference) {
     // create const move_only_any object
     const plssvm::detail::move_only_any a{ 42 };
     // retrieve the contained value and check for correctness
@@ -182,7 +182,7 @@ TEST(MoveOnlyAny, cast_const_lvalue_reference) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<const int &>(a), 42);
 }
 
-TEST(MoveOnlyAny, cast_const_lvalue_reference_wrong_type) {
+TEST(MoveOnlyAny, CastConstLvalueReferenceWrongType) {
     // create const move_only_any object
     const plssvm::detail::move_only_any a{ 42 };
     // try retrieving a value with the wrong type
@@ -190,7 +190,7 @@ TEST(MoveOnlyAny, cast_const_lvalue_reference_wrong_type) {
     EXPECT_THROW_WHAT(std::ignore = plssvm::detail::move_only_any_cast<const float &>(a), plssvm::detail::bad_move_only_any_cast, "plssvm::detail::bad_move_only_any_cast");
 }
 
-TEST(MoveOnlyAny, cast_lvalue_reference) {
+TEST(MoveOnlyAny, CastLvalueReference) {
     // create const move_only_any object
     plssvm::detail::move_only_any a{ 42 };
     // retrieve the contained value and check for correctness
@@ -199,7 +199,7 @@ TEST(MoveOnlyAny, cast_lvalue_reference) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<int &>(a), 42);
 }
 
-TEST(MoveOnlyAny, cast_lvalue_reference_wrong_type) {
+TEST(MoveOnlyAny, CastLvalueReferenceWrongType) {
     // create const move_only_any object
     plssvm::detail::move_only_any a{ 42 };
     // try retrieving a value with the wrong type
@@ -208,23 +208,22 @@ TEST(MoveOnlyAny, cast_lvalue_reference_wrong_type) {
     EXPECT_THROW_WHAT(std::ignore = plssvm::detail::move_only_any_cast<float &>(a), plssvm::detail::bad_move_only_any_cast, "plssvm::detail::bad_move_only_any_cast");
 }
 
-TEST(MoveOnlyAny, cast_rvalue_reference) {
+TEST(MoveOnlyAny, CastRvalueReference) {
     // create const move_only_any object
     plssvm::detail::move_only_any a{ std::string{ "Hello, World!" } };
     // retrieve the contained value and check for correctness
     auto str = plssvm::detail::move_only_any_cast<std::string &&>(std::move(a));
     EXPECT_EQ(str, (std::string{ "Hello, World!" }));
-    EXPECT_EQ(plssvm::detail::move_only_any_cast<std::string>(a), std::string{});
 }
 
-TEST(MoveOnlyAny, cast_rvalue_reference_wrong_type) {
+TEST(MoveOnlyAny, CastRvalueReferenceWrongType) {
     // create const move_only_any object
     plssvm::detail::move_only_any a{ 42 };
     // try retrieving a value with the wrong type
     EXPECT_THROW_WHAT(std::ignore = plssvm::detail::move_only_any_cast<float &&>(std::move(a)), plssvm::detail::bad_move_only_any_cast, "plssvm::detail::bad_move_only_any_cast");
 }
 
-TEST(MoveOnlyAny, cast_const_pointer) {
+TEST(MoveOnlyAny, CastConstPointer) {
     // create const move_only_any object
     const plssvm::detail::move_only_any a{ 42 };
     // retrieve the contained value and check for correctness
@@ -232,20 +231,20 @@ TEST(MoveOnlyAny, cast_const_pointer) {
     EXPECT_EQ(*ptr, 42);
 }
 
-TEST(MoveOnlyAny, cast_const_nullptr_pointer) {
+TEST(MoveOnlyAny, CastConstNullptrPointer) {
     // casting a nullptr should return a nullptr
     const plssvm::detail::move_only_any *a{ nullptr };
     EXPECT_EQ(plssvm::detail::move_only_any_cast<const int>(a), nullptr);
 }
 
-TEST(MoveOnlyAny, cast_const_pointer_wrong_type) {
+TEST(MoveOnlyAny, CastConstPointerWrongType) {
     // create const move_only_any object
     const plssvm::detail::move_only_any a{ 42 };
     // try retrieving a value with the wrong type
     EXPECT_EQ(plssvm::detail::move_only_any_cast<const float>(&a), nullptr);
 }
 
-TEST(MoveOnlyAny, cast_pointer) {
+TEST(MoveOnlyAny, CastPointer) {
     // create const move_only_any object
     plssvm::detail::move_only_any a{ 42 };
     // retrieve the contained value and check for correctness
@@ -253,13 +252,13 @@ TEST(MoveOnlyAny, cast_pointer) {
     EXPECT_EQ(*plssvm::detail::move_only_any_cast<const int>(&a), 42);
 }
 
-TEST(MoveOnlyAny, cast_nullptr_pointer) {
+TEST(MoveOnlyAny, CastNullptrPointer) {
     // casting a nullptr should return a nullptr
     plssvm::detail::move_only_any *a{ nullptr };
     EXPECT_EQ(plssvm::detail::move_only_any_cast<int>(a), nullptr);
 }
 
-TEST(MoveOnlyAny, cast_pointer_wrong_type) {
+TEST(MoveOnlyAny, CastPointerWrongType) {
     // create const move_only_any object
     plssvm::detail::move_only_any a{ 42 };
     // try retrieving a value with the wrong type
@@ -267,7 +266,7 @@ TEST(MoveOnlyAny, cast_pointer_wrong_type) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<const float>(&a), nullptr);
 }
 
-TEST(MoveOnlyAny, make_move_only_any) {
+TEST(MoveOnlyAny, MakeMoveOnlyAny) {
     // construct a move_only_any object
     const auto a = plssvm::detail::make_move_only_any<std::string>(10, 'a');
 
@@ -275,7 +274,7 @@ TEST(MoveOnlyAny, make_move_only_any) {
     EXPECT_EQ(plssvm::detail::move_only_any_cast<std::string>(a), std::string{ "aaaaaaaaaa" });
 }
 
-TEST(MoveOnlyAny, make_move_only_any_with_initializer_list) {
+TEST(MoveOnlyAny, MakeMoveOnlyAnyWithInitializerList) {
     // construct a move_only_any object
     const auto a = plssvm::detail::make_move_only_any<std::vector<int>>({ 0, 1, 2, 3 });
 
diff --git a/tests/detail/operators.cpp b/tests/detail/operators.cpp
index b323dcc3a..285588cd2 100644
--- a/tests/detail/operators.cpp
+++ b/tests/detail/operators.cpp
@@ -20,7 +20,7 @@
 #include <vector>  // std::vector
 
 // make all operator overloads available in all tests
-using namespace plssvm::operators;
+using namespace plssvm::operators;  // NOLINT(google-build-using-namespace): only imports custom math operations on vectors (and scalars)
 
 //*************************************************************************************************************************************//
 //                                                          scalar operations                                                          //
@@ -30,14 +30,14 @@ class ScalarOperations : public ::testing::Test { };
 
 TYPED_TEST_SUITE(ScalarOperations, util::real_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ScalarOperations, operator_sign_positive) {
+TYPED_TEST(ScalarOperations, OperatorSignPositive) {
     using real_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     EXPECT_FLOATING_POINT_EQ(sign(real_type{ 1.6 }), real_type{ 1 });
     EXPECT_FLOATING_POINT_EQ(sign(real_type{ 3 }), real_type{ 1 });
 }
 
-TYPED_TEST(ScalarOperations, operator_sign_negative) {
+TYPED_TEST(ScalarOperations, OperatorSignNegative) {
     using real_type = util::test_parameter_type_at_t<0, TypeParam>;
 
     EXPECT_FLOATING_POINT_EQ(sign(real_type{ -2.4 }), real_type{ -1 });
@@ -127,7 +127,7 @@ class VectorOperationsDeathTest : public ::testing::Test {
 
 TYPED_TEST_SUITE(VectorOperationsDeathTest, util::real_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(VectorOperations, operator_add_binary) {
+TYPED_TEST(VectorOperations, OperatorAddBinary) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // binary addition using two vectors
@@ -136,7 +136,7 @@ TYPED_TEST(VectorOperations, operator_add_binary) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_b() + this->get_a(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_add_compound) {
+TYPED_TEST(VectorOperations, OperatorAddCompound) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // compound addition using two vectors
@@ -144,7 +144,7 @@ TYPED_TEST(VectorOperations, operator_add_compound) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_a() += this->get_b(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_add_scalar_binary) {
+TYPED_TEST(VectorOperations, OperatorAddScalarBinary) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // binary addition using a vector and a scalar
@@ -153,7 +153,7 @@ TYPED_TEST(VectorOperations, operator_add_scalar_binary) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_scalar() + this->get_a(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_add_scalar_compound) {
+TYPED_TEST(VectorOperations, OperatorAddScalarCompound) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // compound addition using a vector and a scalar
@@ -161,40 +161,40 @@ TYPED_TEST(VectorOperations, operator_add_scalar_compound) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_a() += this->get_scalar(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_add_binary_empty) {
+TYPED_TEST(VectorOperations, OperatorAddBinaryEmpty) {
     // binary addition using two empty vectors
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_empty() + this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_add_compound_empty) {
+TYPED_TEST(VectorOperations, OperatorAddCompoundEmpty) {
     // compound addition using two empty vectors
     EXPECT_EQ(this->get_empty() += this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_add_scalar_binary_empty) {
+TYPED_TEST(VectorOperations, OperatorAddScalarBinaryEmpty) {
     // binary addition using an empty vector and a scalar
     EXPECT_EQ(this->get_empty() + this->get_scalar(), this->get_empty());
     EXPECT_EQ(this->get_scalar() + this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_add_scalar_compound_empty) {
+TYPED_TEST(VectorOperations, OperatorAddScalarCompoundEmpty) {
     // compound addition using an empty vector and a scalar
     EXPECT_EQ(this->get_empty() += this->get_scalar(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_add_binary) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorAddBinary) {
     // try to binary add vectors with different sizes
     EXPECT_DEATH(std::ignore = this->get_a() + this->get_b(), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(std::ignore = this->get_b() + this->get_a(), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_add_compound) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorAddCompound) {
     // try to compound add vectors with different sizes
     EXPECT_DEATH(this->get_a() += this->get_b(), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(this->get_b() += this->get_a(), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperations, operator_subtract_binary) {
+TYPED_TEST(VectorOperations, OperatorSubtractBinary) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // binary subtraction using two vectors
@@ -208,7 +208,7 @@ TYPED_TEST(VectorOperations, operator_subtract_binary) {
     }
 }
 
-TYPED_TEST(VectorOperations, operator_subtract_compound) {
+TYPED_TEST(VectorOperations, OperatorSubtractCompound) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // compound subtraction using two vectors
@@ -216,7 +216,7 @@ TYPED_TEST(VectorOperations, operator_subtract_compound) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_a() -= this->get_b(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_subtract_scalar_binary) {
+TYPED_TEST(VectorOperations, OperatorSubtractScalarBinary) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // binary subtraction using a vector and a scalar
@@ -230,7 +230,7 @@ TYPED_TEST(VectorOperations, operator_subtract_scalar_binary) {
     }
 }
 
-TYPED_TEST(VectorOperations, operator_subtract_scalar_compound) {
+TYPED_TEST(VectorOperations, OperatorSubtractScalarCompound) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // compound subtraction using a vector and a scalar
@@ -238,40 +238,40 @@ TYPED_TEST(VectorOperations, operator_subtract_scalar_compound) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_a() -= this->get_scalar(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_subtract_binary_empty) {
+TYPED_TEST(VectorOperations, OperatorSubtractBinaryEmpty) {
     // binary subtraction using two empty vectors
     EXPECT_EQ(this->get_empty() - this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_subtract_compound_empty) {
+TYPED_TEST(VectorOperations, OperatorSubtractCompoundEmpty) {
     // compound subtraction using two empty vectors
     EXPECT_EQ(this->get_empty() -= this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_subtract_scalar_binary_empty) {
+TYPED_TEST(VectorOperations, OperatorSubtractScalarBinaryEmpty) {
     // binary subtraction using an empty vector and a scalar
     EXPECT_EQ(this->get_empty() - this->get_scalar(), this->get_empty());
     EXPECT_EQ(this->get_scalar() - this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_subtract_scalar_compound_empty) {
+TYPED_TEST(VectorOperations, OperatorSubtractScalarCompoundEmpty) {
     // compound subtraction using an empty vector and a scalar
     EXPECT_EQ(this->get_empty() -= this->get_scalar(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_subtract_binary) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorSubtractBinary) {
     // try to binary subtract vectors with different sizes
     EXPECT_DEATH(std::ignore = this->get_a() - this->get_b(), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(std::ignore = this->get_b() - this->get_a(), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_subtract_compound) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorSubtractCompound) {
     // try to compound subtract vectors with different sizes
     EXPECT_DEATH(this->get_a() -= this->get_b(), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(this->get_b() -= this->get_a(), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperations, operator_multiply_binary) {
+TYPED_TEST(VectorOperations, OperatorMultiplyBinary) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // binary multiplication using two vectors
@@ -280,7 +280,7 @@ TYPED_TEST(VectorOperations, operator_multiply_binary) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_b() * this->get_a(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_multiply_compound) {
+TYPED_TEST(VectorOperations, OperatorMultiplyCompound) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // compound multiplication using two vectors
@@ -288,7 +288,7 @@ TYPED_TEST(VectorOperations, operator_multiply_compound) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_a() *= this->get_b(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_multiply_scalar_binary) {
+TYPED_TEST(VectorOperations, OperatorMultiplyScalarBinary) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // binary multiplication using a vector and a scalar
@@ -297,7 +297,7 @@ TYPED_TEST(VectorOperations, operator_multiply_scalar_binary) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_scalar() * this->get_a(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_multiply_scalar_compound) {
+TYPED_TEST(VectorOperations, OperatorMultiplyScalarCompound) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // compound multiplication using a vector and a scalar
@@ -305,40 +305,40 @@ TYPED_TEST(VectorOperations, operator_multiply_scalar_compound) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_a() *= this->get_scalar(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_multiply_binary_empty) {
+TYPED_TEST(VectorOperations, OperatorMultiplyBinaryEmpty) {
     // binary multiplication using two empty vectors
     EXPECT_EQ(this->get_empty() * this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_multiply_compound_empty) {
+TYPED_TEST(VectorOperations, OperatorMultiplyCompoundEmpty) {
     // compound multiplication using two empty vectors
     EXPECT_EQ(this->get_empty() *= this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_multiply_scalar_binary_empty) {
+TYPED_TEST(VectorOperations, OperatorMultiplyScalarBinaryEmpty) {
     // binary multiplication using an empty vector and a scalar
     EXPECT_EQ(this->get_empty() * this->get_scalar(), this->get_empty());
     EXPECT_EQ(this->get_scalar() * this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_multiply_scalar_compound_empty) {
+TYPED_TEST(VectorOperations, OperatorMultiplyScalarCompoundEmpty) {
     // compound multiplication using an empty vector and a scalar
     EXPECT_EQ(this->get_empty() *= this->get_scalar(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_multiply_binary) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorMultiplyBinary) {
     // try to binary multiply vectors with different sizes
     EXPECT_DEATH(std::ignore = this->get_a() * this->get_b(), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(std::ignore = this->get_b() * this->get_a(), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_multiply_compound) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorMultiplyCompound) {
     // try to compound multiply vectors with different sizes
     EXPECT_DEATH(this->get_a() *= this->get_b(), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(this->get_b() *= this->get_a(), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperations, operator_divide_binary) {
+TYPED_TEST(VectorOperations, OperatorDivideBinary) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // binary division using two vectors
@@ -352,7 +352,7 @@ TYPED_TEST(VectorOperations, operator_divide_binary) {
     }
 }
 
-TYPED_TEST(VectorOperations, operator_divide_compound) {
+TYPED_TEST(VectorOperations, OperatorDivideCompound) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // compound division using two vectors
@@ -360,7 +360,7 @@ TYPED_TEST(VectorOperations, operator_divide_compound) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_a() /= this->get_b(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_divide_scalar_binary) {
+TYPED_TEST(VectorOperations, OperatorDivideScalarBinary) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // binary division using a vector and a scalar
@@ -374,7 +374,7 @@ TYPED_TEST(VectorOperations, operator_divide_scalar_binary) {
     }
 }
 
-TYPED_TEST(VectorOperations, operator_divide_scalar_compound) {
+TYPED_TEST(VectorOperations, OperatorDivideScalarCompound) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // compound division using a vector and a scalar
@@ -382,86 +382,96 @@ TYPED_TEST(VectorOperations, operator_divide_scalar_compound) {
     EXPECT_FLOATING_POINT_VECTOR_NEAR(this->get_a() /= this->get_scalar(), c);
 }
 
-TYPED_TEST(VectorOperations, operator_divide_binary_empty) {
+TYPED_TEST(VectorOperations, OperatorDivideBinaryEmpty) {
     // binary division using two empty vectors
     EXPECT_EQ(this->get_empty() / this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_divide_compound_empty) {
+TYPED_TEST(VectorOperations, OperatorDivideCompoundEmpty) {
     // compound division using two empty vectors
     EXPECT_EQ(this->get_empty() /= this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_divide_scalar_binary_empty) {
+TYPED_TEST(VectorOperations, OperatorDivideScalarBinaryEmpty) {
     // binary division using an empty vector and a scalar
     EXPECT_EQ(this->get_empty() / this->get_scalar(), this->get_empty());
     EXPECT_EQ(this->get_scalar() / this->get_empty(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperations, operator_divide_scalar_compound_empty) {
+TYPED_TEST(VectorOperations, OperatorDivideScalarCompoundEmpty) {
     // compound division using an empty vector and a scalar
     EXPECT_EQ(this->get_empty() /= this->get_scalar(), this->get_empty());
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_divide_binary) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorDivideBinary) {
     // try to binary division vectors with different sizes
     EXPECT_DEATH(std::ignore = this->get_a() / this->get_b(), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(std::ignore = this->get_b() / this->get_a(), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_divide_compound) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorDivideCompound) {
     // try to compound division vectors with different sizes
     EXPECT_DEATH(this->get_a() /= this->get_b(), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(this->get_b() /= this->get_a(), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperations, operator_dot_function) {
+TYPED_TEST(VectorOperations, OperatorDotFunction) {
+    using real_type = typename TestFixture::fixture_real_type;
+
     // calculate dot product using the dot function
-    EXPECT_FLOATING_POINT_NEAR(dot(this->get_a(), this->get_b()), 62.5);
-    EXPECT_FLOATING_POINT_NEAR(dot(this->get_b(), this->get_a()), 62.5);
+    EXPECT_FLOATING_POINT_NEAR(dot(this->get_a(), this->get_b()), real_type{ 62.5 });
+    EXPECT_FLOATING_POINT_NEAR(dot(this->get_b(), this->get_a()), real_type{ 62.5 });
 }
 
-TYPED_TEST(VectorOperations, operator_dot_transposed) {
+TYPED_TEST(VectorOperations, OperatorDotTransposed) {
+    using real_type = typename TestFixture::fixture_real_type;
+
     // calculate dot product using the transposed overload function
-    EXPECT_FLOATING_POINT_NEAR(transposed{ this->get_a() } * this->get_b(), 62.5);
-    EXPECT_FLOATING_POINT_NEAR(transposed{ this->get_b() } * this->get_a(), 62.5);
+    EXPECT_FLOATING_POINT_NEAR(transposed{ this->get_a() } * this->get_b(), real_type{ 62.5 });
+    EXPECT_FLOATING_POINT_NEAR(transposed{ this->get_b() } * this->get_a(), real_type{ 62.5 });
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_dot_function) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorDotFunction) {
     // try to calculate the dot product with vectors of different sizes
     EXPECT_DEATH(std::ignore = dot(this->get_a(), this->get_b()), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(std::ignore = dot(this->get_b(), this->get_a()), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_dot_transposed) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorDotTransposed) {
     // try to calculate the dot product with vectors of different sizes
     EXPECT_DEATH(std::ignore = transposed{ this->get_a() } * this->get_b(), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(std::ignore = transposed{ this->get_b() } * this->get_a(), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperations, operator_sum) {
+TYPED_TEST(VectorOperations, OperatorSum) {
+    using real_type = typename TestFixture::fixture_real_type;
+
     // sum vector elements
-    EXPECT_FLOATING_POINT_NEAR(sum(this->get_a()), 15);
-    EXPECT_FLOATING_POINT_NEAR(sum(this->get_b()), 17.5);
+    EXPECT_FLOATING_POINT_NEAR(sum(this->get_a()), real_type{ 15 });
+    EXPECT_FLOATING_POINT_NEAR(sum(this->get_b()), real_type{ 17.5 });
 }
 
-TYPED_TEST(VectorOperations, operator_squared_euclidean_dist) {
+TYPED_TEST(VectorOperations, OperatorSquaredEuclideanDist) {
+    using real_type = typename TestFixture::fixture_real_type;
+
     // calculate the squared Euclidean distance between two vectors
-    EXPECT_FLOATING_POINT_NEAR(squared_euclidean_dist(this->get_a(), this->get_b()), 1.25);
+    EXPECT_FLOATING_POINT_NEAR(squared_euclidean_dist(this->get_a(), this->get_b()), real_type{ 1.25 });
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_squared_euclidean_dist) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorSquaredEuclideanDist) {
     // try to calculate the squared Euclidean distance between two vectors with different distance
     EXPECT_DEATH(std::ignore = squared_euclidean_dist(this->get_a(), this->get_b()), "Sizes mismatch!: 4 != 2");
     EXPECT_DEATH(std::ignore = squared_euclidean_dist(this->get_b(), this->get_a()), "Sizes mismatch!: 2 != 4");
 }
 
-TYPED_TEST(VectorOperations, operator_manhattan_dist) {
+TYPED_TEST(VectorOperations, OperatorManhattanDist) {
+    using real_type = typename TestFixture::fixture_real_type;
+
     // calculate the Manhattan distance between two vectors
-    EXPECT_FLOATING_POINT_NEAR(manhattan_dist(this->get_a(), this->get_b()), 2.5);
+    EXPECT_FLOATING_POINT_NEAR(manhattan_dist(this->get_a(), this->get_b()), real_type{ 2.5 });
 }
 
-TYPED_TEST(VectorOperationsDeathTest, operator_manhattan_dist) {
+TYPED_TEST(VectorOperationsDeathTest, OperatorManhattanDist) {
     // 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");
diff --git a/tests/detail/sha256.cpp b/tests/detail/sha256.cpp
index 95abba6d3..3768b82d4 100644
--- a/tests/detail/sha256.cpp
+++ b/tests/detail/sha256.cpp
@@ -15,13 +15,13 @@
 #include "fmt/format.h"   // fmt::format
 #include "gtest/gtest.h"  // TEST_P, INSTANTIATE_TEST_SUITE_P, ASSERT_EQ, EXPECT_EQ, ::testing::{TestWithParam, Values}
 
-#include <string>   // std::string
-#include <utility>  // std::pair, std::make_pair
-#include <vector>   // std::vector
+#include <string>       // std::string
+#include <string_view>  // std::string_view
+#include <utility>      // std::pair, std::make_pair
 
 class Sha256 : public ::testing::TestWithParam<std::pair<std::string, std::string_view>> { };
 
-TEST_P(Sha256, correct_encoding) {
+TEST_P(Sha256, CorrectEncoding) {
     // get generated parameter
     const auto [input, encoded_output] = GetParam();
 
diff --git a/tests/detail/string_conversion.cpp b/tests/detail/string_conversion.cpp
index 8793f25ad..378631838 100644
--- a/tests/detail/string_conversion.cpp
+++ b/tests/detail/string_conversion.cpp
@@ -17,7 +17,7 @@
 #include "tests/types_to_test.hpp"       // util::{combine_test_parameters_gtest_t, cartesian_type_product_t, test_parameter_type_at_t}
 
 #include "fmt/format.h"   // fmt::format
-#include "fmt/std.h"      // format std::vector<bool>::operator[] proxy type
+#include "fmt/std.h"      // NOLINT: format std::vector<bool>::operator[] proxy type
 #include "gtest/gtest.h"  // TEST, ASSERT_EQ, EXPECT_EQ, EXPECT_TRUE, TYPED_TEST, TYPED_TEST_SUITE, TEST_P, INSTANTIATE_TEST_SUITE_P
                           // ::testing::{Test, TestWithParam, Types, Values}
 
@@ -25,9 +25,10 @@
 #include <string>       // std::string
 #include <string_view>  // std::string_view
 #include <tuple>        // std::tuple, std::ignore
-#include <utility>      // std::pair, std::make_pair
 #include <vector>       // std::vector
 
+namespace {
+
 /**
  * @brief Checks the plssvm::detail::convert_to function.
  * @tparam T the type to convert the input values to
@@ -44,9 +45,9 @@ void check_convert_to(const std::vector<std::string_view> &input, const std::vec
     }
 }
 
-TEST(StringConversion, string_conversion) {
-    using namespace plssvm::detail;
+}  // namespace
 
+TEST(StringConversion, StringConversion) {
     const std::vector<std::string_view> input = { "-3", "-1.5", "0.0", "1.5", "3", "   5", "  6 ", "7  " };
     const std::vector<std::string_view> input_unsigned = { "0.0", "1.5", "3", "   5", "  6 ", "7  " };
     const std::vector<std::string_view> input_signed_unsigned_char = { "0", "48", "65.2", "66", "122", "   119", "  120 ", "121  " };
@@ -102,7 +103,7 @@ class StringConversionException : public ::testing::Test {
 
 TYPED_TEST_SUITE(StringConversionException, string_conversion_exception_types_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(StringConversionException, string_conversion_exception) {
+TYPED_TEST(StringConversionException, StringConversionException) {
     using type = typename TestFixture::fixture_type;
 
     EXPECT_THROW_WHAT(std::ignore = plssvm::detail::convert_to<type>("a"),
@@ -116,7 +117,7 @@ TYPED_TEST(StringConversionException, string_conversion_exception) {
                       fmt::format("Can't convert 'a' to a value of type {}!", plssvm::detail::arithmetic_type_name<type>()));
 }
 
-TEST(StringConversionException, string_conversion_exception_bool) {
+TEST(StringConversionException, StringConversionExceptionBool) {
     EXPECT_THROW_WHAT(std::ignore = plssvm::detail::convert_to<bool>("a"),
                       std::runtime_error,
                       "Can't convert 'a' to a value of type long long!");
@@ -128,7 +129,7 @@ TEST(StringConversionException, string_conversion_exception_bool) {
                       "Can't convert 'a' to a value of type long long!");
 }
 
-TEST(StringConversionException, string_conversion_exception_char) {
+TEST(StringConversionException, StringConversionExceptionChar) {
     EXPECT_THROW_WHAT(std::ignore = plssvm::detail::convert_to<char>("42"),
                       std::runtime_error,
                       "Can't convert '42' to a value of type char!");
@@ -142,7 +143,7 @@ TEST(StringConversionException, string_conversion_exception_char) {
 
 class StringConversionExtract : public ::testing::TestWithParam<std::tuple<std::string_view, int>> { };
 
-TEST_P(StringConversionExtract, extract_first_integer_from_string) {
+TEST_P(StringConversionExtract, ExtractFirstIntegerFromString) {
     auto [input, output] = GetParam();
     EXPECT_EQ(plssvm::detail::extract_first_integer_from_string<int>(input), output);
 }
@@ -157,7 +158,7 @@ INSTANTIATE_TEST_SUITE_P(StringUtility, StringConversionExtract, ::testing::Valu
                 naming::pretty_print_escaped_string<StringConversionExtract>);
 // clang-format on
 
-TEST(StringConversion, extract_first_integer_from_string_exception) {
+TEST(StringConversion, ExtractFirstIntegerFromStringException) {
     EXPECT_THROW_WHAT(std::ignore = plssvm::detail::extract_first_integer_from_string<int>("abc"), std::runtime_error, R"(String "abc" doesn't contain any integer!)");
     EXPECT_THROW_WHAT(std::ignore = plssvm::detail::extract_first_integer_from_string<int>(""), std::runtime_error, R"(String "" doesn't contain any integer!)");
 }
@@ -173,7 +174,7 @@ class StringConversionSplitAs : public ::testing::Test {
 
 TYPED_TEST_SUITE(StringConversionSplitAs, split_as_types_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(StringConversionSplitAs, split_default_delimiter) {
+TYPED_TEST(StringConversionSplitAs, SplitAsDefaultDelimiter) {
     using type = typename TestFixture::fixture_type;
 
     // split string using the default delimiter
@@ -187,7 +188,7 @@ TYPED_TEST(StringConversionSplitAs, split_default_delimiter) {
     }
 }
 
-TYPED_TEST(StringConversionSplitAs, split_custom_delimiter) {
+TYPED_TEST(StringConversionSplitAs, SplitAsCustomDelimiter) {
     using type = typename TestFixture::fixture_type;
 
     // split string using a custom delimiter
@@ -201,7 +202,7 @@ TYPED_TEST(StringConversionSplitAs, split_custom_delimiter) {
     }
 }
 
-TYPED_TEST(StringConversionSplitAs, split_single_value) {
+TYPED_TEST(StringConversionSplitAs, SplitAsSingleValue) {
     using type = typename TestFixture::fixture_type;
 
     // split string containing a single value
@@ -210,7 +211,7 @@ TYPED_TEST(StringConversionSplitAs, split_single_value) {
     EXPECT_EQ(split.front(), static_cast<type>(42)) << fmt::format("split: {}, correct: {}", split.front(), static_cast<type>(42));
 }
 
-TYPED_TEST(StringConversionSplitAs, split_empty_string) {
+TYPED_TEST(StringConversionSplitAs, SplitAsEmptyString) {
     using type = typename TestFixture::fixture_type;
 
     // split the empty string
diff --git a/tests/detail/string_utility.cpp b/tests/detail/string_utility.cpp
index 773357877..24648fd4f 100644
--- a/tests/detail/string_utility.cpp
+++ b/tests/detail/string_utility.cpp
@@ -20,40 +20,40 @@
 #include <tuple>        // std::tuple, std::make_tuple
 #include <vector>       // std::vector
 
-TEST(StringUtility, starts_with_string) {
+TEST(StringUtility, StartsWithString) {
     EXPECT_TRUE(plssvm::detail::starts_with("abc", "abc"));
     EXPECT_TRUE(plssvm::detail::starts_with("abc", "ab"));
     EXPECT_FALSE(plssvm::detail::starts_with("abc", "abcd"));
     EXPECT_FALSE(plssvm::detail::starts_with("abc", "bc"));
 }
 
-TEST(StringUtility, starts_with_char) {
+TEST(StringUtility, StartsWithChar) {
     EXPECT_TRUE(plssvm::detail::starts_with("abc", 'a'));
     EXPECT_FALSE(plssvm::detail::starts_with("abc", 'c'));
     EXPECT_FALSE(plssvm::detail::starts_with("abc", 'd'));
 }
 
-TEST(StringUtility, ends_with_string) {
+TEST(StringUtility, EndsWithString) {
     EXPECT_TRUE(plssvm::detail::ends_with("abc", "abc"));
     EXPECT_FALSE(plssvm::detail::ends_with("abc", "ab"));
     EXPECT_FALSE(plssvm::detail::ends_with("abc", "abcd"));
     EXPECT_TRUE(plssvm::detail::ends_with("abc", "bc"));
 }
 
-TEST(StringUtility, ends_with_char) {
+TEST(StringUtility, EndsWithChar) {
     EXPECT_FALSE(plssvm::detail::ends_with("abc", 'a'));
     EXPECT_TRUE(plssvm::detail::ends_with("abc", 'c'));
     EXPECT_FALSE(plssvm::detail::ends_with("abc", 'd'));
 }
 
-TEST(StringUtility, contains_string) {
+TEST(StringUtility, ContainsString) {
     EXPECT_TRUE(plssvm::detail::contains("abc", "abc"));
     EXPECT_TRUE(plssvm::detail::contains("abc", "ab"));
     EXPECT_FALSE(plssvm::detail::contains("abc", "abcd"));
     EXPECT_TRUE(plssvm::detail::contains("abc", "bc"));
 }
 
-TEST(StringUtility, contains_char) {
+TEST(StringUtility, ContainsChar) {
     EXPECT_TRUE(plssvm::detail::contains("abc", 'a'));
     EXPECT_TRUE(plssvm::detail::contains("abc", 'c'));
     EXPECT_FALSE(plssvm::detail::contains("abc", 'd'));
@@ -64,7 +64,7 @@ class StringUtilityBase : public ::testing::TestWithParam<std::tuple<std::string
 // test trim left only
 class StringUtilityTrimLeft : public StringUtilityBase { };
 
-TEST_P(StringUtilityTrimLeft, trim_left) {
+TEST_P(StringUtilityTrimLeft, TrimLeft) {
     auto [input, output] = GetParam();
     EXPECT_EQ(plssvm::detail::trim_left(input), output);
 }
@@ -81,7 +81,7 @@ INSTANTIATE_TEST_SUITE_P(StringUtility, StringUtilityTrimLeft, ::testing::Values
 // test trim right only
 class StringUtilityTrimRight : public StringUtilityBase { };
 
-TEST_P(StringUtilityTrimRight, trim_right) {
+TEST_P(StringUtilityTrimRight, TrimRight) {
     auto [input, output] = GetParam();
     EXPECT_EQ(plssvm::detail::trim_right(input), output);
 }
@@ -98,7 +98,7 @@ INSTANTIATE_TEST_SUITE_P(StringUtility, StringUtilityTrimRight, ::testing::Value
 // test trim
 class StringUtilityTrim : public StringUtilityBase { };
 
-TEST_P(StringUtilityTrim, trim) {
+TEST_P(StringUtilityTrim, Trim) {
     auto [input, output] = GetParam();
     EXPECT_EQ(plssvm::detail::trim(input), output);
 }
@@ -115,12 +115,12 @@ INSTANTIATE_TEST_SUITE_P(StringUtility, StringUtilityTrim, ::testing::Values(
 // test conversion to lower case
 class StringUtilityConvertLowerCase : public StringUtilityBase { };
 
-TEST_P(StringUtilityConvertLowerCase, to_lower_case) {
+TEST_P(StringUtilityConvertLowerCase, ToLowerCase) {
     auto [input, output] = GetParam();
     EXPECT_EQ(plssvm::detail::to_lower_case(input), output);
 }
 
-TEST_P(StringUtilityConvertLowerCase, as_lower_case) {
+TEST_P(StringUtilityConvertLowerCase, AsLowerCase) {
     auto [input, output] = GetParam();
     EXPECT_EQ(plssvm::detail::as_lower_case(input), output);
 }
@@ -135,12 +135,12 @@ INSTANTIATE_TEST_SUITE_P(StringUtility, StringUtilityConvertLowerCase, ::testing
 // test conversion to upper case
 class StringUtilityConvertUpperCase : public StringUtilityBase { };
 
-TEST_P(StringUtilityConvertUpperCase, to_upper_case) {
+TEST_P(StringUtilityConvertUpperCase, ToUpperCase) {
     auto [input, output] = GetParam();
     EXPECT_EQ(plssvm::detail::to_upper_case(input), output);
 }
 
-TEST_P(StringUtilityConvertUpperCase, as_upper_case) {
+TEST_P(StringUtilityConvertUpperCase, AsUpperCase) {
     auto [input, output] = GetParam();
     EXPECT_EQ(plssvm::detail::as_upper_case(input), output);
 }
@@ -155,7 +155,7 @@ INSTANTIATE_TEST_SUITE_P(StringUtility, StringUtilityConvertUpperCase, ::testing
 // test replace_all
 class StringUtilityReplace : public ::testing::TestWithParam<std::tuple<std::string, std::string_view, std::string_view, std::string_view>> { };
 
-TEST_P(StringUtilityReplace, replace_all) {
+TEST_P(StringUtilityReplace, ReplaceAll) {
     auto [input, what, with, output] = GetParam();
     EXPECT_EQ(plssvm::detail::replace_all(input, what, with), output);
 }
@@ -169,7 +169,7 @@ INSTANTIATE_TEST_SUITE_P(StringUtility, StringUtilityReplace, ::testing::Values(
                 naming::pretty_print_replace<StringUtilityReplace>);
 // clang-format on
 
-TEST(StringUtility, split_default_delimiter) {
+TEST(StringUtility, SplitDefaultDelimiter) {
     // split string using the default delimiter
     const std::string string_to_split = "1.5 2.0 -3.5 4.0 5.0 -6.0  7.5";
 
@@ -181,7 +181,7 @@ TEST(StringUtility, split_default_delimiter) {
     }
 }
 
-TEST(StringUtility, split_custom_delimiter) {
+TEST(StringUtility, SplitCustomDelimiter) {
     // split string using a custom delimiter
     const std::string string_to_split = "1.5,2.0,-3.5,4.0,5.0,-6.0,,7.5";
 
@@ -193,14 +193,14 @@ TEST(StringUtility, split_custom_delimiter) {
     }
 }
 
-TEST(StringUtility, split_single_value) {
+TEST(StringUtility, SplitSingleValue) {
     // split string containing a single value
     const std::vector<std::string_view> split = plssvm::detail::split("42");
     ASSERT_EQ(split.size(), 1);
     EXPECT_EQ(split.front(), "42") << fmt::format("split: {}, correct: 42", split.front());
 }
 
-TEST(StringUtility, split_empty_string) {
+TEST(StringUtility, SplitEmptyString) {
     // split the empty string
     const std::vector<std::string_view> split = plssvm::detail::split("");
     EXPECT_TRUE(split.empty());
diff --git a/tests/detail/tracking/events.cpp b/tests/detail/tracking/events.cpp
index 9c9baad82..59cbe82fc 100644
--- a/tests/detail/tracking/events.cpp
+++ b/tests/detail/tracking/events.cpp
@@ -27,7 +27,7 @@
 class Event : public ::testing::Test,
               protected util::redirect_output<> { };
 
-TEST_F(Event, construct) {
+TEST_F(Event, Construct) {
     const std::chrono::steady_clock::time_point time = std::chrono::steady_clock::now();
 
     // construct an event
@@ -38,7 +38,7 @@ TEST_F(Event, construct) {
     EXPECT_EQ(e.name, std::string{ "EVENT" });
 }
 
-TEST_F(Event, output_operator) {
+TEST_F(Event, OutputOperator) {
     const std::chrono::steady_clock::time_point time = std::chrono::steady_clock::now();
 
     // construct an event
@@ -55,7 +55,7 @@ TEST_F(Event, output_operator) {
 class Events : public ::testing::Test,
                protected util::redirect_output<&std::cout> { };
 
-TEST_F(Events, construct) {
+TEST_F(Events, Construct) {
     // default construct an events wrapper
     const plssvm::detail::tracking::events events{};
 
@@ -63,7 +63,7 @@ TEST_F(Events, construct) {
     EXPECT_TRUE(events.empty());
 }
 
-TEST_F(Events, add_event) {
+TEST_F(Events, AddEvent) {
     // create events wrapper
     plssvm::detail::tracking::events events{};
 
@@ -80,7 +80,7 @@ TEST_F(Events, add_event) {
     EXPECT_EQ(events[0].name, e.name);
 }
 
-TEST_F(Events, add_event_with_time_point_and_name) {
+TEST_F(Events, AddEventWithTimePointAndName) {
     // create events wrapper
     plssvm::detail::tracking::events events{};
 
@@ -97,7 +97,7 @@ TEST_F(Events, add_event_with_time_point_and_name) {
     EXPECT_EQ(events[0].name, std::string{ "EVENT" });
 }
 
-TEST_F(Events, get_event_by_index) {
+TEST_F(Events, GetEventByIndex) {
     const std::chrono::steady_clock::time_point time1 = std::chrono::steady_clock::now();
     const std::chrono::steady_clock::time_point time2 = std::chrono::steady_clock::now();
     // create events wrapper and add events
@@ -114,7 +114,7 @@ TEST_F(Events, get_event_by_index) {
     EXPECT_EQ(events[1].name, std::string{ "EVENT_2" });
 }
 
-TEST_F(Events, get_event_at_index) {
+TEST_F(Events, GetEventAtIndex) {
     const std::chrono::steady_clock::time_point time1 = std::chrono::steady_clock::now();
     const std::chrono::steady_clock::time_point time2 = std::chrono::steady_clock::now();
     // create events wrapper and add events
@@ -131,14 +131,14 @@ TEST_F(Events, get_event_at_index) {
     EXPECT_EQ(events.at(1).name, std::string{ "EVENT_2" });
 }
 
-TEST_F(Events, get_event_at_index_out_of_bounce) {
+TEST_F(Events, GetEventAtIndexOutOfBounce) {
     // create events wrapper
     const plssvm::detail::tracking::events events{};
 
     EXPECT_THROW_WHAT(std::ignore = events.at(0), plssvm::exception, "Index 0 is out-of-bounce for the number of events 0!");
 }
 
-TEST_F(Events, num_events) {
+TEST_F(Events, NumEvents) {
     // create events wrapper
     plssvm::detail::tracking::events events{};
 
@@ -152,7 +152,7 @@ TEST_F(Events, num_events) {
     EXPECT_EQ(events.num_events(), 1);
 }
 
-TEST_F(Events, empty) {
+TEST_F(Events, Empty) {
     // create events wrapper
     plssvm::detail::tracking::events events{};
 
@@ -166,7 +166,7 @@ TEST_F(Events, empty) {
     EXPECT_FALSE(events.empty());
 }
 
-TEST_F(Events, get_time_points) {
+TEST_F(Events, GetTimePoints) {
     const std::chrono::steady_clock::time_point time1 = std::chrono::steady_clock::now();
     const std::chrono::steady_clock::time_point time2 = std::chrono::steady_clock::now();
     // create events wrapper and add events
@@ -179,7 +179,7 @@ TEST_F(Events, get_time_points) {
     EXPECT_EQ(events.get_time_points(), (std::vector<std::chrono::steady_clock::time_point>{ time1, time2 }));
 }
 
-TEST_F(Events, get_names) {
+TEST_F(Events, GetNames) {
     const std::chrono::steady_clock::time_point time1 = std::chrono::steady_clock::now();
     const std::chrono::steady_clock::time_point time2 = std::chrono::steady_clock::now();
     // create events wrapper and add events
@@ -192,7 +192,7 @@ TEST_F(Events, get_names) {
     EXPECT_EQ(events.get_names(), (std::vector<std::string>{ "EVENT_1", "EVENT_2" }));
 }
 
-TEST_F(Events, generate_yaml_string) {
+TEST_F(Events, GenerateYAMLString) {
     const std::chrono::steady_clock::time_point time1 = std::chrono::steady_clock::now();
     const std::chrono::steady_clock::time_point time2 = std::chrono::steady_clock::now();
     // create events wrapper and add events
@@ -212,9 +212,9 @@ TEST_F(Events, generate_yaml_string) {
     EXPECT_EQ(yaml, correct_yaml);
 }
 
-TEST_F(Events, generate_yaml_string_no_events) {
+TEST_F(Events, GenerateYAMLStringNoEvents) {
     // create events wrapper
-    plssvm::detail::tracking::events events{};
+    const plssvm::detail::tracking::events events{};
 
     // get the YAML string
     const std::string yaml = events.generate_yaml_string(std::chrono::steady_clock::now());
@@ -223,7 +223,7 @@ TEST_F(Events, generate_yaml_string_no_events) {
     EXPECT_EQ(yaml, std::string{});
 }
 
-TEST_F(Events, output_operator) {
+TEST_F(Events, OutputOperator) {
     const std::chrono::steady_clock::time_point time1 = std::chrono::steady_clock::now();
     const std::chrono::steady_clock::time_point time2 = std::chrono::steady_clock::now();
     // create events wrapper and add events
@@ -241,7 +241,7 @@ TEST_F(Events, output_operator) {
 
 class EventsDeathTest : public Events { };
 
-TEST_F(EventsDeathTest, get_event_by_index_out_of_bounce) {
+TEST_F(EventsDeathTest, GetEventByIndexOutOfBounce) {
     // create events wrapper
     const plssvm::detail::tracking::events events{};
 
diff --git a/tests/detail/tracking/performance_tracker.cpp b/tests/detail/tracking/performance_tracker.cpp
index 31a0c3d83..555dd526b 100644
--- a/tests/detail/tracking/performance_tracker.cpp
+++ b/tests/detail/tracking/performance_tracker.cpp
@@ -34,9 +34,10 @@
 #include <iostream>    // std::cout, std::clog
 #include <map>         // std::map
 #include <string>      // std::string
+#include <utility>     // std::move
 #include <vector>      // std::vector
 
-using namespace plssvm::detail::literals;
+using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
 
 template <typename T>
 class TrackingEntry : public ::testing::Test,
@@ -47,7 +48,7 @@ class TrackingEntry : public ::testing::Test,
 
 TYPED_TEST_SUITE(TrackingEntry, util::label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(TrackingEntry, construct) {
+TYPED_TEST(TrackingEntry, Construct) {
     using type = typename TestFixture::fixture_type;
 
     // construct a tracking entry
@@ -59,7 +60,7 @@ TYPED_TEST(TrackingEntry, construct) {
     EXPECT_EQ(e.entry_value, type{});
 }
 
-TYPED_TEST(TrackingEntry, output_operator) {
+TYPED_TEST(TrackingEntry, OutputOperator) {
     using type = typename TestFixture::fixture_type;
 
     // construct a tracking entry
@@ -72,7 +73,7 @@ TYPED_TEST(TrackingEntry, output_operator) {
     EXPECT_EQ(this->get_capture(), fmt::format("{}", type{}));
 }
 
-TEST(TrackingEntry, is_tracking_entry) {
+TEST(TrackingEntry, IsTrackingEntry) {
     // check whether the provided type is a tracking entry or not, ignoring any top-level const, reference, and volatile qualifiers
     EXPECT_TRUE(plssvm::detail::tracking::is_tracking_entry<plssvm::detail::tracking::tracking_entry<int>>::value);
     EXPECT_TRUE(plssvm::detail::tracking::is_tracking_entry_v<plssvm::detail::tracking::tracking_entry<int>>);
@@ -82,7 +83,7 @@ TEST(TrackingEntry, is_tracking_entry) {
     EXPECT_TRUE(plssvm::detail::tracking::is_tracking_entry_v<plssvm::detail::tracking::tracking_entry<std::string>>);
 }
 
-TEST(TrackingEntry, is_no_tracking_entry) {
+TEST(TrackingEntry, IsNoTrackingEntry) {
     // the following types are NOT tracking entries
     EXPECT_FALSE(plssvm::detail::tracking::is_tracking_entry<int>::value);
     EXPECT_FALSE(plssvm::detail::tracking::is_tracking_entry_v<int>);
@@ -107,10 +108,10 @@ class PerformanceTracker : public ::testing::Test,
     }
 
   private:
-    plssvm::detail::tracking::performance_tracker tracker_{};
+    plssvm::detail::tracking::performance_tracker tracker_;
 };
 
-TEST_F(PerformanceTracker, copy_construct) {
+TEST_F(PerformanceTracker, CopyConstruct) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -135,7 +136,7 @@ TEST_F(PerformanceTracker, copy_construct) {
     EXPECT_EQ(tracker2.is_tracking(), tracker.is_tracking());
 }
 
-TEST_F(PerformanceTracker, move_construct) {
+TEST_F(PerformanceTracker, MoveConstruct) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -166,11 +167,13 @@ TEST_F(PerformanceTracker, move_construct) {
     EXPECT_EQ(tracker2.is_tracking(), is_tracking);
 
     // check moved-from state
+    // NOLINTBEGIN: use after move wanted since this is tested here
     EXPECT_TRUE(tracker.get_tracking_entries().empty());
     EXPECT_TRUE(tracker.get_events().empty());
+    // NOLINTEND
 }
 
-TEST_F(PerformanceTracker, copy_assign) {
+TEST_F(PerformanceTracker, CopyAssign) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -196,7 +199,7 @@ TEST_F(PerformanceTracker, copy_assign) {
     EXPECT_EQ(tracker2.is_tracking(), tracker.is_tracking());
 }
 
-TEST_F(PerformanceTracker, move_assign) {
+TEST_F(PerformanceTracker, MoveAssign) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -228,14 +231,16 @@ TEST_F(PerformanceTracker, move_assign) {
     EXPECT_EQ(tracker2.is_tracking(), is_tracking);
 
     // check moved-from state
+    // NOLINTBEGIN: use after move wanted since this is tested here
     EXPECT_TRUE(tracker.get_tracking_entries().empty());
     EXPECT_TRUE(tracker.get_events().empty());
+    // NOLINTEND
 }
 
 // the macros are only available if PLSSVM_PERFORMANCE_TRACKER_ENABLED is defined!
 #if defined(PLSSVM_PERFORMANCE_TRACKER_ENABLED)
 
-TEST_F(PerformanceTracker, pause_and_resume_macros) {
+TEST_F(PerformanceTracker, PauseAndResumeMacros) {
     // tracking is enabled per default
     EXPECT_TRUE(plssvm::detail::tracking::global_performance_tracker().is_tracking());
     // disable performance tracking
@@ -248,7 +253,7 @@ TEST_F(PerformanceTracker, pause_and_resume_macros) {
     EXPECT_TRUE(plssvm::detail::tracking::global_performance_tracker().is_tracking());
 }
 
-TEST_F(PerformanceTracker, save_macro) {
+TEST_F(PerformanceTracker, SaveMacro) {
     // create temporary file
     const util::temporary_file tmp_file{};  // automatically removes the created file at the end of its scope
     // save entries to file
@@ -280,7 +285,7 @@ TEST_F(PerformanceTracker, save_macro) {
     plssvm::detail::tracking::global_performance_tracker().clear_tracking_entries();
 }
 
-TEST_F(PerformanceTracker, set_reference_time_macro) {
+TEST_F(PerformanceTracker, SetReferenceTimeMacro) {
     // set the new reference time
     const std::chrono::steady_clock::time_point ref_time = std::chrono::steady_clock::now();
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_SET_REFERENCE_TIME(ref_time);
@@ -289,7 +294,7 @@ TEST_F(PerformanceTracker, set_reference_time_macro) {
     EXPECT_EQ(plssvm::detail::tracking::global_performance_tracker().get_reference_time(), ref_time);
 }
 
-TEST_F(PerformanceTracker, add_entry_macro) {
+TEST_F(PerformanceTracker, AddEntryMacro) {
     // add different tracking entries
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "foo", "bar", 42 }));
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking::tracking_entry{ "foo", "baz", 3.1415 }));
@@ -321,7 +326,7 @@ TEST_F(PerformanceTracker, add_entry_macro) {
     plssvm::detail::tracking::global_performance_tracker().clear_tracking_entries();
 }
 
-TEST_F(PerformanceTracker, add_event_macro) {
+TEST_F(PerformanceTracker, AddEventMacro) {
     // add different events
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT("event_1");
     PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT("event_2");
@@ -342,7 +347,7 @@ TEST_F(PerformanceTracker, add_event_macro) {
 
 #endif
 
-TEST_F(PerformanceTracker, pause_and_resume) {
+TEST_F(PerformanceTracker, PauseAndResume) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -358,7 +363,7 @@ TEST_F(PerformanceTracker, pause_and_resume) {
     EXPECT_TRUE(tracker.is_tracking());
 }
 
-TEST_F(PerformanceTracker, add_generic_tracking_entry) {
+TEST_F(PerformanceTracker, AddGenericTrackingEntry) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -390,7 +395,7 @@ TEST_F(PerformanceTracker, add_generic_tracking_entry) {
     EXPECT_EQ(entries.at("").at("foobar"), (std::vector<std::string>{ "a", "b" }));
 }
 
-TEST_F(PerformanceTracker, add_string_tracking_entry) {
+TEST_F(PerformanceTracker, AddStringTrackingEntry) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -408,7 +413,7 @@ TEST_F(PerformanceTracker, add_string_tracking_entry) {
     EXPECT_EQ(entries.at("foo").at("bar").front(), "\"baz\"");
 }
 
-TEST_F(PerformanceTracker, add_vector_tracking_entry) {
+TEST_F(PerformanceTracker, AddVectorTrackingEntry) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -427,7 +432,7 @@ TEST_F(PerformanceTracker, add_vector_tracking_entry) {
     EXPECT_EQ(entries.at("foo").at("bar"), (std::vector<std::string>{ "[1, 2, 3]", "[\"a\", \"b\"]" }));
 }
 
-TEST_F(PerformanceTracker, add_parameter_tracking_entry) {
+TEST_F(PerformanceTracker, AddParameterTrackingEntry) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -443,7 +448,7 @@ TEST_F(PerformanceTracker, add_parameter_tracking_entry) {
     ASSERT_EQ(entries.at("parameter").size(), 6);
 }
 
-TEST_F(PerformanceTracker, add_parser_train_tracking_entry) {
+TEST_F(PerformanceTracker, AddParserTrainTrackingEntry) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -467,7 +472,7 @@ TEST_F(PerformanceTracker, add_parser_train_tracking_entry) {
     ASSERT_EQ(entries.at("parameter").size(), 18);
 }
 
-TEST_F(PerformanceTracker, add_parser_predict_tracking_entry) {
+TEST_F(PerformanceTracker, AddParserPredictTrackingEntry) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -488,10 +493,10 @@ TEST_F(PerformanceTracker, add_parser_predict_tracking_entry) {
     // check entries for correctness
     EXPECT_EQ(entries.size(), 1);
 
-    ASSERT_EQ(entries.at("parameter").size(), 10);
+    ASSERT_EQ(entries.at("parameter").size(), 11);
 }
 
-TEST_F(PerformanceTracker, add_parser_scale_tracking_entry) {
+TEST_F(PerformanceTracker, AddParserScaleTrackingEntry) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -515,7 +520,7 @@ TEST_F(PerformanceTracker, add_parser_scale_tracking_entry) {
     ASSERT_EQ(entries.at("parameter").size(), 10);
 }
 
-TEST_F(PerformanceTracker, add_event) {
+TEST_F(PerformanceTracker, AddEvent) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -527,7 +532,7 @@ TEST_F(PerformanceTracker, add_event) {
     EXPECT_EQ(tracker.get_events()[0].name, std::string{ "EVENT" });
 }
 
-TEST_F(PerformanceTracker, set_reference_time) {
+TEST_F(PerformanceTracker, SetReferenceTime) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -539,7 +544,7 @@ TEST_F(PerformanceTracker, set_reference_time) {
     EXPECT_EQ(tracker.get_reference_time(), ref_time);
 }
 
-TEST_F(PerformanceTracker, get_reference_time) {
+TEST_F(PerformanceTracker, GetReferenceTime) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -551,7 +556,7 @@ TEST_F(PerformanceTracker, get_reference_time) {
     EXPECT_EQ(tracker.get_reference_time(), ref_time);
 }
 
-TEST_F(PerformanceTracker, save_no_additional_entries) {
+TEST_F(PerformanceTracker, SaveNoAdditionalEntries) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -567,7 +572,7 @@ TEST_F(PerformanceTracker, save_no_additional_entries) {
     EXPECT_TRUE(tracker.get_tracking_entries().empty());
 }
 
-TEST_F(PerformanceTracker, save_entries_to_file) {
+TEST_F(PerformanceTracker, SaveEntriesToFile) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -603,7 +608,7 @@ TEST_F(PerformanceTracker, save_entries_to_file) {
     EXPECT_EQ(tracker.get_tracking_entries().size(), 3);
 }
 
-TEST_F(PerformanceTracker, save_entries_empty_file) {
+TEST_F(PerformanceTracker, SaveEntriesEmptyFile) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -634,7 +639,7 @@ TEST_F(PerformanceTracker, save_entries_empty_file) {
     EXPECT_EQ(tracker.get_tracking_entries().size(), 3);
 }
 
-TEST_F(PerformanceTracker, get_tracking_entries) {
+TEST_F(PerformanceTracker, GetTrackingEntries) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -662,7 +667,7 @@ TEST_F(PerformanceTracker, get_tracking_entries) {
     ASSERT_EQ(entries.at("").at("foobar").size(), 2);
 }
 
-TEST_F(PerformanceTracker, get_events) {
+TEST_F(PerformanceTracker, GetEvents) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
@@ -687,7 +692,7 @@ TEST_F(PerformanceTracker, get_events) {
     EXPECT_GE(events[2].time_point, events[1].time_point);
 }
 
-TEST_F(PerformanceTracker, clear_tracking_entries) {
+TEST_F(PerformanceTracker, ClearTrackingEntries) {
     // get performance tracker from fixture class
     plssvm::detail::tracking::performance_tracker &tracker = this->get_performance_tracker();
 
diff --git a/tests/detail/tracking/utility.cpp b/tests/detail/tracking/utility.cpp
index 5893fb17e..f4ef43f46 100644
--- a/tests/detail/tracking/utility.cpp
+++ b/tests/detail/tracking/utility.cpp
@@ -10,16 +10,13 @@
 
 #include "plssvm/detail/tracking/utility.hpp"
 
-#include "gtest/gtest.h"  // TEST, ASSERT_EQ, EXPECT_EQ, ::testing::StaticAssertTypeEq
+#include "gtest/gtest.h"  // TEST, ASSERT_EQ, EXPECT_EQ
 
-#include <chrono>       // std::chrono::steady_clock::{time_point, now}, std::chrono::milliseconds
-#include <cstddef>      // std::size_t
-#include <optional>     // std::optional, std::nullopt
-#include <string>       // std::string
-#include <type_traits>  // std::result_of_t
-#include <vector>       // std::vector
+#include <chrono>   // std::chrono::steady_clock::{time_point, now}, std::chrono::milliseconds, std::chrono literals
+#include <cstddef>  // std::size_t
+#include <vector>   // std::vector
 
-TEST(TrackingUtility, durations_from_reference_time) {
+TEST(TrackingUtility, DurationsFromReferenceTime) {
     // create different time points
     std::vector<std::chrono::steady_clock::time_point> time_points{ std::chrono::steady_clock::now() };
     for (std::size_t i = 0; i < 3; ++i) {
@@ -30,12 +27,12 @@ TEST(TrackingUtility, durations_from_reference_time) {
     const std::vector<std::chrono::milliseconds> durations = plssvm::detail::tracking::durations_from_reference_time(time_points, time_points.front());
 
     // check the durations
-    using namespace std::chrono_literals;
+    using namespace std::chrono_literals;  // NOLINT: included via <chrono>
     ASSERT_EQ(durations.size(), 4);
-    EXPECT_EQ(durations, (std::vector<std::chrono::milliseconds>{ 0ms, 50ms, 100ms, 150ms }));
+    EXPECT_EQ(durations, (std::vector<std::chrono::milliseconds>{ 0ms, 50ms, 100ms, 150ms }));  // NOLINT(misc-include-cleaner): included via <chrono>
 }
 
-TEST(TrackingUtility, time_points_to_epoch) {
+TEST(TrackingUtility, TimePointsToEpoch) {
     // create different time points
     std::vector<std::chrono::steady_clock::time_point> time_points{ std::chrono::steady_clock::now() };
     for (std::size_t i = 0; i < 3; ++i) {
diff --git a/tests/detail/type_traits.cpp b/tests/detail/type_traits.cpp
index 6fd7ef630..305597b77 100644
--- a/tests/detail/type_traits.cpp
+++ b/tests/detail/type_traits.cpp
@@ -10,14 +10,16 @@
 
 #include "plssvm/detail/type_traits.hpp"
 
-#include "gmock/gmock.h"  // EXPECT_THAT, ::testing::{HasSubstr, ContainsRegex}
 #include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_TRUE, EXPECT_FALSE
 
 #include <array>          // std::array
+#include <cstddef>        // std::nullptr_t
 #include <deque>          // std::deque
 #include <forward_list>   // std::forward_list
+#include <functional>     // std::reference_wrapper
 #include <list>           // std::list
 #include <map>            // std::map, std::multimap
+#include <optional>       // std::optional
 #include <set>            // std::set, std::multiset
 #include <string>         // std::basic_string
 #include <type_traits>    // std::is_same_v
@@ -25,13 +27,19 @@
 #include <unordered_set>  // std::unordered_set, std::unordered_multiset
 #include <vector>         // std::vector
 
-TEST(TypeTraits, always_false) {
+TEST(TypeTraits, AlwaysFalse) {
     EXPECT_FALSE(plssvm::detail::always_false_v<void>);
     EXPECT_FALSE(plssvm::detail::always_false_v<int>);
     EXPECT_FALSE(plssvm::detail::always_false_v<double>);
 }
 
-TEST(TypeTraits, remove_cvref_t) {
+TEST(TypeTraits, AlwaysFalseNonType) {
+    EXPECT_FALSE(plssvm::detail::always_false_non_type_v<42>);
+    EXPECT_FALSE(plssvm::detail::always_false_non_type_v<'a'>);
+    EXPECT_FALSE(plssvm::detail::always_false_non_type_v<true>);
+}
+
+TEST(TypeTraits, RemoveCvrefT) {
     EXPECT_TRUE((std::is_same_v<double, plssvm::detail::remove_cvref_t<double>>) );
     EXPECT_TRUE((std::is_same_v<double, plssvm::detail::remove_cvref_t<const double>>) );
     EXPECT_TRUE((std::is_same_v<double, plssvm::detail::remove_cvref_t<volatile double>>) );
@@ -42,7 +50,7 @@ TEST(TypeTraits, remove_cvref_t) {
     EXPECT_TRUE((std::is_same_v<double, plssvm::detail::remove_cvref_t<const volatile double &>>) );
 }
 
-TEST(TypeTraits, is_string) {
+TEST(TypeTraits, IsString) {
     // sequence containers
     EXPECT_TRUE((plssvm::detail::is_string_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_string_v<std::array<int, 2>>) );
@@ -61,10 +69,10 @@ TEST(TypeTraits, is_string) {
     EXPECT_FALSE((plssvm::detail::is_string_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_string_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_string_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_string_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_array) {
+TEST(TypeTraits, IsArray) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_array_v<std::string>) );
     EXPECT_TRUE((plssvm::detail::is_array_v<std::array<int, 2>>) );
@@ -83,10 +91,10 @@ TEST(TypeTraits, is_array) {
     EXPECT_FALSE((plssvm::detail::is_array_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_array_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_array_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_array_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_vector) {
+TEST(TypeTraits, IsVector) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_vector_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_vector_v<std::array<int, 2>>) );
@@ -105,10 +113,10 @@ TEST(TypeTraits, is_vector) {
     EXPECT_FALSE((plssvm::detail::is_vector_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_vector_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_vector_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_vector_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_deque) {
+TEST(TypeTraits, IsDeque) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_deque_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_deque_v<std::array<int, 2>>) );
@@ -127,10 +135,10 @@ TEST(TypeTraits, is_deque) {
     EXPECT_FALSE((plssvm::detail::is_deque_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_deque_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_deque_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_deque_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_forward_list) {
+TEST(TypeTraits, IsForwardList) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_forward_list_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_forward_list_v<std::array<int, 2>>) );
@@ -149,10 +157,10 @@ TEST(TypeTraits, is_forward_list) {
     EXPECT_FALSE((plssvm::detail::is_forward_list_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_forward_list_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_forward_list_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_forward_list_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_list) {
+TEST(TypeTraits, IsList) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_list_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_list_v<std::array<int, 2>>) );
@@ -171,10 +179,10 @@ TEST(TypeTraits, is_list) {
     EXPECT_FALSE((plssvm::detail::is_list_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_list_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_list_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_list_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_set) {
+TEST(TypeTraits, IsSet) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_set_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_set_v<std::array<int, 2>>) );
@@ -193,10 +201,10 @@ TEST(TypeTraits, is_set) {
     EXPECT_FALSE((plssvm::detail::is_set_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_set_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_set_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_set_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_map) {
+TEST(TypeTraits, IsMap) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_map_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_map_v<std::array<int, 2>>) );
@@ -215,10 +223,10 @@ TEST(TypeTraits, is_map) {
     EXPECT_FALSE((plssvm::detail::is_map_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_map_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_map_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_map_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_multiset) {
+TEST(TypeTraits, IsMultiset) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_multiset_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_multiset_v<std::array<int, 2>>) );
@@ -237,10 +245,10 @@ TEST(TypeTraits, is_multiset) {
     EXPECT_FALSE((plssvm::detail::is_multiset_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_multiset_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_multiset_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_multiset_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_multimap) {
+TEST(TypeTraits, IsMultimap) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_multimap_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_multimap_v<std::array<int, 2>>) );
@@ -259,10 +267,10 @@ TEST(TypeTraits, is_multimap) {
     EXPECT_FALSE((plssvm::detail::is_multimap_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_multimap_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_multimap_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_multimap_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_unordered_set) {
+TEST(TypeTraits, IsUnorderedSet) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_unordered_set_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_unordered_set_v<std::array<int, 2>>) );
@@ -281,10 +289,10 @@ TEST(TypeTraits, is_unordered_set) {
     EXPECT_FALSE((plssvm::detail::is_unordered_set_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_unordered_set_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_unordered_set_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_unordered_set_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_unordered_map) {
+TEST(TypeTraits, IsUnorderedMap) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_unordered_map_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_unordered_map_v<std::array<int, 2>>) );
@@ -303,10 +311,10 @@ TEST(TypeTraits, is_unordered_map) {
     EXPECT_FALSE((plssvm::detail::is_unordered_map_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_unordered_map_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_unordered_map_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_unordered_map_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_unordered_multiset) {
+TEST(TypeTraits, IsUnorderedMultiset) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_unordered_multiset_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_unordered_multiset_v<std::array<int, 2>>) );
@@ -325,10 +333,10 @@ TEST(TypeTraits, is_unordered_multiset) {
     EXPECT_TRUE((plssvm::detail::is_unordered_multiset_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_unordered_multiset_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_unordered_multiset_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_unordered_multiset_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_unordered_multimap) {
+TEST(TypeTraits, IsUnorderedMultimap) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_unordered_multimap_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_unordered_multimap_v<std::array<int, 2>>) );
@@ -347,10 +355,10 @@ TEST(TypeTraits, is_unordered_multimap) {
     EXPECT_FALSE((plssvm::detail::is_unordered_multimap_v<std::unordered_multiset<int>>) );
     EXPECT_TRUE((plssvm::detail::is_unordered_multimap_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_unordered_multimap_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_unordered_multimap_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_contiguous_container) {
+TEST(TypeTraits, IsContiguousContainer) {
     // sequence containers
     EXPECT_TRUE((plssvm::detail::is_contiguous_container_v<std::string>) );
     EXPECT_TRUE((plssvm::detail::is_contiguous_container_v<std::array<int, 2>>) );
@@ -369,10 +377,10 @@ TEST(TypeTraits, is_contiguous_container) {
     EXPECT_FALSE((plssvm::detail::is_contiguous_container_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_contiguous_container_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_contiguous_container_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_contiguous_container_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_sequence_container) {
+TEST(TypeTraits, IsSequenceContainer) {
     // sequence containers
     EXPECT_TRUE((plssvm::detail::is_sequence_container_v<std::string>) );
     EXPECT_TRUE((plssvm::detail::is_sequence_container_v<std::array<int, 2>>) );
@@ -391,10 +399,10 @@ TEST(TypeTraits, is_sequence_container) {
     EXPECT_FALSE((plssvm::detail::is_sequence_container_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_sequence_container_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_sequence_container_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_sequence_container_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_associative_container) {
+TEST(TypeTraits, IsAssociativeContainer) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_associative_container_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_associative_container_v<std::array<int, 2>>) );
@@ -413,10 +421,10 @@ TEST(TypeTraits, is_associative_container) {
     EXPECT_FALSE((plssvm::detail::is_associative_container_v<std::unordered_multiset<int>>) );
     EXPECT_FALSE((plssvm::detail::is_associative_container_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_associative_container_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_associative_container_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_unordered_associative_container) {
+TEST(TypeTraits, IsUnorderedAssociativeContainer) {
     // sequence containers
     EXPECT_FALSE((plssvm::detail::is_unordered_associative_container_v<std::string>) );
     EXPECT_FALSE((plssvm::detail::is_unordered_associative_container_v<std::array<int, 2>>) );
@@ -435,10 +443,10 @@ TEST(TypeTraits, is_unordered_associative_container) {
     EXPECT_TRUE((plssvm::detail::is_unordered_associative_container_v<std::unordered_multiset<int>>) );
     EXPECT_TRUE((plssvm::detail::is_unordered_associative_container_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_unordered_associative_container_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_unordered_associative_container_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
 }
 
-TEST(TypeTraits, is_container) {
+TEST(TypeTraits, IsContainer) {
     // sequence containers
     EXPECT_TRUE((plssvm::detail::is_container_v<std::string>) );
     EXPECT_TRUE((plssvm::detail::is_container_v<std::array<int, 2>>) );
@@ -457,5 +465,37 @@ TEST(TypeTraits, is_container) {
     EXPECT_TRUE((plssvm::detail::is_container_v<std::unordered_multiset<int>>) );
     EXPECT_TRUE((plssvm::detail::is_container_v<std::unordered_multimap<int, int>>) );
     // other
-    EXPECT_FALSE((plssvm::detail::is_container_v<int[2]>) );
+    EXPECT_FALSE((plssvm::detail::is_container_v<int[2]>) );  // NOLINT: using a C-style array is part of the test and necessary
+}
+
+TEST(TypeTraits, IsOptional) {
+    // optionals
+    EXPECT_TRUE((plssvm::detail::is_optional_v<std::optional<int>>) );
+    EXPECT_TRUE((plssvm::detail::is_optional_v<std::optional<double>>) );
+    EXPECT_TRUE((plssvm::detail::is_optional_v<std::optional<std::string>>) );
+    EXPECT_TRUE((plssvm::detail::is_optional_v<std::optional<std::reference_wrapper<std::vector<double>>>>) );
+    // no optionals
+    EXPECT_FALSE((plssvm::detail::is_optional_v<int>) );
+    EXPECT_FALSE((plssvm::detail::is_optional_v<std::nullptr_t>) );
+    EXPECT_FALSE((plssvm::detail::is_optional_v<std::string>) );
+    EXPECT_FALSE((plssvm::detail::is_optional_v<std::vector<int>>) );
+}
+
+TEST(TypeTraits, IsReferenceWrapper) {
+    // reference wrapper
+    EXPECT_TRUE((plssvm::detail::is_reference_wrapper_v<std::reference_wrapper<int>>) );
+    EXPECT_TRUE((plssvm::detail::is_reference_wrapper_v<std::reference_wrapper<double>>) );
+    EXPECT_TRUE((plssvm::detail::is_reference_wrapper_v<std::reference_wrapper<std::string>>) );
+    EXPECT_TRUE((plssvm::detail::is_reference_wrapper_v<std::reference_wrapper<std::vector<double>>>) );
+    // no reference wrapper
+    EXPECT_FALSE((plssvm::detail::is_reference_wrapper_v<int>) );
+    EXPECT_FALSE((plssvm::detail::is_reference_wrapper_v<std::nullptr_t>) );
+    EXPECT_FALSE((plssvm::detail::is_reference_wrapper_v<std::string>) );
+    EXPECT_FALSE((plssvm::detail::is_reference_wrapper_v<std::vector<int>>) );
+}
+
+TEST(TypeTrais, IsOneTypeOf) {
+    EXPECT_TRUE((plssvm::detail::is_one_type_of_v<double, float, double, long double>) );
+    EXPECT_TRUE((plssvm::detail::is_one_type_of_v<int, char, short, int, long, long long>) );
+    EXPECT_FALSE((plssvm::detail::is_one_type_of_v<char, bool, std::string>) );
 }
diff --git a/tests/detail/utility.cpp b/tests/detail/utility.cpp
index 25cfb8fcc..a33c410a1 100644
--- a/tests/detail/utility.cpp
+++ b/tests/detail/utility.cpp
@@ -10,13 +10,20 @@
 
 #include "plssvm/detail/utility.hpp"
 
-#include "tests/naming.hpp"         // naming::{test_parameter_to_name}
-#include "tests/types_to_test.hpp"  // util::{combine_test_parameters_gtest_t, cartesian_type_product_t, test_parameter_type_at_t}
+#include "plssvm/constants.hpp"                 // plssvm::THREAD_BLOCK_SIZE, plssvm::INTERNAL_BLOCK_SIZE
+#include "plssvm/detail/data_distribution.hpp"  // plssvm::detail::data_distribution::maximum_local_memory_needed
+#include "plssvm/detail/memory_size.hpp"        // plssvm::detail::memory_size
+#include "plssvm/exceptions/exceptions.hpp"     // plssvm::kernel_launch_resources
 
-#include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
-#include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_TRUE, EXPECT_FALSE, ::testing::Test
+#include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT
+#include "tests/naming.hpp"              // naming::{test_parameter_to_name}
+#include "tests/types_to_test.hpp"       // util::{combine_test_parameters_gtest_t, cartesian_type_product_t, test_parameter_type_at_t}
+
+#include "fmt/format.h"   // fmt::format
+#include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_TRUE, EXPECT_FALSE, EXPECT_NO_THROW, ::testing::Test
 
 #include <map>            // std::map
+#include <optional>       // std::optional, std::nullopt
 #include <regex>          // std::regex, std::regex::extended, std::regex_match
 #include <set>            // std::set
 #include <string>         // std::string
@@ -25,7 +32,11 @@
 #include <unordered_set>  // std::unordered_set
 #include <vector>         // std::vector
 
-TEST(Utility, plssvm_is_defined_macro) {
+#if !defined(_WIN32) && !defined(_WIN64)
+    #include <stdlib.h>  // NOLINT: setenv (not available on Windows)
+#endif
+
+TEST(Utility, PlssvmIsDefinedMacro) {
     // the following macro is ALWAYS defined in PLSSVM
     constexpr bool is_defined = PLSSVM_IS_DEFINED(PLSSVM_BUILD_TYPE);
     EXPECT_TRUE(is_defined);
@@ -35,7 +46,7 @@ TEST(Utility, plssvm_is_defined_macro) {
     EXPECT_FALSE(not_defined);
 }
 
-TEST(Utility, get) {
+TEST(Utility, Get) {
     EXPECT_EQ(plssvm::detail::get<0>(0, 1, 2, 3, 4), 0);
     EXPECT_EQ(plssvm::detail::get<1>(0, 1.5, 2, 3, 4), 1.5);
     EXPECT_EQ(plssvm::detail::get<2>(0, 1, -2, 3, 4), -2);
@@ -43,9 +54,9 @@ TEST(Utility, get) {
     EXPECT_EQ(plssvm::detail::get<4>(0, 1, 2, 3, std::string{ "abc" }), std::string{ "abc" });
 }
 
-TEST(Utility, to_underlying_int) {
+TEST(Utility, ToUnderlyingInt) {
     // clang-format off
-    enum class int_enum { a, b, c = 10 };
+    enum class int_enum { a = 0, b = 1, c = 10 };
     // clang-format on
 
     EXPECT_EQ(plssvm::detail::to_underlying(int_enum::a), 0);
@@ -53,7 +64,7 @@ TEST(Utility, to_underlying_int) {
     EXPECT_EQ(plssvm::detail::to_underlying(int_enum::c), 10);
 }
 
-TEST(Utility, to_underlying_char) {
+TEST(Utility, ToUnderlyingChar) {
     // clang-format off
     enum class char_enum : char { a = 'a', b = 'b', c = 'c' };
     // clang-format on
@@ -95,7 +106,7 @@ class UtilityMapContainer : public ::testing::Test {
 
 TYPED_TEST_SUITE(UtilityMapContainer, map_types_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(UtilityMapContainer, erase_if) {
+TYPED_TEST(UtilityMapContainer, EraseIf) {
     EXPECT_EQ(plssvm::detail::erase_if(this->get_map(), [](const typename TestFixture::map_type::value_type value) { return value.second % 2 == 0; }), 1);
     EXPECT_EQ(this->get_map().size(), 1);
     EXPECT_EQ(plssvm::detail::erase_if(this->get_map(), [](const typename TestFixture::map_type::value_type value) { return value.second % 2 == 0; }), 0);
@@ -104,7 +115,7 @@ TYPED_TEST(UtilityMapContainer, erase_if) {
     EXPECT_TRUE(this->get_map().empty());
 }
 
-TYPED_TEST(UtilityMapContainer, contains) {
+TYPED_TEST(UtilityMapContainer, Contains) {
     EXPECT_TRUE(plssvm::detail::contains(this->get_map(), 0));
     EXPECT_TRUE(plssvm::detail::contains(this->get_map(), 1));
     EXPECT_FALSE(plssvm::detail::contains(this->get_map(), 2));
@@ -143,7 +154,7 @@ class UtilitySetContainer : public ::testing::Test {
 
 TYPED_TEST_SUITE(UtilitySetContainer, set_types_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(UtilitySetContainer, erase_if) {
+TYPED_TEST(UtilitySetContainer, EraseIf) {
     EXPECT_EQ(plssvm::detail::erase_if(this->get_set(), [](const typename TestFixture::set_type::value_type value) { return value % 2 == 0; }), 1);
     EXPECT_EQ(this->get_set().size(), 1);
     EXPECT_EQ(plssvm::detail::erase_if(this->get_set(), [](const typename TestFixture::set_type::value_type value) { return value % 2 == 0; }), 0);
@@ -152,7 +163,7 @@ TYPED_TEST(UtilitySetContainer, erase_if) {
     EXPECT_TRUE(this->get_set().empty());
 }
 
-TYPED_TEST(UtilitySetContainer, contains) {
+TYPED_TEST(UtilitySetContainer, Contains) {
     EXPECT_TRUE(plssvm::detail::contains(this->get_set(), 0));
     EXPECT_TRUE(plssvm::detail::contains(this->get_set(), 1));
     EXPECT_FALSE(plssvm::detail::contains(this->get_set(), 2));
@@ -191,7 +202,7 @@ class UtilityVectorContainer : public ::testing::Test {
 
 TYPED_TEST_SUITE(UtilityVectorContainer, vector_types_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(UtilityVectorContainer, erase_if) {
+TYPED_TEST(UtilityVectorContainer, EraseIf) {
     EXPECT_EQ(plssvm::detail::erase_if(this->get_vector(), [](const typename TestFixture::vector_type::value_type value) { return value % 2 == 0; }), 1);
     EXPECT_EQ(this->get_vector().size(), 1);
     EXPECT_EQ(plssvm::detail::erase_if(this->get_vector(), [](const typename TestFixture::vector_type::value_type value) { return value % 2 == 0; }), 0);
@@ -200,20 +211,79 @@ TYPED_TEST(UtilityVectorContainer, erase_if) {
     EXPECT_TRUE(this->get_vector().empty());
 }
 
-TYPED_TEST(UtilityVectorContainer, contains) {
+TYPED_TEST(UtilityVectorContainer, Contains) {
     EXPECT_TRUE(plssvm::detail::contains(this->get_vector(), 0));
     EXPECT_TRUE(plssvm::detail::contains(this->get_vector(), 1));
     EXPECT_FALSE(plssvm::detail::contains(this->get_vector(), 2));
     EXPECT_FALSE(plssvm::detail::contains(this->get_vector(), -1));
 }
 
-TEST(Utility, current_date_time) {
+TEST(Utility, CheckLocalMemoryUsageNullopt) {
+    // create a std::vector of std::nullopt
+    const std::vector<std::optional<plssvm::detail::memory_size>> available_local_memory{ std::nullopt, std::nullopt };
+
+    // a vector of nullopt means that the "backend" has no notion of local memory
+    // -> the check function must not throw!
+    EXPECT_NO_THROW(plssvm::detail::check_local_memory_usage(available_local_memory));
+}
+
+TEST(Utility, CheckLocalMemoryUsage) {
+    // create a std::vector local memory sizes that will always satisfy the needed amount of local memory
+    constexpr plssvm::detail::memory_size needed_local_memory = plssvm::detail::data_distribution::maximum_local_memory_needed();
+    const std::vector<std::optional<plssvm::detail::memory_size>> available_local_memory{ needed_local_memory * 2, needed_local_memory * 2 };
+
+    // the vector is created such that the requirements are always fulfilled
+    // -> the check function must not throw!
+    EXPECT_NO_THROW(plssvm::detail::check_local_memory_usage(available_local_memory));
+}
+
+TEST(Utility, CheckLocalMemoryUsageTooSmall) {
+    // create a std::vector local memory sizes that will never satisfy the needed amount of local memory
+    constexpr plssvm::detail::memory_size needed_local_memory = plssvm::detail::data_distribution::maximum_local_memory_needed();
+    const std::vector<std::optional<plssvm::detail::memory_size>> available_local_memory{ needed_local_memory / 2, needed_local_memory / 2 };
+
+    // the vector is created such that the requirements are never fulfilled
+    EXPECT_THROW_WHAT(plssvm::detail::check_local_memory_usage(available_local_memory),
+                      plssvm::kernel_launch_resources,
+                      fmt::format("At least {} of local memory must be available for the hyperparameter combination THREAD_BLOCK_SIZE={} and INTERNAL_BLOCK_SIZE={}, but available are only {}!",
+                                  needed_local_memory,
+                                  plssvm::THREAD_BLOCK_SIZE,
+                                  plssvm::INTERNAL_BLOCK_SIZE,
+                                  needed_local_memory / 2));
+}
+
+TEST(UtilityDeathTest, CheckLocalMemoryUsageEmpty) {
+    // create a std::vector of std::nullopt
+    const std::vector<std::optional<plssvm::detail::memory_size>> available_local_memory{};
+
+    // the local memory vector may not be empty
+    EXPECT_DEATH(plssvm::detail::check_local_memory_usage(available_local_memory), "At least one local memory value must be available since at least one place must always be present!");
+}
+
+TEST(Utility, CurrentDateTime) {
     // test if the current date time matches the pattern
     EXPECT_TRUE(std::regex_match(std::string{ plssvm::detail::current_date_time() },
                                  std::regex{ "[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}", std::regex::extended }));
 }
 
-TEST(Utility, get_system_memory) {
+TEST(Utility, GetSystemMemory) {
     // the available system memory must be greater than 0!
     EXPECT_GT(plssvm::detail::get_system_memory().num_bytes(), 0ULL);
 }
+
+TEST(Utility, GetExistingEnvVariable) {
+#if defined(_WIN32) || defined(_WIN64)
+    GTEST_SKIP() << "Can't set an environment variable from within C++ on Windows!";
+#else
+    // set an env variable so we can be sure that it exists
+    setenv("PLSSVM_ENV_VARIABLE_THAT_WILL_ONLY_EVER_EXIST_IN_TESTS", "gpu_nvidia:0", 1);
+    // check the created environment variable
+    const std::optional<std::string> env_variable = plssvm::detail::get_env_variable("PLSSVM_ENV_VARIABLE_THAT_WILL_ONLY_EVER_EXIST_IN_TESTS");
+    ASSERT_TRUE(env_variable.has_value());
+    EXPECT_EQ(env_variable.value(), std::string{ "gpu_nvidia:0" });  // NOLINT(bugprone-unchecked-optional-access): optional checked with ASSERT_TRUE
+#endif
+}
+
+TEST(Utility, GetNotExistingEnvVariable) {
+    EXPECT_FALSE(plssvm::detail::get_env_variable("PLSSVM_ENV_VARIABLE_THAT_WILL_NEVER_EXIST").has_value());
+}
diff --git a/tests/environment.cpp b/tests/environment.cpp
index 1ca3ab44d..f8c166712 100644
--- a/tests/environment.cpp
+++ b/tests/environment.cpp
@@ -16,13 +16,16 @@
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING, EXPECT_THROW_WHAT
 
+#include "fmt/format.h"   // fmt::format
+#include "fmt/ranges.h"   // fmt::join
 #include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_NE, EXPECT_DEATH
 
-#include <tuple>   // std::ignore
-#include <vector>  // std::vector
+#include <sstream>  // std::istringstream
+#include <tuple>    // std::ignore
+#include <vector>   // std::vector
 
 // check whether the plssvm::environment::status -> std::string conversions are correct
-TEST(EnvironmentStatus, to_string) {
+TEST(EnvironmentStatus, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::environment::status::uninitialized, "uninitialized");
     EXPECT_CONVERSION_TO_STRING(plssvm::environment::status::initialized, "initialized");
@@ -30,13 +33,13 @@ TEST(EnvironmentStatus, to_string) {
     EXPECT_CONVERSION_TO_STRING(plssvm::environment::status::unnecessary, "unnecessary");
 }
 
-TEST(EnvironmentStatus, to_string_unknown) {
+TEST(EnvironmentStatus, ToStringUnknown) {
     // check conversions to std::string from unknown environment status
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::environment::status>(4), "unknown");
 }
 
 // check whether the std::string -> plssvm::environment::status conversions are correct
-TEST(EnvironmentStatus, from_string) {
+TEST(EnvironmentStatus, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("uninitialized", plssvm::environment::status::uninitialized);
     EXPECT_CONVERSION_FROM_STRING("UNINITIALIZED", plssvm::environment::status::uninitialized);
@@ -48,7 +51,7 @@ TEST(EnvironmentStatus, from_string) {
     EXPECT_CONVERSION_FROM_STRING("UNNECESSARY", plssvm::environment::status::unnecessary);
 }
 
-TEST(EnvironmentStatus, from_string_unknown) {
+TEST(EnvironmentStatus, FromStringUnknown) {
     // foo isn't a valid environment status
     std::istringstream input{ "foo" };
     plssvm::environment::status status{};
@@ -56,7 +59,7 @@ TEST(EnvironmentStatus, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(Environment, get_backend_status) {
+TEST(Environment, GetBackendStatus) {
     // check the backend statis for all supported backends
 
     // the automatic backend may not be used and throws an exception
@@ -84,17 +87,17 @@ TEST(Environment, get_backend_status) {
 #endif
 }
 
-TEST(EnvironmentDeathTest, initialize_backend) {
+TEST(EnvironmentDeathTest, InitializeBackend) {
     // the function may never be called with the automatic backend
     EXPECT_DEATH(plssvm::environment::detail::initialize_backend(plssvm::backend_type::automatic), "The automatic backend may never be initialized!");
 }
 
-TEST(EnvironmentDeathTest, finalize_backend) {
+TEST(EnvironmentDeathTest, FinalizeBackend) {
     // the function may never be called with the automatic backend
     EXPECT_DEATH(plssvm::environment::detail::finalize_backend(plssvm::backend_type::automatic), "The automatic backend may never be finalized!");
 }
 
-TEST(Environment, initialize_impl) {
+TEST(Environment, InitializeImpl) {
     // the function may never be called with a backend that hasn't been enabled
     const std::vector<plssvm::backend_type> all_backends{
         plssvm::backend_type::openmp,
@@ -119,13 +122,13 @@ TEST(Environment, initialize_impl) {
     }
 }
 
-TEST(Environment, initialize_impl_automatic) {
+TEST(Environment, InitializeImplAutomatic) {
     // the function may never be called with the automatic backend
     const std::vector<plssvm::backend_type> backends{ plssvm::backend_type::automatic };
     EXPECT_THROW_WHAT(plssvm::environment::detail::initialize_impl(backends), plssvm::environment_exception, "The automatic backend cannot be initialized!");
 }
 
-TEST(Environment, finalize) {
+TEST(Environment, Finalize) {
     // the function may never be called with a backend that hasn't been enabled
     const std::vector<plssvm::backend_type> all_backends{
         plssvm::backend_type::openmp,
@@ -150,7 +153,7 @@ TEST(Environment, finalize) {
     }
 }
 
-TEST(Environment, finalize_automatic) {
+TEST(Environment, FinalizeAutomatic) {
     // the function may never be called with the automatic backend
     const std::vector<plssvm::backend_type> backends{ plssvm::backend_type::automatic };
     EXPECT_THROW_WHAT(plssvm::environment::finalize(backends), plssvm::environment_exception, "The automatic backend cannot be finalized!");
diff --git a/tests/exceptions/exceptions.cpp b/tests/exceptions/exceptions.cpp
index 69bf8d9d3..5a8f7c1f4 100644
--- a/tests/exceptions/exceptions.cpp
+++ b/tests/exceptions/exceptions.cpp
@@ -10,10 +10,12 @@
 
 #include "plssvm/exceptions/exceptions.hpp"  // plssvm::{*_exception}
 
+#include "plssvm/detail/string_utility.hpp"  // plssvm::detail::split
+
 #include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT
+#include "tests/exceptions/utility.hpp"  // util::exception_type_name
 #include "tests/naming.hpp"              // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"       // util::{combine_test_parameters_gtest_t, cartesian_type_product_t, test_parameter_type_at_t}
-#include "tests/utility.hpp"             // util::exception_type_name
 
 #include "fmt/format.h"   // fmt::format
 #include "gmock/gmock.h"  // EXPECT_THAT, ::testing::{HasSubstr, ContainsRegex}
@@ -25,12 +27,21 @@
 #include <tuple>        // std::tuple
 #include <vector>       // std::vector
 
+namespace {
+
 // helper function returning an exception used to be able to name the source location function
 template <typename Exception>
 Exception dummy(const std::string &msg) {
     return Exception{ msg };
 }
 
+// helper function returning a cmd_parser_exit exception used to be able to name the source location function
+plssvm::cmd_parser_exit dummy_exit(const int exit_code) {
+    return plssvm::cmd_parser_exit{ exit_code };
+}
+
+}  // namespace
+
 // clang-format off
 // enumerate all custom exception types; ATTENTION: don't forget to also specialize the PLSSVM_CREATE_EXCEPTION_TYPE_NAME macro if a new exception type is added
 using exception_types_list = std::tuple<plssvm::exception, plssvm::invalid_parameter_exception, plssvm::file_reader_exception,
@@ -51,7 +62,7 @@ class Exceptions : public ::testing::Test {
 TYPED_TEST_SUITE(Exceptions, exception_types_gtest, naming::test_parameter_to_name);
 
 // check whether throwing exceptions works as intended
-TYPED_TEST(Exceptions, throwing_excpetion) {
+TYPED_TEST(Exceptions, ThrowingExcpetion) {
     using exception_type = typename TestFixture::fixture_exception_type;
 
     // throw the specified exception
@@ -60,7 +71,7 @@ TYPED_TEST(Exceptions, throwing_excpetion) {
 }
 
 // check whether the source location information are populated correctly
-TYPED_TEST(Exceptions, exception_source_location) {
+TYPED_TEST(Exceptions, ExceptionSourceLocation) {
     using exception_type = typename TestFixture::fixture_exception_type;
 
     const auto exc = dummy<exception_type>("exception message");
@@ -72,7 +83,7 @@ TYPED_TEST(Exceptions, exception_source_location) {
 }
 
 // check whether what message including the source location information is assembled correctly
-TYPED_TEST(Exceptions, exception_what_with_source_location) {
+TYPED_TEST(Exceptions, ExceptionWhatWithSourceLocation) {
     using exception_type = typename TestFixture::fixture_exception_type;
 
     const auto exc = dummy<exception_type>("exception message");
@@ -92,20 +103,15 @@ TYPED_TEST(Exceptions, exception_what_with_source_location) {
     EXPECT_THAT(std::string{ what_lines[4] }, ::testing::StartsWith("  @ line       "));  // attention: some line must be given, hardcoded value not feasible
 }
 
-// helper function returning an exception used to be able to name the source location function
-plssvm::cmd_parser_exit dummy_exit(const int exit_code) {
-    return plssvm::cmd_parser_exit{ exit_code };
-}
-
 // check whether throwing exceptions works as intended
-TEST(CMDParserExitException, throwing_excpetion) {
+TEST(CMDParserExitException, ThrowingExcpetion) {
     // throw the specified exception
     const auto dummy_exit = []() { throw plssvm::cmd_parser_exit{ 1 }; };
     EXPECT_THROW_WHAT(dummy_exit(), plssvm::cmd_parser_exit, "exit code: 1");
 }
 
 // check whether the source location information are populated correctly
-TEST(CMDParserExitException, exception_source_location) {
+TEST(CMDParserExitException, ExceptionSourceLocation) {
     const auto exc = dummy_exit(2);
 
     EXPECT_EQ(exc.loc().file_name(), std::string{ __builtin_FILE() });
@@ -116,7 +122,7 @@ TEST(CMDParserExitException, exception_source_location) {
 }
 
 // check whether what message including the source location information is assembled correctly
-TEST(CMDParserExitException, exception_what_with_source_location) {
+TEST(CMDParserExitException, ExceptionWhatWithSourceLocation) {
     const auto exc = dummy_exit(0);
 
     // get exception message with source location information split into a vector of separate lines
diff --git a/tests/exceptions/source_location.cpp b/tests/exceptions/source_location.cpp
index 1e8bc2e25..ae29c3d3b 100644
--- a/tests/exceptions/source_location.cpp
+++ b/tests/exceptions/source_location.cpp
@@ -12,17 +12,25 @@
 
 #include "plssvm/mpi/environment.hpp"  // plssvm::mpi::is_active
 
+#if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "tests/custom_test_macros.hpp"  // EXPECT_OPTIONAL_EQ
+#endif
+
 #include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
-#include "gtest/gtest.h"  // TEST, EXPECT_EQ
+#include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_FALSE
 
 #include <cstdint>  // std::uint_least32_t
 
+namespace {
+
 // dummy function to be able to specify the function name
 [[nodiscard]] plssvm::source_location dummy() {
     return plssvm::source_location::current();
 }
 
-TEST(SourceLocation, default_construct) {
+}  // namespace
+
+TEST(SourceLocation, DefaultConstruct) {
     const plssvm::source_location loc{};
 
     EXPECT_EQ(loc.file_name(), std::string{ "unknown" });
@@ -32,19 +40,18 @@ TEST(SourceLocation, default_construct) {
     EXPECT_FALSE(loc.world_rank().has_value());
 }
 
-TEST(SourceLocation, current_location) {
+TEST(SourceLocation, CurrentLocation) {
     const plssvm::source_location loc = dummy();
 
     EXPECT_EQ(loc.file_name(), __builtin_FILE());
     EXPECT_THAT(loc.function_name(), ::testing::HasSubstr("dummy"));
-    EXPECT_EQ(loc.line(), std::uint_least32_t{ 22 });   // attention: hardcoded line!
+    EXPECT_EQ(loc.line(), std::uint_least32_t{ 28 });   // attention: hardcoded line!
     EXPECT_EQ(loc.column(), std::uint_least32_t{ 0 });  // attention: always 0!
 
     if (plssvm::mpi::is_active()) {
 #if defined(PLSSVM_HAS_MPI_ENABLED)
-        ASSERT_TRUE(loc.world_rank().has_value());
         // since MPI is disabled, the world rank must always be zero
-        EXPECT_EQ(loc.world_rank().value(), 0);
+        EXPECT_OPTIONAL_EQ(loc.world_rank(), 0);
 #else
         EXPECT_FALSE(loc.world_rank().has_value());
 #endif
diff --git a/tests/exceptions/utility.hpp b/tests/exceptions/utility.hpp
index 324f2b289..08b04e702 100644
--- a/tests/exceptions/utility.hpp
+++ b/tests/exceptions/utility.hpp
@@ -24,11 +24,11 @@
  */
 #define PLSSVM_CREATE_EXCEPTION_TYPE_NAME(type) \
     template <>                                 \
-    [[nodiscard]] constexpr inline std::string_view exception_type_name<type>() { return #type; }
+    [[nodiscard]] constexpr std::string_view exception_type_name<type>() { return #type; }
 
 namespace util {
-// used that `exception_type_name` doesn't also print plssvm::
-using namespace plssvm;
+
+using namespace plssvm;  // NOLINT(google-build-using-namespace): used that `exception_type_name` doesn't also print plssvm::
 
 /**
  * @brief Tries to convert the given exception to its name as string representation.
@@ -37,7 +37,7 @@ using namespace plssvm;
  * @return the name of the exception type `T` (`[[nodiscard]]`)
  */
 template <typename T>
-[[nodiscard]] constexpr inline std::string_view exception_type_name() = delete;
+[[nodiscard]] constexpr std::string_view exception_type_name() = delete;
 
 // create exception type -> string mapping for all custom exception types
 PLSSVM_CREATE_EXCEPTION_TYPE_NAME(exception)
diff --git a/tests/file_format_types.cpp b/tests/file_format_types.cpp
index 0fed1903b..c29a6e1da 100644
--- a/tests/file_format_types.cpp
+++ b/tests/file_format_types.cpp
@@ -17,19 +17,19 @@
 #include <sstream>  // std::istringstream
 
 // check whether the plssvm::file_format_type -> std::string conversions are correct
-TEST(FileFormatType, to_string) {
+TEST(FileFormatType, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::file_format_type::libsvm, "libsvm");
     EXPECT_CONVERSION_TO_STRING(plssvm::file_format_type::arff, "arff");
 }
 
-TEST(FileFormatType, to_string_unknown) {
+TEST(FileFormatType, ToStringUnknown) {
     // check conversions to std::string from unknown file_format_type
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::file_format_type>(2), "unknown");
 }
 
 // check whether the std::string -> plssvm::file_format_type conversions are correct
-TEST(FileFormatType, from_string) {
+TEST(FileFormatType, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("LIBSVM", plssvm::file_format_type::libsvm);
     EXPECT_CONVERSION_FROM_STRING("libsvm", plssvm::file_format_type::libsvm);
@@ -37,7 +37,7 @@ TEST(FileFormatType, from_string) {
     EXPECT_CONVERSION_FROM_STRING("arff", plssvm::file_format_type::arff);
 }
 
-TEST(FileFormatType, from_string_unknown) {
+TEST(FileFormatType, FromStringUnknown) {
     // foo isn't a valid file_format_type
     std::istringstream input{ "foo" };
     plssvm::file_format_type file_format{};
diff --git a/tests/gamma.cpp b/tests/gamma.cpp
index 15e1b9f84..e258a3ead 100644
--- a/tests/gamma.cpp
+++ b/tests/gamma.cpp
@@ -10,9 +10,8 @@
 
 #include "plssvm/gamma.hpp"
 
-#include "plssvm/constants.hpp"              // plssvm::real_type
-#include "plssvm/exceptions/exceptions.hpp"  // plssvm::exception
-#include "plssvm/matrix.hpp"                 // plssvm::aos_matrix
+#include "plssvm/constants.hpp"  // plssvm::real_type
+#include "plssvm/matrix.hpp"     // plssvm::aos_matrix
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING, EXPECT_THROW_WHAT
 #include "tests/utility.hpp"             // util::generate_specific_matrix
@@ -22,23 +21,22 @@
 
 #include <sstream>  // std::istringstream
 #include <string>   // std::string
-#include <tuple>    // std::ignore
 #include <variant>  // std::variant, std::holds_alternative, std::get
 
 // check whether the plssvm::gamma_coefficient_type -> std::string conversions are correct
-TEST(GammaCoefficientType, to_string) {
+TEST(GammaCoefficientType, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::gamma_coefficient_type::automatic, "automatic");
     EXPECT_CONVERSION_TO_STRING(plssvm::gamma_coefficient_type::scale, "scale");
 }
 
-TEST(GammaCoefficientType, to_string_unknown) {
+TEST(GammaCoefficientType, ToStringUnknown) {
     // check conversions to std::string from unknown gamma_coefficient_type
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::gamma_coefficient_type>(2), "unknown");
 }
 
 // check whether the std::string -> plssvm::gamma_coefficient_type conversions are correct
-TEST(GammaCoefficientType, from_string) {
+TEST(GammaCoefficientType, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("automatic", plssvm::gamma_coefficient_type::automatic);
     EXPECT_CONVERSION_FROM_STRING("AUTOmatic", plssvm::gamma_coefficient_type::automatic);
@@ -47,7 +45,7 @@ TEST(GammaCoefficientType, from_string) {
     EXPECT_CONVERSION_FROM_STRING("SCALE", plssvm::gamma_coefficient_type::scale);
 }
 
-TEST(GammaCoefficientType, from_string_unknown) {
+TEST(GammaCoefficientType, FromStringUnknown) {
     // foo isn't a valid gamma_coefficient_type
     std::istringstream input{ "foo" };
     plssvm::gamma_coefficient_type gamma_coef{};
@@ -56,7 +54,7 @@ TEST(GammaCoefficientType, from_string_unknown) {
 }
 
 // check whether the plssvm::gamma_type -> std::string conversions are correct
-TEST(GammaType, to_string) {
+TEST(GammaType, ToString) {
     // check conversions to std::string
     plssvm::gamma_type gamma_value = plssvm::real_type{ 1.5 };
     EXPECT_CONVERSION_TO_STRING(gamma_value, "1.5");
@@ -66,14 +64,14 @@ TEST(GammaType, to_string) {
     EXPECT_CONVERSION_TO_STRING(gamma_value, "scale");
 }
 
-TEST(GammaType, to_string_unknown) {
+TEST(GammaType, ToStringUnknown) {
     // check conversions to std::string from unknown gamma_type
     const plssvm::gamma_type gamma_value = static_cast<plssvm::gamma_coefficient_type>(2);
     EXPECT_CONVERSION_TO_STRING(gamma_value, "unknown");
 }
 
 // check whether the std::string -> plssvm::gamma_type conversions are correct
-TEST(GammaType, from_string) {
+TEST(GammaType, FromString) {
     // check conversion from std::string
     plssvm::gamma_type gamma_value = plssvm::real_type{ 1.5 };
     EXPECT_CONVERSION_FROM_STRING("1.5", gamma_value);
@@ -84,7 +82,7 @@ TEST(GammaType, from_string) {
     EXPECT_CONVERSION_FROM_STRING("scale", gamma_value);
 }
 
-TEST(GammaType, from_string_unknown) {
+TEST(GammaType, FromStringUnknown) {
     // foo isn't a valid gamma_type
     std::istringstream input{ "foo" };
     plssvm::gamma_type gamma_value{};
@@ -92,7 +90,7 @@ TEST(GammaType, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(GammaType, calculate_gamma_value_real_type) {
+TEST(GammaType, CalculateGammaValueRealType) {
     // create a gamma_type with a real_type value
     const plssvm::gamma_type gamma_value = plssvm::real_type{ 1.5 };
 
@@ -105,7 +103,7 @@ TEST(GammaType, calculate_gamma_value_real_type) {
     EXPECT_FLOATING_POINT_EQ(plssvm::calculate_gamma_value(gamma_value, matr), plssvm::real_type{ 1.5 });
 }
 
-TEST(GammaType, calculate_gamma_value_gamma_coefficient_type_automatic) {
+TEST(GammaType, CalculateGammaValueGammaCoefficientTypeAutomatic) {
     // create a gamma_type with a real_type value
     const plssvm::gamma_type gamma_value = plssvm::gamma_coefficient_type::automatic;
 
@@ -118,7 +116,7 @@ TEST(GammaType, calculate_gamma_value_gamma_coefficient_type_automatic) {
     EXPECT_FLOATING_POINT_EQ(plssvm::calculate_gamma_value(gamma_value, matr), plssvm::real_type{ 0.25 });
 }
 
-TEST(GammaType, calculate_gamma_value_gamma_coefficient_type_scale) {
+TEST(GammaType, CalculateGammaValueGammaCoefficientTypeScale) {
     // create a gamma_type with a real_type value
     const plssvm::gamma_type gamma_value = plssvm::gamma_coefficient_type::scale;
 
@@ -131,7 +129,7 @@ TEST(GammaType, calculate_gamma_value_gamma_coefficient_type_scale) {
     EXPECT_FLOATING_POINT_NEAR(plssvm::calculate_gamma_value(gamma_value, matr), plssvm::real_type{ 0.047505938242280283668 });
 }
 
-TEST(GammaType, calculate_gamma_value_invalid_gamma_coefficient_type) {
+TEST(GammaType, CalculateGammaValueInvalidGammaCoefficientType) {
     // create a gamma_type with a real_type value
     const plssvm::gamma_type gamma_value = static_cast<plssvm::gamma_coefficient_type>(2);
 
@@ -144,7 +142,7 @@ TEST(GammaType, calculate_gamma_value_invalid_gamma_coefficient_type) {
     EXPECT_EQ(plssvm::calculate_gamma_value(gamma_value, matr), plssvm::real_type{ 1.0 });
 }
 
-TEST(GammaType, get_gamma_string_real_type) {
+TEST(GammaType, GetGammaStringRealType) {
     // create a gamma_type with a real_type value
     const plssvm::gamma_type gamma_value = plssvm::real_type{ 1.5 };
 
@@ -154,7 +152,7 @@ TEST(GammaType, get_gamma_string_real_type) {
     EXPECT_EQ(plssvm::get_gamma_string(gamma_value), fmt::format("{}", plssvm::real_type{ 1.5 }));
 }
 
-TEST(GammaType, get_gamma_string_gamma_coefficient_type_automatic) {
+TEST(GammaType, GetGammaStringGammaCoefficientTypeAutomatic) {
     // create a gamma_type with a real_type value
     const plssvm::gamma_type gamma_value = plssvm::gamma_coefficient_type::automatic;
 
@@ -164,7 +162,7 @@ TEST(GammaType, get_gamma_string_gamma_coefficient_type_automatic) {
     EXPECT_EQ(plssvm::get_gamma_string(gamma_value), std::string{ "\"1 / num_features\"" });
 }
 
-TEST(GammaType, get_gamma_string_gamma_coefficient_type_scale) {
+TEST(GammaType, GetGammaStringGammaCoefficientTypeScale) {
     // create a gamma_type with a real_type value
     const plssvm::gamma_type gamma_value = plssvm::gamma_coefficient_type::scale;
 
@@ -174,7 +172,7 @@ TEST(GammaType, get_gamma_string_gamma_coefficient_type_scale) {
     EXPECT_EQ(plssvm::get_gamma_string(gamma_value), std::string{ "\"1 / (num_features * variance(input_data))\"" });
 }
 
-TEST(GammaType, get_gamma_string_invalid_gamma_coefficient_type) {
+TEST(GammaType, GetGammaStringInvalidGammaCoefficientType) {
     // create a gamma_type with a real_type value
     const plssvm::gamma_type gamma_value = static_cast<plssvm::gamma_coefficient_type>(2);
 
diff --git a/tests/hpx_main.cpp b/tests/hpx_main.cpp
index ac84be4b4..4179eff25 100644
--- a/tests/hpx_main.cpp
+++ b/tests/hpx_main.cpp
@@ -10,15 +10,17 @@
  * @brief Contains the googletest main function. Sets the DeathTest to "threadsafe" execution instead of "fast".
  */
 
-#include "plssvm/environment.hpp"  // plssvm::environment::scope_guard
+#include "plssvm/backend_types.hpp"          // plssvm::backend_type
+#include "plssvm/environment.hpp"            // plssvm::environment::scope_guard
+#include "plssvm/exceptions/exceptions.hpp"  // plssvm::mpi_exception
 
-#include "gtest/gtest.h"  // RUN_ALL_TESTS, ::testing::{InitGoogleTest, GTEST_FLAG},GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST definitions
+#include "hpx/hpx_init.hpp"  // hpx::init
 
-#include <cstdlib>  // std::atexit
+#include "gtest/gtest.h"  // RUN_ALL_TESTS, ::testing::{InitGoogleTest, GTEST_FLAG},GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST definitions
 
-// Workaround as HPX runtime not working properly with Google Test
-// Run the entire main function in HPX runtime
-#include "hpx/hpx_main.hpp"
+#include <iostream>  // std::cerr, std::endl
+#include <memory>    // std::unique_ptr, std::make_unique
+#include <vector>    // std::vector
 
 // silence GTest warnings/test errors
 
@@ -49,9 +51,26 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DevicePtrDeathTest);
 // exception tests
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Exception);
 
+// NOLINTBEGIN: hpx_main MUST be in global namespace, internal linkage DOES NOT work
+
+[[nodiscard]] int hpx_main([[maybe_unused]] int argc, [[maybe_unused]] char **argv) {
+    // be sure that the HPX runtime is only started ONCE for all test invocations
+    const int result = RUN_ALL_TESTS();
+    ::hpx::finalize();
+    return result;
+}
+
+// NOLINTEND
+
 int main(int argc, char **argv) {
-    // initialize MPI environment only via the plssvm::scope_guard (by explicitly specifying NO backend)
-    [[maybe_unused]] plssvm::environment::scope_guard mpi_guard{ {} };
+    // may throw an exception if the required level of MPI parallelism isn't available (really rare)
+    std::unique_ptr<plssvm::environment::scope_guard> mpi_guard{};
+    try {
+        // initialize MPI environment via the plssvm::scope_guard
+        mpi_guard = std::make_unique<plssvm::environment::scope_guard>(std::vector<plssvm::backend_type>{});
+    } catch (const plssvm::mpi_exception &e) {
+        std::cerr << "An exception occurred while setting up the MPI environment!: " << e.what_with_loc() << std::endl;
+    }
 
     ::testing::InitGoogleTest(&argc, argv);
 
@@ -61,5 +80,5 @@ int main(int argc, char **argv) {
 #if !defined(_WIN32)
     ::testing::GTEST_FLAG(death_test_style) = "threadsafe";
 #endif
-    return RUN_ALL_TESTS();
+    return ::hpx::init(argc, argv);
 }
diff --git a/tests/kernel_function_types.cpp b/tests/kernel_function_types.cpp
index 864a2b0e9..7f949c858 100644
--- a/tests/kernel_function_types.cpp
+++ b/tests/kernel_function_types.cpp
@@ -17,7 +17,7 @@
 #include <sstream>  // std::istringstream
 
 // check whether the plssvm::kernel_function_type -> std::string conversions are correct
-TEST(KernelType, to_string) {
+TEST(KernelType, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::kernel_function_type::linear, "linear");
     EXPECT_CONVERSION_TO_STRING(plssvm::kernel_function_type::polynomial, "polynomial");
@@ -27,13 +27,13 @@ TEST(KernelType, to_string) {
     EXPECT_CONVERSION_TO_STRING(plssvm::kernel_function_type::chi_squared, "chi_squared");
 }
 
-TEST(KernelType, to_string_unknown) {
+TEST(KernelType, ToStringUnknown) {
     // check conversions to std::string from unknown kernel_type
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::kernel_function_type>(6), "unknown");
 }
 
 // check whether the std::string -> plssvm::kernel_function_type conversions are correct
-TEST(KernelType, from_string) {
+TEST(KernelType, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("linear", plssvm::kernel_function_type::linear);
     EXPECT_CONVERSION_FROM_STRING("LINEAR", plssvm::kernel_function_type::linear);
@@ -56,7 +56,7 @@ TEST(KernelType, from_string) {
     EXPECT_CONVERSION_FROM_STRING("5", plssvm::kernel_function_type::chi_squared);
 }
 
-TEST(KernelType, from_string_unknown) {
+TEST(KernelType, FromStringUnknown) {
     // foo isn't a valid kernel_type
     std::istringstream input{ "foo" };
     plssvm::kernel_function_type kernel{};
@@ -65,7 +65,7 @@ TEST(KernelType, from_string_unknown) {
 }
 
 // check whether the plssvm::kernel_function_type -> math string conversions are correct
-TEST(KernelType, kernel_to_math_string) {
+TEST(KernelType, KernelToMathString) {
     // check conversion from plssvm::kernel_function_type to the respective math function string
     EXPECT_EQ(plssvm::kernel_function_type_to_math_string(plssvm::kernel_function_type::linear), "u'*v");
     EXPECT_EQ(plssvm::kernel_function_type_to_math_string(plssvm::kernel_function_type::polynomial), "(gamma*u'*v+coef0)^degree");
@@ -75,7 +75,7 @@ TEST(KernelType, kernel_to_math_string) {
     EXPECT_EQ(plssvm::kernel_function_type_to_math_string(plssvm::kernel_function_type::chi_squared), "exp(-gamma*sum_i((x[i]-y[i])^2/(x[i]+y[i])))");
 }
 
-TEST(KernelType, kernel_to_math_string_unkown) {
+TEST(KernelType, KernelToMathStringUnkown) {
     // check conversion from an unknown plssvm::kernel_function_type to the (non-existing) math string
     EXPECT_EQ(plssvm::kernel_function_type_to_math_string(static_cast<plssvm::kernel_function_type>(6)), "unknown");
 }
diff --git a/tests/kernel_functions.cpp b/tests/kernel_functions.cpp
index e2734aae5..f204036d0 100644
--- a/tests/kernel_functions.cpp
+++ b/tests/kernel_functions.cpp
@@ -29,8 +29,7 @@
 #include <array>    // std::array
 #include <cstddef>  // std::size_t
 #include <tuple>    // std::tuple, std::ignore
-#include <utility>  // std::pair
-#include <variant>  // std::get
+#include <utility>  // std::pair, std::get
 #include <vector>   // std::vector
 
 //*************************************************************************************************************************************//
@@ -68,7 +67,7 @@ class KernelFunctionVector : public ::testing::Test {
 
 TYPED_TEST_SUITE(KernelFunctionVector, util::real_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(KernelFunctionVector, linear_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionVector, LinearKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -84,7 +83,7 @@ TYPED_TEST(KernelFunctionVector, linear_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionVector, linear_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionVector, LinearKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -101,7 +100,7 @@ TYPED_TEST(KernelFunctionVector, linear_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionVector, polynomial_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionVector, PolynomialKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -120,7 +119,7 @@ TYPED_TEST(KernelFunctionVector, polynomial_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionVector, polynomial_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionVector, PolynomialKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -138,7 +137,7 @@ TYPED_TEST(KernelFunctionVector, polynomial_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionVector, radial_basis_function_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionVector, RadialBasisFunctionKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -155,7 +154,7 @@ TYPED_TEST(KernelFunctionVector, radial_basis_function_kernel_function_variadic)
     }
 }
 
-TYPED_TEST(KernelFunctionVector, radial_basis_function_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionVector, RadialBasisFunctionKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -172,7 +171,7 @@ TYPED_TEST(KernelFunctionVector, radial_basis_function_kernel_function_parameter
     }
 }
 
-TYPED_TEST(KernelFunctionVector, sigmoid_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionVector, SigmoidKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -190,7 +189,7 @@ TYPED_TEST(KernelFunctionVector, sigmoid_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionVector, sigmoid_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionVector, SigmoidKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -207,7 +206,7 @@ TYPED_TEST(KernelFunctionVector, sigmoid_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionVector, laplacian_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionVector, LaplacianKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -224,7 +223,7 @@ TYPED_TEST(KernelFunctionVector, laplacian_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionVector, laplacian_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionVector, LaplacianKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -241,7 +240,7 @@ TYPED_TEST(KernelFunctionVector, laplacian_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionVector, chi_squared_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionVector, ChiSquaredKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -258,7 +257,7 @@ TYPED_TEST(KernelFunctionVector, chi_squared_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionVector, chi_squared_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionVector, ChiSquaredKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
 
     for (const std::size_t size : this->get_sizes()) {
@@ -275,7 +274,7 @@ TYPED_TEST(KernelFunctionVector, chi_squared_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionVector, unknown_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionVector, UnknownKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // create two vectors
@@ -296,7 +295,7 @@ class KernelFunctionVectorDeathTest : public KernelFunctionVector<T> { };
 
 TYPED_TEST_SUITE(KernelFunctionVectorDeathTest, util::real_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(KernelFunctionVectorDeathTest, size_mismatch_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionVectorDeathTest, SizeMismatchKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // create random vector with the specified size
@@ -318,7 +317,7 @@ TYPED_TEST(KernelFunctionVectorDeathTest, size_mismatch_kernel_function_variadic
                  "Sizes mismatch!: 1 != 2");
 }
 
-TYPED_TEST(KernelFunctionVectorDeathTest, size_mismatch_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionVectorDeathTest, SizeMismatchKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
 
     // create random vector with the specified size
@@ -354,7 +353,7 @@ class KernelFunctionMatrix : public KernelFunctionVector<T> {
 
 TYPED_TEST_SUITE(KernelFunctionMatrix, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(KernelFunctionMatrix, linear_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionMatrix, LinearKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -378,7 +377,7 @@ TYPED_TEST(KernelFunctionMatrix, linear_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, linear_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionMatrix, LinearKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -403,7 +402,7 @@ TYPED_TEST(KernelFunctionMatrix, linear_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, polynomial_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionMatrix, PolynomialKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -431,7 +430,7 @@ TYPED_TEST(KernelFunctionMatrix, polynomial_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, polynomial_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionMatrix, PolynomialKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -457,7 +456,7 @@ TYPED_TEST(KernelFunctionMatrix, polynomial_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, rbf_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionMatrix, RadialBassisFunctionKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -482,7 +481,7 @@ TYPED_TEST(KernelFunctionMatrix, rbf_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, rbf_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionMatrix, RadialBasisFunctionKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -508,7 +507,7 @@ TYPED_TEST(KernelFunctionMatrix, rbf_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, sigmoid_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionMatrix, SigmoidKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -535,7 +534,7 @@ TYPED_TEST(KernelFunctionMatrix, sigmoid_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, sigmoid_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionMatrix, SigmoidKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -561,7 +560,7 @@ TYPED_TEST(KernelFunctionMatrix, sigmoid_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, laplacian_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionMatrix, LaplacianKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -587,7 +586,7 @@ TYPED_TEST(KernelFunctionMatrix, laplacian_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, laplacian_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionMatrix, LaplacianKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -613,7 +612,7 @@ TYPED_TEST(KernelFunctionMatrix, laplacian_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, chi_squared_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionMatrix, ChiSquaredKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -639,7 +638,7 @@ TYPED_TEST(KernelFunctionMatrix, chi_squared_kernel_function_variadic) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, chi_squared_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionMatrix, ChiSquaredKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -665,7 +664,7 @@ TYPED_TEST(KernelFunctionMatrix, chi_squared_kernel_function_parameter) {
     }
 }
 
-TYPED_TEST(KernelFunctionMatrix, unknown_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionMatrix, UnknownKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -688,7 +687,7 @@ class KernelFunctionMatrixDeathTest : public KernelFunctionMatrix<T> { };
 
 TYPED_TEST_SUITE(KernelFunctionMatrixDeathTest, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(KernelFunctionMatrixDeathTest, size_mismatch_kernel_function_variadic) {
+TYPED_TEST(KernelFunctionMatrixDeathTest, SizeMismatchKernelFunctionVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -711,7 +710,7 @@ TYPED_TEST(KernelFunctionMatrixDeathTest, size_mismatch_kernel_function_variadic
                  "Sizes mismatch!: 1 != 2");
 }
 
-TYPED_TEST(KernelFunctionMatrixDeathTest, invalid_indices_variadic) {
+TYPED_TEST(KernelFunctionMatrixDeathTest, InvalidIndicesVariadic) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -734,7 +733,7 @@ TYPED_TEST(KernelFunctionMatrixDeathTest, invalid_indices_variadic) {
                  "Out-of-bounce access for i and x!: 2 < 2");
 }
 
-TYPED_TEST(KernelFunctionMatrixDeathTest, size_mismatch_kernel_function_parameter) {
+TYPED_TEST(KernelFunctionMatrixDeathTest, SizeMismatchKernelFunctionParameter) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
@@ -746,7 +745,7 @@ TYPED_TEST(KernelFunctionMatrixDeathTest, size_mismatch_kernel_function_paramete
     EXPECT_DEATH(std::ignore = plssvm::kernel_function(matr1, 0, matr2, 0, plssvm::parameter{}), "Sizes mismatch!: 1 != 2");
 }
 
-TYPED_TEST(KernelFunctionMatrixDeathTest, invalid_indices_parameter) {
+TYPED_TEST(KernelFunctionMatrixDeathTest, InvalidIndicesParameter) {
     using real_type = typename TestFixture::fixture_real_type;
     constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
 
diff --git a/tests/main.cpp b/tests/main.cpp
index 308d7f17d..7e9e9b8fa 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -9,7 +9,7 @@
  * @brief Contains the googletest main function. Sets the DeathTest to "threadsafe" execution instead of "fast".
  */
 
-#include "plssvm/environment.hpp"  // plssvm::environment::{scope_guard, initialize, finalize}
+#include "plssvm/environment.hpp"  // plssvm::environment::{scope_guard, finalize}
 
 #include "gtest/gtest.h"  // RUN_ALL_TESTS, ::testing::{InitGoogleTest, GTEST_FLAG},GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST definitions
 
@@ -60,10 +60,14 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Exception);
     #pragma clang diagnostic pop
 #endif
 
-static void ensure_finalization() {
+namespace {
+
+void ensure_finalization() {
     plssvm::environment::finalize();
 }
 
+}  // namespace
+
 int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
diff --git a/tests/matrix.cpp b/tests/matrix.cpp
deleted file mode 100644
index 4d334bea6..000000000
--- a/tests/matrix.cpp
+++ /dev/null
@@ -1,2479 +0,0 @@
-/**
- * @author Alexander Van Craen
- * @author Marcel Breyer
- * @copyright 2018-today The PLSSVM project - All Rights Reserved
- * @license This file is part of the PLSSVM project which is released under the MIT license.
- *          See the LICENSE.md file in the project root for full license information.
- *
- * @brief Test the plssvm::matrix class and related functions like the plssvm::layout_type.
- */
-
-#include "plssvm/matrix.hpp"
-
-#include "plssvm/exceptions/exceptions.hpp"  // plssvm::matrix_exception
-#include "plssvm/shape.hpp"                  // plssvm::shape
-
-#include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING, EXPECT_THROW_WHAT
-#include "tests/naming.hpp"              // naming::test_parameter_to_name
-#include "tests/types_to_test.hpp"       // util::{real_type_layout_type_gtest, test_parameter_type_at_t, test_parameter_value_at_v}
-#include "tests/utility.hpp"             // util::{generate_random_matrix, redirect_output}
-
-#include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
-#include "gtest/gtest.h"  // TEST, TYPED_TEST, TYPED_TEST_SUITE, EXPECT_EQ, EXPECT_TRUE, EXPECT_FALSE, EXPECT_DEATH, ASSERT_EQ, SCOPED_TRACE, FAIL,
-                          // ::testing::{Test, StaticAssertTypeEq}
-#include "fmt/format.h"   // fmt::format
-
-#include <algorithm>  // std::swap
-#include <cstddef>    // std::size_t
-#include <iostream>   // std::clog
-#include <sstream>    // std::istringstream, std::ostringstream
-#include <string>     // std::string
-#include <tuple>      // std::ignore
-#include <vector>     // std::vector
-
-// check whether the plssvm::layout_type -> std::string conversions are correct
-TEST(LayoutType, to_string) {
-    // check conversions to std::string
-    EXPECT_CONVERSION_TO_STRING(plssvm::layout_type::aos, "aos");
-    EXPECT_CONVERSION_TO_STRING(plssvm::layout_type::soa, "soa");
-}
-
-TEST(LayoutType, to_string_unknown) {
-    // check conversions to std::string from unknown layout_type
-    EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::layout_type>(2), "unknown");
-}
-
-// check whether the std::string -> plssvm::layout_type conversions are correct
-TEST(LayoutType, from_string) {
-    // check conversion from std::string
-    EXPECT_CONVERSION_FROM_STRING("aos", plssvm::layout_type::aos);
-    EXPECT_CONVERSION_FROM_STRING("AoS", plssvm::layout_type::aos);
-    EXPECT_CONVERSION_FROM_STRING("Array-of-Structs", plssvm::layout_type::aos);
-    EXPECT_CONVERSION_FROM_STRING("soa", plssvm::layout_type::soa);
-    EXPECT_CONVERSION_FROM_STRING("SoA", plssvm::layout_type::soa);
-    EXPECT_CONVERSION_FROM_STRING("Struct-of-Arrays", plssvm::layout_type::soa);
-}
-
-TEST(LayoutType, from_string_unknown) {
-    // foo isn't a valid layout_type
-    std::istringstream input{ "foo" };
-    plssvm::layout_type layout{};
-    input >> layout;
-    EXPECT_TRUE(input.fail());
-}
-
-TEST(LayoutType, layout_type_to_full_string) {
-    // check conversion from plssvm::classification_type to a full string
-    EXPECT_EQ(plssvm::layout_type_to_full_string(plssvm::layout_type::aos), "Array-of-Structs");
-    EXPECT_EQ(plssvm::layout_type_to_full_string(plssvm::layout_type::soa), "Struct-of-Arrays");
-}
-
-TEST(LayoutType, layout_type_to_full_string_unknown) {
-    // check conversion from unknown classification_typ to a full string
-    EXPECT_EQ(plssvm::layout_type_to_full_string(static_cast<plssvm::layout_type>(2)), "unknown");
-}
-
-template <typename T>
-class Matrix : public ::testing::Test,
-               public util::redirect_output<&std::clog> {
-  protected:
-    using fixture_real_type = util::test_parameter_type_at_t<0, T>;
-    constexpr static plssvm::layout_type fixture_layout = util::test_parameter_value_at_v<0, T>;
-};
-
-TYPED_TEST_SUITE(Matrix, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
-
-TYPED_TEST(Matrix, construct_default) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // default construct matrix
-    const plssvm::matrix<real_type, layout> matr{};
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 3, 2 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 3, 2 }));
-    ASSERT_EQ(matr.size(), 6);
-    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size(), [](const real_type val) { return val == real_type{}; }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 3, 2 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_empty) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_zero_num_rows) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero rows
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 } }),
-                      plssvm::matrix_exception,
-                      "The number of rows is zero but the number of columns is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_zero_num_cols) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero columns
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 } }),
-                      plssvm::matrix_exception,
-                      "The number of columns is zero but the number of rows is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 3, 2 }, plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 3, 2 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 7, 7 }));
-    // default values == padding values
-    ASSERT_EQ(matr.size_padded(), 49);
-    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{}; }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_empty_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 4, 5 }));
-
-    // default values == padding values
-    ASSERT_EQ(matr.size_padded(), 20);
-    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{}; }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_empty_and_zero_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, plssvm::shape{ 0, 0 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_zero_num_rows_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero rows
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The number of rows is zero but the number of columns is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_zero_num_cols_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero columns
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The number of columns is zero but the number of rows is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_default_value) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, real_type{ 3.1415 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
-    ASSERT_EQ(matr.size(), 6);
-    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size(), [](const real_type val) { return val == real_type{ 3.1415 }; }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 2, 3 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_default_value_empty) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, real_type{ 3.1415 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_default_value_zero_num_rows) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero rows
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, real_type{ 3.1415 } }),
-                      plssvm::matrix_exception,
-                      "The number of rows is zero but the number of columns is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_default_value_zero_num_cols) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero columns
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, real_type{ 3.1415 } }),
-                      plssvm::matrix_exception,
-                      "The number of columns is zero but the number of rows is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_default_value_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, real_type{ 3.1415 }, plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 8 }));
-
-    // check content while paying attention to padding!
-    ASSERT_EQ(matr.size_padded(), 48);
-    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < matr.num_rows() && col < matr.num_cols()) {
-                EXPECT_EQ(matr(row, col), real_type{ 3.1415 });
-            } else {
-                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_default_value_empty_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, real_type{ 3.1415 }, plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 4, 5 }));
-
-    // only padding entries should be present
-    ASSERT_EQ(matr.size_padded(), 20);
-    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{ 0.0 }; }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_default_value_empty_and_zero_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, real_type{ 3.1415 }, plssvm::shape{ 0, 0 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_default_value_zero_num_rows_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero rows
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, real_type{ 3.1415 }, plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The number of rows is zero but the number of columns is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_default_value_zero_num_cols_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero columns
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, real_type{ 3.1415 }, plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The number of columns is zero but the number of rows is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const std::vector<real_type> data = { real_type{ 0.1 }, real_type{ 0.2 }, real_type{ 0.3 }, real_type{ 0.4 }, real_type{ 0.5 }, real_type{ 0.6 } };
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, data };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
-    ASSERT_EQ(matr.size(), 6);
-    for (std::size_t i = 0; i < matr.size(); ++i) {
-        EXPECT_FLOATING_POINT_EQ(*(matr.data() + i), data[i]);
-    }
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 2, 3 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector_empty) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, std::vector<real_type>{} };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector_value_zero_num_rows) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero rows
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, std::vector<real_type>(2) }),
-                      plssvm::matrix_exception,
-                      "The number of rows is zero but the number of columns is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector_zero_num_cols) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero columns
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, std::vector<real_type>(2) }),
-                      plssvm::matrix_exception,
-                      "The number of columns is zero but the number of rows is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector_size_mismatch) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero columns
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 2 }, std::vector<real_type>(2) }),
-                      plssvm::matrix_exception,
-                      "The number of entries in the matrix (4) must be equal to the size of the data (2)!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const std::vector<real_type> data = { real_type{ 0.1 }, real_type{ 0.2 }, real_type{ 0.3 }, real_type{ 0.4 }, real_type{ 0.5 }, real_type{ 0.6 } };
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, data, plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 8 }));
-
-    // check content while paying attention to padding!
-    ASSERT_EQ(matr.size_padded(), 48);
-    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < matr.num_rows() && col < matr.num_cols()) {
-                const real_type val = layout == plssvm::layout_type::aos ? data[row * 3 + col] : data[col * 2 + row];
-                EXPECT_EQ(matr(row, col), val);
-            } else {
-                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector_empty_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, std::vector<real_type>{}, plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 4, 5 }));
-
-    // only padding entries should be present
-    ASSERT_EQ(matr.size_padded(), 20);
-    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{ 0.0 }; }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector_empty_and_zero_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, std::vector<real_type>{}, plssvm::shape{ 0, 0 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector_value_zero_num_rows_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero rows
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, std::vector<real_type>(2), plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The number of rows is zero but the number of columns is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector_zero_num_cols_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero columns
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, std::vector<real_type>(2), plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The number of columns is zero but the number of rows is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_vector_size_mismatch_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero columns
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 2 }, std::vector<real_type>(3), plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The number of entries in the matrix (4) must be equal to the size of the data (3)!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_pointer) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const std::vector<real_type> data = { real_type{ 0.1 }, real_type{ 0.2 }, real_type{ 0.3 }, real_type{ 0.4 }, real_type{ 0.5 }, real_type{ 0.6 } };
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, data.data() };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
-    ASSERT_EQ(matr.size(), 6);
-    for (std::size_t i = 0; i < matr.size(); ++i) {
-        EXPECT_FLOATING_POINT_EQ(*(matr.data() + i), data[i]);
-    }
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 2, 3 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_ptr_empty) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const std::vector<real_type> data{};
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, data.data() };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_nullptr_ptr) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size and a nullptr
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 3 }, nullptr }),
-                      plssvm::matrix_exception,
-                      "The provided data pointer may not be a nullptr if the matrix size is greater than 0!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_ptr_value_zero_num_rows) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero rows
-    const std::vector<real_type> data(2);
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, data.data() }),
-                      plssvm::matrix_exception,
-                      "The number of rows is zero but the number of columns is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_ptr_zero_num_cols) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero columns
-    const std::vector<real_type> data(2);
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, data.data() }),
-                      plssvm::matrix_exception,
-                      "The number of columns is zero but the number of rows is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_pointer_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const std::vector<real_type> data = { real_type{ 0.1 }, real_type{ 0.2 }, real_type{ 0.3 }, real_type{ 0.4 }, real_type{ 0.5 }, real_type{ 0.6 } };
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, data.data(), plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 8 }));
-
-    // check content while paying attention to padding!
-    ASSERT_EQ(matr.size_padded(), 48);
-    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < matr.num_rows() && col < matr.num_cols()) {
-                const real_type val = layout == plssvm::layout_type::aos ? data[row * 3 + col] : data[col * 2 + row];
-                EXPECT_EQ(matr(row, col), val);
-            } else {
-                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_ptr_empty_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const std::vector<real_type> data;
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, data.data(), plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 4, 5 }));
-
-    // only padding entries should be present
-    ASSERT_EQ(matr.size_padded(), 20);
-    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{ 0.0 }; }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_nullptr_empty_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size, padding and a nullptr
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 3 }, nullptr, plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The provided data pointer may not be a nullptr if the matrix size is greater than 0!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_ptr_empty_and_zero_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix with a specific size
-    const std::vector<real_type> data;
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, data.data(), plssvm::shape{ 0, 0 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_ptr_value_zero_num_rows_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero rows
-    const std::vector<real_type> data(2);
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, data.data(), plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The number of rows is zero but the number of columns is not!");
-}
-
-TYPED_TEST(Matrix, construct_with_size_and_ptr_zero_num_cols_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix with zero columns
-    const std::vector<real_type> data(2);
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, data.data(), plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The number of columns is zero but the number of rows is not!");
-}
-
-TYPED_TEST(Matrix, construct_from_same_matrix_layout) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct matrix
-    const auto matr = util::generate_random_matrix<plssvm::matrix<real_type, layout>>(plssvm::shape{ 3, 2 });
-
-    // create a new matrix from this matrix
-    const plssvm::matrix<real_type, layout> new_matr{ matr };
-
-    // both matrices should be identical
-    EXPECT_EQ(new_matr, matr);
-}
-
-TYPED_TEST(Matrix, construct_from_other_matrix_layout) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct matrix with the opposite layout type
-    const auto matr = util::generate_random_matrix<plssvm::matrix<real_type, layout == plssvm::layout_type::aos ? plssvm::layout_type::soa : plssvm::layout_type::aos>>(plssvm::shape{ 3, 2 });
-
-    // create a new matrix from this matrix
-    const plssvm::matrix<real_type, layout> new_matr{ matr };
-
-    // both matrices should be identical
-    EXPECT_EQ(new_matr.layout(), layout);
-    EXPECT_EQ(new_matr.shape(), matr.shape());
-    // check padding
-    EXPECT_EQ(new_matr.padding(), matr.padding());
-    EXPECT_EQ(new_matr.shape_padded(), matr.shape_padded());
-
-    // check content
-    ASSERT_EQ(new_matr.size_padded(), matr.size_padded());
-    for (std::size_t row = 0; row < new_matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < new_matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < new_matr.num_rows() && col < new_matr.num_cols()) {
-                EXPECT_EQ(new_matr(row, col), matr(row, col));
-            } else {
-                EXPECT_EQ(new_matr(row, col), real_type{ 0.0 });
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, construct_from_same_matrix_layout_and_same_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct matrix
-    const auto matr = util::generate_random_matrix<plssvm::matrix<real_type, layout>>(plssvm::shape{ 3, 2 }, plssvm::shape{ 4, 5 });
-
-    // create a new matrix from this matrix
-    const plssvm::matrix<real_type, layout> new_matr{ matr, plssvm::shape{ 4, 5 } };
-
-    // both matrices should be identical
-    EXPECT_EQ(new_matr, matr);
-}
-
-TYPED_TEST(Matrix, construct_from_same_matrix_layout_and_different_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct matrix
-    const auto matr = util::generate_random_matrix<plssvm::matrix<real_type, layout>>(plssvm::shape{ 3, 2 }, plssvm::shape{ 4, 5 });
-
-    // create a new matrix from this matrix
-    const plssvm::matrix<real_type, layout> new_matr{ matr, plssvm::shape{ 2, 3 } };
-
-    // both matrices shouldn't be identical because of different padding sizes
-    EXPECT_NE(new_matr, matr);
-    // check content
-    EXPECT_EQ(new_matr.layout(), layout);
-    EXPECT_EQ(new_matr.shape(), matr.shape());
-    // only padding sizes should have changed
-    EXPECT_EQ(new_matr.padding(), (plssvm::shape{ 2, 3 }));
-    EXPECT_EQ(new_matr.shape_padded(), (plssvm::shape{ 5, 5 }));
-
-    // check content
-    ASSERT_EQ(new_matr.size_padded(), 25);
-    for (std::size_t row = 0; row < new_matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < new_matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < new_matr.num_rows() && col < new_matr.num_cols()) {
-                EXPECT_EQ(new_matr(row, col), matr(row, col));
-            } else {
-                EXPECT_EQ(new_matr(row, col), real_type{ 0.0 });
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, construct_from_other_matrix_layout_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct matrix with the opposite layout type
-    const auto matr = util::generate_random_matrix<plssvm::matrix<real_type, layout == plssvm::layout_type::aos ? plssvm::layout_type::soa : plssvm::layout_type::aos>>(plssvm::shape{ 3, 2 });
-
-    // create a new matrix from this matrix
-    const plssvm::matrix<real_type, layout> new_matr{ matr, plssvm::shape{ 4, 5 } };
-
-    // both matrices shouldn't be identical because of different layout types
-    // check content
-    EXPECT_EQ(new_matr.layout(), layout);
-    EXPECT_EQ(new_matr.shape(), matr.shape());
-    // only padding sizes should have changed
-    EXPECT_EQ(new_matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(new_matr.shape_padded(), (plssvm::shape{ 7, 7 }));
-
-    // check content
-    ASSERT_EQ(new_matr.size_padded(), 49);
-    for (std::size_t row = 0; row < new_matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < new_matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < new_matr.num_rows() && col < new_matr.num_cols()) {
-                EXPECT_EQ(new_matr(row, col), matr(row, col));
-            } else {
-                EXPECT_EQ(new_matr(row, col), real_type{ 0.0 });
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, construct_from_2D_vector) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 0.3 }, real_type{ 0.4 } } };
-
-    // construct a matrix from a std::vector<std::vector<>>
-    const plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    ASSERT_EQ(matr.size_padded(), 4);
-    auto val = static_cast<real_type>(0.1);
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            EXPECT_FLOATING_POINT_EQ(matr(row, col), val);
-            val += real_type{ 0.1 };
-        }
-    }
-    EXPECT_EQ(matr.to_2D_vector(), matr_2D);
-
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ matr_2D.size(), matr_2D.front().size() }));
-}
-
-TYPED_TEST(Matrix, construct_from_2D_vector_empty) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix from a std::vector<std::vector<>>
-    const plssvm::matrix<real_type, layout> matr{ std::vector<std::vector<real_type>>{} };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, construct_from_2D_vector_invalid_columns) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix from an empty 2D vector with mismatching column sizes
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ { { real_type{ 0.0 }, real_type{ 0.0 } },
-                                                            { real_type{ 0.0 } } } }),
-                      plssvm::matrix_exception,
-                      "Each row in the matrix must contain the same amount of columns!");
-}
-
-TYPED_TEST(Matrix, construct_from_2D_vector_empty_columns) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix from an empty 2D vector with empty columns
-    const std::vector<std::vector<real_type>> matr{ {}, {} };
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ matr }),
-                      plssvm::matrix_exception,
-                      "The data to create the matrix must at least have one column!");
-}
-
-TYPED_TEST(Matrix, construct_from_2D_vector_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 0.3 }, real_type{ 0.4 } } };
-
-    // construct a matrix from a std::vector<std::vector<>>
-    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    ASSERT_EQ(matr.size_padded(), 42);
-    // check content while paying attention to padding!
-    auto val = static_cast<real_type>(0.1);
-    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < matr.num_rows() && col < matr.num_cols()) {
-                EXPECT_FLOATING_POINT_EQ(matr(row, col), val);
-                val += real_type{ 0.1 };
-            } else {
-                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
-            }
-        }
-    }
-    EXPECT_EQ(matr.to_2D_vector(), matr_2D);
-
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
-}
-
-TYPED_TEST(Matrix, construct_from_2D_vector_empty_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // construct a matrix from a std::vector<std::vector<>>
-    const std::vector<std::vector<real_type>> empty{};
-    const plssvm::matrix<real_type, layout> matr{ empty, plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
-    // check padding
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 4, 5 }));
-
-    // only padding entries should be present
-    ASSERT_EQ(matr.size_padded(), 20);
-    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{ 0.0 }; }));
-}
-
-TYPED_TEST(Matrix, construct_from_2D_vector_invalid_columns_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix from an empty 2D vector with mismatching column sizes
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ { { real_type{ 0.0 }, real_type{ 0.0 } },
-                                                            { real_type{ 0.0 } } },
-                                                          plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "Each row in the matrix must contain the same amount of columns!");
-}
-
-TYPED_TEST(Matrix, construct_from_2D_vector_empty_columns_and_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // try constructing a matrix from an empty 2D vector with empty columns
-    const std::vector<std::vector<real_type>> matr{ {}, {} };
-    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ matr, plssvm::shape{ 4, 5 } }),
-                      plssvm::matrix_exception,
-                      "The data to create the matrix must at least have one column!");
-}
-
-TYPED_TEST(Matrix, size) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-    // check getter
-    EXPECT_EQ(matr.size(), 168);
-}
-
-TYPED_TEST(Matrix, size_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_EQ(matr.size(), 168);
-}
-
-TYPED_TEST(Matrix, shape) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-    // check getter
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 42, 4 }));
-}
-
-TYPED_TEST(Matrix, shape_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_EQ(matr.shape(), (plssvm::shape{ 42, 4 }));
-}
-
-TYPED_TEST(Matrix, num_rows) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-    // check getter
-    EXPECT_EQ(matr.num_rows(), 42);
-}
-
-TYPED_TEST(Matrix, num_rows_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_EQ(matr.num_rows(), 42);
-}
-
-TYPED_TEST(Matrix, num_cols) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-    // check getter
-    EXPECT_EQ(matr.num_cols(), 4);
-}
-
-TYPED_TEST(Matrix, num_cols_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_EQ(matr.num_cols(), 4);
-}
-
-TYPED_TEST(Matrix, empty) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-    // check getter
-    EXPECT_FALSE(matr.empty());
-    EXPECT_TRUE((plssvm::matrix<real_type, layout>{}).empty());
-}
-
-TYPED_TEST(Matrix, empty_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr1{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_FALSE(matr1.empty());
-
-    // create empty matrix with padding
-    const plssvm::matrix<real_type, layout> matr2{ plssvm::shape{ 0, 0 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_TRUE(matr2.empty());
-}
-
-TYPED_TEST(Matrix, padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-    // check getter
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
-}
-
-TYPED_TEST(Matrix, padding_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-}
-
-TYPED_TEST(Matrix, shape_padded) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-    // check getter
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 42, 4 }));
-}
-
-TYPED_TEST(Matrix, shape_padded_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 46, 9 }));
-}
-
-TYPED_TEST(Matrix, num_rows_padded) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-    // check getter
-    EXPECT_EQ(matr.num_rows_padded(), 42);
-}
-
-TYPED_TEST(Matrix, num_rows_padded_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_EQ(matr.num_rows_padded(), 46);
-}
-
-TYPED_TEST(Matrix, num_cols_padded) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-    // check getter
-    EXPECT_EQ(matr.num_cols_padded(), 4);
-}
-
-TYPED_TEST(Matrix, num_cols_padded_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_EQ(matr.num_cols_padded(), 9);
-}
-
-TYPED_TEST(Matrix, size_padded) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-    // check getter
-    EXPECT_EQ(matr.size_padded(), 168);
-}
-
-TYPED_TEST(Matrix, size_padded_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_EQ(matr.size_padded(), 414);
-}
-
-TYPED_TEST(Matrix, is_padded) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    {
-        // create random matrix
-        const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
-        // check getter
-        EXPECT_FALSE(matr.is_padded());
-    }
-    {
-        // create random matrix
-        const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 0, 0 } };
-        // check getter
-        EXPECT_FALSE(matr.is_padded());
-    }
-}
-
-TYPED_TEST(Matrix, is_padded_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
-    // check getter
-    EXPECT_TRUE(matr.is_padded());
-}
-
-TYPED_TEST(Matrix, layout) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 4, 4 } };
-
-    // check getter
-    EXPECT_EQ(matr.layout(), layout);
-}
-
-TYPED_TEST(Matrix, restore_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create matrix and copy of it
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, real_type{ 42.0 } };
-    const plssvm::matrix<real_type, layout> ground_truth{ matr };
-    // restore padding
-    matr.restore_padding();
-    // nothing should have changed since no padding entries are present!
-    EXPECT_EQ(matr, ground_truth);
-}
-
-TYPED_TEST(Matrix, restore_padding_empty) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create matrix and copy of it
-    plssvm::matrix<real_type, layout> matr{};
-    const plssvm::matrix<real_type, layout> ground_truth{ matr };
-    // restore padding
-    matr.restore_padding();
-    // nothing should have changed since no padding entries are present!
-    EXPECT_EQ(matr, ground_truth);
-}
-
-TYPED_TEST(Matrix, restore_padding_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create matrix and copy of it
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, real_type{ 42.0 }, plssvm::shape{ 4, 4 } };
-    const plssvm::matrix<real_type, layout> ground_truth{ matr };
-    // set all padding entries to some value
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = matr.num_cols(); col < matr.num_cols_padded(); ++col) {
-            matr(row, col) = real_type{ 1.0 };
-        }
-    }
-    for (std::size_t row = matr.num_rows(); row < matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
-            matr(row, col) = real_type{ 2.0 };
-        }
-    }
-
-    // matrix shouldn't be equal
-    EXPECT_NE(matr, ground_truth);
-    // restore padding
-    matr.restore_padding();
-    // the matrix should look like at the beginning!
-    EXPECT_EQ(matr, ground_truth);
-}
-
-TYPED_TEST(Matrix, restore_padding_empty_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create matrix and copy of it
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, plssvm::shape{ 4, 4 } };
-    const plssvm::matrix<real_type, layout> ground_truth{ matr };
-    // set all padding entries to some value
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = matr.num_cols(); col < matr.num_cols_padded(); ++col) {
-            matr(row, col) = real_type{ 1.0 };
-        }
-    }
-    for (std::size_t row = matr.num_rows(); row < matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
-            matr(row, col) = real_type{ 2.0 };
-        }
-    }
-
-    // matrix shouldn't be equal
-    EXPECT_NE(matr, ground_truth);
-    // restore padding
-    matr.restore_padding();
-    // the matrix should look like at the beginning!
-    EXPECT_EQ(matr, ground_truth);
-}
-
-TYPED_TEST(Matrix, function_call_operator) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            EXPECT_EQ(matr(row, col), matr_2D[row][col]);
-        }
-    }
-}
-
-TYPED_TEST(Matrix, function_call_operator_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
-    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < matr.num_rows() && col < matr.num_cols()) {
-                EXPECT_EQ(matr(row, col), matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, function_call_operator_const) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            EXPECT_EQ(matr(row, col), matr_2D[row][col]);
-        }
-    }
-}
-
-TYPED_TEST(Matrix, function_call_operator_const_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
-    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < matr.num_rows() && col < matr.num_cols()) {
-                EXPECT_EQ(matr(row, col), matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, at) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            EXPECT_EQ(matr.at(row, col), matr_2D[row][col]);
-        }
-    }
-}
-
-TYPED_TEST(Matrix, at_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
-    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < matr.num_rows() && col < matr.num_cols()) {
-                EXPECT_EQ(matr.at(row, col), matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr.at(row, col), real_type{ 0.0 });
-                if (row >= matr.num_rows()) {
-                    EXPECT_THAT(this->get_capture(), ::testing::HasSubstr(fmt::format("WARNING: attempting to access padding row {} (only 2 real rows exist)!", row)));
-                } else {
-                    EXPECT_THAT(this->get_capture(), ::testing::HasSubstr(fmt::format("WARNING: attempting to access padding column {} (only 2 real columns exist)!", col)));
-                }
-                this->clear_capture();
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, at_out_of_bounce) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
-
-    // try out-of-bounce access
-    EXPECT_THROW_WHAT(std::ignore = matr.at(3, 0), plssvm::matrix_exception, "The current row (3) must be smaller than the number of rows including padding (2 + 0)!");
-    EXPECT_THROW_WHAT(std::ignore = matr.at(0, 2), plssvm::matrix_exception, "The current column (2) must be smaller than the number of columns including padding (2 + 0)!");
-}
-
-TYPED_TEST(Matrix, at_out_of_bounce_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
-
-    // try out-of-bounce access
-    EXPECT_THROW_WHAT(std::ignore = matr.at(6, 0), plssvm::matrix_exception, "The current row (6) must be smaller than the number of rows including padding (2 + 3)!");
-    EXPECT_THROW_WHAT(std::ignore = matr.at(0, 10), plssvm::matrix_exception, "The current column (10) must be smaller than the number of columns including padding (2 + 3)!");
-}
-
-TYPED_TEST(Matrix, at_const) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            EXPECT_EQ(matr.at(row, col), matr_2D[row][col]);
-        }
-    }
-}
-
-TYPED_TEST(Matrix, at_const_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
-    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if (row < matr.num_rows() && col < matr.num_cols()) {
-                EXPECT_EQ(matr.at(row, col), matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr.at(row, col), real_type{ 0.0 });
-                if (row >= matr.num_rows()) {
-                    EXPECT_THAT(this->get_capture(), ::testing::HasSubstr(fmt::format("WARNING: attempting to access padding row {} (only 2 real rows exist)!", row)));
-                } else {
-                    EXPECT_THAT(this->get_capture(), ::testing::HasSubstr(fmt::format("WARNING: attempting to access padding column {} (only 2 real columns exist)!", col)));
-                }
-                this->clear_capture();
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, at_const_out_of_bounce) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
-
-    // try out-of-bounce access
-    EXPECT_THROW_WHAT(std::ignore = matr.at(3, 0), plssvm::matrix_exception, "The current row (3) must be smaller than the number of rows including padding (2 + 0)!");
-    EXPECT_THROW_WHAT(std::ignore = matr.at(0, 2), plssvm::matrix_exception, "The current column (2) must be smaller than the number of columns including padding (2 + 0)!");
-}
-
-TYPED_TEST(Matrix, at_const_out_of_bounce_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
-
-    // try out-of-bounce access
-    EXPECT_THROW_WHAT(std::ignore = matr.at(6, 0), plssvm::matrix_exception, "The current row (6) must be smaller than the number of rows including padding (2 + 3)!");
-    EXPECT_THROW_WHAT(std::ignore = matr.at(0, 10), plssvm::matrix_exception, "The current column (10) must be smaller than the number of columns including padding (2 + 3)!");
-}
-
-TYPED_TEST(Matrix, subscript_operator) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if constexpr (layout == plssvm::layout_type::aos) {
-                EXPECT_EQ(matr[row * 2 + col], matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr[col * 2 + row], matr_2D[row][col]);
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, subscript_operator_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if constexpr (layout == plssvm::layout_type::aos) {
-                EXPECT_EQ(matr[row * (2 + 5) + col], matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr[col * (2 + 4) + row], matr_2D[row][col]);
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, subscript_operator_const) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if constexpr (layout == plssvm::layout_type::aos) {
-                EXPECT_EQ(matr[row * 2 + col], matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr[col * 2 + row], matr_2D[row][col]);
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, subscript_operator_const_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if constexpr (layout == plssvm::layout_type::aos) {
-                EXPECT_EQ(matr[row * (2 + 5) + col], matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr[col * (2 + 4) + row], matr_2D[row][col]);
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, linear_at) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if constexpr (layout == plssvm::layout_type::aos) {
-                EXPECT_EQ(matr.at(row * 2 + col), matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr.at(col * 2 + row), matr_2D[row][col]);
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, linear_at_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if constexpr (layout == plssvm::layout_type::aos) {
-                EXPECT_EQ(matr[row * (2 + 5) + col], matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr[col * (2 + 4) + row], matr_2D[row][col]);
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, linear_at_out_of_bounce) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
-
-    // try out-of-bounce access
-    EXPECT_THROW_WHAT(std::ignore = matr.at(4), plssvm::matrix_exception, "The current index (4) must be smaller than the total number of matrix entries (4)!");
-}
-
-TYPED_TEST(Matrix, linear_at_out_of_bounce_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
-
-    // try out-of-bounce access
-    EXPECT_THROW_WHAT(std::ignore = matr.at(36), plssvm::matrix_exception, "The current index (36) must be smaller than the total number of matrix entries (25)!");
-}
-
-TYPED_TEST(Matrix, linear_at_const) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if constexpr (layout == plssvm::layout_type::aos) {
-                EXPECT_EQ(matr.at(row * 2 + col), matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr.at(col * 2 + row), matr_2D[row][col]);
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, linear_at_const_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // check content
-    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
-    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
-    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
-    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
-        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
-            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
-            if constexpr (layout == plssvm::layout_type::aos) {
-                EXPECT_EQ(matr[row * (2 + 5) + col], matr_2D[row][col]);
-            } else {
-                EXPECT_EQ(matr[col * (2 + 4) + row], matr_2D[row][col]);
-            }
-        }
-    }
-}
-
-TYPED_TEST(Matrix, linear_at_const_out_of_bounce) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
-
-    // try out-of-bounce access
-    EXPECT_THROW_WHAT(std::ignore = matr.at(4), plssvm::matrix_exception, "The current index (4) must be smaller than the total number of matrix entries (4)!");
-}
-
-TYPED_TEST(Matrix, linear_at_const_out_of_bounce_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
-
-    // try out-of-bounce access
-    EXPECT_THROW_WHAT(std::ignore = matr.at(36), plssvm::matrix_exception, "The current index (36) must be smaller than the total number of matrix entries (25)!");
-}
-
-TYPED_TEST(Matrix, to_2D_vector) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // construct a matrix from a std::vector<std::vector<>>
-    const plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    EXPECT_EQ(matr.to_2D_vector(), matr_2D);
-}
-
-TYPED_TEST(Matrix, to_2D_vector_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
-                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // construct a matrix from a std::vector<std::vector<>>
-    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // check content
-    EXPECT_EQ(matr.to_2D_vector(), matr_2D);
-}
-
-TYPED_TEST(Matrix, to_2D_vector_padded) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // construct a matrix from a std::vector<std::vector<>>
-    const plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check content
-    EXPECT_EQ(matr.to_2D_vector_padded(), matr_2D);
-}
-
-TYPED_TEST(Matrix, to_2D_vector_padded_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create the 2D vector
-    std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 1.1 }, real_type{ 1.2 } } };
-
-    // construct a matrix from a std::vector<std::vector<>>
-    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
-
-    // add padding to ground truth vector
-    matr_2D[0].resize(matr_2D[0].size() + 5);
-    matr_2D[1].resize(matr_2D[1].size() + 5);
-    matr_2D.resize(matr_2D.size() + 4);
-    for (std::size_t row = 0; row < 4; ++row) {
-        matr_2D[2 + row].resize(7);
-    }
-
-    // check content
-    EXPECT_EQ(matr.to_2D_vector_padded(), matr_2D);
-}
-
-TYPED_TEST(Matrix, swap_member_function) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create data
-    const std::vector<std::vector<real_type>> matr1_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } }, { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
-    const std::vector<std::vector<real_type>> matr2_2D = { { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 0.3 }, real_type{ 0.4 } }, { real_type{ 0.5 }, real_type{ 0.6 } } };
-
-    // create two matrices and swap their content
-    plssvm::matrix<real_type, layout> matr1{ matr1_2D };
-    plssvm::matrix<real_type, layout> matr2{ matr2_2D, plssvm::shape{ 4, 5 } };
-
-    // swap both matrices
-    matr1.swap(matr2);
-
-    // check the content of matr1
-    ASSERT_EQ(matr1.shape(), (plssvm::shape{ 3, 2 }));
-    ASSERT_EQ(matr1.size(), 6);
-    EXPECT_EQ(matr1.to_2D_vector(), matr2_2D);
-    // check the padding of matr1
-    EXPECT_EQ(matr1.padding(), (plssvm::shape{ 4, 5 }));
-    ASSERT_EQ(matr1.shape_padded(), (plssvm::shape{ 7, 7 }));
-
-    // check the content of matr2
-    ASSERT_EQ(matr2.shape(), (plssvm::shape{ 2, 3 }));
-    ASSERT_EQ(matr2.size(), 6);
-    EXPECT_EQ(matr2.to_2D_vector(), matr1_2D);
-    // check the padding of matr2
-    EXPECT_EQ(matr2.padding(), (plssvm::shape{ 0, 0 }));
-    ASSERT_EQ(matr2.shape_padded(), (plssvm::shape{ 2, 3 }));
-}
-
-TYPED_TEST(Matrix, swap_free_function) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create data
-    const std::vector<std::vector<real_type>> matr1_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } }, { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
-    const std::vector<std::vector<real_type>> matr2_2D = { { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 0.3 }, real_type{ 0.4 } }, { real_type{ 0.5 }, real_type{ 0.6 } } };
-
-    // create two matrices and swap their content
-    plssvm::matrix<real_type, layout> matr1{ matr1_2D };
-    plssvm::matrix<real_type, layout> matr2{ matr2_2D, plssvm::shape{ 4, 5 } };
-
-    // swap both matrices
-    using std::swap;
-    swap(matr1, matr2);
-
-    // check the content of matr1
-    ASSERT_EQ(matr1.shape(), (plssvm::shape{ 3, 2 }));
-    ASSERT_EQ(matr1.size(), 6);
-    EXPECT_EQ(matr1.to_2D_vector(), matr2_2D);
-    // check the padding of matr1
-    EXPECT_EQ(matr1.padding(), (plssvm::shape{ 4, 5 }));
-    ASSERT_EQ(matr1.shape_padded(), (plssvm::shape{ 7, 7 }));
-
-    // check the content of matr2
-    ASSERT_EQ(matr2.shape(), (plssvm::shape{ 2, 3 }));
-    ASSERT_EQ(matr2.size(), 6);
-    EXPECT_EQ(matr2.to_2D_vector(), matr1_2D);
-    // check the padding of matr2
-    EXPECT_EQ(matr2.padding(), (plssvm::shape{ 0, 0 }));
-    ASSERT_EQ(matr2.shape_padded(), (plssvm::shape{ 2, 3 }));
-}
-
-TYPED_TEST(Matrix, operator_equal) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create matrices
-    const plssvm::matrix<real_type, layout> matr1{ plssvm::shape{ 3, 2 } };
-    const plssvm::matrix<real_type, layout> matr2{ plssvm::shape{ 2, 3 } };
-    const plssvm::matrix<real_type, layout> matr3{ plssvm::shape{ 3, 3 } };
-    const plssvm::matrix<real_type, layout> matr4{ plssvm::shape{ 3, 3 }, real_type{ 3.1415 } };
-    const plssvm::matrix<real_type, layout> matr5{ plssvm::shape{ 3, 3 }, real_type{} };
-    const plssvm::matrix<real_type, layout> matr6{ plssvm::shape{ 3, 3 }, plssvm::shape{ 4, 4 } };
-    const plssvm::matrix<real_type, layout> matr7{ plssvm::shape{ 3, 3 }, plssvm::shape{ 2, 4 } };
-    const plssvm::matrix<real_type, layout> matr8{ plssvm::shape{ 3, 3 }, real_type{}, plssvm::shape{ 2, 4 } };
-
-    // check for equality
-    EXPECT_FALSE(matr1 == matr2);
-    EXPECT_FALSE(matr1 == matr3);
-    EXPECT_FALSE(matr2 == matr3);
-    EXPECT_FALSE(matr3 == matr4);
-    EXPECT_TRUE(matr3 == matr5);
-    EXPECT_TRUE(matr4 == matr4);
-
-    EXPECT_FALSE(matr3 == matr6);
-    EXPECT_FALSE(matr3 == matr7);
-    EXPECT_FALSE(matr3 == matr8);
-    EXPECT_FALSE(matr6 == matr7);
-    EXPECT_TRUE(matr7 == matr8);
-}
-
-TYPED_TEST(Matrix, operator_unequal) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create matrices
-    const plssvm::matrix<real_type, layout> matr1{ plssvm::shape{ 3, 2 } };
-    const plssvm::matrix<real_type, layout> matr2{ plssvm::shape{ 2, 3 } };
-    const plssvm::matrix<real_type, layout> matr3{ plssvm::shape{ 3, 3 } };
-    const plssvm::matrix<real_type, layout> matr4{ plssvm::shape{ 3, 3 }, real_type{ 3.1415 } };
-    const plssvm::matrix<real_type, layout> matr5{ plssvm::shape{ 3, 3 }, real_type{} };
-    const plssvm::matrix<real_type, layout> matr6{ plssvm::shape{ 3, 3 }, plssvm::shape{ 4, 4 } };
-    const plssvm::matrix<real_type, layout> matr7{ plssvm::shape{ 3, 3 }, plssvm::shape{ 2, 4 } };
-    const plssvm::matrix<real_type, layout> matr8{ plssvm::shape{ 3, 3 }, real_type{}, plssvm::shape{ 2, 4 } };
-
-    // check for equality
-    EXPECT_TRUE(matr1 != matr2);
-    EXPECT_TRUE(matr1 != matr3);
-    EXPECT_TRUE(matr2 != matr3);
-    EXPECT_TRUE(matr3 != matr4);
-    EXPECT_FALSE(matr3 != matr5);
-    EXPECT_FALSE(matr4 != matr4);
-
-    EXPECT_TRUE(matr3 != matr6);
-    EXPECT_TRUE(matr3 != matr7);
-    EXPECT_TRUE(matr3 != matr8);
-    EXPECT_TRUE(matr6 != matr7);
-    EXPECT_FALSE(matr7 != matr8);
-}
-
-TYPED_TEST(Matrix, output_operator) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create data
-    const std::vector<std::vector<real_type>> matr_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } }, { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
-
-    // create matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check
-    std::string correct_output{};
-    for (const std::vector<real_type> &row : matr_2D) {
-        correct_output += fmt::format("{:.10e} \n", fmt::join(row, " "));
-    }
-    correct_output.pop_back();  // remove last newline
-    EXPECT_CONVERSION_TO_STRING(matr, correct_output);
-}
-
-TYPED_TEST(Matrix, output_operator_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create data
-    const std::vector<std::vector<real_type>> matr_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } }, { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
-
-    // create matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 4 } };
-
-    // check
-    std::string correct_output{};
-    for (const std::vector<real_type> &row : matr_2D) {
-        correct_output += fmt::format("{:.10e} \n", fmt::join(row, " "));
-    }
-    correct_output.pop_back();  // remove last newline (\n)
-    EXPECT_CONVERSION_TO_STRING(matr, correct_output);
-}
-
-TYPED_TEST(Matrix, formatter) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create data
-    const std::vector<std::vector<real_type>> matr_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } },
-                                                          { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
-
-    // create matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D };
-
-    // check
-    std::string correct_output{};
-    for (const std::vector<real_type> &row : matr_2D) {
-        correct_output += fmt::format("{:.10e} \n", fmt::join(row, " "));
-    }
-    correct_output.pop_back();  // remove last newline
-    EXPECT_EQ(fmt::format("{}", matr), correct_output);
-}
-
-TYPED_TEST(Matrix, formatter_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create data
-    const std::vector<std::vector<real_type>> matr_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } },
-                                                          { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
-
-    // create matrix
-    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 4 } };
-
-    // check
-    std::string correct_output{};
-    for (const std::vector<real_type> &row : matr_2D) {
-        correct_output += fmt::format("{:.10e} 0 0 0 0 \n", fmt::join(row, " "));
-    }
-    correct_output += "0 0 0 0 0 0 0 \n0 0 0 0 0 0 0 \n0 0 0 0 0 0 0 \n0 0 0 0 0 0 0 ";
-    EXPECT_EQ(fmt::format("{:p}", matr), correct_output);
-}
-
-//*************************************************************************************************************************************//
-//                                                      plssvm::matrix operations                                                      //
-//*************************************************************************************************************************************//
-template <typename T>
-class MatrixOperations : public ::testing::Test {
-  protected:
-    using fixture_real_type = util::test_parameter_type_at_t<0, T>;
-    constexpr static plssvm::layout_type fixture_layout = util::test_parameter_value_at_v<0, T>;
-
-    void SetUp() override {
-        A_ = plssvm::matrix<fixture_real_type, fixture_layout>{ { { 1, 2, 3 }, { 4, 5, 6 } } };
-        B_ = plssvm::matrix<fixture_real_type, fixture_layout>{ { { 1.5, 2.5, 3.5 }, { 4.5, 5.5, 6.5 } } };
-        c_ = std::vector<fixture_real_type>{ 1.5, -2.5 };
-        scalar_ = fixture_real_type{ 1.5 };
-    }
-
-    /**
-     * @brief Return the sample matrix @p A.
-     * @return the matrix vector (`[[nodiscard]]`)
-     */
-    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_A() noexcept { return A_; }
-
-    /**
-     * @brief Return the sample matrix @p B.
-     * @return the sample matrix (`[[nodiscard]]`)
-     */
-    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_B() noexcept { return B_; }
-
-    /**
-     * @brief Return the sample vector @p c.
-     * @return the sample vector (`[[nodiscard]]`)
-     */
-    [[nodiscard]] std::vector<fixture_real_type> &get_c() noexcept { return c_; }
-
-    /**
-     * @brief Return the empty matrix.
-     * @return the empty matrix (`[[nodiscard]]`)
-     */
-    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_empty() noexcept { return empty_; }
-
-    /**
-     * @brief Return the sample scalar.
-     * @return the scalar (`[[nodiscard]]`)
-     */
-    [[nodiscard]] fixture_real_type &get_scalar() noexcept { return scalar_; }
-
-  private:
-    /// Sample matrix to test the different operations.
-    plssvm::matrix<fixture_real_type, fixture_layout> A_{};
-    /// Sample matrix to test the different operations.
-    plssvm::matrix<fixture_real_type, fixture_layout> B_{};
-    /// Sample vector to test the different operations.
-    std::vector<fixture_real_type> c_{};
-    /// Empty matrix to test the different operations.
-    plssvm::matrix<fixture_real_type, fixture_layout> empty_{};
-    /// Sample scalar to test the different operations.
-    fixture_real_type scalar_{};
-};
-
-TYPED_TEST_SUITE(MatrixOperations, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
-
-template <typename T>
-class MatrixOperationsDeathTest : public ::testing::Test {
-  protected:
-    using fixture_real_type = util::test_parameter_type_at_t<0, T>;
-    constexpr static plssvm::layout_type fixture_layout = util::test_parameter_value_at_v<0, T>;
-
-    void SetUp() override {
-        A_ = plssvm::matrix<fixture_real_type, fixture_layout>{ { { 1, 2, 3 }, { 4, 5, 6 } } };
-        B_ = plssvm::matrix<fixture_real_type, fixture_layout>{ { { 1.5, 2.5 }, { 3.5, 4.5 }, { 5.5, 6.5 } } };
-    }
-
-    /**
-     * @brief Return the sample matrix @p A.
-     * @return the matrix vector (`[[nodiscard]]`)
-     */
-    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_A() noexcept { return A_; }
-
-    /**
-     * @brief Return the sample matrix @p B.
-     * @return the sample matrix (`[[nodiscard]]`)
-     */
-    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_B() noexcept { return B_; }
-
-    /**
-     * @brief Return the empty matrix.
-     * @return the empty matrix (`[[nodiscard]]`)
-     */
-    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_empty() noexcept { return empty_; }
-
-  private:
-    /// Sample matrix to test the different operations.
-    plssvm::matrix<fixture_real_type, fixture_layout> A_{};
-    /// Sample matrix to test the different operations.
-    plssvm::matrix<fixture_real_type, fixture_layout> B_{};
-    /// Empty matrix to test the different operations.
-    plssvm::matrix<fixture_real_type, fixture_layout> empty_{};
-};
-
-TYPED_TEST_SUITE(MatrixOperationsDeathTest, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
-
-TYPED_TEST(MatrixOperations, operator_scale_binary) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // scale a matrix using a scalar
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 1.5, 3.0, 4.5 }, { 6.0, 7.5, 9.0 } } };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_scalar() * this->get_A(), C);
-    }
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 2.25, 3.75, 5.25 }, { 6.75, 8.25, 9.75 } } };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_B() * this->get_scalar(), C);
-    }
-}
-
-TYPED_TEST(MatrixOperations, operator_scale_binary_empty) {
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() * this->get_scalar(), this->get_empty());
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_scalar() * this->get_empty(), this->get_empty());
-}
-
-TYPED_TEST(MatrixOperations, operator_scale_compound) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // scale a matrix using a scalar
-    const plssvm::matrix<real_type, layout> C{ { { 1.5, 3.0, 4.5 }, { 6.0, 7.5, 9.0 } } };
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_A() *= this->get_scalar(), C);
-}
-
-TYPED_TEST(MatrixOperations, operator_scale_compound_empty) {
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() *= this->get_scalar(), this->get_empty());
-}
-
-TYPED_TEST(MatrixOperations, operator_add_binary) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // add two matrices to each other
-    const plssvm::matrix<real_type, layout> C{ { { 2.5, 4.5, 6.5 }, { 8.5, 10.5, 12.5 } } };
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_A() + this->get_B(), C);
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_B() + this->get_A(), C);
-}
-
-TYPED_TEST(MatrixOperations, operator_add_binary_empty) {
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() + this->get_empty(), this->get_empty());
-}
-
-TYPED_TEST(MatrixOperations, operator_add_compound) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // add two matrices to each other
-    const plssvm::matrix<real_type, layout> C{ { { 2.5, 4.5, 6.5 }, { 8.5, 10.5, 12.5 } } };
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_A() += this->get_B(), C);
-}
-
-TYPED_TEST(MatrixOperations, operator_add_compound_empty) {
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() += this->get_empty(), this->get_empty());
-}
-
-TYPED_TEST(MatrixOperationsDeathTest, operator_add_binary) {
-    // try adding two matrices with mismatching sizes
-    EXPECT_DEATH(std::ignore = this->get_A() + this->get_B(), ::testing::HasSubstr("Error: shapes missmatch! ([2, 3] != [3, 2])"));
-    EXPECT_DEATH(std::ignore = this->get_B() + this->get_A(), ::testing::HasSubstr("Error: shapes missmatch! ([3, 2] != [2, 3])"));
-}
-
-TYPED_TEST(MatrixOperationsDeathTest, operator_add_compound) {
-    // try adding two matrices with mismatching sizes
-    EXPECT_DEATH(this->get_A() += this->get_B(), ::testing::HasSubstr("Error: shapes missmatch! ([2, 3] != [3, 2])"));
-    EXPECT_DEATH(this->get_B() += this->get_A(), ::testing::HasSubstr("Error: shapes missmatch! ([3, 2] != [2, 3])"));
-}
-
-TYPED_TEST(MatrixOperations, operator_subtract_binary) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // subtract two matrices from each other
-    {
-        const plssvm::matrix<real_type, layout> C{ { { -0.5, -0.5, -0.5 }, { -0.5, -0.5, -0.5 } } };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_A() - this->get_B(), C);
-    }
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 0.5, 0.5, 0.5 }, { 0.5, 0.5, 0.5 } } };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_B() - this->get_A(), C);
-    }
-}
-
-TYPED_TEST(MatrixOperations, operator_subtract_binary_empty) {
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() - this->get_empty(), this->get_empty());
-}
-
-TYPED_TEST(MatrixOperations, operator_subtract_compound) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // add two matrices to each other
-    const plssvm::matrix<real_type, layout> C{ { { -0.5, -0.5, -0.5 }, { -0.5, -0.5, -0.5 } } };
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_A() -= this->get_B(), C);
-}
-
-TYPED_TEST(MatrixOperations, operator_subtract_compound_empty) {
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() -= this->get_empty(), this->get_empty());
-}
-
-TYPED_TEST(MatrixOperationsDeathTest, operator_subtract_binary) {
-    // try subtracting two matrices with mismatching sizes
-    EXPECT_DEATH(std::ignore = this->get_A() - this->get_B(), ::testing::HasSubstr("Error: shapes missmatch! ([2, 3] != [3, 2])"));
-    EXPECT_DEATH(std::ignore = this->get_B() - this->get_A(), ::testing::HasSubstr("Error: shapes missmatch! ([3, 2] != [2, 3])"));
-}
-
-TYPED_TEST(MatrixOperationsDeathTest, operator_subtract_compound) {
-    // try subtracting two matrices with mismatching sizes
-    EXPECT_DEATH(this->get_A() -= this->get_B(), ::testing::HasSubstr("Error: shapes missmatch! ([2, 3] != [3, 2])"));
-    EXPECT_DEATH(this->get_B() -= this->get_A(), ::testing::HasSubstr("Error: shapes missmatch! ([3, 2] != [2, 3])"));
-}
-
-TYPED_TEST(MatrixOperations, operator_matrix_multiplication_square) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    const plssvm::matrix<real_type, layout> square_A{ { { 1.0, 2.0, 3.0 }, { 4.0, 5.0, 6.0 }, { 7.0, 8.0, 9.0 } } };
-    const plssvm::matrix<real_type, layout> square_B{ { { 1.5, 2.5, 3.5 }, { 4.5, 5.5, 6.5 }, { 7.5, 8.5, 9.5 } } };
-
-    // matrix-matrix multiplication with squared matrices
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 33.0, 39.0, 45.0 }, { 73.5, 88.5, 103.5 }, { 114.0, 138.0, 162.0 } } };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(square_A * square_B, C);
-    }
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 36.0, 43.5, 51.0 }, { 72.0, 88.5, 105.0 }, { 108.0, 133.5, 159.0 } } };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(square_B * square_A, C);
-    }
-}
-
-TYPED_TEST(MatrixOperations, operator_matrix_multiplication) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    const plssvm::matrix<real_type, layout> input_A{ { { 1, 2, 3 }, { 4, 5, 6 } } };
-    const plssvm::matrix<real_type, layout> input_B{ { { 1.5, 2.5 }, { 4.5, 5.5 }, { 7.5, 8.5 } } };
-
-    // matrix-matrix multiplication
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 33.0, 39.0 }, { 73.5, 88.5 } } };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(input_A * input_B, C);
-    }
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 11.5, 15.5, 19.5 }, { 26.5, 36.5, 46.5 }, { 41.5, 57.5, 73.5 } } };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(input_B * input_A, C);
-    }
-}
-
-TYPED_TEST(MatrixOperations, operator_matrix_multiplication_empty) {
-    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() * this->get_empty(), this->get_empty());
-}
-
-TYPED_TEST(MatrixOperationsDeathTest, operator_matrix_multiplication) {
-    EXPECT_DEATH(std::ignore = this->get_A() * this->get_empty(), ::testing::HasSubstr("Error: shapes missmatch! (3 (num_cols) != 0 (num_rows))"));
-    EXPECT_DEATH(std::ignore = this->get_empty() * this->get_A(), ::testing::HasSubstr("Error: shapes missmatch! (0 (num_cols) != 2 (num_rows))"));
-}
-
-TYPED_TEST(MatrixOperations, operator_rowwise_dot) {
-    using real_type = typename TestFixture::fixture_real_type;
-
-    // rowwise dot product
-    const std::vector<real_type> ret{ 17.0, 84.5 };
-    EXPECT_FLOATING_POINT_VECTOR_EQ(rowwise_dot(this->get_A(), this->get_B()), ret);
-    EXPECT_FLOATING_POINT_VECTOR_EQ(rowwise_dot(this->get_B(), this->get_A()), ret);
-}
-
-TYPED_TEST(MatrixOperations, operator_rowwise_dot_empty) {
-    EXPECT_FLOATING_POINT_VECTOR_EQ(rowwise_dot(this->get_empty(), this->get_empty()), {});
-}
-
-TYPED_TEST(MatrixOperationsDeathTest, operator_rowwise_dot) {
-    // sizes missmatch
-    EXPECT_DEATH(std::ignore = rowwise_dot({}, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! ([0, 0] != [2, 3])"));
-    EXPECT_DEATH(std::ignore = rowwise_dot(this->get_A(), this->get_B()), ::testing::HasSubstr("Error: shapes missmatch! ([2, 3] != [3, 2])"));
-}
-
-TYPED_TEST(MatrixOperations, operator_rowwise_scale) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // rowwise scale
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 1.5, 3.0, 4.5 }, { -10.0, -12.5, -15.0 } } };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(rowwise_scale(this->get_c(), this->get_A()), C);
-    }
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 2.25, 3.75, 5.25 }, { -11.25, -13.75, -16.25 } } };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(rowwise_scale(this->get_c(), this->get_B()), C);
-    }
-}
-
-TYPED_TEST(MatrixOperations, operator_rowwise_scale_empty) {
-    EXPECT_FLOATING_POINT_MATRIX_EQ(rowwise_scale({}, this->get_empty()), this->get_empty());
-}
-
-TYPED_TEST(MatrixOperationsDeathTest, operator_rowwise_scale) {
-    using real_type = typename TestFixture::fixture_real_type;
-
-    // sizes missmatch
-    EXPECT_DEATH(std::ignore = rowwise_scale({}, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (0 != 2 (num_rows))"));
-    EXPECT_DEATH(std::ignore = rowwise_scale(std::vector<real_type>{ 1.0, 2.0, 3.0 }, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (3 != 2 (num_rows))"));
-}
-
-TYPED_TEST(MatrixOperations, operator_masked_rowwise_scale) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // rowwise scale
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 0.0, 0.0, 0.0 }, { -10.0, -12.5, -15.0 } } };
-        const std::vector<unsigned long long> mask{ 0, 1 };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(masked_rowwise_scale(mask, this->get_c(), this->get_A()), C);
-    }
-    {
-        const plssvm::matrix<real_type, layout> C{ { { 2.25, 3.75, 5.25 }, { 0.0, 0.0, 0.0 } } };
-        const std::vector<unsigned long long> mask{ 1, 0 };
-        EXPECT_FLOATING_POINT_MATRIX_EQ(masked_rowwise_scale(mask, this->get_c(), this->get_B()), C);
-    }
-}
-
-TYPED_TEST(MatrixOperations, operator_masked_rowwise_scale_empty) {
-    EXPECT_FLOATING_POINT_MATRIX_EQ(masked_rowwise_scale({}, {}, this->get_empty()), this->get_empty());
-}
-
-TYPED_TEST(MatrixOperationsDeathTest, operator_masked_rowwise_scale) {
-    using real_type = typename TestFixture::fixture_real_type;
-
-    const std::vector<real_type> scale{ 1.0, 2.0 };
-    const std::vector<unsigned long long> mask{ 1, 0 };
-
-    // sizes missmatch
-    EXPECT_DEATH(std::ignore = masked_rowwise_scale(mask, {}, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (0 != 2 (num_rows))"));
-    EXPECT_DEATH(std::ignore = masked_rowwise_scale(mask, std::vector<real_type>{ 1.0, 2.0, 3.0 }, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (3 != 2 (num_rows))"));
-    EXPECT_DEATH(std::ignore = masked_rowwise_scale(std::vector<unsigned long long>{}, scale, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (0 != 2 (num_rows))"));
-    EXPECT_DEATH(std::ignore = masked_rowwise_scale(std::vector<unsigned long long>{ 1, 0, 1 }, scale, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (3 != 2 (num_rows))"));
-}
-
-TYPED_TEST(MatrixOperations, operator_variance) {
-    using real_type = typename TestFixture::fixture_real_type;
-
-    EXPECT_FLOATING_POINT_NEAR(variance(this->get_A()), (real_type{ 17.5 } / static_cast<real_type>(this->get_A().size())));
-    EXPECT_FLOATING_POINT_NEAR(variance(this->get_B()), (real_type{ 17.5 } / static_cast<real_type>(this->get_A().size())));
-}
-
-TYPED_TEST(Matrix, matrix_shorthands) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    if constexpr (layout == plssvm::layout_type::aos) {
-        ::testing::StaticAssertTypeEq<plssvm::matrix<real_type, layout>, plssvm::aos_matrix<real_type>>();
-    } else if constexpr (layout == plssvm::layout_type::soa) {
-        ::testing::StaticAssertTypeEq<plssvm::matrix<real_type, layout>, plssvm::soa_matrix<real_type>>();
-    } else {
-        FAIL() << "Unrecognized layout type!";
-    }
-}
-
-template <typename T>
-class MatrixDeathTest : public Matrix<T> { };
-
-TYPED_TEST_SUITE(MatrixDeathTest, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
-
-TYPED_TEST(MatrixDeathTest, function_call_operator_out_of_bounce) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
-
-    // try out-of-bounce access
-    EXPECT_DEATH(std::ignore = matr(3, 0), ::testing::HasSubstr("The current row (3) must be smaller than the number of padded rows (2)!"));
-    EXPECT_DEATH(std::ignore = matr(0, 2), ::testing::HasSubstr("The current column (2) must be smaller than the number of padded columns (2)!"));
-}
-
-TYPED_TEST(MatrixDeathTest, function_call_operator_out_of_bounce_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
-
-    // try out-of-bounce access
-    EXPECT_DEATH(std::ignore = matr(6, 0), ::testing::HasSubstr("The current row (6) must be smaller than the number of padded rows (5)!"));
-    EXPECT_DEATH(std::ignore = matr(0, 10), ::testing::HasSubstr("The current column (10) must be smaller than the number of padded columns (5)!"));
-}
-
-TYPED_TEST(MatrixDeathTest, function_call_operator_const_out_of_bounce) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
-
-    // try out-of-bounce access
-    EXPECT_DEATH(std::ignore = matr(3, 0), ::testing::HasSubstr("The current row (3) must be smaller than the number of padded rows (2)!"));
-    EXPECT_DEATH(std::ignore = matr(0, 2), ::testing::HasSubstr("The current column (2) must be smaller than the number of padded columns (2)!"));
-}
-
-TYPED_TEST(MatrixDeathTest, function_call_operator_const_out_of_bounce_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 4, 5 } };
-
-    // try out-of-bounce access
-    EXPECT_DEATH(std::ignore = matr(6, 0), ::testing::HasSubstr("The current row (6) must be smaller than the number of padded rows (6)!"));
-    EXPECT_DEATH(std::ignore = matr(0, 10), ::testing::HasSubstr("The current column (10) must be smaller than the number of padded columns (7)!"));
-}
-
-TYPED_TEST(MatrixDeathTest, subscript_operator_out_of_bounce) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
-
-    // try out-of-bounce access
-    EXPECT_DEATH(std::ignore = matr[4], ::testing::HasSubstr("The current index (4) must be smaller than the total number of matrix entries (4)!"));
-}
-
-TYPED_TEST(MatrixDeathTest, subscript_operator_out_of_bounce_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
-
-    // try out-of-bounce access
-    EXPECT_DEATH(std::ignore = matr[36], ::testing::HasSubstr("The current index (36) must be smaller than the total number of matrix entries (25)!"));
-}
-
-TYPED_TEST(MatrixDeathTest, subscript_operator_const_out_of_bounce) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
-
-    // try out-of-bounce access
-    EXPECT_DEATH(std::ignore = matr[4], ::testing::HasSubstr("The current index (4) must be smaller than the total number of matrix entries (4)!"));
-}
-
-TYPED_TEST(MatrixDeathTest, subscript_operator_const_out_of_bounce_with_padding) {
-    using real_type = typename TestFixture::fixture_real_type;
-    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
-
-    // create random matrix
-    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 4, 5 } };
-
-    // try out-of-bounce access
-    EXPECT_DEATH(std::ignore = matr[42], ::testing::HasSubstr("The current index (42) must be smaller than the total number of matrix entries (42)!"));
-}
diff --git a/tests/matrix/constructors.cpp b/tests/matrix/constructors.cpp
new file mode 100644
index 000000000..d10a8364d
--- /dev/null
+++ b/tests/matrix/constructors.cpp
@@ -0,0 +1,877 @@
+/**
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Test the plssvm::matrix class constructors.
+ */
+
+#include "plssvm/exceptions/exceptions.hpp"  // plssvm::matrix_exception
+#include "plssvm/matrix.hpp"
+#include "plssvm/shape.hpp"  // plssvm::shape
+
+#include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT
+#include "tests/naming.hpp"              // naming::test_parameter_to_name
+#include "tests/types_to_test.hpp"       // util::{real_type_layout_type_gtest, test_parameter_type_at_t, test_parameter_value_at_v}
+#include "tests/utility.hpp"             // util::{generate_random_matrix, redirect_output}
+
+#include "fmt/format.h"   // fmt::format
+#include "gtest/gtest.h"  // TEST, TYPED_TEST, TYPED_TEST_SUITE, EXPECT_EQ, EXPECT_TRUE, ASSERT_EQ, SCOPED_TRACE, ::testing::Test
+
+#include <cstddef>   // std::size_t
+#include <iostream>  // std::clog
+#include <vector>    // std::vector
+
+template <typename T>
+class MatrixConstructors : public ::testing::Test,
+                           public util::redirect_output<&std::clog> {
+  protected:
+    using fixture_real_type = util::test_parameter_type_at_t<0, T>;
+    constexpr static plssvm::layout_type fixture_layout = util::test_parameter_value_at_v<0, T>;
+};
+
+TYPED_TEST_SUITE(MatrixConstructors, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
+
+TYPED_TEST(MatrixConstructors, ConstructDefault) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // default construct matrix
+    const plssvm::matrix<real_type, layout> matr{};
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSize) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 3, 2 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 3, 2 }));
+    ASSERT_EQ(matr.size(), 6);
+    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size(), [](const real_type val) { return val == real_type{}; }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 3, 2 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeEmpty) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeZeroNumRows) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero rows
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 } }),
+                      plssvm::matrix_exception,
+                      "The number of rows is zero but the number of columns is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeZeroNumCols) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero columns
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 } }),
+                      plssvm::matrix_exception,
+                      "The number of columns is zero but the number of rows is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 3, 2 }, plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 3, 2 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 7, 7 }));
+    // default values == padding values
+    ASSERT_EQ(matr.size_padded(), 49);
+    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{}; }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeEmptyAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 4, 5 }));
+
+    // default values == padding values
+    ASSERT_EQ(matr.size_padded(), 20);
+    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{}; }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeEmptyAndZeroPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, plssvm::shape{ 0, 0 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeZeroNumRowsAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero rows
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The number of rows is zero but the number of columns is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeZeroNumColsAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero columns
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The number of columns is zero but the number of rows is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndDefaultValue) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, real_type{ 3.1415 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
+    ASSERT_EQ(matr.size(), 6);
+    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size(), [](const real_type val) { return val == real_type{ 3.1415 }; }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 2, 3 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndDefaultValueEmpty) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, real_type{ 3.1415 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndDefaultValueZeroNumRows) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero rows
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, real_type{ 3.1415 } }),
+                      plssvm::matrix_exception,
+                      "The number of rows is zero but the number of columns is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndDefaultValueZeroNumCols) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero columns
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, real_type{ 3.1415 } }),
+                      plssvm::matrix_exception,
+                      "The number of columns is zero but the number of rows is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndDefaultValueAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, real_type{ 3.1415 }, plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 8 }));
+
+    // check content while paying attention to padding!
+    ASSERT_EQ(matr.size_padded(), 48);
+    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < matr.num_rows() && col < matr.num_cols()) {
+                EXPECT_EQ(matr(row, col), real_type{ 3.1415 });
+            } else {
+                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndDefaultValueEmptyAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, real_type{ 3.1415 }, plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 4, 5 }));
+
+    // only padding entries should be present
+    ASSERT_EQ(matr.size_padded(), 20);
+    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{ 0.0 }; }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndDefaultValueEmptyAndZeroPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, real_type{ 3.1415 }, plssvm::shape{ 0, 0 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndDefaultValueZeroNumRowsAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero rows
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, real_type{ 3.1415 }, plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The number of rows is zero but the number of columns is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndDefaultValueZeroNumColsAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero columns
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, real_type{ 3.1415 }, plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The number of columns is zero but the number of rows is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVector) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const std::vector<real_type> data = { real_type{ 0.1 }, real_type{ 0.2 }, real_type{ 0.3 }, real_type{ 0.4 }, real_type{ 0.5 }, real_type{ 0.6 } };
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, data };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
+    ASSERT_EQ(matr.size(), 6);
+    for (std::size_t i = 0; i < matr.size(); ++i) {
+        EXPECT_FLOATING_POINT_EQ(*(matr.data() + i), data[i]);
+    }
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 2, 3 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVectorEmpty) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, std::vector<real_type>{} };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVectorValueZeroNumRows) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero rows
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, std::vector<real_type>(2) }),
+                      plssvm::matrix_exception,
+                      "The number of rows is zero but the number of columns is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVectorZeroNumCols) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero columns
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, std::vector<real_type>(2) }),
+                      plssvm::matrix_exception,
+                      "The number of columns is zero but the number of rows is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVectorSizeMismatch) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero columns
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 2 }, std::vector<real_type>(2) }),
+                      plssvm::matrix_exception,
+                      "The number of entries in the matrix (4) must be equal to the size of the data (2)!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVectorAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const std::vector<real_type> data = { real_type{ 0.1 }, real_type{ 0.2 }, real_type{ 0.3 }, real_type{ 0.4 }, real_type{ 0.5 }, real_type{ 0.6 } };
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, data, plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 8 }));
+
+    // check content while paying attention to padding!
+    ASSERT_EQ(matr.size_padded(), 48);
+    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < matr.num_rows() && col < matr.num_cols()) {
+                const real_type val = layout == plssvm::layout_type::aos ? data[row * 3 + col] : data[col * 2 + row];
+                EXPECT_EQ(matr(row, col), val);
+            } else {
+                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVectorEmptyAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, std::vector<real_type>{}, plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 4, 5 }));
+
+    // only padding entries should be present
+    ASSERT_EQ(matr.size_padded(), 20);
+    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{ 0.0 }; }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVectorEmptyAndZeroPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, std::vector<real_type>{}, plssvm::shape{ 0, 0 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVectorValueZeroNumRowsAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero rows
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, std::vector<real_type>(2), plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The number of rows is zero but the number of columns is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVectorZeroNumColsAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero columns
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, std::vector<real_type>(2), plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The number of columns is zero but the number of rows is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndVectorSizeMismatchAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero columns
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 2 }, std::vector<real_type>(3), plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The number of entries in the matrix (4) must be equal to the size of the data (3)!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndPointer) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const std::vector<real_type> data = { real_type{ 0.1 }, real_type{ 0.2 }, real_type{ 0.3 }, real_type{ 0.4 }, real_type{ 0.5 }, real_type{ 0.6 } };
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, data.data() };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
+    ASSERT_EQ(matr.size(), 6);
+    for (std::size_t i = 0; i < matr.size(); ++i) {
+        EXPECT_FLOATING_POINT_EQ(*(matr.data() + i), data[i]);
+    }
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 2, 3 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndPointerEmpty) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const std::vector<real_type> data{};
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, data.data() };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndNullptrPointer) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size and a nullptr
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 3 }, nullptr }),
+                      plssvm::matrix_exception,
+                      "The provided data pointer may not be a nullptr if the matrix size is greater than 0!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndPointerValueZeroNumRows) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero rows
+    const std::vector<real_type> data(2);
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, data.data() }),
+                      plssvm::matrix_exception,
+                      "The number of rows is zero but the number of columns is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndPointerZeroNumCols) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero columns
+    const std::vector<real_type> data(2);
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, data.data() }),
+                      plssvm::matrix_exception,
+                      "The number of columns is zero but the number of rows is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndPointerAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const std::vector<real_type> data = { real_type{ 0.1 }, real_type{ 0.2 }, real_type{ 0.3 }, real_type{ 0.4 }, real_type{ 0.5 }, real_type{ 0.6 } };
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, data.data(), plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 3 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 8 }));
+
+    // check content while paying attention to padding!
+    ASSERT_EQ(matr.size_padded(), 48);
+    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < matr.num_rows() && col < matr.num_cols()) {
+                const real_type val = layout == plssvm::layout_type::aos ? data[row * 3 + col] : data[col * 2 + row];
+                EXPECT_EQ(matr(row, col), val);
+            } else {
+                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndPointerEmptyAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const std::vector<real_type> data;
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, data.data(), plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 4, 5 }));
+
+    // only padding entries should be present
+    ASSERT_EQ(matr.size_padded(), 20);
+    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{ 0.0 }; }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndNullptrEmptyAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size, padding and a nullptr
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 3 }, nullptr, plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The provided data pointer may not be a nullptr if the matrix size is greater than 0!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndPointerEmptyAndZeroPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix with a specific size
+    const std::vector<real_type> data;
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, data.data(), plssvm::shape{ 0, 0 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndPointerValueZeroNumRowsAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero rows
+    const std::vector<real_type> data(2);
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 0, 2 }, data.data(), plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The number of rows is zero but the number of columns is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructWithSizeAndPointerZeroNumColsAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix with zero columns
+    const std::vector<real_type> data(2);
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ plssvm::shape{ 2, 0 }, data.data(), plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The number of columns is zero but the number of rows is not!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFromSameMatrixLayout) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct matrix
+    const auto matr = util::generate_random_matrix<plssvm::matrix<real_type, layout>>(plssvm::shape{ 3, 2 });
+
+    // create a new matrix from this matrix
+    const plssvm::matrix<real_type, layout> new_matr{ matr };  // NOLINT(performance-unnecessary-copy-initialization): copy explicitly wanted
+
+    // both matrices should be identical
+    EXPECT_EQ(new_matr, matr);
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFromOtherMatrixLayout) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct matrix with the opposite layout type
+    const auto matr = util::generate_random_matrix<plssvm::matrix<real_type, layout == plssvm::layout_type::aos ? plssvm::layout_type::soa : plssvm::layout_type::aos>>(plssvm::shape{ 3, 2 });
+
+    // create a new matrix from this matrix
+    const plssvm::matrix<real_type, layout> new_matr{ matr };
+
+    // both matrices should be identical
+    EXPECT_EQ(new_matr.layout(), layout);
+    EXPECT_EQ(new_matr.shape(), matr.shape());
+    // check padding
+    EXPECT_EQ(new_matr.padding(), matr.padding());
+    EXPECT_EQ(new_matr.shape_padded(), matr.shape_padded());
+
+    // check content
+    ASSERT_EQ(new_matr.size_padded(), matr.size_padded());
+    for (std::size_t row = 0; row < new_matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < new_matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < new_matr.num_rows() && col < new_matr.num_cols()) {
+                EXPECT_EQ(new_matr(row, col), matr(row, col));
+            } else {
+                EXPECT_EQ(new_matr(row, col), real_type{ 0.0 });
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFromSameMatrixLayoutAndSamePadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct matrix
+    const auto matr = util::generate_random_matrix<plssvm::matrix<real_type, layout>>(plssvm::shape{ 3, 2 }, plssvm::shape{ 4, 5 });
+
+    // create a new matrix from this matrix
+    const plssvm::matrix<real_type, layout> new_matr{ matr, plssvm::shape{ 4, 5 } };
+
+    // both matrices should be identical
+    EXPECT_EQ(new_matr, matr);
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFromSameMatrixLayoutAndDifferentPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct matrix
+    const auto matr = util::generate_random_matrix<plssvm::matrix<real_type, layout>>(plssvm::shape{ 3, 2 }, plssvm::shape{ 4, 5 });
+
+    // create a new matrix from this matrix
+    const plssvm::matrix<real_type, layout> new_matr{ matr, plssvm::shape{ 2, 3 } };
+
+    // both matrices shouldn't be identical because of different padding sizes
+    EXPECT_NE(new_matr, matr);
+    // check content
+    EXPECT_EQ(new_matr.layout(), layout);
+    EXPECT_EQ(new_matr.shape(), matr.shape());
+    // only padding sizes should have changed
+    EXPECT_EQ(new_matr.padding(), (plssvm::shape{ 2, 3 }));
+    EXPECT_EQ(new_matr.shape_padded(), (plssvm::shape{ 5, 5 }));
+
+    // check content
+    ASSERT_EQ(new_matr.size_padded(), 25);
+    for (std::size_t row = 0; row < new_matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < new_matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < new_matr.num_rows() && col < new_matr.num_cols()) {
+                EXPECT_EQ(new_matr(row, col), matr(row, col));
+            } else {
+                EXPECT_EQ(new_matr(row, col), real_type{ 0.0 });
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFromOtherMatrixLayoutAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct matrix with the opposite layout type
+    const auto matr = util::generate_random_matrix<plssvm::matrix<real_type, layout == plssvm::layout_type::aos ? plssvm::layout_type::soa : plssvm::layout_type::aos>>(plssvm::shape{ 3, 2 });
+
+    // create a new matrix from this matrix
+    const plssvm::matrix<real_type, layout> new_matr{ matr, plssvm::shape{ 4, 5 } };
+
+    // both matrices shouldn't be identical because of different layout types
+    // check content
+    EXPECT_EQ(new_matr.layout(), layout);
+    EXPECT_EQ(new_matr.shape(), matr.shape());
+    // only padding sizes should have changed
+    EXPECT_EQ(new_matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(new_matr.shape_padded(), (plssvm::shape{ 7, 7 }));
+
+    // check content
+    ASSERT_EQ(new_matr.size_padded(), 49);
+    for (std::size_t row = 0; row < new_matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < new_matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < new_matr.num_rows() && col < new_matr.num_cols()) {
+                EXPECT_EQ(new_matr(row, col), matr(row, col));
+            } else {
+                EXPECT_EQ(new_matr(row, col), real_type{ 0.0 });
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFrom2DVector) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 0.3 }, real_type{ 0.4 } } };
+
+    // construct a matrix from a std::vector<std::vector<>>
+    const plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    ASSERT_EQ(matr.size_padded(), 4);
+    auto val = static_cast<real_type>(0.1);
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            EXPECT_FLOATING_POINT_EQ(matr(row, col), val);
+            val += real_type{ 0.1 };
+        }
+    }
+    EXPECT_EQ(matr.to_2D_vector(), matr_2D);
+
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ matr_2D.size(), matr_2D.front().size() }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFrom2DVectorEmpty) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix from a std::vector<std::vector<>>
+    const plssvm::matrix<real_type, layout> matr{ std::vector<std::vector<real_type>>{} };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFrom2DVectorInvalidColumns) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix from an empty 2D vector with mismatching column sizes
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ { { real_type{ 0.0 }, real_type{ 0.0 } },
+                                                            { real_type{ 0.0 } } } }),
+                      plssvm::matrix_exception,
+                      "Each row in the matrix must contain the same amount of columns!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFrom2DVectorEmptyColumns) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix from an empty 2D vector with empty columns
+    const std::vector<std::vector<real_type>> matr{ {}, {} };
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ matr }),
+                      plssvm::matrix_exception,
+                      "The data to create the matrix must at least have one column!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFrom2DVectorAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 0.3 }, real_type{ 0.4 } } };
+
+    // construct a matrix from a std::vector<std::vector<>>
+    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    ASSERT_EQ(matr.size_padded(), 42);
+    // check content while paying attention to padding!
+    auto val = static_cast<real_type>(0.1);
+    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < matr.num_rows() && col < matr.num_cols()) {
+                EXPECT_FLOATING_POINT_EQ(matr(row, col), val);
+                val += real_type{ 0.1 };
+            } else {
+                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
+            }
+        }
+    }
+    EXPECT_EQ(matr.to_2D_vector(), matr_2D);
+
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFrom2DVectorEmptyAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // construct a matrix from a std::vector<std::vector<>>
+    const std::vector<std::vector<real_type>> empty{};
+    const plssvm::matrix<real_type, layout> matr{ empty, plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 0, 0 }));
+    // check padding
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 4, 5 }));
+
+    // only padding entries should be present
+    ASSERT_EQ(matr.size_padded(), 20);
+    EXPECT_TRUE(std::all_of(matr.data(), matr.data() + matr.size_padded(), [](const real_type val) { return val == real_type{ 0.0 }; }));
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFrom2DVectorInvalidColumnsAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix from an empty 2D vector with mismatching column sizes
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ { { real_type{ 0.0 }, real_type{ 0.0 } },
+                                                            { real_type{ 0.0 } } },
+                                                          plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "Each row in the matrix must contain the same amount of columns!");
+}
+
+TYPED_TEST(MatrixConstructors, ConstructFrom2DVectorEmptyColumnsAndPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // try constructing a matrix from an empty 2D vector with empty columns
+    const std::vector<std::vector<real_type>> matr{ {}, {} };
+    EXPECT_THROW_WHAT((plssvm::matrix<real_type, layout>{ matr, plssvm::shape{ 4, 5 } }),
+                      plssvm::matrix_exception,
+                      "The data to create the matrix must at least have one column!");
+}
diff --git a/tests/matrix/layout_type.cpp b/tests/matrix/layout_type.cpp
new file mode 100644
index 000000000..e101f88ff
--- /dev/null
+++ b/tests/matrix/layout_type.cpp
@@ -0,0 +1,60 @@
+/**
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Test the plssvm::layout_type used in the plssvm::matrix class.
+ */
+
+#include "plssvm/matrix.hpp"
+
+#include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING
+
+#include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_TRUE
+
+#include <sstream>  // std::istringstream, std::ostringstream
+#include <string>   // std::string
+
+// check whether the plssvm::layout_type -> std::string conversions are correct
+TEST(LayoutType, ToString) {
+    // check conversions to std::string
+    EXPECT_CONVERSION_TO_STRING(plssvm::layout_type::aos, "aos");
+    EXPECT_CONVERSION_TO_STRING(plssvm::layout_type::soa, "soa");
+}
+
+TEST(LayoutType, ToStringUnknown) {
+    // check conversions to std::string from unknown layout_type
+    EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::layout_type>(2), "unknown");
+}
+
+// check whether the std::string -> plssvm::layout_type conversions are correct
+TEST(LayoutType, FromString) {
+    // check conversion from std::string
+    EXPECT_CONVERSION_FROM_STRING("aos", plssvm::layout_type::aos);
+    EXPECT_CONVERSION_FROM_STRING("AoS", plssvm::layout_type::aos);
+    EXPECT_CONVERSION_FROM_STRING("Array-of-Structs", plssvm::layout_type::aos);
+    EXPECT_CONVERSION_FROM_STRING("soa", plssvm::layout_type::soa);
+    EXPECT_CONVERSION_FROM_STRING("SoA", plssvm::layout_type::soa);
+    EXPECT_CONVERSION_FROM_STRING("Struct-of-Arrays", plssvm::layout_type::soa);
+}
+
+TEST(LayoutType, FromStringUnknown) {
+    // foo isn't a valid layout_type
+    std::istringstream input{ "foo" };
+    plssvm::layout_type layout{};
+    input >> layout;
+    EXPECT_TRUE(input.fail());
+}
+
+TEST(LayoutType, LayoutTypeToFullString) {
+    // check conversion from plssvm::classification_type to a full string
+    EXPECT_EQ(plssvm::layout_type_to_full_string(plssvm::layout_type::aos), "Array-of-Structs");
+    EXPECT_EQ(plssvm::layout_type_to_full_string(plssvm::layout_type::soa), "Struct-of-Arrays");
+}
+
+TEST(LayoutType, LayoutTypeToFullStringUnknown) {
+    // check conversion from unknown classification_typ to a full string
+    EXPECT_EQ(plssvm::layout_type_to_full_string(static_cast<plssvm::layout_type>(2)), "unknown");
+}
diff --git a/tests/matrix/member_and_free_functions.cpp b/tests/matrix/member_and_free_functions.cpp
new file mode 100644
index 000000000..60cda77fa
--- /dev/null
+++ b/tests/matrix/member_and_free_functions.cpp
@@ -0,0 +1,1244 @@
+/**
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Test the plssvm::matrix class member and free functions.
+ */
+
+#include "plssvm/exceptions/exceptions.hpp"  // plssvm::matrix_exception
+#include "plssvm/matrix.hpp"
+#include "plssvm/shape.hpp"  // plssvm::shape
+
+#include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING, EXPECT_THROW_WHAT
+#include "tests/naming.hpp"              // naming::test_parameter_to_name
+#include "tests/types_to_test.hpp"       // util::{real_type_layout_type_gtest, test_parameter_type_at_t, test_parameter_value_at_v}
+#include "tests/utility.hpp"             // util::redirect_output
+
+#include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
+#include "gtest/gtest.h"  // TEST, TYPED_TEST, TYPED_TEST_SUITE, EXPECT_EQ, EXPECT_TRUE, EXPECT_FALSE, EXPECT_DEATH, ASSERT_EQ, SCOPED_TRACE, FAIL,
+                          // ::testing::{Test, StaticAssertTypeEq}
+#include "fmt/format.h"   // fmt::format
+
+#include <algorithm>  // std::swap
+#include <cstddef>    // std::size_t
+#include <iostream>   // std::clog
+#include <string>     // std::string
+#include <tuple>      // std::ignore
+#include <vector>     // std::vector
+
+template <typename T>
+class MatrixFunctions : public ::testing::Test,
+                        public util::redirect_output<&std::clog> {
+  protected:
+    using fixture_real_type = util::test_parameter_type_at_t<0, T>;
+    constexpr static plssvm::layout_type fixture_layout = util::test_parameter_value_at_v<0, T>;
+};
+
+TYPED_TEST_SUITE(MatrixFunctions, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
+
+TYPED_TEST(MatrixFunctions, Size) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+    // check getter
+    EXPECT_EQ(matr.size(), 168);
+}
+
+TYPED_TEST(MatrixFunctions, SizeWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_EQ(matr.size(), 168);
+}
+
+TYPED_TEST(MatrixFunctions, Shape) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+    // check getter
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 42, 4 }));
+}
+
+TYPED_TEST(MatrixFunctions, ShapeWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_EQ(matr.shape(), (plssvm::shape{ 42, 4 }));
+}
+
+TYPED_TEST(MatrixFunctions, NumRows) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+    // check getter
+    EXPECT_EQ(matr.num_rows(), 42);
+}
+
+TYPED_TEST(MatrixFunctions, NumRowsWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_EQ(matr.num_rows(), 42);
+}
+
+TYPED_TEST(MatrixFunctions, NumCols) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+    // check getter
+    EXPECT_EQ(matr.num_cols(), 4);
+}
+
+TYPED_TEST(MatrixFunctions, NumColsWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_EQ(matr.num_cols(), 4);
+}
+
+TYPED_TEST(MatrixFunctions, Empty) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+    // check getter
+    EXPECT_FALSE(matr.empty());
+    EXPECT_TRUE((plssvm::matrix<real_type, layout>{}).empty());
+}
+
+TYPED_TEST(MatrixFunctions, EmptyWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr1{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_FALSE(matr1.empty());
+
+    // create empty matrix with padding
+    const plssvm::matrix<real_type, layout> matr2{ plssvm::shape{ 0, 0 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_TRUE(matr2.empty());
+}
+
+TYPED_TEST(MatrixFunctions, Padding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+    // check getter
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 0, 0 }));
+}
+
+TYPED_TEST(MatrixFunctions, PaddingWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+}
+
+TYPED_TEST(MatrixFunctions, ShapePadded) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+    // check getter
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 42, 4 }));
+}
+
+TYPED_TEST(MatrixFunctions, ShapePaddedWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_EQ(matr.shape_padded(), (plssvm::shape{ 46, 9 }));
+}
+
+TYPED_TEST(MatrixFunctions, NumRowsPadded) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+    // check getter
+    EXPECT_EQ(matr.num_rows_padded(), 42);
+}
+
+TYPED_TEST(MatrixFunctions, NumRowsPaddedWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_EQ(matr.num_rows_padded(), 46);
+}
+
+TYPED_TEST(MatrixFunctions, NumColsPadded) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+    // check getter
+    EXPECT_EQ(matr.num_cols_padded(), 4);
+}
+
+TYPED_TEST(MatrixFunctions, NumColsPaddedWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_EQ(matr.num_cols_padded(), 9);
+}
+
+TYPED_TEST(MatrixFunctions, SizePadded) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+    // check getter
+    EXPECT_EQ(matr.size_padded(), 168);
+}
+
+TYPED_TEST(MatrixFunctions, SizePaddedWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_EQ(matr.size_padded(), 414);
+}
+
+TYPED_TEST(MatrixFunctions, IsPadded) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    {
+        // create random matrix
+        const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 } };
+        // check getter
+        EXPECT_FALSE(matr.is_padded());
+    }
+    {
+        // create random matrix
+        const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 0, 0 } };
+        // check getter
+        EXPECT_FALSE(matr.is_padded());
+    }
+}
+
+TYPED_TEST(MatrixFunctions, IsPaddedWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 42, 4 }, plssvm::shape{ 4, 5 } };
+    // check getter
+    EXPECT_TRUE(matr.is_padded());
+}
+
+TYPED_TEST(MatrixFunctions, Layout) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 4, 4 } };
+
+    // check getter
+    EXPECT_EQ(matr.layout(), layout);
+}
+
+TYPED_TEST(MatrixFunctions, RestorePadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create matrix and copy of it
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, real_type{ 42.0 } };
+    const plssvm::matrix<real_type, layout> ground_truth{ matr };
+    // restore padding
+    matr.restore_padding();
+    // nothing should have changed since no padding entries are present!
+    EXPECT_EQ(matr, ground_truth);
+}
+
+TYPED_TEST(MatrixFunctions, RestorePaddingEmpty) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create matrix and copy of it
+    plssvm::matrix<real_type, layout> matr{};
+    const plssvm::matrix<real_type, layout> ground_truth{ matr };
+    // restore padding
+    matr.restore_padding();
+    // nothing should have changed since no padding entries are present!
+    EXPECT_EQ(matr, ground_truth);
+}
+
+TYPED_TEST(MatrixFunctions, RestorePaddingWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create matrix and copy of it
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 3 }, real_type{ 42.0 }, plssvm::shape{ 4, 4 } };
+    const plssvm::matrix<real_type, layout> ground_truth{ matr };
+    // set all padding entries to some value
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = matr.num_cols(); col < matr.num_cols_padded(); ++col) {
+            matr(row, col) = real_type{ 1.0 };
+        }
+    }
+    for (std::size_t row = matr.num_rows(); row < matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
+            matr(row, col) = real_type{ 2.0 };
+        }
+    }
+
+    // matrix shouldn't be equal
+    EXPECT_NE(matr, ground_truth);
+    // restore padding
+    matr.restore_padding();
+    // the matrix should look like at the beginning!
+    EXPECT_EQ(matr, ground_truth);
+}
+
+TYPED_TEST(MatrixFunctions, RestorePaddingEmptyWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create matrix and copy of it
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 0, 0 }, plssvm::shape{ 4, 4 } };
+    const plssvm::matrix<real_type, layout> ground_truth{ matr };
+    // set all padding entries to some value
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = matr.num_cols(); col < matr.num_cols_padded(); ++col) {
+            matr(row, col) = real_type{ 1.0 };
+        }
+    }
+    for (std::size_t row = matr.num_rows(); row < matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
+            matr(row, col) = real_type{ 2.0 };
+        }
+    }
+
+    // matrix shouldn't be equal
+    EXPECT_NE(matr, ground_truth);
+    // restore padding
+    matr.restore_padding();
+    // the matrix should look like at the beginning!
+    EXPECT_EQ(matr, ground_truth);
+}
+
+TYPED_TEST(MatrixFunctions, FunctionCallOperator) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            EXPECT_EQ(matr(row, col), matr_2D[row][col]);
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, FunctionCallOperatorWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
+    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < matr.num_rows() && col < matr.num_cols()) {
+                EXPECT_EQ(matr(row, col), matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, FunctionCallOperatorConst) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            EXPECT_EQ(matr(row, col), matr_2D[row][col]);
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, FunctionCallOperatorConstWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
+    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < matr.num_rows() && col < matr.num_cols()) {
+                EXPECT_EQ(matr(row, col), matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr(row, col), real_type{ 0.0 });
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, At) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            EXPECT_EQ(matr.at(row, col), matr_2D[row][col]);
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, AtWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
+    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < matr.num_rows() && col < matr.num_cols()) {
+                EXPECT_EQ(matr.at(row, col), matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr.at(row, col), real_type{ 0.0 });
+                if (row >= matr.num_rows()) {
+                    EXPECT_THAT(this->get_capture(), ::testing::HasSubstr(fmt::format("WARNING: attempting to access padding row {} (only 2 real rows exist)!", row)));
+                } else {
+                    EXPECT_THAT(this->get_capture(), ::testing::HasSubstr(fmt::format("WARNING: attempting to access padding column {} (only 2 real columns exist)!", col)));
+                }
+                this->clear_capture();
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, AtOutOfBounce) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
+
+    // try out-of-bounce access
+    EXPECT_THROW_WHAT(std::ignore = matr.at(3, 0), plssvm::matrix_exception, "The current row (3) must be smaller than the number of rows including padding (2 + 0)!");
+    EXPECT_THROW_WHAT(std::ignore = matr.at(0, 2), plssvm::matrix_exception, "The current column (2) must be smaller than the number of columns including padding (2 + 0)!");
+}
+
+TYPED_TEST(MatrixFunctions, AtOutOfBounceWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
+
+    // try out-of-bounce access
+    EXPECT_THROW_WHAT(std::ignore = matr.at(6, 0), plssvm::matrix_exception, "The current row (6) must be smaller than the number of rows including padding (2 + 3)!");
+    EXPECT_THROW_WHAT(std::ignore = matr.at(0, 10), plssvm::matrix_exception, "The current column (10) must be smaller than the number of columns including padding (2 + 3)!");
+}
+
+TYPED_TEST(MatrixFunctions, AtConst) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            EXPECT_EQ(matr.at(row, col), matr_2D[row][col]);
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, AtConstWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
+    for (std::size_t row = 0; row < matr.num_rows_padded(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols_padded(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if (row < matr.num_rows() && col < matr.num_cols()) {
+                EXPECT_EQ(matr.at(row, col), matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr.at(row, col), real_type{ 0.0 });
+                if (row >= matr.num_rows()) {
+                    EXPECT_THAT(this->get_capture(), ::testing::HasSubstr(fmt::format("WARNING: attempting to access padding row {} (only 2 real rows exist)!", row)));
+                } else {
+                    EXPECT_THAT(this->get_capture(), ::testing::HasSubstr(fmt::format("WARNING: attempting to access padding column {} (only 2 real columns exist)!", col)));
+                }
+                this->clear_capture();
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, AtConstOutOfBounce) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
+
+    // try out-of-bounce access
+    EXPECT_THROW_WHAT(std::ignore = matr.at(3, 0), plssvm::matrix_exception, "The current row (3) must be smaller than the number of rows including padding (2 + 0)!");
+    EXPECT_THROW_WHAT(std::ignore = matr.at(0, 2), plssvm::matrix_exception, "The current column (2) must be smaller than the number of columns including padding (2 + 0)!");
+}
+
+TYPED_TEST(MatrixFunctions, AtConstOutOfBounceWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
+
+    // try out-of-bounce access
+    EXPECT_THROW_WHAT(std::ignore = matr.at(6, 0), plssvm::matrix_exception, "The current row (6) must be smaller than the number of rows including padding (2 + 3)!");
+    EXPECT_THROW_WHAT(std::ignore = matr.at(0, 10), plssvm::matrix_exception, "The current column (10) must be smaller than the number of columns including padding (2 + 3)!");
+}
+
+TYPED_TEST(MatrixFunctions, SubscriptOperator) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if constexpr (layout == plssvm::layout_type::aos) {
+                EXPECT_EQ(matr[row * 2 + col], matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr[col * 2 + row], matr_2D[row][col]);
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, SubscriptOperatorWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if constexpr (layout == plssvm::layout_type::aos) {
+                EXPECT_EQ(matr[row * (2 + 5) + col], matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr[col * (2 + 4) + row], matr_2D[row][col]);
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, SubscriptOperatorConst) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if constexpr (layout == plssvm::layout_type::aos) {
+                EXPECT_EQ(matr[row * 2 + col], matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr[col * 2 + row], matr_2D[row][col]);
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, SubscriptOperatorConstWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if constexpr (layout == plssvm::layout_type::aos) {
+                EXPECT_EQ(matr[row * (2 + 5) + col], matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr[col * (2 + 4) + row], matr_2D[row][col]);
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, LinearAt) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if constexpr (layout == plssvm::layout_type::aos) {
+                EXPECT_EQ(matr.at(row * 2 + col), matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr.at(col * 2 + row), matr_2D[row][col]);
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, LinearAtWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if constexpr (layout == plssvm::layout_type::aos) {
+                EXPECT_EQ(matr[row * (2 + 5) + col], matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr[col * (2 + 4) + row], matr_2D[row][col]);
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, LinearAtOutOfBounce) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
+
+    // try out-of-bounce access
+    EXPECT_THROW_WHAT(std::ignore = matr.at(4), plssvm::matrix_exception, "The current index (4) must be smaller than the total number of matrix entries (4)!");
+}
+
+TYPED_TEST(MatrixFunctions, LinearAtOutOfBounceWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
+
+    // try out-of-bounce access
+    EXPECT_THROW_WHAT(std::ignore = matr.at(36), plssvm::matrix_exception, "The current index (36) must be smaller than the total number of matrix entries (25)!");
+}
+
+TYPED_TEST(MatrixFunctions, LinearAtConst) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if constexpr (layout == plssvm::layout_type::aos) {
+                EXPECT_EQ(matr.at(row * 2 + col), matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr.at(col * 2 + row), matr_2D[row][col]);
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, LinearAtConstWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // check content
+    ASSERT_EQ(matr.shape(), (plssvm::shape{ 2, 2 }));
+    ASSERT_EQ(matr.padding(), (plssvm::shape{ 4, 5 }));
+    ASSERT_EQ(matr.shape_padded(), (plssvm::shape{ 6, 7 }));
+    for (std::size_t row = 0; row < matr.num_rows(); ++row) {
+        for (std::size_t col = 0; col < matr.num_cols(); ++col) {
+            SCOPED_TRACE(fmt::format("row: {}; col: {}", row, col));
+            if constexpr (layout == plssvm::layout_type::aos) {
+                EXPECT_EQ(matr[row * (2 + 5) + col], matr_2D[row][col]);
+            } else {
+                EXPECT_EQ(matr[col * (2 + 4) + row], matr_2D[row][col]);
+            }
+        }
+    }
+}
+
+TYPED_TEST(MatrixFunctions, LinearAtConstOutOfBounce) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
+
+    // try out-of-bounce access
+    EXPECT_THROW_WHAT(std::ignore = matr.at(4), plssvm::matrix_exception, "The current index (4) must be smaller than the total number of matrix entries (4)!");
+}
+
+TYPED_TEST(MatrixFunctions, LinearAtConstOutOfBounceWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
+
+    // try out-of-bounce access
+    EXPECT_THROW_WHAT(std::ignore = matr.at(36), plssvm::matrix_exception, "The current index (36) must be smaller than the total number of matrix entries (25)!");
+}
+
+TYPED_TEST(MatrixFunctions, To2DVector) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // construct a matrix from a std::vector<std::vector<>>
+    const plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    EXPECT_EQ(matr.to_2D_vector(), matr_2D);
+}
+
+TYPED_TEST(MatrixFunctions, To2DVectorWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } },
+                                                       { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // construct a matrix from a std::vector<std::vector<>>
+    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // check content
+    EXPECT_EQ(matr.to_2D_vector(), matr_2D);
+}
+
+TYPED_TEST(MatrixFunctions, To2DVectorPadded) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    const std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // construct a matrix from a std::vector<std::vector<>>
+    const plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check content
+    EXPECT_EQ(matr.to_2D_vector_padded(), matr_2D);
+}
+
+TYPED_TEST(MatrixFunctions, To2DVectorPaddedWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create the 2D vector
+    std::vector<std::vector<real_type>> matr_2D{ { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 1.1 }, real_type{ 1.2 } } };
+
+    // construct a matrix from a std::vector<std::vector<>>
+    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 5 } };
+
+    // add padding to ground truth vector
+    matr_2D[0].resize(matr_2D[0].size() + 5);
+    matr_2D[1].resize(matr_2D[1].size() + 5);
+    matr_2D.resize(matr_2D.size() + 4);
+    for (std::size_t row = 0; row < 4; ++row) {
+        matr_2D[2 + row].resize(7);
+    }
+
+    // check content
+    EXPECT_EQ(matr.to_2D_vector_padded(), matr_2D);
+}
+
+TYPED_TEST(MatrixFunctions, SwapMemberFunction) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create data
+    const std::vector<std::vector<real_type>> matr1_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } }, { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
+    const std::vector<std::vector<real_type>> matr2_2D = { { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 0.3 }, real_type{ 0.4 } }, { real_type{ 0.5 }, real_type{ 0.6 } } };
+
+    // create two matrices and swap their content
+    plssvm::matrix<real_type, layout> matr1{ matr1_2D };
+    plssvm::matrix<real_type, layout> matr2{ matr2_2D, plssvm::shape{ 4, 5 } };
+
+    // swap both matrices
+    matr1.swap(matr2);
+
+    // check the content of matr1
+    ASSERT_EQ(matr1.shape(), (plssvm::shape{ 3, 2 }));
+    ASSERT_EQ(matr1.size(), 6);
+    EXPECT_EQ(matr1.to_2D_vector(), matr2_2D);
+    // check the padding of matr1
+    EXPECT_EQ(matr1.padding(), (plssvm::shape{ 4, 5 }));
+    ASSERT_EQ(matr1.shape_padded(), (plssvm::shape{ 7, 7 }));
+
+    // check the content of matr2
+    ASSERT_EQ(matr2.shape(), (plssvm::shape{ 2, 3 }));
+    ASSERT_EQ(matr2.size(), 6);
+    EXPECT_EQ(matr2.to_2D_vector(), matr1_2D);
+    // check the padding of matr2
+    EXPECT_EQ(matr2.padding(), (plssvm::shape{ 0, 0 }));
+    ASSERT_EQ(matr2.shape_padded(), (plssvm::shape{ 2, 3 }));
+}
+
+TYPED_TEST(MatrixFunctions, SwapFreeFunction) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create data
+    const std::vector<std::vector<real_type>> matr1_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } }, { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
+    const std::vector<std::vector<real_type>> matr2_2D = { { real_type{ 0.1 }, real_type{ 0.2 } }, { real_type{ 0.3 }, real_type{ 0.4 } }, { real_type{ 0.5 }, real_type{ 0.6 } } };
+
+    // create two matrices and swap their content
+    plssvm::matrix<real_type, layout> matr1{ matr1_2D };
+    plssvm::matrix<real_type, layout> matr2{ matr2_2D, plssvm::shape{ 4, 5 } };
+
+    // swap both matrices
+    using std::swap;
+    swap(matr1, matr2);
+
+    // check the content of matr1
+    ASSERT_EQ(matr1.shape(), (plssvm::shape{ 3, 2 }));
+    ASSERT_EQ(matr1.size(), 6);
+    EXPECT_EQ(matr1.to_2D_vector(), matr2_2D);
+    // check the padding of matr1
+    EXPECT_EQ(matr1.padding(), (plssvm::shape{ 4, 5 }));
+    ASSERT_EQ(matr1.shape_padded(), (plssvm::shape{ 7, 7 }));
+
+    // check the content of matr2
+    ASSERT_EQ(matr2.shape(), (plssvm::shape{ 2, 3 }));
+    ASSERT_EQ(matr2.size(), 6);
+    EXPECT_EQ(matr2.to_2D_vector(), matr1_2D);
+    // check the padding of matr2
+    EXPECT_EQ(matr2.padding(), (plssvm::shape{ 0, 0 }));
+    ASSERT_EQ(matr2.shape_padded(), (plssvm::shape{ 2, 3 }));
+}
+
+TYPED_TEST(MatrixFunctions, OperatorEqual) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create matrices
+    const plssvm::matrix<real_type, layout> matr1{ plssvm::shape{ 3, 2 } };
+    const plssvm::matrix<real_type, layout> matr2{ plssvm::shape{ 2, 3 } };
+    const plssvm::matrix<real_type, layout> matr3{ plssvm::shape{ 3, 3 } };
+    const plssvm::matrix<real_type, layout> matr4{ plssvm::shape{ 3, 3 }, real_type{ 3.1415 } };
+    const plssvm::matrix<real_type, layout> matr5{ plssvm::shape{ 3, 3 }, real_type{} };
+    const plssvm::matrix<real_type, layout> matr6{ plssvm::shape{ 3, 3 }, plssvm::shape{ 4, 4 } };
+    const plssvm::matrix<real_type, layout> matr7{ plssvm::shape{ 3, 3 }, plssvm::shape{ 2, 4 } };
+    const plssvm::matrix<real_type, layout> matr8{ plssvm::shape{ 3, 3 }, real_type{}, plssvm::shape{ 2, 4 } };
+
+    // check for equality
+    EXPECT_FALSE(matr1 == matr2);
+    EXPECT_FALSE(matr1 == matr3);
+    EXPECT_FALSE(matr2 == matr3);
+    EXPECT_FALSE(matr3 == matr4);
+    EXPECT_TRUE(matr3 == matr5);
+    EXPECT_TRUE(matr4 == matr4);
+
+    EXPECT_FALSE(matr3 == matr6);
+    EXPECT_FALSE(matr3 == matr7);
+    EXPECT_FALSE(matr3 == matr8);
+    EXPECT_FALSE(matr6 == matr7);
+    EXPECT_TRUE(matr7 == matr8);
+}
+
+TYPED_TEST(MatrixFunctions, OperatorUnequal) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create matrices
+    const plssvm::matrix<real_type, layout> matr1{ plssvm::shape{ 3, 2 } };
+    const plssvm::matrix<real_type, layout> matr2{ plssvm::shape{ 2, 3 } };
+    const plssvm::matrix<real_type, layout> matr3{ plssvm::shape{ 3, 3 } };
+    const plssvm::matrix<real_type, layout> matr4{ plssvm::shape{ 3, 3 }, real_type{ 3.1415 } };
+    const plssvm::matrix<real_type, layout> matr5{ plssvm::shape{ 3, 3 }, real_type{} };
+    const plssvm::matrix<real_type, layout> matr6{ plssvm::shape{ 3, 3 }, plssvm::shape{ 4, 4 } };
+    const plssvm::matrix<real_type, layout> matr7{ plssvm::shape{ 3, 3 }, plssvm::shape{ 2, 4 } };
+    const plssvm::matrix<real_type, layout> matr8{ plssvm::shape{ 3, 3 }, real_type{}, plssvm::shape{ 2, 4 } };
+
+    // check for equality
+    EXPECT_TRUE(matr1 != matr2);
+    EXPECT_TRUE(matr1 != matr3);
+    EXPECT_TRUE(matr2 != matr3);
+    EXPECT_TRUE(matr3 != matr4);
+    EXPECT_FALSE(matr3 != matr5);
+    EXPECT_FALSE(matr4 != matr4);
+
+    EXPECT_TRUE(matr3 != matr6);
+    EXPECT_TRUE(matr3 != matr7);
+    EXPECT_TRUE(matr3 != matr8);
+    EXPECT_TRUE(matr6 != matr7);
+    EXPECT_FALSE(matr7 != matr8);
+}
+
+TYPED_TEST(MatrixFunctions, OutputOperator) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create data
+    const std::vector<std::vector<real_type>> matr_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } }, { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
+
+    // create matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check
+    std::string correct_output{};
+    for (const std::vector<real_type> &row : matr_2D) {
+        correct_output += fmt::format("{:.10e} \n", fmt::join(row, " "));
+    }
+    correct_output.pop_back();  // remove last newline
+    EXPECT_CONVERSION_TO_STRING(matr, correct_output);
+}
+
+TYPED_TEST(MatrixFunctions, OutputOperatorWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create data
+    const std::vector<std::vector<real_type>> matr_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } }, { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
+
+    // create matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 4 } };
+
+    // check
+    std::string correct_output{};
+    for (const std::vector<real_type> &row : matr_2D) {
+        correct_output += fmt::format("{:.10e} \n", fmt::join(row, " "));
+    }
+    correct_output.pop_back();  // remove last newline (\n)
+    EXPECT_CONVERSION_TO_STRING(matr, correct_output);
+}
+
+TYPED_TEST(MatrixFunctions, Formatter) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create data
+    const std::vector<std::vector<real_type>> matr_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } },
+                                                          { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
+
+    // create matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D };
+
+    // check
+    std::string correct_output{};
+    for (const std::vector<real_type> &row : matr_2D) {
+        correct_output += fmt::format("{:.10e} \n", fmt::join(row, " "));
+    }
+    correct_output.pop_back();  // remove last newline
+    EXPECT_EQ(fmt::format("{}", matr), correct_output);
+}
+
+TYPED_TEST(MatrixFunctions, FormatterWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create data
+    const std::vector<std::vector<real_type>> matr_2D = { { real_type{ 1.0 }, real_type{ 2.0 }, real_type{ 3.0 } },
+                                                          { real_type{ 4.0 }, real_type{ 5.0 }, real_type{ 6.0 } } };
+
+    // create matrix
+    const plssvm::matrix<real_type, layout> matr{ matr_2D, plssvm::shape{ 4, 4 } };
+
+    // check
+    std::string correct_output{};
+    for (const std::vector<real_type> &row : matr_2D) {
+        correct_output += fmt::format("{:.10e} 0 0 0 0 \n", fmt::join(row, " "));
+    }
+    correct_output += "0 0 0 0 0 0 0 \n0 0 0 0 0 0 0 \n0 0 0 0 0 0 0 \n0 0 0 0 0 0 0 ";
+    EXPECT_EQ(fmt::format("{:p}", matr), correct_output);
+}
+
+TYPED_TEST(MatrixFunctions, MatrixShorthands) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    if constexpr (layout == plssvm::layout_type::aos) {
+        ::testing::StaticAssertTypeEq<plssvm::matrix<real_type, layout>, plssvm::aos_matrix<real_type>>();
+    } else if constexpr (layout == plssvm::layout_type::soa) {
+        ::testing::StaticAssertTypeEq<plssvm::matrix<real_type, layout>, plssvm::soa_matrix<real_type>>();
+    } else {
+        FAIL() << "Unrecognized layout type!";
+    }
+}
+
+template <typename T>
+class MatrixFunctionsDeathTest : public MatrixFunctions<T> { };
+
+TYPED_TEST_SUITE(MatrixFunctionsDeathTest, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
+
+TYPED_TEST(MatrixFunctionsDeathTest, FunctionCallOperatorOutOfBounce) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
+
+    // try out-of-bounce access
+    EXPECT_DEATH(std::ignore = matr(3, 0), ::testing::HasSubstr("The current row (3) must be smaller than the number of padded rows (2)!"));
+    EXPECT_DEATH(std::ignore = matr(0, 2), ::testing::HasSubstr("The current column (2) must be smaller than the number of padded columns (2)!"));
+}
+
+TYPED_TEST(MatrixFunctionsDeathTest, FunctionCallOperatorOutOfBounceWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
+
+    // try out-of-bounce access
+    EXPECT_DEATH(std::ignore = matr(6, 0), ::testing::HasSubstr("The current row (6) must be smaller than the number of padded rows (5)!"));
+    EXPECT_DEATH(std::ignore = matr(0, 10), ::testing::HasSubstr("The current column (10) must be smaller than the number of padded columns (5)!"));
+}
+
+TYPED_TEST(MatrixFunctionsDeathTest, FunctionCallOperatorConstOutOfBounce) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
+
+    // try out-of-bounce access
+    EXPECT_DEATH(std::ignore = matr(3, 0), ::testing::HasSubstr("The current row (3) must be smaller than the number of padded rows (2)!"));
+    EXPECT_DEATH(std::ignore = matr(0, 2), ::testing::HasSubstr("The current column (2) must be smaller than the number of padded columns (2)!"));
+}
+
+TYPED_TEST(MatrixFunctionsDeathTest, FunctionCallOperatorConstOutOfBounceWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 4, 5 } };
+
+    // try out-of-bounce access
+    EXPECT_DEATH(std::ignore = matr(6, 0), ::testing::HasSubstr("The current row (6) must be smaller than the number of padded rows (6)!"));
+    EXPECT_DEATH(std::ignore = matr(0, 10), ::testing::HasSubstr("The current column (10) must be smaller than the number of padded columns (7)!"));
+}
+
+TYPED_TEST(MatrixFunctionsDeathTest, SubscriptOperatorOutOfBounce) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
+
+    // try out-of-bounce access
+    EXPECT_DEATH(std::ignore = matr[4], ::testing::HasSubstr("The current index (4) must be smaller than the total number of matrix entries (4)!"));
+}
+
+TYPED_TEST(MatrixFunctionsDeathTest, SubscriptOperatoroutOfBounceWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 3, 3 } };
+
+    // try out-of-bounce access
+    EXPECT_DEATH(std::ignore = matr[36], ::testing::HasSubstr("The current index (36) must be smaller than the total number of matrix entries (25)!"));
+}
+
+TYPED_TEST(MatrixFunctionsDeathTest, SubscriptOperatorConstOutOfBounce) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 } };
+
+    // try out-of-bounce access
+    EXPECT_DEATH(std::ignore = matr[4], ::testing::HasSubstr("The current index (4) must be smaller than the total number of matrix entries (4)!"));
+}
+
+TYPED_TEST(MatrixFunctionsDeathTest, SubscriptOperatorConstOutOfBounceWithPadding) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // create random matrix
+    const plssvm::matrix<real_type, layout> matr{ plssvm::shape{ 2, 2 }, plssvm::shape{ 4, 5 } };
+
+    // try out-of-bounce access
+    EXPECT_DEATH(std::ignore = matr[42], ::testing::HasSubstr("The current index (42) must be smaller than the total number of matrix entries (42)!"));
+}
diff --git a/tests/matrix/operators.cpp b/tests/matrix/operators.cpp
new file mode 100644
index 000000000..f52acabcd
--- /dev/null
+++ b/tests/matrix/operators.cpp
@@ -0,0 +1,367 @@
+/**
+ * @author Alexander Van Craen
+ * @author Marcel Breyer
+ * @copyright 2018-today The PLSSVM project - All Rights Reserved
+ * @license This file is part of the PLSSVM project which is released under the MIT license.
+ *          See the LICENSE.md file in the project root for full license information.
+ *
+ * @brief Test the plssvm::matrix class operation overloads and math functions.
+ */
+
+#include "plssvm/matrix.hpp"
+
+#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_VECTOR_EQ
+#include "tests/naming.hpp"              // naming::test_parameter_to_name
+#include "tests/types_to_test.hpp"       // util::{real_type_layout_type_gtest, test_parameter_type_at_t, test_parameter_value_at_v}
+
+#include "gmock/gmock.h"  // ::testing::HasSubstr
+#include "gtest/gtest.h"  // TEST, TYPED_TEST, TYPED_TEST_SUITE, EXPECT_DEATH, ::testing::Test
+
+#include <tuple>   // std::ignore
+#include <vector>  // std::vector
+
+template <typename T>
+class MatrixOperations : public ::testing::Test {
+  protected:
+    using fixture_real_type = util::test_parameter_type_at_t<0, T>;
+    constexpr static plssvm::layout_type fixture_layout = util::test_parameter_value_at_v<0, T>;
+
+    void SetUp() override {
+        A_ = plssvm::matrix<fixture_real_type, fixture_layout>{ { { 1, 2, 3 }, { 4, 5, 6 } } };
+        B_ = plssvm::matrix<fixture_real_type, fixture_layout>{ { { 1.5, 2.5, 3.5 }, { 4.5, 5.5, 6.5 } } };
+        c_ = std::vector<fixture_real_type>{ 1.5, -2.5 };
+        scalar_ = fixture_real_type{ 1.5 };
+    }
+
+    /**
+     * @brief Return the sample matrix @p A.
+     * @return the matrix vector (`[[nodiscard]]`)
+     */
+    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_A() noexcept { return A_; }
+
+    /**
+     * @brief Return the sample matrix @p B.
+     * @return the sample matrix (`[[nodiscard]]`)
+     */
+    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_B() noexcept { return B_; }
+
+    /**
+     * @brief Return the sample vector @p c.
+     * @return the sample vector (`[[nodiscard]]`)
+     */
+    [[nodiscard]] std::vector<fixture_real_type> &get_c() noexcept { return c_; }
+
+    /**
+     * @brief Return the empty matrix.
+     * @return the empty matrix (`[[nodiscard]]`)
+     */
+    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_empty() noexcept { return empty_; }
+
+    /**
+     * @brief Return the sample scalar.
+     * @return the scalar (`[[nodiscard]]`)
+     */
+    [[nodiscard]] fixture_real_type &get_scalar() noexcept { return scalar_; }
+
+  private:
+    /// Sample matrix to test the different operations.
+    plssvm::matrix<fixture_real_type, fixture_layout> A_{};
+    /// Sample matrix to test the different operations.
+    plssvm::matrix<fixture_real_type, fixture_layout> B_{};
+    /// Sample vector to test the different operations.
+    std::vector<fixture_real_type> c_{};
+    /// Empty matrix to test the different operations.
+    plssvm::matrix<fixture_real_type, fixture_layout> empty_{};
+    /// Sample scalar to test the different operations.
+    fixture_real_type scalar_{};
+};
+
+TYPED_TEST_SUITE(MatrixOperations, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
+
+template <typename T>
+class MatrixOperationsDeathTest : public ::testing::Test {
+  protected:
+    using fixture_real_type = util::test_parameter_type_at_t<0, T>;
+    constexpr static plssvm::layout_type fixture_layout = util::test_parameter_value_at_v<0, T>;
+
+    void SetUp() override {
+        A_ = plssvm::matrix<fixture_real_type, fixture_layout>{ { { 1, 2, 3 }, { 4, 5, 6 } } };
+        B_ = plssvm::matrix<fixture_real_type, fixture_layout>{ { { 1.5, 2.5 }, { 3.5, 4.5 }, { 5.5, 6.5 } } };
+    }
+
+    /**
+     * @brief Return the sample matrix @p A.
+     * @return the matrix vector (`[[nodiscard]]`)
+     */
+    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_A() noexcept { return A_; }
+
+    /**
+     * @brief Return the sample matrix @p B.
+     * @return the sample matrix (`[[nodiscard]]`)
+     */
+    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_B() noexcept { return B_; }
+
+    /**
+     * @brief Return the empty matrix.
+     * @return the empty matrix (`[[nodiscard]]`)
+     */
+    [[nodiscard]] plssvm::matrix<fixture_real_type, fixture_layout> &get_empty() noexcept { return empty_; }
+
+  private:
+    /// Sample matrix to test the different operations.
+    plssvm::matrix<fixture_real_type, fixture_layout> A_{};
+    /// Sample matrix to test the different operations.
+    plssvm::matrix<fixture_real_type, fixture_layout> B_{};
+    /// Empty matrix to test the different operations.
+    plssvm::matrix<fixture_real_type, fixture_layout> empty_{};
+};
+
+TYPED_TEST_SUITE(MatrixOperationsDeathTest, util::real_type_layout_type_gtest, naming::test_parameter_to_name);
+
+TYPED_TEST(MatrixOperations, OperatorScaleBinary) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // scale a matrix using a scalar
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 1.5, 3.0, 4.5 }, { 6.0, 7.5, 9.0 } } };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_scalar() * this->get_A(), C);
+    }
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 2.25, 3.75, 5.25 }, { 6.75, 8.25, 9.75 } } };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_B() * this->get_scalar(), C);
+    }
+}
+
+TYPED_TEST(MatrixOperations, OperatorScaleBinaryEmpty) {
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() * this->get_scalar(), this->get_empty());
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_scalar() * this->get_empty(), this->get_empty());
+}
+
+TYPED_TEST(MatrixOperations, OperatorScaleCompound) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // scale a matrix using a scalar
+    const plssvm::matrix<real_type, layout> C{ { { 1.5, 3.0, 4.5 }, { 6.0, 7.5, 9.0 } } };
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_A() *= this->get_scalar(), C);
+}
+
+TYPED_TEST(MatrixOperations, OperatorScaleCompoundEmpty) {
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() *= this->get_scalar(), this->get_empty());
+}
+
+TYPED_TEST(MatrixOperations, OperatorAddBinary) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // add two matrices to each other
+    const plssvm::matrix<real_type, layout> C{ { { 2.5, 4.5, 6.5 }, { 8.5, 10.5, 12.5 } } };
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_A() + this->get_B(), C);
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_B() + this->get_A(), C);
+}
+
+TYPED_TEST(MatrixOperations, OperatorAddBinaryEmpty) {
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() + this->get_empty(), this->get_empty());
+}
+
+TYPED_TEST(MatrixOperations, OperatorAddCompound) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // add two matrices to each other
+    const plssvm::matrix<real_type, layout> C{ { { 2.5, 4.5, 6.5 }, { 8.5, 10.5, 12.5 } } };
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_A() += this->get_B(), C);
+}
+
+TYPED_TEST(MatrixOperations, OperatorAddCompoundEmpty) {
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() += this->get_empty(), this->get_empty());
+}
+
+TYPED_TEST(MatrixOperationsDeathTest, OperatorAddBinary) {
+    // try adding two matrices with mismatching sizes
+    EXPECT_DEATH(std::ignore = this->get_A() + this->get_B(), ::testing::HasSubstr("Error: shapes missmatch! ([2, 3] != [3, 2])"));
+    EXPECT_DEATH(std::ignore = this->get_B() + this->get_A(), ::testing::HasSubstr("Error: shapes missmatch! ([3, 2] != [2, 3])"));
+}
+
+TYPED_TEST(MatrixOperationsDeathTest, OperatorAddCompound) {
+    // try adding two matrices with mismatching sizes
+    EXPECT_DEATH(this->get_A() += this->get_B(), ::testing::HasSubstr("Error: shapes missmatch! ([2, 3] != [3, 2])"));
+    EXPECT_DEATH(this->get_B() += this->get_A(), ::testing::HasSubstr("Error: shapes missmatch! ([3, 2] != [2, 3])"));
+}
+
+TYPED_TEST(MatrixOperations, OperatorSubtractBinary) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // subtract two matrices from each other
+    {
+        const plssvm::matrix<real_type, layout> C{ { { -0.5, -0.5, -0.5 }, { -0.5, -0.5, -0.5 } } };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_A() - this->get_B(), C);
+    }
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 0.5, 0.5, 0.5 }, { 0.5, 0.5, 0.5 } } };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_B() - this->get_A(), C);
+    }
+}
+
+TYPED_TEST(MatrixOperations, OperatorSubtractBinaryEmpty) {
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() - this->get_empty(), this->get_empty());
+}
+
+TYPED_TEST(MatrixOperations, OperatorSubtractCompound) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // add two matrices to each other
+    const plssvm::matrix<real_type, layout> C{ { { -0.5, -0.5, -0.5 }, { -0.5, -0.5, -0.5 } } };
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_A() -= this->get_B(), C);
+}
+
+TYPED_TEST(MatrixOperations, OperatorSubtractCompoundEmpty) {
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() -= this->get_empty(), this->get_empty());
+}
+
+TYPED_TEST(MatrixOperationsDeathTest, OperatorSubtractBinary) {
+    // try subtracting two matrices with mismatching sizes
+    EXPECT_DEATH(std::ignore = this->get_A() - this->get_B(), ::testing::HasSubstr("Error: shapes missmatch! ([2, 3] != [3, 2])"));
+    EXPECT_DEATH(std::ignore = this->get_B() - this->get_A(), ::testing::HasSubstr("Error: shapes missmatch! ([3, 2] != [2, 3])"));
+}
+
+TYPED_TEST(MatrixOperationsDeathTest, OperatorSubtractCompound) {
+    // try subtracting two matrices with mismatching sizes
+    EXPECT_DEATH(this->get_A() -= this->get_B(), ::testing::HasSubstr("Error: shapes missmatch! ([2, 3] != [3, 2])"));
+    EXPECT_DEATH(this->get_B() -= this->get_A(), ::testing::HasSubstr("Error: shapes missmatch! ([3, 2] != [2, 3])"));
+}
+
+TYPED_TEST(MatrixOperations, OperatorMatrixMultiplicationSquare) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    const plssvm::matrix<real_type, layout> square_A{ { { 1.0, 2.0, 3.0 }, { 4.0, 5.0, 6.0 }, { 7.0, 8.0, 9.0 } } };
+    const plssvm::matrix<real_type, layout> square_B{ { { 1.5, 2.5, 3.5 }, { 4.5, 5.5, 6.5 }, { 7.5, 8.5, 9.5 } } };
+
+    // matrix-matrix multiplication with squared matrices
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 33.0, 39.0, 45.0 }, { 73.5, 88.5, 103.5 }, { 114.0, 138.0, 162.0 } } };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(square_A * square_B, C);
+    }
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 36.0, 43.5, 51.0 }, { 72.0, 88.5, 105.0 }, { 108.0, 133.5, 159.0 } } };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(square_B * square_A, C);
+    }
+}
+
+TYPED_TEST(MatrixOperations, OperatorMatrixMultiplication) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    const plssvm::matrix<real_type, layout> input_A{ { { 1, 2, 3 }, { 4, 5, 6 } } };
+    const plssvm::matrix<real_type, layout> input_B{ { { 1.5, 2.5 }, { 4.5, 5.5 }, { 7.5, 8.5 } } };
+
+    // matrix-matrix multiplication
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 33.0, 39.0 }, { 73.5, 88.5 } } };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(input_A * input_B, C);
+    }
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 11.5, 15.5, 19.5 }, { 26.5, 36.5, 46.5 }, { 41.5, 57.5, 73.5 } } };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(input_B * input_A, C);
+    }
+}
+
+TYPED_TEST(MatrixOperations, OperatorMatrixMultiplicationEmpty) {
+    EXPECT_FLOATING_POINT_MATRIX_EQ(this->get_empty() * this->get_empty(), this->get_empty());
+}
+
+TYPED_TEST(MatrixOperationsDeathTest, OperatorMatrixMultiplication) {
+    EXPECT_DEATH(std::ignore = this->get_A() * this->get_empty(), ::testing::HasSubstr("Error: shapes missmatch! (3 (num_cols) != 0 (num_rows))"));
+    EXPECT_DEATH(std::ignore = this->get_empty() * this->get_A(), ::testing::HasSubstr("Error: shapes missmatch! (0 (num_cols) != 2 (num_rows))"));
+}
+
+TYPED_TEST(MatrixOperations, OperatorRowwiseDot) {
+    using real_type = typename TestFixture::fixture_real_type;
+
+    // rowwise dot product
+    const std::vector<real_type> ret{ 17.0, 84.5 };
+    EXPECT_FLOATING_POINT_VECTOR_EQ(rowwise_dot(this->get_A(), this->get_B()), ret);
+    EXPECT_FLOATING_POINT_VECTOR_EQ(rowwise_dot(this->get_B(), this->get_A()), ret);
+}
+
+TYPED_TEST(MatrixOperations, OperatorRowwiseDotEmpty) {
+    EXPECT_FLOATING_POINT_VECTOR_EQ(rowwise_dot(this->get_empty(), this->get_empty()), {});
+}
+
+TYPED_TEST(MatrixOperationsDeathTest, OperatorRowwiseDot) {
+    // sizes missmatch
+    EXPECT_DEATH(std::ignore = rowwise_dot({}, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! ([0, 0] != [2, 3])"));
+    EXPECT_DEATH(std::ignore = rowwise_dot(this->get_A(), this->get_B()), ::testing::HasSubstr("Error: shapes missmatch! ([2, 3] != [3, 2])"));
+}
+
+TYPED_TEST(MatrixOperations, OperatorRowwiseScale) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // rowwise scale
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 1.5, 3.0, 4.5 }, { -10.0, -12.5, -15.0 } } };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(rowwise_scale(this->get_c(), this->get_A()), C);
+    }
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 2.25, 3.75, 5.25 }, { -11.25, -13.75, -16.25 } } };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(rowwise_scale(this->get_c(), this->get_B()), C);
+    }
+}
+
+TYPED_TEST(MatrixOperations, OperatorRowwiseScaleEmpty) {
+    EXPECT_FLOATING_POINT_MATRIX_EQ(rowwise_scale({}, this->get_empty()), this->get_empty());
+}
+
+TYPED_TEST(MatrixOperationsDeathTest, OperatorRowwiseScale) {
+    using real_type = typename TestFixture::fixture_real_type;
+
+    // sizes missmatch
+    EXPECT_DEATH(std::ignore = rowwise_scale({}, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (0 != 2 (num_rows))"));
+    EXPECT_DEATH(std::ignore = rowwise_scale(std::vector<real_type>{ 1.0, 2.0, 3.0 }, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (3 != 2 (num_rows))"));
+}
+
+TYPED_TEST(MatrixOperations, OperatorMaskedRowwiseScale) {
+    using real_type = typename TestFixture::fixture_real_type;
+    constexpr plssvm::layout_type layout = TestFixture::fixture_layout;
+
+    // rowwise scale
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 0.0, 0.0, 0.0 }, { -10.0, -12.5, -15.0 } } };
+        const std::vector<unsigned long long> mask{ 0, 1 };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(masked_rowwise_scale(mask, this->get_c(), this->get_A()), C);
+    }
+    {
+        const plssvm::matrix<real_type, layout> C{ { { 2.25, 3.75, 5.25 }, { 0.0, 0.0, 0.0 } } };
+        const std::vector<unsigned long long> mask{ 1, 0 };
+        EXPECT_FLOATING_POINT_MATRIX_EQ(masked_rowwise_scale(mask, this->get_c(), this->get_B()), C);
+    }
+}
+
+TYPED_TEST(MatrixOperations, OperatorMaskedRowwiseScaleEmpty) {
+    EXPECT_FLOATING_POINT_MATRIX_EQ(masked_rowwise_scale({}, {}, this->get_empty()), this->get_empty());
+}
+
+TYPED_TEST(MatrixOperationsDeathTest, OperatorMaskedRowwiseScale) {
+    using real_type = typename TestFixture::fixture_real_type;
+
+    const std::vector<real_type> scale{ 1.0, 2.0 };
+    const std::vector<unsigned long long> mask{ 1, 0 };
+
+    // sizes missmatch
+    EXPECT_DEATH(std::ignore = masked_rowwise_scale(mask, {}, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (0 != 2 (num_rows))"));
+    EXPECT_DEATH(std::ignore = masked_rowwise_scale(mask, std::vector<real_type>{ 1.0, 2.0, 3.0 }, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (3 != 2 (num_rows))"));
+    EXPECT_DEATH(std::ignore = masked_rowwise_scale(std::vector<unsigned long long>{}, scale, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (0 != 2 (num_rows))"));
+    EXPECT_DEATH(std::ignore = masked_rowwise_scale(std::vector<unsigned long long>{ 1, 0, 1 }, scale, this->get_A()), ::testing::HasSubstr("Error: shapes missmatch! (3 != 2 (num_rows))"));
+}
+
+TYPED_TEST(MatrixOperations, OperatorVariance) {
+    using real_type = typename TestFixture::fixture_real_type;
+
+    EXPECT_FLOATING_POINT_NEAR(variance(this->get_A()), (real_type{ 17.5 } / static_cast<real_type>(this->get_A().size())));
+    EXPECT_FLOATING_POINT_NEAR(variance(this->get_B()), (real_type{ 17.5 } / static_cast<real_type>(this->get_A().size())));
+}
diff --git a/tests/model/classification_model.cpp b/tests/model/classification_model.cpp
index d8dbb7148..b72e03238 100644
--- a/tests/model/classification_model.cpp
+++ b/tests/model/classification_model.cpp
@@ -18,7 +18,7 @@
 #include "plssvm/parameter.hpp"              // plssvm::parameter
 #include "plssvm/shape.hpp"                  // plssvm::shape
 
-#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_VECTOR_EQ
+#include "tests/custom_test_macros.hpp"  // EXPECT_FLOATING_POINT_MATRIX_EQ, EXPECT_FLOATING_POINT_VECTOR_EQ, EXPECT_OPTIONAL_EQ
 #include "tests/naming.hpp"              // naming::test_parameter_to_name
 #include "tests/types_to_test.hpp"       // util::{classification_label_type_classification_type_gtest, test_parameter_type_at_t, test_parameter_value_at_v}
 #include "tests/utility.hpp"             // util::{redirect_output, temporary_file, instantiate_template_file, get_num_classes, get_distinct_label, get_correct_model_file_labels}
@@ -50,7 +50,7 @@ class ClassificationModel : public ::testing::Test,
 
 TYPED_TEST_SUITE(ClassificationModel, util::classification_label_type_classification_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ClassificationModel, typedefs) {
+TYPED_TEST(ClassificationModel, Typedefs) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -61,7 +61,7 @@ TYPED_TEST(ClassificationModel, typedefs) {
     ::testing::StaticAssertTypeEq<std::size_t, typename decltype(model)::size_type>();
 }
 
-TYPED_TEST(ClassificationModel, construct) {
+TYPED_TEST(ClassificationModel, Construct) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
@@ -74,8 +74,11 @@ TYPED_TEST(ClassificationModel, construct) {
     EXPECT_EQ(model.num_features(), 4);
     EXPECT_EQ(model.get_params(), plssvm::parameter{ plssvm::kernel_type = plssvm::kernel_function_type::linear });
     EXPECT_EQ(model.support_vectors().shape(), (plssvm::shape{ 6, 4 }));
-    ASSERT_TRUE(model.labels().has_value());
-    EXPECT_EQ(model.labels()->get().size(), 6);
+    const auto &labels_opt = model.labels();
+    ASSERT_TRUE(labels_opt.has_value());
+    if (labels_opt.has_value()) {
+        EXPECT_EQ(labels_opt.value().get().size(), 6);
+    }
     EXPECT_EQ(model.num_classes(), num_classes_for_label_type);
     EXPECT_EQ(model.classes(), util::get_distinct_label<label_type>());
     if constexpr (classification == plssvm::classification_type::oaa) {
@@ -93,7 +96,7 @@ TYPED_TEST(ClassificationModel, construct) {
     EXPECT_FALSE(model.num_iters().has_value());
 }
 
-TYPED_TEST(ClassificationModel, num_support_vectors) {
+TYPED_TEST(ClassificationModel, NumSupportVectors) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -103,7 +106,7 @@ TYPED_TEST(ClassificationModel, num_support_vectors) {
     EXPECT_EQ(model.num_support_vectors(), 6);
 }
 
-TYPED_TEST(ClassificationModel, num_features) {
+TYPED_TEST(ClassificationModel, NumFeatures) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -113,7 +116,7 @@ TYPED_TEST(ClassificationModel, num_features) {
     EXPECT_EQ(model.num_features(), 4);
 }
 
-TYPED_TEST(ClassificationModel, get_params) {
+TYPED_TEST(ClassificationModel, GetParams) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -123,7 +126,7 @@ TYPED_TEST(ClassificationModel, get_params) {
     EXPECT_EQ(model.get_params(), plssvm::parameter{ plssvm::kernel_type = plssvm::kernel_function_type::linear });
 }
 
-TYPED_TEST(ClassificationModel, support_vectors) {
+TYPED_TEST(ClassificationModel, SupportVectors) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -140,18 +143,17 @@ TYPED_TEST(ClassificationModel, support_vectors) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(model.support_vectors(), support_vectors);
 }
 
-TYPED_TEST(ClassificationModel, labels) {
+TYPED_TEST(ClassificationModel, Labels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
     const plssvm::classification_model<label_type> model{ this->filename };
 
     // check labels getter
-    ASSERT_TRUE(model.labels().has_value());
-    EXPECT_EQ(model.labels()->get(), util::get_correct_model_file_labels<label_type>());
+    EXPECT_OPTIONAL_EQ(model.labels(), util::get_correct_model_file_labels<label_type>());
 }
 
-TYPED_TEST(ClassificationModel, num_classes) {
+TYPED_TEST(ClassificationModel, NumClasses) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -161,7 +163,7 @@ TYPED_TEST(ClassificationModel, num_classes) {
     EXPECT_EQ(model.num_classes(), util::get_num_classes<label_type>());
 }
 
-TYPED_TEST(ClassificationModel, classes) {
+TYPED_TEST(ClassificationModel, Classes) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -171,7 +173,7 @@ TYPED_TEST(ClassificationModel, classes) {
     EXPECT_EQ(model.classes(), util::get_distinct_label<label_type>());
 }
 
-TYPED_TEST(ClassificationModel, weights) {
+TYPED_TEST(ClassificationModel, Weights) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
@@ -254,7 +256,7 @@ TYPED_TEST(ClassificationModel, weights) {
     }
 }
 
-TYPED_TEST(ClassificationModel, rho) {
+TYPED_TEST(ClassificationModel, Rho) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
@@ -304,7 +306,7 @@ TYPED_TEST(ClassificationModel, rho) {
     }
 }
 
-TYPED_TEST(ClassificationModel, get_classification_type) {
+TYPED_TEST(ClassificationModel, GetClassificationType) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
@@ -315,7 +317,7 @@ TYPED_TEST(ClassificationModel, get_classification_type) {
     EXPECT_EQ(model.get_classification_type(), classification);
 }
 
-TYPED_TEST(ClassificationModel, num_iters) {
+TYPED_TEST(ClassificationModel, NumIters) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -335,7 +337,7 @@ class ClassificationModelSave : public ::testing::Test,
 
 TYPED_TEST_SUITE(ClassificationModelSave, util::classification_label_type_classification_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(ClassificationModelSave, save) {
+TYPED_TEST(ClassificationModelSave, Save) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
diff --git a/tests/model/regression_model.cpp b/tests/model/regression_model.cpp
index 9755ae3b6..6c92c49f2 100644
--- a/tests/model/regression_model.cpp
+++ b/tests/model/regression_model.cpp
@@ -47,7 +47,7 @@ class RegressionModel : public ::testing::Test,
 
 TYPED_TEST_SUITE(RegressionModel, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(RegressionModel, typedefs) {
+TYPED_TEST(RegressionModel, Typedefs) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -58,7 +58,7 @@ TYPED_TEST(RegressionModel, typedefs) {
     ::testing::StaticAssertTypeEq<std::size_t, typename decltype(model)::size_type>();
 }
 
-TYPED_TEST(RegressionModel, construct) {
+TYPED_TEST(RegressionModel, Construct) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -76,7 +76,7 @@ TYPED_TEST(RegressionModel, construct) {
     EXPECT_FALSE(model.num_iters().has_value());
 }
 
-TYPED_TEST(RegressionModel, num_support_vectors) {
+TYPED_TEST(RegressionModel, NumSupportVectors) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -86,7 +86,7 @@ TYPED_TEST(RegressionModel, num_support_vectors) {
     EXPECT_EQ(model.num_support_vectors(), 6);
 }
 
-TYPED_TEST(RegressionModel, num_features) {
+TYPED_TEST(RegressionModel, NumFeatures) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -96,7 +96,7 @@ TYPED_TEST(RegressionModel, num_features) {
     EXPECT_EQ(model.num_features(), 4);
 }
 
-TYPED_TEST(RegressionModel, get_params) {
+TYPED_TEST(RegressionModel, GetParams) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -106,7 +106,7 @@ TYPED_TEST(RegressionModel, get_params) {
     EXPECT_EQ(model.get_params(), plssvm::parameter{ plssvm::kernel_type = plssvm::kernel_function_type::linear });
 }
 
-TYPED_TEST(RegressionModel, support_vectors) {
+TYPED_TEST(RegressionModel, SupportVectors) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -123,7 +123,7 @@ TYPED_TEST(RegressionModel, support_vectors) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(model.support_vectors(), support_vectors);
 }
 
-TYPED_TEST(RegressionModel, labels) {
+TYPED_TEST(RegressionModel, Labels) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -133,7 +133,7 @@ TYPED_TEST(RegressionModel, labels) {
     ASSERT_FALSE(model.labels().has_value());
 }
 
-TYPED_TEST(RegressionModel, weights) {
+TYPED_TEST(RegressionModel, Weights) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -146,7 +146,7 @@ TYPED_TEST(RegressionModel, weights) {
     EXPECT_FLOATING_POINT_MATRIX_EQ(model.weights().front(), (plssvm::aos_matrix<plssvm::real_type>{ correct_weights, plssvm::shape{ plssvm::PADDING_SIZE, plssvm::PADDING_SIZE } }));
 }
 
-TYPED_TEST(RegressionModel, rho) {
+TYPED_TEST(RegressionModel, Rho) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -157,7 +157,7 @@ TYPED_TEST(RegressionModel, rho) {
     EXPECT_FLOATING_POINT_VECTOR_EQ(model.rho(), rho);
 }
 
-TYPED_TEST(RegressionModel, num_iters) {
+TYPED_TEST(RegressionModel, NumIters) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create model
@@ -176,7 +176,7 @@ class RegressionModelSave : public ::testing::Test,
 
 TYPED_TEST_SUITE(RegressionModelSave, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(RegressionModelSave, save) {
+TYPED_TEST(RegressionModelSave, Save) {
     using label_type = typename TestFixture::fixture_label_type;
 
     for (const plssvm::kernel_function_type kernel_function : util::kernel_functions_to_test) {
diff --git a/tests/mpi/communicator.cpp b/tests/mpi/communicator.cpp
index 30078c8a5..5c88a68f1 100644
--- a/tests/mpi/communicator.cpp
+++ b/tests/mpi/communicator.cpp
@@ -16,7 +16,7 @@
 #include "plssvm/matrix.hpp"                 // plssvm::aos_matrix, plssvm::soa_matrix
 #include "plssvm/shape.hpp"                  // plssvm::shape
 
-#include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT
+#include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT, EXPECT_OPTIONAL_EQ
 #include "tests/utility.hpp"             // util::generate_random_matrix
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
@@ -32,7 +32,7 @@
 #include <string>    // std::string
 #include <vector>    // std::vector
 
-TEST(MPICommunicator, default_construct) {
+TEST(MPICommunicator, DefaultConstruct) {
     // create a default constructed MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -40,18 +40,17 @@ TEST(MPICommunicator, default_construct) {
     EXPECT_FALSE(comm.get_load_balancing_weights().has_value());
 }
 
-TEST(MPICommunicator, construct_weights) {
+TEST(MPICommunicator, ConstructWeights) {
     const std::vector<std::size_t> weights = { std::size_t{ 42 } };
     // create an MPI communicator with load-balancing weights
     const plssvm::mpi::communicator comm{ weights };
 
     // load-balancing weights should be set
-    ASSERT_TRUE(comm.get_load_balancing_weights().has_value());
-    EXPECT_EQ(comm.get_load_balancing_weights().value(), weights);
+    EXPECT_OPTIONAL_EQ(comm.get_load_balancing_weights(), weights);
 }
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
-TEST(MPICommunicator, construct_mpi_comm) {
+TEST(MPICommunicator, ConstructMPIComm) {
     // create an MPI communicator wrapping an MPI_Comm
     const plssvm::mpi::communicator comm{ MPI_COMM_WORLD };
 
@@ -64,14 +63,13 @@ TEST(MPICommunicator, construct_mpi_comm) {
     EXPECT_EQ(result, MPI_IDENT);
 }
 
-TEST(MPICommunicator, construct_mpi_comm_and_weights) {
+TEST(MPICommunicator, ConstructMPICommAndWeights) {
     const std::vector<std::size_t> weights = { std::size_t{ 42 } };
     // create a MPI communicator with load-balancing weights
     const plssvm::mpi::communicator comm{ MPI_COMM_WORLD, weights };
 
     // load-balancing weights should be set
-    ASSERT_TRUE(comm.get_load_balancing_weights().has_value());
-    EXPECT_EQ(comm.get_load_balancing_weights().value(), weights);
+    EXPECT_OPTIONAL_EQ(comm.get_load_balancing_weights(), weights);
 
     // the wrapped MPI communicator should be equal to MPI_COMM_WORLD
     int result{};
@@ -80,7 +78,7 @@ TEST(MPICommunicator, construct_mpi_comm_and_weights) {
 }
 #endif
 
-TEST(MPICommunicator, size) {
+TEST(MPICommunicator, Size) {
     // create a default constructed MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -88,7 +86,7 @@ TEST(MPICommunicator, size) {
     EXPECT_EQ(comm.size(), std::size_t{ 1 });
 }
 
-TEST(MPICommunicator, rank) {
+TEST(MPICommunicator, Rank) {
     // create a default constructed MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -96,12 +94,12 @@ TEST(MPICommunicator, rank) {
     EXPECT_EQ(comm.rank(), std::size_t{ 0 });
 }
 
-TEST(MPICommunicator, main_rank) {
+TEST(MPICommunicator, MainRank) {
     // always 0
     EXPECT_EQ(plssvm::mpi::communicator::main_rank(), std::size_t{ 0 });
 }
 
-TEST(MPICommunicator, is_mpi_enabled) {
+TEST(MPICommunicator, IsMPIEnabled) {
 #if defined(PLSSVM_HAS_MPI_ENABLED)
     EXPECT_TRUE(plssvm::mpi::communicator::is_mpi_enabled());
 #else
@@ -109,7 +107,7 @@ TEST(MPICommunicator, is_mpi_enabled) {
 #endif
 }
 
-TEST(MPICommunicator, is_main_rank) {
+TEST(MPICommunicator, IsMainRank) {
     // create a default constructed MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -117,7 +115,7 @@ TEST(MPICommunicator, is_main_rank) {
     EXPECT_TRUE(comm.is_main_rank());
 }
 
-TEST(MPICommunicator, serialize) {
+TEST(MPICommunicator, Serialize) {
     // create a default constructed MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -125,7 +123,7 @@ TEST(MPICommunicator, serialize) {
     comm.serialize([&]() { std::cout << comm.rank() << std::endl; });
 }
 
-TEST(MPICommunicator, gather) {
+TEST(MPICommunicator, Gather) {
     // create a default constructed MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -135,7 +133,7 @@ TEST(MPICommunicator, gather) {
     EXPECT_EQ(res.front(), 42);
 }
 
-TEST(MPICommunicator, gather_string) {
+TEST(MPICommunicator, GatherString) {
     // create a default constructed MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -148,7 +146,7 @@ TEST(MPICommunicator, gather_string) {
     EXPECT_EQ(res.front(), msg);
 }
 
-TEST(MPICommunicator, gather_milli) {
+TEST(MPICommunicator, GatherMilli) {
     // create a default constructed MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -158,7 +156,7 @@ TEST(MPICommunicator, gather_milli) {
     EXPECT_EQ(res.front(), std::chrono::milliseconds{ 13 });
 }
 
-TEST(MPICommunicator, allgather) {
+TEST(MPICommunicator, Allgather) {
     // create a default constructed MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -168,7 +166,7 @@ TEST(MPICommunicator, allgather) {
     EXPECT_EQ(res.front(), 42);
 }
 
-TEST(MPICommunicator, allreduce_inplace) {
+TEST(MPICommunicator, AllreduceInplace) {
     // create a default constructed MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -187,7 +185,7 @@ TEST(MPICommunicator, allreduce_inplace) {
     }
 }
 
-TEST(MPICommunicator, set_load_balancing_weights) {
+TEST(MPICommunicator, SetLoadBalancingWeights) {
     const std::vector<std::size_t> weights = { std::size_t{ 42 } };
     // create default constructed MPI communicator
     plssvm::mpi::communicator comm{};
@@ -203,7 +201,7 @@ TEST(MPICommunicator, set_load_balancing_weights) {
     EXPECT_EQ(comm.get_load_balancing_weights(), weights);
 }
 
-TEST(MPICommunicator, get_load_balancing_weights) {
+TEST(MPICommunicator, GetLoadBalancingWeights) {
     const std::vector<std::size_t> weights = { std::size_t{ 42 } };
     // create default constructed MPI communicator
     plssvm::mpi::communicator comm{};
@@ -218,7 +216,7 @@ TEST(MPICommunicator, get_load_balancing_weights) {
     EXPECT_TRUE(comm.get_load_balancing_weights().has_value());
 }
 
-TEST(MPICommunicator, equal) {
+TEST(MPICommunicator, Equal) {
     // create two default constructed MPI communicators
     const plssvm::mpi::communicator comm1{};
     const plssvm::mpi::communicator comm2{};
@@ -229,7 +227,7 @@ TEST(MPICommunicator, equal) {
 #if defined(PLSSVM_HAS_MPI_ENABLED)
     const plssvm::mpi::communicator comm3{ MPI_COMM_WORLD };
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm4{ duplicated_mpi_comm };
 
@@ -241,7 +239,7 @@ TEST(MPICommunicator, equal) {
 #endif
 }
 
-TEST(MPICommunicator, unequal) {
+TEST(MPICommunicator, Unequal) {
     // create two default constructed MPI communicators
     const plssvm::mpi::communicator comm1{};
     const plssvm::mpi::communicator comm2{};
@@ -252,7 +250,7 @@ TEST(MPICommunicator, unequal) {
 #if defined(PLSSVM_HAS_MPI_ENABLED)
     const plssvm::mpi::communicator comm3{ MPI_COMM_WORLD };
     // create a duplicated communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm4{ duplicated_mpi_comm };
 
@@ -264,19 +262,19 @@ TEST(MPICommunicator, unequal) {
 #endif
 }
 
-TEST(MPICommunicatorDeathTest, construct_too_few_weights) {
+TEST(MPICommunicatorDeathTest, ConstructTooFewWeights) {
     // since MPI is not enabled, we can only pass exactly ONE weight value
     EXPECT_THROW_WHAT_MATCHER(plssvm::mpi::communicator{ std::vector<std::size_t>{} }, plssvm::mpi_exception, ::testing::HasSubstr("The number of load balancing weights (0) must match the number of MPI ranks (1)!"));
 }
 
-TEST(MPICommunicatorDeathTest, construct_too_many_weights) {
+TEST(MPICommunicatorDeathTest, ConstructTooManyWeights) {
     // since MPI is not enabled, we can only pass exactly ONE weight value
     EXPECT_THROW_WHAT_MATCHER((plssvm::mpi::communicator{ std::vector<std::size_t>{ std::size_t{ 1 }, std::size_t{ 2 } } }),
                               plssvm::mpi_exception,
                               ::testing::HasSubstr("The number of load balancing weights (2) must match the number of MPI ranks (1)!"));
 }
 
-TEST(MPICommunicatorDeathTest, set_too_few_load_balancing_weights) {
+TEST(MPICommunicatorDeathTest, SetTooFewLoadBalancingWeights) {
     // create default constructed MPI communicator
     plssvm::mpi::communicator comm{};
 
@@ -284,7 +282,7 @@ TEST(MPICommunicatorDeathTest, set_too_few_load_balancing_weights) {
     EXPECT_THROW_WHAT_MATCHER(comm.set_load_balancing_weights({}), plssvm::mpi_exception, ::testing::HasSubstr("The number of load balancing weights (0) must match the number of MPI ranks (1)!"));
 }
 
-TEST(MPICommunicatorDeathTest, set_too_many_load_balancing_weights) {
+TEST(MPICommunicatorDeathTest, SetTooManyLoadBalancingWeights) {
     // create default constructed MPI communicator
     plssvm::mpi::communicator comm{};
 
diff --git a/tests/mpi/detail/information.cpp b/tests/mpi/detail/information.cpp
index 9e7799dfa..cfaf3b7bc 100644
--- a/tests/mpi/detail/information.cpp
+++ b/tests/mpi/detail/information.cpp
@@ -27,7 +27,7 @@
 class MPIInformation : public ::testing::Test,
                        public util::redirect_output<&std::cout> { };
 
-TEST_F(MPIInformation, gather_and_print_solver_information) {
+TEST_F(MPIInformation, GatherAndPrintSolverInformationNotEmpty) {
     // construct an MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -38,7 +38,7 @@ TEST_F(MPIInformation, gather_and_print_solver_information) {
     EXPECT_FALSE(this->get_capture().empty());
 }
 
-TEST_F(MPIInformation, gather_and_print_csvm_information_with_device_names) {
+TEST_F(MPIInformation, GatherAndPrintCsvmInformationWithDeviceNamesNotEmpty) {
     // construct an MPI communicator
     const plssvm::mpi::communicator comm{};
 
@@ -49,7 +49,7 @@ TEST_F(MPIInformation, gather_and_print_csvm_information_with_device_names) {
     EXPECT_FALSE(this->get_capture().empty());
 }
 
-TEST_F(MPIInformation, gather_and_print_csvm_information) {
+TEST_F(MPIInformation, GatherAndPrintCsvmInformationNotEmpty) {
     // construct an MPI communicator
     const plssvm::mpi::communicator comm{};
 
diff --git a/tests/mpi/detail/mpi_datatype.cpp b/tests/mpi/detail/mpi_datatype.cpp
index 9ed41b4cc..a2b238831 100644
--- a/tests/mpi/detail/mpi_datatype.cpp
+++ b/tests/mpi/detail/mpi_datatype.cpp
@@ -11,13 +11,13 @@
 
 #include "plssvm/mpi/detail/mpi_datatype.hpp"
 
-#include "gtest/gtest.h"  // TEST, EXPECT_FALSE, EXPECT_DEATH
-
-#include <complex>  // std::complex
-
 #if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "gtest/gtest.h"  // TEST, EXPECT_FALSE, EXPECT_DEATH
+    #include "mpi.h"          // MPI data types
+
+    #include <complex>  // std::complex
 
-TEST(MPIDataTypes, mpi_datatype) {
+TEST(MPIDataTypes, MPIDatatype) {
     // check type conversions
     EXPECT_EQ(plssvm::mpi::detail::mpi_datatype<bool>(), MPI_C_BOOL);
 
@@ -51,7 +51,7 @@ TEST(MPIDataTypes, mpi_datatype) {
 enum class dummy1 : int {};
 enum class dummy2 : char {};
 
-TEST(MPIDataTypes, mpi_datatype_from_enum) {
+TEST(MPIDataTypes, MPIDatatypeFromEnum) {
     // check type conversions from enum's underlying type
     EXPECT_EQ(plssvm::mpi::detail::mpi_datatype<dummy1>(), MPI_INT);
     EXPECT_EQ(plssvm::mpi::detail::mpi_datatype<dummy2>(), MPI_CHAR);
diff --git a/tests/mpi/detail/utility.cpp b/tests/mpi/detail/utility.cpp
index 278b9ec1f..0bfe46243 100644
--- a/tests/mpi/detail/utility.cpp
+++ b/tests/mpi/detail/utility.cpp
@@ -11,9 +11,9 @@
 
 #include "plssvm/mpi/detail/utility.hpp"
 
-#include "plssvm/exceptions/exceptions.hpp"  // plssvm::mpi_exception
-
 #if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/exceptions/exceptions.hpp"  // plssvm::mpi_exception
+
     #include "mpi.h"  // MPI_SUCCESS, MPI_ERR_COMM
 #endif
 
@@ -21,7 +21,7 @@
 
 #include <string>  // std::string
 
-TEST(MPIUtility, mpi_error_check) {
+TEST(MPIUtility, MPIErrorCheck) {
     // test error check macro
 #if defined(PLSSVM_HAS_MPI_ENABLED)
     // if MPI is enabled, MPI_SUCCESS may never throw
@@ -35,7 +35,7 @@ TEST(MPIUtility, mpi_error_check) {
 #endif
 }
 
-TEST(MPIUtility, node_name) {
+TEST(MPIUtility, NodeName) {
     // the MPI node name may not be empty
     EXPECT_FALSE(plssvm::mpi::detail::node_name().empty());
 }
diff --git a/tests/mpi/detail/version.cpp b/tests/mpi/detail/version.cpp
index 59f99e828..e8deacac9 100644
--- a/tests/mpi/detail/version.cpp
+++ b/tests/mpi/detail/version.cpp
@@ -15,12 +15,12 @@
 
 #include <string>  // std::string
 
-TEST(MPIVersion, mpi_library_version) {
+TEST(MPIVersion, MPILibraryVersionNotEmpty) {
     // the MPI library version may not be empty
     EXPECT_FALSE(plssvm::mpi::detail::mpi_library_version().empty());
 }
 
-TEST(MPIVersion, mpi_version) {
+TEST(MPIVersion, MPIVersionNotEmpty) {
     // the MPI version may not be empty
     EXPECT_FALSE(plssvm::mpi::detail::mpi_version().empty());
 }
diff --git a/tests/mpi/environment.cpp b/tests/mpi/environment.cpp
index 812f1f5ab..bfd824e22 100644
--- a/tests/mpi/environment.cpp
+++ b/tests/mpi/environment.cpp
@@ -13,12 +13,12 @@
 
 #include "gtest/gtest.h"  // TEST, EXPECT_FALSE, EXPECT_DEATH
 
-TEST(MPIEnvironment, is_executed_via_mpirun) {
+TEST(MPIEnvironment, IsExecutedViaMpirun) {
     // since we do not support mpirun ctest, the function must return false
     EXPECT_FALSE(plssvm::mpi::is_executed_via_mpirun());
 }
 
-TEST(MPIEnvironmentDeathTest, abort_world) {
+TEST(MPIEnvironmentDeathTest, AbortWorld) {
     // test whether the abort function fires correctly
     EXPECT_DEATH(plssvm::mpi::abort_world(), "");
 }
diff --git a/tests/naming.hpp b/tests/naming.hpp
index e774820c4..a439155cd 100644
--- a/tests/naming.hpp
+++ b/tests/naming.hpp
@@ -23,7 +23,6 @@
 #include "tests/exceptions/utility.hpp"  // util::exception_type_name
 
 #include "fmt/format.h"   // fmt::format
-#include "fmt/ostream.h"  // directly output types with an operator<< overload using fmt
 #include "fmt/ranges.h"   // fmt::join, directly output a std::tuple
 #include "gtest/gtest.h"  // ::testing::TestParamInfo
 
@@ -128,7 +127,8 @@ PLSSVM_CREATE_HAS_MEMBER_VARIABLE_TYPE_TRAIT(space)
 
     // replace all remaining characters with '_' that are not alphanumeric values or underscores
     for (char &c : str) {
-        if (!std::isalnum(static_cast<int>(c)) && c != '_') {
+        // std::isalnum: Non-zero value if the character is an alphanumeric character, 0 otherwise.
+        if (std::isalnum(static_cast<int>(c)) == 0 && c != '_') {
             c = '_';
         }
     }
@@ -283,7 +283,7 @@ template <typename T>
 class test_parameter_to_name {
   public:
     template <typename T>
-    static std::string GetName(int) {
+    static std::string GetName([[maybe_unused]] int i) {
         using used_type_list = typename T::types;
         using used_value_list = typename T::values;
 
diff --git a/tests/parameter.cpp b/tests/parameter.cpp
index 940aa7d08..e9da7cf1a 100644
--- a/tests/parameter.cpp
+++ b/tests/parameter.cpp
@@ -10,13 +10,14 @@
 
 #include "plssvm/parameter.hpp"
 
-#include "plssvm/backends/Kokkos/execution_space.hpp"        // plssvm::kokkos::execution_space
-#include "plssvm/backends/SYCL/implementation_types.hpp"     // plssvm::sycl::implementation_type
-#include "plssvm/backends/SYCL/kernel_invocation_types.hpp"  // plssvm::sycl::kernel_invocation_type
-#include "plssvm/constants.hpp"                              // plssvm::real_type
-#include "plssvm/detail/arithmetic_type_name.hpp"            // plssvm::detail::arithmetic_type_name
-#include "plssvm/gamma.hpp"                                  // plssvm::gamma_coefficient_type
-#include "plssvm/kernel_function_types.hpp"                  // plssvm::kernel_function_type
+#include "plssvm/backends/Kokkos/execution_spaces.hpp"     // plssvm::kokkos::execution_space
+#include "plssvm/backends/SYCL/data_parallel_kernels.hpp"  // plssvm::sycl::data_parallel_kernel
+#include "plssvm/backends/SYCL/implementation_types.hpp"   // plssvm::sycl::implementation_type
+#include "plssvm/constants.hpp"                            // plssvm::real_type
+#include "plssvm/detail/arithmetic_type_name.hpp"          // plssvm::detail::arithmetic_type_name
+#include "plssvm/exceptions/exceptions.hpp"                // plssvm::invalid_parameter_exception
+#include "plssvm/gamma.hpp"                                // plssvm::gamma_coefficient_type
+#include "plssvm/kernel_function_types.hpp"                // plssvm::kernel_function_type
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_FLOATING_POINT_EQ
 
@@ -25,7 +26,7 @@
 
 #include <variant>  // std::holds_alternative, std::get
 
-TEST(Parameter, default_construct) {
+TEST(Parameter, DefaultConstruct) {
     // default construct parameter set
     const plssvm::parameter param{};
 
@@ -38,7 +39,7 @@ TEST(Parameter, default_construct) {
     EXPECT_FLOATING_POINT_EQ(param.cost, plssvm::real_type{ 1.0 });
 }
 
-TEST(Parameter, construct) {
+TEST(Parameter, Construct) {
     // construct a parameter set explicitly overwriting the default values
     const plssvm::parameter param{ plssvm::kernel_function_type::polynomial, 1, plssvm::real_type{ 0.1 }, plssvm::real_type{ 2.5 }, plssvm::real_type{ 0.05 } };
 
@@ -51,7 +52,7 @@ TEST(Parameter, construct) {
     EXPECT_FLOATING_POINT_EQ(param.cost, plssvm::real_type{ 0.05 });
 }
 
-TEST(Parameter, construct_named_args_all) {
+TEST(Parameter, ConstructNamedArgsAll) {
     // construct a parameter set explicitly overwriting all default values using named parameters
     const plssvm::parameter param{
         plssvm::kernel_type = plssvm::kernel_function_type::polynomial,
@@ -70,7 +71,7 @@ TEST(Parameter, construct_named_args_all) {
     EXPECT_FLOATING_POINT_EQ(param.cost, plssvm::real_type{ 0.05 });
 }
 
-TEST(Parameter, construct_named_args) {
+TEST(Parameter, ConstructNamedArgs) {
     // construct a parameter set explicitly overwriting some default values using named parameters
     const plssvm::parameter param{
         plssvm::kernel_type = plssvm::kernel_function_type::polynomial,
@@ -87,7 +88,7 @@ TEST(Parameter, construct_named_args) {
     EXPECT_FLOATING_POINT_EQ(param.cost, plssvm::real_type{ 0.05 });
 }
 
-TEST(Parameter, construct_parameter_and_named_args) {
+TEST(Parameter, ConstructParameterAndNamedArgs) {
     // construct a parameter set
     const plssvm::parameter param_base{
         plssvm::kernel_type = plssvm::kernel_function_type::laplacian,
@@ -99,7 +100,7 @@ TEST(Parameter, construct_parameter_and_named_args) {
     const plssvm::parameter param{ param_base,
                                    plssvm::kernel_type = plssvm::kernel_function_type::rbf,
                                    plssvm::sycl_implementation_type = plssvm::sycl::implementation_type::adaptivecpp,
-                                   plssvm::sycl_kernel_invocation_type = plssvm::sycl::kernel_invocation_type::work_group,
+                                   plssvm::sycl_data_parallel_kernel = plssvm::sycl::data_parallel_kernel::work_group,
                                    plssvm::kokkos_execution_space = plssvm::kokkos::execution_space::cuda };
 
     // test default values
@@ -111,25 +112,25 @@ TEST(Parameter, construct_parameter_and_named_args) {
     EXPECT_FLOATING_POINT_EQ(param.cost, plssvm::real_type{ 0.05 });
 }
 
-TEST(Parameter, construct_invalid_kernel_type) {
+TEST(Parameter, ConstructInvalidKernelType) {
     EXPECT_THROW_WHAT(plssvm::parameter{ plssvm::kernel_type = static_cast<plssvm::kernel_function_type>(6) },
                       plssvm::invalid_parameter_exception,
                       "Invalid kernel function with value 6 given!");
 }
 
-TEST(Parameter, construct_invalid_degree) {
+TEST(Parameter, ConstructInvalidDegree) {
     EXPECT_THROW_WHAT((plssvm::parameter{ plssvm::kernel_type = plssvm::kernel_function_type::polynomial, plssvm::degree = -1 }),
                       plssvm::invalid_parameter_exception,
                       "degree must be non-negative, but is -1!");
 }
 
-TEST(Parameter, construct_invalid_gamma) {
+TEST(Parameter, ConstructInvalidGamma) {
     EXPECT_THROW_WHAT(plssvm::parameter{ plssvm::gamma = plssvm::real_type{ -0.1 } },
                       plssvm::invalid_parameter_exception,
                       "gamma must be non-negative, but is -0.1!");
 }
 
-TEST(Parameter, construct_invalid_cost) {
+TEST(Parameter, ConstructInvalidCost) {
     EXPECT_THROW_WHAT(plssvm::parameter{ plssvm::cost = plssvm::real_type{ 0.0 } },
                       plssvm::invalid_parameter_exception,
                       "cost must be strictly-positive, but is 0!");
@@ -138,7 +139,7 @@ TEST(Parameter, construct_invalid_cost) {
                       "cost must be strictly-positive, but is -0.1!");
 }
 
-TEST(Parameter, equal) {
+TEST(Parameter, Equal) {
     // test whether different parameter sets are equal, i.e., all member variables have the same value
     const plssvm::parameter params1{ plssvm::kernel_function_type::rbf, 3, plssvm::real_type{ 0.02 }, plssvm::real_type{ 1.5 }, plssvm::real_type{ 1.0 } };
     const plssvm::parameter params2{ plssvm::kernel_function_type::rbf, 3, plssvm::real_type{ 0.02 }, plssvm::real_type{ 1.5 }, plssvm::real_type{ 1.0 } };
@@ -152,7 +153,7 @@ TEST(Parameter, equal) {
     EXPECT_FALSE(params3 == params4);
 }
 
-TEST(Parameter, equal_default_constructed) {
+TEST(Parameter, EqualDefaultConstructed) {
     // test whether two default constructed parameter sets are equal, i.e., all member variables have the same value
     const plssvm::parameter params1{};
     const plssvm::parameter params2{};
@@ -161,7 +162,7 @@ TEST(Parameter, equal_default_constructed) {
     EXPECT_TRUE(params1 == params2);
 }
 
-TEST(Parameter, unequal) {
+TEST(Parameter, Unequal) {
     // test whether different parameter sets are unequal, i.e., any member variables differ in value
     const plssvm::parameter params1{ plssvm::kernel_function_type::rbf, 3, plssvm::real_type{ 0.02 }, plssvm::real_type{ 1.5 }, plssvm::real_type{ 1.0 } };
     const plssvm::parameter params2{ plssvm::kernel_function_type::rbf, 3, plssvm::real_type{ 0.02 }, plssvm::real_type{ 1.5 }, plssvm::real_type{ 1.0 } };
@@ -175,7 +176,7 @@ TEST(Parameter, unequal) {
     EXPECT_TRUE(params3 != params4);
 }
 
-TEST(Parameter, unequal_default_constructed) {
+TEST(Parameter, UnequalDefaultConstructed) {
     // test whether two default constructed parameter sets are unequal, i.e., any member variables differ in value
     const plssvm::parameter params1{};
     const plssvm::parameter params2{};
@@ -184,7 +185,7 @@ TEST(Parameter, unequal_default_constructed) {
     EXPECT_FALSE(params1 != params2);
 }
 
-TEST(Parameter, equivalent_member_function) {
+TEST(Parameter, EquivalentMemberFunction) {
     // test whether different parameter sets are equivalent, i.e., all member variables IMPORTANT FOR THE KERNEL TYPE have the same value
     const plssvm::parameter params1{ plssvm::kernel_function_type::rbf, 3, plssvm::real_type{ 0.02 }, plssvm::real_type{ 1.5 }, plssvm::real_type{ 1.0 } };
     const plssvm::parameter params2{ plssvm::kernel_function_type::rbf, 3, plssvm::real_type{ 0.02 }, plssvm::real_type{ 1.5 }, plssvm::real_type{ 1.0 } };
@@ -210,7 +211,7 @@ TEST(Parameter, equivalent_member_function) {
     EXPECT_FALSE(params4.equivalent(params10));
 }
 
-TEST(Parameter, equivalent_member_function_default_constructed) {
+TEST(Parameter, EquivalentMemberFunctionDefaultConstructed) {
     // test whether two default constructed parameter sets are equal, i.e., all member variables have the same value
     const plssvm::parameter params1{};
     const plssvm::parameter params2{};
@@ -219,7 +220,7 @@ TEST(Parameter, equivalent_member_function_default_constructed) {
     EXPECT_TRUE(params1.equivalent(params2));
 }
 
-TEST(Parameter, equivalent_free_function) {
+TEST(Parameter, EquivalentFreeFunction) {
     // test whether different parameter sets are equivalent, i.e., all member variables IMPORTANT FOR THE KERNEL TYPE have the same value
     const plssvm::parameter params1{ plssvm::kernel_function_type::rbf, 3, plssvm::real_type{ 0.02 }, plssvm::real_type{ 1.5 }, plssvm::real_type{ 1.0 } };
     const plssvm::parameter params2{ plssvm::kernel_function_type::rbf, 3, plssvm::real_type{ 0.02 }, plssvm::real_type{ 1.5 }, plssvm::real_type{ 1.0 } };
@@ -245,7 +246,7 @@ TEST(Parameter, equivalent_free_function) {
     EXPECT_FALSE(plssvm::equivalent(params4, params10));
 }
 
-TEST(Parameter, equivalent_free_function_default_constructed) {
+TEST(Parameter, EquivalentFreeFunctionDefaultConstructed) {
     // test whether two default constructed parameter sets are equal, i.e., all member variables have the same value
     const plssvm::parameter params1{};
     const plssvm::parameter params2{};
@@ -254,7 +255,7 @@ TEST(Parameter, equivalent_free_function_default_constructed) {
     EXPECT_TRUE(plssvm::equivalent(params1, params2));
 }
 
-TEST(Parameter, to_string) {
+TEST(Parameter, ToString) {
     // check conversions to std::string
     const plssvm::parameter param{ plssvm::kernel_function_type::linear, 3, plssvm::real_type{ 0.1 }, plssvm::real_type{ 0.0 }, plssvm::real_type{ 1.0 } };
     EXPECT_CONVERSION_TO_STRING(param, fmt::format("kernel_type                 linear\n"
diff --git a/tests/regression_report.cpp b/tests/regression_report.cpp
index c9451dcc7..2748b8656 100644
--- a/tests/regression_report.cpp
+++ b/tests/regression_report.cpp
@@ -10,6 +10,7 @@
 
 #include "plssvm/regression_report.hpp"
 
+#include "plssvm/constants.hpp"              // plssvm::real_type
 #include "plssvm/exceptions/exceptions.hpp"  // plssvm::regression_report_exception
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT, EXPECT_CONVERSION_TO_STRING, EXPECT_FLOATING_POINT_NEAR, EXPECT_FLOATING_POINT_NEAR_EPS
@@ -26,7 +27,7 @@
 //                                                               metrics                                                               //
 //*************************************************************************************************************************************//
 
-TEST(RegressionReportMetrics, construct_metric) {
+TEST(RegressionReportMetrics, ConstructMetric) {
     // construct a metric object
     const plssvm::regression_report::metric m{ 0.1, 0.2, 0.3, 0.4, 0.5 };
 
@@ -38,7 +39,7 @@ TEST(RegressionReportMetrics, construct_metric) {
     EXPECT_FLOATING_POINT_NEAR(m.squared_correlation_coefficient, 0.5);
 }
 
-TEST(RegressionReportMetrics, output_metric) {
+TEST(RegressionReportMetrics, OutputMetric) {
     // construct a metric object
     EXPECT_CONVERSION_TO_STRING((plssvm::regression_report::metric{ 0.1, 0.2, 0.3, 0.4, 0.5 }),
                                 "Explained variance score:        0.1\n"
@@ -74,7 +75,7 @@ class RegressionReport : public ::testing::Test,
     std::vector<plssvm::real_type> predicted_label_ = { 0.1, 0.4, 0.7, 0.8, 1.1, 1.2, 1.5, 1.6, 1.7, 2.0 };
 };
 
-TEST_F(RegressionReport, construct) {
+TEST_F(RegressionReport, Construct) {
     // construct a regression report
     const plssvm::regression_report report{ this->get_correct_label(), this->get_predicted_label() };
 
@@ -87,7 +88,7 @@ TEST_F(RegressionReport, construct) {
     EXPECT_FLOATING_POINT_NEAR_EPS(m.squared_correlation_coefficient, 0.9852899678673179, 1e6);
 }
 
-TEST_F(RegressionReport, construct_perfect_prediction) {
+TEST_F(RegressionReport, ConstructPerfectPrediction) {
     // construct a regression report
     const plssvm::regression_report report{ this->get_correct_label(), this->get_correct_label() };
 
@@ -100,7 +101,7 @@ TEST_F(RegressionReport, construct_perfect_prediction) {
     EXPECT_FLOATING_POINT_NEAR(m.squared_correlation_coefficient, 1.0);
 }
 
-TEST_F(RegressionReport, construct_force_finite) {
+TEST_F(RegressionReport, ConstructForceFinite) {
     // construct a regression report
     const plssvm::regression_report report{ this->get_correct_label(), this->get_predicted_label(), plssvm::regression_report::force_finite = true };
 
@@ -113,7 +114,7 @@ TEST_F(RegressionReport, construct_force_finite) {
     EXPECT_FLOATING_POINT_NEAR_EPS(m.squared_correlation_coefficient, 0.9852899678673179, 1e6);
 }
 
-TEST_F(RegressionReport, construct_force_finite_perfect_prediction) {
+TEST_F(RegressionReport, ConstructForceFinitePerfectPrediction) {
     // construct a regression report
     const plssvm::regression_report report{ this->get_correct_label(), this->get_correct_label(), plssvm::regression_report::force_finite = true };
 
@@ -126,28 +127,28 @@ TEST_F(RegressionReport, construct_force_finite_perfect_prediction) {
     EXPECT_FLOATING_POINT_NEAR(m.squared_correlation_coefficient, 1.0);
 }
 
-TEST_F(RegressionReport, construct_empty_correct_label) {
+TEST_F(RegressionReport, ConstructEmptyCorrectLabel) {
     // the correct labels vector must not be empty
     EXPECT_THROW_WHAT((plssvm::regression_report{ std::vector<plssvm::real_type>{}, this->get_predicted_label() }),
                       plssvm::regression_report_exception,
                       "The correct labels list must not be empty!");
 }
 
-TEST_F(RegressionReport, construct_empty_predicted_label) {
+TEST_F(RegressionReport, ConstructEmptyPredictedLabel) {
     // the predicted labels vector must not be empty
     EXPECT_THROW_WHAT((plssvm::regression_report{ this->get_correct_label(), std::vector<plssvm::real_type>{} }),
                       plssvm::regression_report_exception,
                       "The predicted labels list must not be empty!");
 }
 
-TEST_F(RegressionReport, construct_label_size_mismatch) {
+TEST_F(RegressionReport, ConstructLabelSizeMismatch) {
     // constructing a regression report with different number of correct and predicted labels must throw
     EXPECT_THROW_WHAT((plssvm::regression_report{ std::vector<plssvm::real_type>{ 0, 0, 0 }, std::vector<plssvm::real_type>{ 0, 0 } }),
                       plssvm::regression_report_exception,
                       "The number of correct labels (3) and predicted labels (2) must be the same!");
 }
 
-TEST_F(RegressionReport, loss) {
+TEST_F(RegressionReport, Loss) {
     // construct a regression report
     const plssvm::regression_report report{ this->get_correct_label(), this->get_predicted_label() };
 
@@ -160,7 +161,7 @@ TEST_F(RegressionReport, loss) {
     EXPECT_FLOATING_POINT_NEAR_EPS(m.squared_correlation_coefficient, 0.9852899678673179, 1e6);
 }
 
-TEST_F(RegressionReport, regression_report) {
+TEST_F(RegressionReport, RegressionReport) {
     // construct a regression report
     const plssvm::regression_report report{ this->get_correct_label(), this->get_predicted_label() };
     std::cout << report;
diff --git a/tests/shape.cpp b/tests/shape.cpp
index 7083fc591..8f7cb241e 100644
--- a/tests/shape.cpp
+++ b/tests/shape.cpp
@@ -19,7 +19,7 @@
 #include <functional>  // std::hash
 #include <sstream>     // std::istringstream
 
-TEST(Shape, default_construct) {
+TEST(Shape, DefaultConstruct) {
     // default construct a shape
     const plssvm::shape s{};
 
@@ -28,7 +28,7 @@ TEST(Shape, default_construct) {
     EXPECT_EQ(s.y, 0);
 }
 
-TEST(Shape, construct) {
+TEST(Shape, Construct) {
     // construct a shape with values
     const plssvm::shape s{ 4, 5 };
 
@@ -37,7 +37,7 @@ TEST(Shape, construct) {
     EXPECT_EQ(s.y, 5);
 }
 
-TEST(Shape, swap_member_function) {
+TEST(Shape, SwapMemberFunction) {
     // construct two shape objects
     plssvm::shape s1{ 4, 5 };
     plssvm::shape s2{};
@@ -53,7 +53,7 @@ TEST(Shape, swap_member_function) {
 }
 
 // check whether the plssvm::shape -> std::string conversions are correct
-TEST(Shape, to_string) {
+TEST(Shape, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING((plssvm::shape{ 0, 0 }), "[0, 0]");
     EXPECT_CONVERSION_TO_STRING((plssvm::shape{ 4, 0 }), "[4, 0]");
@@ -62,7 +62,7 @@ TEST(Shape, to_string) {
 }
 
 // check whether the std::string -> plssvm::shape conversions are correct
-TEST(Shape, from_string) {
+TEST(Shape, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("0 0", (plssvm::shape{ 0, 0 }));
     EXPECT_CONVERSION_FROM_STRING("4 0", (plssvm::shape{ 4, 0 }));
@@ -70,7 +70,7 @@ TEST(Shape, from_string) {
     EXPECT_CONVERSION_FROM_STRING("4 5", (plssvm::shape{ 4, 5 }));
 }
 
-TEST(Shape, from_string_unknown) {
+TEST(Shape, FromStringUnknown) {
     // foo isn't a valid solver_type
     std::istringstream input{ "foo" };
     plssvm::shape shape{};
@@ -78,7 +78,7 @@ TEST(Shape, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(Shape, swap_free_function) {
+TEST(Shape, SwapFreeFunction) {
     // construct two shape objects
     plssvm::shape s1{ 4, 5 };
     plssvm::shape s2{};
@@ -94,7 +94,7 @@ TEST(Shape, swap_free_function) {
     EXPECT_EQ(s2.y, 5);
 }
 
-TEST(Shape, equal) {
+TEST(Shape, Equal) {
     // construct shape objects
     const plssvm::shape s1{ 4, 5 };
     const plssvm::shape s2{};
@@ -106,7 +106,7 @@ TEST(Shape, equal) {
     EXPECT_TRUE(s2 == s3);
 }
 
-TEST(Shape, unequal) {
+TEST(Shape, Unequal) {
     // construct shape objects
     const plssvm::shape s1{ 4, 5 };
     const plssvm::shape s2{};
@@ -118,7 +118,7 @@ TEST(Shape, unequal) {
     EXPECT_FALSE(s2 != s3);
 }
 
-TEST(Shape, hash) {
+TEST(Shape, Hash) {
     // create a shape object
     const plssvm::shape s{ 2, 3 };
 
diff --git a/tests/solver_types.cpp b/tests/solver_types.cpp
index acf5a5464..6b08f8dd9 100644
--- a/tests/solver_types.cpp
+++ b/tests/solver_types.cpp
@@ -12,26 +12,25 @@
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING
 
-#include "gmock/gmock.h"  // EXPECT_THAT, ::testing::Contains
 #include "gtest/gtest.h"  // TEST, EXPECT_TRUE
 
 #include <sstream>  // std::istringstream
 
 // check whether the plssvm::solver_type -> std::string conversions are correct
-TEST(SolverType, to_string) {
+TEST(SolverType, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::solver_type::automatic, "automatic");
     EXPECT_CONVERSION_TO_STRING(plssvm::solver_type::cg_explicit, "cg_explicit");
     EXPECT_CONVERSION_TO_STRING(plssvm::solver_type::cg_implicit, "cg_implicit");
 }
 
-TEST(SolverType, to_string_unknown) {
+TEST(SolverType, ToStringUnknown) {
     // check conversions to std::string from unknown solver_type
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::solver_type>(3), "unknown");
 }
 
 // check whether the std::string -> plssvm::solver_type conversions are correct
-TEST(SolverType, from_string) {
+TEST(SolverType, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("automatic", plssvm::solver_type::automatic);
     EXPECT_CONVERSION_FROM_STRING("AUTOmatic", plssvm::solver_type::automatic);
@@ -43,7 +42,7 @@ TEST(SolverType, from_string) {
     EXPECT_CONVERSION_FROM_STRING("CG_Implicit", plssvm::solver_type::cg_implicit);
 }
 
-TEST(SolverType, from_string_unknown) {
+TEST(SolverType, FromStringUnknown) {
     // foo isn't a valid solver_type
     std::istringstream input{ "foo" };
     plssvm::solver_type solver{};
diff --git a/tests/svm/csvc.cpp b/tests/svm/csvc.cpp
index 0a505d094..d7985845c 100644
--- a/tests/svm/csvc.cpp
+++ b/tests/svm/csvc.cpp
@@ -10,11 +10,14 @@
 
 #include "plssvm/svm/csvc.hpp"  // plssvm::csvc
 
-#include "plssvm/backend_types.hpp"                     // plssvm::csvm_backend_exists, plssvm::csvm_backend_exists_v, plssvm::backend_csvm_type, plssvm::backend_csvm_type_t
+#include "plssvm/backend_types.hpp"                     // plssvm::csvm_backend_exists, plssvm::backend_csvm_type, plssvm::backend_csvm_type_t
+#include "plssvm/backends/SYCL/detail/constants.hpp"    // NOLINT: namespace plssvm::sycl
 #include "plssvm/classification_types.hpp"              // plssvm::classification_type
-#include "plssvm/constants.hpp"                         // plssvm::real_type, plssvm::PADDING_SIZE
-#include "plssvm/core.hpp"                              // sycl namespace handling
+#include "plssvm/constants.hpp"                         // plssvm::real_type, plssvm::THREAD_BLOCK_SIZE, plssvm::INTERNAL_BLOCK_SIZE, plssvm::PADDING_SIZE
+#include "plssvm/core.hpp"                              // NOLINT: include all csvm_backend_exists_v specializations
 #include "plssvm/data_set/classification_data_set.hpp"  // plssvm::classification_data_set
+#include "plssvm/detail/data_distribution.hpp"          // plssvm::detail::data_distribution::maximum_local_memory_needed
+#include "plssvm/detail/memory_size.hpp"                // plssvm::detail::memory_size
 #include "plssvm/detail/move_only_any.hpp"              // plssvm::detail::move_only_any
 #include "plssvm/exceptions/exceptions.hpp"             // plssvm::invalid_parameter_exception
 #include "plssvm/kernel_function_types.hpp"             // plssvm::kernel_function_type
@@ -22,6 +25,7 @@
 #include "plssvm/model/classification_model.hpp"        // plssvm::classification_model
 #include "plssvm/parameter.hpp"                         // plssvm::parameter
 #include "plssvm/solver_types.hpp"                      // plssvm::solver_type
+#include "plssvm/svm/csvm.hpp"                          // plssvm::csvm_backend_exists_v
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT, EXPECT_THROW_WHAT_MATCHER, EXPECT_INCLUSIVE_RANGE
 #include "tests/naming.hpp"              // naming::parameter_definition_to_name
@@ -31,22 +35,26 @@
                                          // generate_random_matrix, get_correct_data_file_labels}
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/mpi/communicator.hpp"  // plssvm::mpi::communicator
+
     #include "mpi.h"  // MPI_COMM_WORLD, MPI_Comm_dup, MPI_Comm_free
 #endif
 
+#include "fmt/format.h"   // fmt::format
 #include "gmock/gmock.h"  // EXPECT_CALL, EXPECT_THAT, ::testing::{An, Between, Return, HasSubstr, ContainsRegex}
 #include "gtest/gtest.h"  // TEST, TYPED_TEST, TYPED_TEST_SUITE, EXPECT_EQ, EXPECT_TRUE, EXPECT_FALSE, EXPECT_THAT,
 
-#include <cstddef>  // std::size_t
-#include <string>   // std::string
-#include <tuple>    // std::ignore
-#include <utility>  // std::move
-#include <variant>  // std::holds_alternative
-#include <vector>   // std::vector
+#include <cstddef>   // std::size_t
+#include <optional>  // std::optional, std::make_optional
+#include <string>    // std::string
+#include <tuple>     // std::ignore
+#include <utility>   // std::move
+#include <variant>   // std::holds_alternative
+#include <vector>    // std::vector
 
 class BaseCSVC : public ::testing::Test { };
 
-TEST(BaseCSVC, csvc_backend_exists) {
+TEST(BaseCSVC, CsvcBackendExists) {
     // test whether the given C-SVC backend exist
 #if defined(PLSSVM_HAS_OPENMP_BACKEND)
     EXPECT_TRUE(plssvm::csvm_backend_exists_v<plssvm::openmp::csvc>);
@@ -115,7 +123,7 @@ TEST(BaseCSVC, csvc_backend_exists) {
 #endif
 }
 
-TEST(BaseCSVC, backend_csvm_type) {
+TEST(BaseCSVC, BackendCsvmType) {
 #if defined(PLSSVM_HAS_OPENMP_BACKEND)
     ::testing::StaticAssertTypeEq<plssvm::openmp::backend_csvm_type<plssvm::csvc>::type, plssvm::openmp::csvc>();
     ::testing::StaticAssertTypeEq<plssvm::openmp::backend_csvm_type_t<plssvm::csvc>, plssvm::openmp::csvc>();
@@ -189,9 +197,9 @@ class BaseCSVCMemberBase : public BaseCSVC,
 
   private:
     /// The temporary data file.
-    util::temporary_file data_set_file_{};
+    util::temporary_file data_set_file_;
     /// The temporary model file.
-    util::temporary_file model_file_{};
+    util::temporary_file model_file_;
 };
 
 template <typename T>
@@ -215,12 +223,12 @@ class BaseCSVCFit : public BaseCSVC,
 
   private:
     /// The temporary data file.
-    util::temporary_file data_set_file_{};
+    util::temporary_file data_set_file_;
 };
 
 TYPED_TEST_SUITE(BaseCSVCFit, util::classification_label_type_solver_and_kernel_function_and_classification_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(BaseCSVCFit, fit) {
+TYPED_TEST(BaseCSVCFit, Fit) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -234,6 +242,7 @@ TYPED_TEST(BaseCSVCFit, fit) {
     const int num_calls = classification == plssvm::classification_type::oaa ? 1 : static_cast<int>(util::calculate_number_of_classifiers(plssvm::classification_type::oao, util::get_num_classes<label_type>()));
 
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(num_calls);
     if constexpr (solver == plssvm::solver_type::automatic) {
         EXPECT_CALL(csvc, get_device_memory()).Times(num_calls);
         EXPECT_CALL(csvc, num_available_devices()).Times(num_calls);
@@ -266,11 +275,12 @@ TYPED_TEST(BaseCSVCFit, fit) {
     // clang-format on
 
     // create data set
-    plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };
+    plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (training_data.labels().has_value()) {
-            training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), *training_data.labels() };
+        const auto &labels_opt = training_data.labels();
+        if (labels_opt.has_value()) {
+            training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
         }
     }
 
@@ -285,7 +295,7 @@ TYPED_TEST(BaseCSVCFit, fit) {
     EXPECT_EQ(std::get<plssvm::real_type>(model.get_params().gamma), plssvm::real_type{ 0.25 });
 }
 
-TYPED_TEST(BaseCSVCFit, fit_named_parameters) {
+TYPED_TEST(BaseCSVCFit, FitNamedParameters) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -300,6 +310,7 @@ TYPED_TEST(BaseCSVCFit, fit_named_parameters) {
     const int max_iter = 20;
 
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(num_calls);
     if constexpr (solver == plssvm::solver_type::automatic) {
         EXPECT_CALL(csvc, get_device_memory()).Times(num_calls);
         EXPECT_CALL(csvc, num_available_devices()).Times(num_calls);
@@ -332,11 +343,12 @@ TYPED_TEST(BaseCSVCFit, fit_named_parameters) {
     // clang-format on
 
     // create data set
-    plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };
+    plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (training_data.labels().has_value()) {
-            training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), *training_data.labels() };
+        const auto &labels_opt = training_data.labels();
+        if (labels_opt.has_value()) {
+            training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
         }
     }
 
@@ -355,7 +367,7 @@ TYPED_TEST(BaseCSVCFit, fit_named_parameters) {
     EXPECT_EQ(std::get<plssvm::real_type>(model.get_params().gamma), plssvm::real_type{ 0.25 });
 }
 
-TYPED_TEST(BaseCSVCFit, fit_named_parameters_invalid_epsilon) {
+TYPED_TEST(BaseCSVCFit, FitNamedParametersInvalidEpsilon) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -366,6 +378,7 @@ TYPED_TEST(BaseCSVCFit, fit_named_parameters_invalid_epsilon) {
 
     // since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(0);
     EXPECT_CALL(csvc, get_device_memory()).Times(0);
     EXPECT_CALL(csvc, num_available_devices()).Times(0);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -389,11 +402,12 @@ TYPED_TEST(BaseCSVCFit, fit_named_parameters_invalid_epsilon) {
     // clang-format on
 
     // create data set
-    plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };
+    plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (training_data.labels().has_value()) {
-            training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), *training_data.labels() };
+        const auto &labels_opt = training_data.labels();
+        if (labels_opt.has_value()) {
+            training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
         }
     }
 
@@ -403,7 +417,7 @@ TYPED_TEST(BaseCSVCFit, fit_named_parameters_invalid_epsilon) {
                       "epsilon must be less than 0.0, but is 0!");
 }
 
-TYPED_TEST(BaseCSVCFit, fit_named_parameters_invalid_max_iter) {
+TYPED_TEST(BaseCSVCFit, FitNamedParametersInvalidMaxIter) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -414,6 +428,7 @@ TYPED_TEST(BaseCSVCFit, fit_named_parameters_invalid_max_iter) {
 
     // since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(0);
     EXPECT_CALL(csvc, get_device_memory()).Times(0);
     EXPECT_CALL(csvc, num_available_devices()).Times(0);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -437,11 +452,12 @@ TYPED_TEST(BaseCSVCFit, fit_named_parameters_invalid_max_iter) {
     // clang-format on
 
     // create data set
-    plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };
+    plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (training_data.labels().has_value()) {
-            training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), *training_data.labels() };
+        const auto &labels_opt = training_data.labels();
+        if (labels_opt.has_value()) {
+            training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
         }
     }
 
@@ -453,7 +469,7 @@ TYPED_TEST(BaseCSVCFit, fit_named_parameters_invalid_max_iter) {
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(BaseCSVCFit, fit_communicator_mismatch) {
+TYPED_TEST(BaseCSVCFit, FitCommunicatorMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -464,6 +480,7 @@ TYPED_TEST(BaseCSVCFit, fit_communicator_mismatch) {
 
     // since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(0);
     EXPECT_CALL(csvc, get_device_memory()).Times(0);
     EXPECT_CALL(csvc, num_available_devices()).Times(0);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -487,16 +504,17 @@ TYPED_TEST(BaseCSVCFit, fit_communicator_mismatch) {
     // clang-format on
 
     // create mismatching MPI communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
     // create data set
-    plssvm::classification_data_set<label_type> training_data{ comm, this->get_data_filename() };
+    plssvm::classification_data_set<label_type> training_data{ comm, this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (training_data.labels().has_value()) {
-            training_data = plssvm::classification_data_set<label_type>{ comm, util::matrix_abs(training_data.data()), *training_data.labels() };
+        const auto &labels_opt = training_data.labels();
+        if (labels_opt.has_value()) {
+            training_data = plssvm::classification_data_set<label_type>{ comm, util::matrix_abs(training_data.data()), labels_opt.value() };
         }
     }
 
@@ -510,7 +528,7 @@ TYPED_TEST(BaseCSVCFit, fit_communicator_mismatch) {
 
 #endif
 
-TYPED_TEST(BaseCSVCFit, fit_no_label) {
+TYPED_TEST(BaseCSVCFit, FitNoLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -521,6 +539,7 @@ TYPED_TEST(BaseCSVCFit, fit_no_label) {
 
     // since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(0);
     EXPECT_CALL(csvc, get_device_memory()).Times(0);
     EXPECT_CALL(csvc, num_available_devices()).Times(0);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -544,7 +563,7 @@ TYPED_TEST(BaseCSVCFit, fit_no_label) {
     // clang-format on
 
     // create data set without labels
-    plssvm::classification_data_set<label_type> training_data{ PLSSVM_TEST_PATH "/data/libsvm/3x2_without_label.libsvm" };
+    plssvm::classification_data_set<label_type> training_data{ PLSSVM_TEST_PATH "/data/libsvm/3x2_without_label.libsvm" };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
         training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()) };
@@ -556,7 +575,7 @@ TYPED_TEST(BaseCSVCFit, fit_no_label) {
                       "No labels given for training! Maybe the data is only usable for prediction?");
 }
 
-TYPED_TEST(BaseCSVCFit, fit_out_of_resources) {
+TYPED_TEST(BaseCSVCFit, FitOutOfResources) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -568,10 +587,11 @@ TYPED_TEST(BaseCSVCFit, fit_out_of_resources) {
         const mock_csvc csvc{ plssvm::parameter{ plssvm::kernel_type = kernel } };
 
         // override on call
-        using namespace plssvm::detail::literals;
+        using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
         ON_CALL(csvc, get_device_memory()).WillByDefault(::testing::Return(std::vector<plssvm::detail::memory_size>{ 512_MiB + 1_KiB, 512_MiB + 1_KiB }));
 
         // clang-format off
+        EXPECT_CALL(csvc, get_local_memory()).Times(1);
         EXPECT_CALL(csvc, get_device_memory()).Times(1);
         EXPECT_CALL(csvc, num_available_devices()).Times(1);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -595,11 +615,12 @@ TYPED_TEST(BaseCSVCFit, fit_out_of_resources) {
         // clang-format on
 
         // create data set
-        plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };
+        plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
         if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
             // chi-squared is well-defined for non-negative values only
-            if (training_data.labels().has_value()) {
-                training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), *training_data.labels() };
+            const auto &labels_opt = training_data.labels();
+            if (labels_opt.has_value()) {
+                training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
             }
         }
 
@@ -610,7 +631,7 @@ TYPED_TEST(BaseCSVCFit, fit_out_of_resources) {
     }
 }
 
-TYPED_TEST(BaseCSVCFit, fit_device_memory_too_small) {
+TYPED_TEST(BaseCSVCFit, FitDeviceMemoryTooSmall) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -622,10 +643,11 @@ TYPED_TEST(BaseCSVCFit, fit_device_memory_too_small) {
         const mock_csvc csvc{ plssvm::parameter{ plssvm::kernel_type = kernel } };
 
         // override on call
-        using namespace plssvm::detail::literals;
+        using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
         ON_CALL(csvc, get_device_memory()).WillByDefault(::testing::Return(std::vector<plssvm::detail::memory_size>{ 1_KiB, 1_KiB }));
 
         // clang-format off
+        EXPECT_CALL(csvc, get_local_memory()).Times(1);
         EXPECT_CALL(csvc, get_device_memory()).Times(1);
         EXPECT_CALL(csvc, num_available_devices()).Times(0);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -649,11 +671,12 @@ TYPED_TEST(BaseCSVCFit, fit_device_memory_too_small) {
         // clang-format on
 
         // create data set
-        plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };
+        plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
         if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
             // chi-squared is well-defined for non-negative values only
-            if (training_data.labels().has_value()) {
-                training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), *training_data.labels() };
+            const auto &labels_opt = training_data.labels();
+            if (labels_opt.has_value()) {
+                training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
             }
         }
 
@@ -664,12 +687,72 @@ TYPED_TEST(BaseCSVCFit, fit_device_memory_too_small) {
     }
 }
 
+TYPED_TEST(BaseCSVCFit, FitLocalMemoryTooSmall) {
+    using label_type = typename TestFixture::fixture_label_type;
+    constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
+    constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
+    constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
+
+    // create C-SVC: must be done using the mock class since the csvc base class is pure virtual
+    const mock_csvc csvc{ plssvm::parameter{ plssvm::kernel_type = kernel } };
+
+    // override on call
+    constexpr plssvm::detail::memory_size needed_local_mem_size = plssvm::detail::data_distribution::maximum_local_memory_needed();
+    ON_CALL(csvc, get_local_memory()).WillByDefault(::testing::Return((std::vector<std::optional<plssvm::detail::memory_size>>{ std::make_optional(needed_local_mem_size / 2), std::make_optional(needed_local_mem_size / 2) })));
+
+    EXPECT_CALL(csvc, get_local_memory()).Times(1);
+    // this test is only really applicable for the automatic solver type
+    if constexpr (solver == plssvm::solver_type::automatic) {
+        // clang-format off
+        EXPECT_CALL(csvc, get_device_memory()).Times(0);
+        EXPECT_CALL(csvc, num_available_devices()).Times(0);
+#if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
+        EXPECT_CALL(csvc, get_max_mem_alloc_size()).Times(0);
+#endif
+        EXPECT_CALL(csvc, assemble_kernel_matrix(
+                                ::testing::An<plssvm::solver_type>(),
+                                ::testing::An<const plssvm::parameter &>(),
+                                ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
+                                ::testing::An<const std::vector<plssvm::real_type> &>(),
+                                ::testing::An<plssvm::real_type>()))
+                            .Times(0);
+        EXPECT_CALL(csvc, blas_level_3(
+                                ::testing::An<plssvm::solver_type>(),
+                                ::testing::An<plssvm::real_type>(),
+                                ::testing::An<const std::vector<plssvm::detail::move_only_any> &>(),
+                                ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
+                                ::testing::An<plssvm::real_type>(),
+                                ::testing::An<plssvm::soa_matrix<plssvm::real_type> &>()))
+                            .Times(0);
+        // clang-format on
+    }
+
+    // create data set
+    plssvm::classification_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
+    if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
+        // chi-squared is well-defined for non-negative values only
+        const auto &labels_opt = training_data.labels();
+        if (labels_opt.has_value()) {
+            training_data = plssvm::classification_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
+        }
+    }
+
+    // call function -> should throw since we are out of resources
+    EXPECT_THROW_WHAT((std::ignore = csvc.fit(training_data, plssvm::solver = solver, plssvm::classification = classification)),
+                      plssvm::kernel_launch_resources,
+                      fmt::format("At least {} of local memory must be available for the hyperparameter combination THREAD_BLOCK_SIZE={} and INTERNAL_BLOCK_SIZE={}, but available are only {}!",
+                                  needed_local_mem_size,
+                                  plssvm::THREAD_BLOCK_SIZE,
+                                  plssvm::INTERNAL_BLOCK_SIZE,
+                                  needed_local_mem_size / 2));
+}
+
 template <typename T>
 class BaseCSVCPredict : public BaseCSVCMemberBase<T> { };
 
 TYPED_TEST_SUITE(BaseCSVCPredict, util::classification_label_type_classification_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(BaseCSVCPredict, predict) {
+TYPED_TEST(BaseCSVCPredict, Predict) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
@@ -682,15 +765,16 @@ TYPED_TEST(BaseCSVCPredict, predict) {
 
     // mock the predict_values function
     // clang-format off
-     EXPECT_CALL(csvc, predict_values(
-                             ::testing::An<const plssvm::parameter &>(),
-                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
-                             ::testing::An<const plssvm::aos_matrix<plssvm::real_type> &>(),
-                             ::testing::An<const std::vector<plssvm::real_type> &>(),
-                             ::testing::An<plssvm::soa_matrix<plssvm::real_type> &>(),
-                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>()))
-                         .Times(num_calls)
-                         .WillRepeatedly(::testing::Return(util::generate_random_matrix<plssvm::aos_matrix<plssvm::real_type>>(plssvm::shape{ 6, num_cols_in_return_matrix })));
+    EXPECT_CALL(csvc, get_local_memory()).Times(1);
+    EXPECT_CALL(csvc, predict_values(
+                            ::testing::An<const plssvm::parameter &>(),
+                            ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
+                            ::testing::An<const plssvm::aos_matrix<plssvm::real_type> &>(),
+                            ::testing::An<const std::vector<plssvm::real_type> &>(),
+                            ::testing::An<plssvm::soa_matrix<plssvm::real_type> &>(),
+                            ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>()))
+                        .Times(num_calls)
+                        .WillRepeatedly(::testing::Return(util::generate_random_matrix<plssvm::aos_matrix<plssvm::real_type>>(plssvm::shape{ 6, num_cols_in_return_matrix })));
     // clang-format on
 
     // create data set and previously learned model
@@ -702,7 +786,7 @@ TYPED_TEST(BaseCSVCPredict, predict) {
     EXPECT_EQ(prediction.size(), 6);
 }
 
-TYPED_TEST(BaseCSVCPredict, predict_num_feature_mismatch) {
+TYPED_TEST(BaseCSVCPredict, PredictNumFeatureMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVC: must be done using the mock class since the csvc base class is pure virtual
@@ -710,6 +794,7 @@ TYPED_TEST(BaseCSVCPredict, predict_num_feature_mismatch) {
 
     // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(0);
     EXPECT_CALL(csvc, predict_values(
                             ::testing::An<const plssvm::parameter &>(),
                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -731,7 +816,7 @@ TYPED_TEST(BaseCSVCPredict, predict_num_feature_mismatch) {
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(BaseCSVCPredict, predict_communicator_mismatch) {
+TYPED_TEST(BaseCSVCPredict, PredictCommismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVC: must be done using the mock class since the csvc base class is pure virtual
@@ -739,6 +824,7 @@ TYPED_TEST(BaseCSVCPredict, predict_communicator_mismatch) {
 
     // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(0);
     EXPECT_CALL(csvc, predict_values(
                             ::testing::An<const plssvm::parameter &>(),
                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -749,7 +835,7 @@ TYPED_TEST(BaseCSVCPredict, predict_communicator_mismatch) {
     // clang-format on
 
     // create mismatching MPI communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -777,7 +863,7 @@ class BaseCSVCScore : public BaseCSVCMemberBase<T> { };
 
 TYPED_TEST_SUITE(BaseCSVCScore, util::classification_label_type_classification_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(BaseCSVCScore, score_model) {
+TYPED_TEST(BaseCSVCScore, ScoreModel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
@@ -790,6 +876,7 @@ TYPED_TEST(BaseCSVCScore, score_model) {
 
     // mock the predict_values function
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(1);
     EXPECT_CALL(csvc, predict_values(
                             ::testing::An<const plssvm::parameter &>(),
                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -809,7 +896,7 @@ TYPED_TEST(BaseCSVCScore, score_model) {
     EXPECT_INCLUSIVE_RANGE(score, plssvm::real_type{ 0.0 }, plssvm::real_type{ 1.0 });
 }
 
-TYPED_TEST(BaseCSVCScore, score_data_set) {
+TYPED_TEST(BaseCSVCScore, ScoreDataSet) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::classification_type classification = TestFixture::fixture_classification;
 
@@ -822,6 +909,7 @@ TYPED_TEST(BaseCSVCScore, score_data_set) {
 
     // mock the predict_values function
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(1);
     EXPECT_CALL(csvc, predict_values(
                         ::testing::An<const plssvm::parameter &>(),
                         ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -842,7 +930,7 @@ TYPED_TEST(BaseCSVCScore, score_data_set) {
     EXPECT_INCLUSIVE_RANGE(score, plssvm::real_type{ 0.0 }, plssvm::real_type{ 1.0 });
 }
 
-TYPED_TEST(BaseCSVCScore, score_data_set_no_label) {
+TYPED_TEST(BaseCSVCScore, ScoreDataSetNoLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVC: must be done using the mock class since the csvc base class is pure virtual
@@ -850,6 +938,7 @@ TYPED_TEST(BaseCSVCScore, score_data_set_no_label) {
 
     // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(0);
     EXPECT_CALL(csvc, predict_values(
                     ::testing::An<const plssvm::parameter &>(),
                     ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -868,7 +957,7 @@ TYPED_TEST(BaseCSVCScore, score_data_set_no_label) {
     EXPECT_THROW_WHAT(std::ignore = csvc.score(learned_model, data_to_score), plssvm::invalid_parameter_exception, "The data set to score must have labels!");
 }
 
-TYPED_TEST(BaseCSVCScore, score_data_set_num_features_mismatch) {
+TYPED_TEST(BaseCSVCScore, ScoreDataSetNumFeaturesMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVC: must be done using the mock class since the csvc base class is pure virtual
@@ -876,6 +965,7 @@ TYPED_TEST(BaseCSVCScore, score_data_set_num_features_mismatch) {
 
     // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(0);
     EXPECT_CALL(csvc, predict_values(
                         ::testing::An<const plssvm::parameter &>(),
                         ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -903,7 +993,7 @@ TYPED_TEST(BaseCSVCScore, score_data_set_num_features_mismatch) {
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(BaseCSVCScore, predict_communicator_mismatch) {
+TYPED_TEST(BaseCSVCScore, PredictCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVC: must be done using the mock class since the csvc base class is pure virtual
@@ -911,6 +1001,7 @@ TYPED_TEST(BaseCSVCScore, predict_communicator_mismatch) {
 
     // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(0);
     EXPECT_CALL(csvc, predict_values(
                             ::testing::An<const plssvm::parameter &>(),
                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -921,7 +1012,7 @@ TYPED_TEST(BaseCSVCScore, predict_communicator_mismatch) {
     // clang-format on
 
     // create mismatching MPI communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -943,3 +1034,39 @@ TYPED_TEST(BaseCSVCScore, predict_communicator_mismatch) {
 }
 
 #endif
+
+TYPED_TEST(BaseCSVCScore, PredictLocalMemoryTooSmall) {
+    using label_type = typename TestFixture::fixture_label_type;
+
+    // create C-SVC: must be done using the mock class since the csvc base class is pure virtual
+    const mock_csvc csvc{};
+
+    // override on call
+    constexpr plssvm::detail::memory_size needed_local_mem_size = plssvm::detail::data_distribution::maximum_local_memory_needed();
+    ON_CALL(csvc, get_local_memory()).WillByDefault(::testing::Return((std::vector<std::optional<plssvm::detail::memory_size>>{ std::make_optional(needed_local_mem_size / 2), std::make_optional(needed_local_mem_size / 2) })));
+
+    // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
+    // clang-format off
+    EXPECT_CALL(csvc, get_local_memory()).Times(1);
+    EXPECT_CALL(csvc, predict_values(
+                            ::testing::An<const plssvm::parameter &>(),
+                            ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
+                            ::testing::An<const plssvm::aos_matrix<plssvm::real_type> &>(),
+                            ::testing::An<const std::vector<plssvm::real_type> &>(),
+                            ::testing::An<plssvm::soa_matrix<plssvm::real_type> &>(),
+                            ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>())).Times(0);
+    // clang-format on
+
+    // create data set and previously learned model
+    const plssvm::classification_data_set<label_type> data_to_predict{ this->get_data_filename() };
+    const plssvm::classification_model<label_type> learned_model{ this->get_model_filename() };
+
+    // calling the function with mismatching MPI communicators should throw
+    EXPECT_THROW_WHAT(std::ignore = csvc.score(learned_model, data_to_predict),
+                      plssvm::kernel_launch_resources,
+                      fmt::format("At least {} of local memory must be available for the hyperparameter combination THREAD_BLOCK_SIZE={} and INTERNAL_BLOCK_SIZE={}, but available are only {}!",
+                                  needed_local_mem_size,
+                                  plssvm::THREAD_BLOCK_SIZE,
+                                  plssvm::INTERNAL_BLOCK_SIZE,
+                                  needed_local_mem_size / 2));
+}
diff --git a/tests/svm/csvm.cpp b/tests/svm/csvm.cpp
index fb2caa9df..c9ab67bbf 100644
--- a/tests/svm/csvm.cpp
+++ b/tests/svm/csvm.cpp
@@ -10,17 +10,16 @@
 
 #include "plssvm/svm/csvm.hpp"
 
-#include "plssvm/backend_types.hpp"          // plssvm::csvm_backend_exists, plssvm::csvm_backend_exists_v, plssvm::backend_csvm_type, plssvm::backend_csvm_type_t
-#include "plssvm/constants.hpp"              // plssvm::real_type
-#include "plssvm/core.hpp"                   // sycl namespace handling
-#include "plssvm/exceptions/exceptions.hpp"  // plssvm::invalid_parameter_exception
-#include "plssvm/kernel_function_types.hpp"  // plssvm::kernel_function_type
-#include "plssvm/parameter.hpp"              // plssvm::parameter
-#include "plssvm/target_platforms.hpp"       // plssvm::target_platform
-
-#include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT
-#include "tests/svm/mock_csvm.hpp"       // mock_csvm
-#include "tests/utility.hpp"             // util::redirect_output
+#include "plssvm/backend_types.hpp"                   // plssvm::csvm_backend_exists, plssvm::csvm_backend_exists_v, plssvm::backend_csvm_type, plssvm::backend_csvm_type_t
+#include "plssvm/backends/SYCL/detail/constants.hpp"  // NOLINT: namespace plssvm::sycl
+#include "plssvm/constants.hpp"                       // plssvm::real_type
+#include "plssvm/core.hpp"                            // NOLINT: include all csvm_backend_exists_v specializations
+#include "plssvm/kernel_function_types.hpp"           // plssvm::kernel_function_type
+#include "plssvm/parameter.hpp"                       // plssvm::parameter
+#include "plssvm/target_platforms.hpp"                // plssvm::target_platform
+
+#include "tests/svm/mock_csvm.hpp"  // mock_csvm
+#include "tests/utility.hpp"        // util::redirect_output
 
 #include "gmock/gmock.h"  // EXPECT_THAT, ::testing::HasSubstr
 #include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_TRUE, EXPECT_FALSE, EXPECT_THAT
@@ -29,7 +28,7 @@
 
 class BaseCSVM : public ::testing::Test { };
 
-TEST(BaseCSVM, default_construct_from_parameter) {
+TEST(BaseCSVM, DefaultConstructFromParameter) {
     // create C-SVM: must be done using the mock class since the csvm base class is pure virtual
     const mock_csvm csvm{};
 
@@ -37,7 +36,7 @@ TEST(BaseCSVM, default_construct_from_parameter) {
     EXPECT_EQ(csvm.get_params(), plssvm::parameter{});
 }
 
-TEST(BaseCSVM, construct_from_parameter) {
+TEST(BaseCSVM, ConstructFromParameter) {
     // create parameter
     const plssvm::parameter params{ plssvm::kernel_function_type::polynomial, 4, plssvm::real_type{ 0.2 }, plssvm::real_type{ 0.1 }, plssvm::real_type{ 0.01 } };
 
@@ -48,7 +47,7 @@ TEST(BaseCSVM, construct_from_parameter) {
     EXPECT_EQ(csvm.get_params(), params);
 }
 
-TEST(BaseCSVM, construct_linear_from_named_parameters) {
+TEST(BaseCSVM, ConstructLinearFromNamedParameters) {
     // correct parameter
     const plssvm::parameter params{ plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::cost = 2.0 };
 
@@ -59,7 +58,7 @@ TEST(BaseCSVM, construct_linear_from_named_parameters) {
     EXPECT_TRUE(csvm.get_params().equivalent(params));
 }
 
-TEST(BaseCSVM, construct_polynomial_from_named_parameters) {
+TEST(BaseCSVM, ConstructPolynomialFromNamedParameters) {
     // correct parameter
     const plssvm::parameter params{ plssvm::kernel_function_type::polynomial, 4, plssvm::real_type{ 0.1 }, plssvm::real_type{ 1.2 }, plssvm::real_type{ 0.001 } };
 
@@ -74,7 +73,7 @@ TEST(BaseCSVM, construct_polynomial_from_named_parameters) {
     EXPECT_TRUE(csvm.get_params().equivalent(params));
 }
 
-TEST(BaseCSVM, construct_rbf_from_named_parameters) {
+TEST(BaseCSVM, ConstructRadialBasisFunctionFromNamedParameters) {
     // correct parameter
     const plssvm::parameter params{ plssvm::kernel_type = plssvm::kernel_function_type::rbf, plssvm::gamma = 0.00001, plssvm::cost = 10.0 };
 
@@ -87,14 +86,53 @@ TEST(BaseCSVM, construct_rbf_from_named_parameters) {
     EXPECT_TRUE(csvm.get_params().equivalent(params));
 }
 
-TEST(BaseCSVM, get_target_platforms) {
+TEST(BaseCSVM, ConstructSigmoidFromNamedParameters) {
+    // correct parameter
+    const plssvm::parameter params{ plssvm::kernel_type = plssvm::kernel_function_type::sigmoid, plssvm::gamma = 0.00001, plssvm::cost = 10.0 };
+
+    // create C-SVM: must be done using the mock class since the csvm base class is pure virtual
+    const mock_csvm csvm{ plssvm::kernel_type = params.kernel_type,
+                          plssvm::gamma = params.gamma,
+                          plssvm::cost = params.cost };
+
+    // check whether the parameters have been set correctly
+    EXPECT_TRUE(csvm.get_params().equivalent(params));
+}
+
+TEST(BaseCSVM, ConstructLaplacianFromNamedParameters) {
+    // correct parameter
+    const plssvm::parameter params{ plssvm::kernel_type = plssvm::kernel_function_type::laplacian, plssvm::gamma = 0.00001, plssvm::cost = 10.0 };
+
+    // create C-SVM: must be done using the mock class since the csvm base class is pure virtual
+    const mock_csvm csvm{ plssvm::kernel_type = params.kernel_type,
+                          plssvm::gamma = params.gamma,
+                          plssvm::cost = params.cost };
+
+    // check whether the parameters have been set correctly
+    EXPECT_TRUE(csvm.get_params().equivalent(params));
+}
+
+TEST(BaseCSVM, ConstructChiSquaredFromNamedParameters) {
+    // correct parameter
+    const plssvm::parameter params{ plssvm::kernel_type = plssvm::kernel_function_type::chi_squared, plssvm::gamma = 0.00001, plssvm::cost = 10.0 };
+
+    // create C-SVM: must be done using the mock class since the csvm base class is pure virtual
+    const mock_csvm csvm{ plssvm::kernel_type = params.kernel_type,
+                          plssvm::gamma = params.gamma,
+                          plssvm::cost = params.cost };
+
+    // check whether the parameters have been set correctly
+    EXPECT_TRUE(csvm.get_params().equivalent(params));
+}
+
+TEST(BaseCSVM, GetTargetPlatforms) {
     // create C-SVM: must be done using the mock class since the csvm base class is pure virtual
     const mock_csvm csvm{};
 
     EXPECT_EQ(csvm.get_target_platform(), plssvm::target_platform::automatic);
 }
 
-TEST(BaseCSVM, get_params) {
+TEST(BaseCSVM, GetParams) {
     // create parameter
     const plssvm::parameter params{ plssvm::kernel_function_type::polynomial, 4, plssvm::real_type{ 0.2 }, plssvm::real_type{ 0.1 }, plssvm::real_type{ 0.01 } };
 
@@ -107,7 +145,7 @@ TEST(BaseCSVM, get_params) {
     EXPECT_TRUE(csvm_params.equivalent(params));
 }
 
-TEST(BaseCSVM, set_params_from_parameter) {
+TEST(BaseCSVM, SetParamsFromParameter) {
     // create C-SVM: must be done using the mock class since the csvm base class is pure virtual
     mock_csvm csvm{};
     ASSERT_EQ(csvm.get_params(), plssvm::parameter{});
@@ -122,7 +160,7 @@ TEST(BaseCSVM, set_params_from_parameter) {
     EXPECT_EQ(csvm.get_params(), params);
 }
 
-TEST(BaseCSVM, set_params_from_named_parameters) {
+TEST(BaseCSVM, SetParamsFromNamedParameters) {
     // create C-SVM: must be done using the mock class since the csvm base class is pure virtual
     mock_csvm csvm{};
     ASSERT_EQ(csvm.get_params(), plssvm::parameter{});
@@ -141,7 +179,7 @@ TEST(BaseCSVM, set_params_from_named_parameters) {
     EXPECT_EQ(csvm.get_params(), params);
 }
 
-TEST(BaseCSVM, csvm_backend_exists) {
+TEST(BaseCSVM, CsvmBackendExists) {
     // test whether the given C-SVM backend exist
 #if defined(PLSSVM_HAS_OPENMP_BACKEND)
     EXPECT_TRUE(plssvm::csvm_backend_exists_v<plssvm::openmp::csvm>);
@@ -221,7 +259,7 @@ TEST(BaseCSVM, csvm_backend_exists) {
 class BaseCSVMWarning : public BaseCSVM,
                         protected util::redirect_output<&std::clog> { };
 
-TEST_F(BaseCSVMWarning, construct_unused_parameter_warning_degree) {
+TEST_F(BaseCSVMWarning, ConstructUnusedParameterWarningDegree) {
     // start capture of std::clog
     // create C-SVM: must be done using the mock class since the csvm base class is pure virtual
     [[maybe_unused]] const mock_csvm csvm{ plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::degree = 2 };
@@ -230,7 +268,7 @@ TEST_F(BaseCSVMWarning, construct_unused_parameter_warning_degree) {
     EXPECT_THAT(this->get_capture(), ::testing::HasSubstr("WARNING: degree parameter provided, which is not used in the linear kernel (u'*v)!"));
 }
 
-TEST_F(BaseCSVMWarning, construct_unused_parameter_warning_gamma) {
+TEST_F(BaseCSVMWarning, ConstructUnusedParameterWarningGamma) {
     // start capture of std::clog
     // create C-SVM: must be done using the mock class since the csvm base class is pure virtual
     [[maybe_unused]] const mock_csvm csvm{ plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::gamma = 0.1 };
@@ -239,7 +277,7 @@ TEST_F(BaseCSVMWarning, construct_unused_parameter_warning_gamma) {
     EXPECT_THAT(this->get_capture(), ::testing::HasSubstr("WARNING: gamma parameter provided, which is not used in the linear kernel (u'*v)!"));
 }
 
-TEST_F(BaseCSVMWarning, construct_unused_parameter_warning_coef0) {
+TEST_F(BaseCSVMWarning, ConstructUnusedParameterWarningCoef0) {
     // start capture of std::clog
     // create C-SVM: must be done using the mock class since the csvm base class is pure virtual
     [[maybe_unused]] const mock_csvm csvm{ plssvm::kernel_type = plssvm::kernel_function_type::linear, plssvm::coef0 = 0.1 };
diff --git a/tests/svm/csvr.cpp b/tests/svm/csvr.cpp
index d11f5343e..12c539ee1 100644
--- a/tests/svm/csvr.cpp
+++ b/tests/svm/csvr.cpp
@@ -10,17 +10,21 @@
 
 #include "plssvm/svm/csvr.hpp"  // plssvm::csvr
 
-#include "plssvm/backend_types.hpp"                 // plssvm::csvm_backend_exists, plssvm::csvm_backend_exists_v, plssvm::backend_csvm_type, plssvm::backend_csvm_type_t
-#include "plssvm/constants.hpp"                     // plssvm::real_type, plssvm::PADDING_SIZE
-#include "plssvm/core.hpp"                          // sycl namespace handling
-#include "plssvm/data_set/regression_data_set.hpp"  // plssvm::regression_data_set
-#include "plssvm/detail/move_only_any.hpp"          // plssvm::detail::move_only_any
-#include "plssvm/exceptions/exceptions.hpp"         // plssvm::invalid_parameter_exception
-#include "plssvm/kernel_function_types.hpp"         // plssvm::kernel_function_type
-#include "plssvm/matrix.hpp"                        // plssvm::aos_matrix
-#include "plssvm/model/regression_model.hpp"        // plssvm::regression_model
-#include "plssvm/parameter.hpp"                     // plssvm::parameter
-#include "plssvm/solver_types.hpp"                  // plssvm::solver_type
+#include "plssvm/backend_types.hpp"                   // plssvm::csvm_backend_exists, plssvm::backend_csvm_type, plssvm::backend_csvm_type_t
+#include "plssvm/backends/SYCL/detail/constants.hpp"  // NOLINT: namespace plssvm::sycl
+#include "plssvm/constants.hpp"                       // plssvm::real_type, plssvm::THREAD_BLOCK_SIZE, plssvm::INTERNAL_BLOCK_SIZE, plssvm::PADDING_SIZE
+#include "plssvm/core.hpp"                            // NOLINT: include all csvm_backend_exists_v specializations
+#include "plssvm/data_set/regression_data_set.hpp"    // plssvm::regression_data_set
+#include "plssvm/detail/data_distribution.hpp"        // plssvm::detail::data_distribution::maximum_local_memory_needed
+#include "plssvm/detail/memory_size.hpp"              // plssvm::detail::memory_size
+#include "plssvm/detail/move_only_any.hpp"            // plssvm::detail::move_only_any
+#include "plssvm/exceptions/exceptions.hpp"           // plssvm::invalid_parameter_exception
+#include "plssvm/kernel_function_types.hpp"           // plssvm::kernel_function_type
+#include "plssvm/matrix.hpp"                          // plssvm::aos_matrix
+#include "plssvm/model/regression_model.hpp"          // plssvm::regression_model
+#include "plssvm/parameter.hpp"                       // plssvm::parameter
+#include "plssvm/solver_types.hpp"                    // plssvm::solver_type
+#include "plssvm/svm/csvm.hpp"                        // plssvm::csvm_backend_exists_v
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_THROW_WHAT, EXPECT_THROW_WHAT_MATCHER, EXPECT_INCLUSIVE_RANGE
 #include "tests/naming.hpp"              // naming::parameter_definition_to_name
@@ -29,22 +33,26 @@
 #include "tests/utility.hpp"             // util::{redirect_output, temporary_file, instantiate_template_file, generate_random_matrix, get_correct_data_file_labels}
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
+    #include "plssvm/mpi/communicator.hpp"  // plssvm::mpi:::communicator
+
     #include "mpi.h"  // MPI_COMM_WORLD, MPI_Comm_dup, MPI_Comm_free
 #endif
 
+#include "fmt/format.h"   // fmt::format
 #include "gmock/gmock.h"  // EXPECT_CALL, EXPECT_THAT, ::testing::{An, Between, Return, HasSubstr, ContainsRegex}
 #include "gtest/gtest.h"  // TEST, TYPED_TEST, TYPED_TEST_SUITE, EXPECT_EQ, EXPECT_TRUE, EXPECT_FALSE, EXPECT_THAT,
 
-#include <cstddef>  // std::size_t
-#include <string>   // std::string
-#include <tuple>    // std::ignore
-#include <utility>  // std::move
-#include <variant>  // std::holds_alternative
-#include <vector>   // std::vector
+#include <cstddef>   // std::size_t
+#include <optional>  // std::optional, std::make_optional
+#include <string>    // std::string
+#include <tuple>     // std::ignore
+#include <utility>   // std::move
+#include <variant>   // std::holds_alternative
+#include <vector>    // std::vector
 
 class BaseCSVR : public ::testing::Test { };
 
-TEST(BaseCSVR, csvr_backend_exists) {
+TEST(BaseCSVR, CsvrBackendExists) {
     // test whether the given C-SVR backend exist
 #if defined(PLSSVM_HAS_OPENMP_BACKEND)
     EXPECT_TRUE(plssvm::csvm_backend_exists_v<plssvm::openmp::csvr>);
@@ -113,7 +121,7 @@ TEST(BaseCSVR, csvr_backend_exists) {
 #endif
 }
 
-TEST(BaseCSVR, backend_csvm_type) {
+TEST(BaseCSVR, BackendCsvmType) {
 #if defined(PLSSVM_HAS_OPENMP_BACKEND)
     ::testing::StaticAssertTypeEq<plssvm::openmp::backend_csvm_type<plssvm::csvr>::type, plssvm::openmp::csvr>();
     ::testing::StaticAssertTypeEq<plssvm::openmp::backend_csvm_type_t<plssvm::csvr>, plssvm::openmp::csvr>();
@@ -185,7 +193,7 @@ class BaseCSVRMemberBase : public BaseCSVR,
     /// The name of the data set file.
     std::string data_set_file_name_{ PLSSVM_TEST_PATH "/data/libsvm/regression/6x4.libsvm" };
     /// The temporary model file.
-    util::temporary_file model_file_{};
+    util::temporary_file model_file_;
 };
 
 template <typename T>
@@ -209,7 +217,7 @@ class BaseCSVRFit : public BaseCSVR,
 
 TYPED_TEST_SUITE(BaseCSVRFit, util::regression_label_type_solver_and_kernel_function_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(BaseCSVRFit, fit) {
+TYPED_TEST(BaseCSVRFit, Fit) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -222,6 +230,7 @@ TYPED_TEST(BaseCSVRFit, fit) {
     const int num_calls = 1;
 
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(num_calls);
     if constexpr (solver == plssvm::solver_type::automatic) {
         EXPECT_CALL(csvr, get_device_memory()).Times(num_calls);
         EXPECT_CALL(csvr, num_available_devices()).Times(num_calls);
@@ -254,7 +263,7 @@ TYPED_TEST(BaseCSVRFit, fit) {
     // clang-format on
 
     // create data set
-    plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };
+    plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
         if (training_data.labels().has_value()) {
@@ -271,7 +280,7 @@ TYPED_TEST(BaseCSVRFit, fit) {
     EXPECT_EQ(std::get<plssvm::real_type>(model.get_params().gamma), plssvm::real_type{ 0.25 });
 }
 
-TYPED_TEST(BaseCSVRFit, fit_named_parameters) {
+TYPED_TEST(BaseCSVRFit, FitNamedParameters) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -285,6 +294,7 @@ TYPED_TEST(BaseCSVRFit, fit_named_parameters) {
     const int max_iter = 20;
 
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(num_calls);
     if constexpr (solver == plssvm::solver_type::automatic) {
         EXPECT_CALL(csvr, get_device_memory()).Times(num_calls);
         EXPECT_CALL(csvr, num_available_devices()).Times(num_calls);
@@ -317,7 +327,7 @@ TYPED_TEST(BaseCSVRFit, fit_named_parameters) {
     // clang-format on
 
     // create data set
-    plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };
+    plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
         if (training_data.labels().has_value()) {
@@ -337,7 +347,7 @@ TYPED_TEST(BaseCSVRFit, fit_named_parameters) {
     EXPECT_EQ(std::get<plssvm::real_type>(model.get_params().gamma), plssvm::real_type{ 0.25 });
 }
 
-TYPED_TEST(BaseCSVRFit, fit_named_parameters_invalid_epsilon) {
+TYPED_TEST(BaseCSVRFit, FitNamedParametersInvalidEpsilon) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -347,6 +357,7 @@ TYPED_TEST(BaseCSVRFit, fit_named_parameters_invalid_epsilon) {
 
     // since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(0);
     EXPECT_CALL(csvr, get_device_memory()).Times(0);
     EXPECT_CALL(csvr, num_available_devices()).Times(0);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -370,11 +381,12 @@ TYPED_TEST(BaseCSVRFit, fit_named_parameters_invalid_epsilon) {
     // clang-format on
 
     // create data set
-    plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };
+    plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (training_data.labels().has_value()) {
-            training_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(training_data.data()), *training_data.labels() };
+        const auto &labels_opt = training_data.labels();
+        if (labels_opt.has_value()) {
+            training_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
         }
     }
 
@@ -384,7 +396,7 @@ TYPED_TEST(BaseCSVRFit, fit_named_parameters_invalid_epsilon) {
                       "epsilon must be less than 0.0, but is 0!");
 }
 
-TYPED_TEST(BaseCSVRFit, fit_named_parameters_invalid_max_iter) {
+TYPED_TEST(BaseCSVRFit, FitNamedParametersInvalidMaxIter) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -394,6 +406,7 @@ TYPED_TEST(BaseCSVRFit, fit_named_parameters_invalid_max_iter) {
 
     // since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(0);
     EXPECT_CALL(csvr, get_device_memory()).Times(0);
     EXPECT_CALL(csvr, num_available_devices()).Times(0);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -417,11 +430,12 @@ TYPED_TEST(BaseCSVRFit, fit_named_parameters_invalid_max_iter) {
     // clang-format on
 
     // create data set
-    plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };
+    plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (training_data.labels().has_value()) {
-            training_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(training_data.data()), *training_data.labels() };
+        const auto &labels_opt = training_data.labels();
+        if (labels_opt.has_value()) {
+            training_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
         }
     }
 
@@ -433,7 +447,7 @@ TYPED_TEST(BaseCSVRFit, fit_named_parameters_invalid_max_iter) {
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(BaseCSVRFit, fit_communicator_mismatch) {
+TYPED_TEST(BaseCSVRFit, FitCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -443,6 +457,7 @@ TYPED_TEST(BaseCSVRFit, fit_communicator_mismatch) {
 
     // since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(0);
     EXPECT_CALL(csvr, get_device_memory()).Times(0);
     EXPECT_CALL(csvr, num_available_devices()).Times(0);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -466,16 +481,17 @@ TYPED_TEST(BaseCSVRFit, fit_communicator_mismatch) {
     // clang-format on
 
     // create mismatching MPI communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
     // create data set
-    plssvm::regression_data_set<label_type> training_data{ comm, this->get_data_filename() };
+    plssvm::regression_data_set<label_type> training_data{ comm, this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
-        if (training_data.labels().has_value()) {
-            training_data = plssvm::regression_data_set<label_type>{ comm, util::matrix_abs(training_data.data()), *training_data.labels() };
+        const auto &labels_opt = training_data.labels();
+        if (labels_opt.has_value()) {
+            training_data = plssvm::regression_data_set<label_type>{ comm, util::matrix_abs(training_data.data()), labels_opt.value() };
         }
     }
 
@@ -489,7 +505,7 @@ TYPED_TEST(BaseCSVRFit, fit_communicator_mismatch) {
 
 #endif
 
-TYPED_TEST(BaseCSVRFit, fit_no_label) {
+TYPED_TEST(BaseCSVRFit, FitNoLabel) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -499,6 +515,7 @@ TYPED_TEST(BaseCSVRFit, fit_no_label) {
 
     // since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(0);
     EXPECT_CALL(csvr, get_device_memory()).Times(0);
     EXPECT_CALL(csvr, num_available_devices()).Times(0);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -522,7 +539,7 @@ TYPED_TEST(BaseCSVRFit, fit_no_label) {
     // clang-format on
 
     // create data set without labels
-    plssvm::regression_data_set<label_type> training_data{ PLSSVM_TEST_PATH "/data/libsvm/3x2_without_label.libsvm" };
+    plssvm::regression_data_set<label_type> training_data{ PLSSVM_TEST_PATH "/data/libsvm/3x2_without_label.libsvm" };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
     if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
         // chi-squared is well-defined for non-negative values only
         training_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(training_data.data()) };
@@ -534,7 +551,7 @@ TYPED_TEST(BaseCSVRFit, fit_no_label) {
                       "No labels given for training! Maybe the data is only usable for prediction?");
 }
 
-TYPED_TEST(BaseCSVRFit, fit_out_of_resources) {
+TYPED_TEST(BaseCSVRFit, FitOutOfResources) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -545,10 +562,11 @@ TYPED_TEST(BaseCSVRFit, fit_out_of_resources) {
         const mock_csvr csvr{ plssvm::parameter{ plssvm::kernel_type = kernel } };
 
         // override on call
-        using namespace plssvm::detail::literals;
+        using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
         ON_CALL(csvr, get_device_memory()).WillByDefault(::testing::Return(std::vector<plssvm::detail::memory_size>{ 512_MiB + 1_KiB, 512_MiB + 1_KiB }));
 
         // clang-format off
+        EXPECT_CALL(csvr, get_local_memory()).Times(1);
         EXPECT_CALL(csvr, get_device_memory()).Times(1);
         EXPECT_CALL(csvr, num_available_devices()).Times(1);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -572,11 +590,12 @@ TYPED_TEST(BaseCSVRFit, fit_out_of_resources) {
         // clang-format on
 
         // create data set
-        plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };
+        plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
         if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
             // chi-squared is well-defined for non-negative values only
-            if (training_data.labels().has_value()) {
-                training_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(training_data.data()), *training_data.labels() };
+            const auto &labels_opt = training_data.labels();
+            if (labels_opt.has_value()) {
+                training_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
             }
         }
 
@@ -587,7 +606,7 @@ TYPED_TEST(BaseCSVRFit, fit_out_of_resources) {
     }
 }
 
-TYPED_TEST(BaseCSVRFit, fit_device_memory_too_small) {
+TYPED_TEST(BaseCSVRFit, FitDeviceMemoryTooSmall) {
     using label_type = typename TestFixture::fixture_label_type;
     constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
     constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
@@ -598,10 +617,11 @@ TYPED_TEST(BaseCSVRFit, fit_device_memory_too_small) {
         const mock_csvr csvr{ plssvm::parameter{ plssvm::kernel_type = kernel } };
 
         // override on call
-        using namespace plssvm::detail::literals;
+        using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
         ON_CALL(csvr, get_device_memory()).WillByDefault(::testing::Return(std::vector<plssvm::detail::memory_size>{ 1_KiB, 1_KiB }));
 
         // clang-format off
+        EXPECT_CALL(csvr, get_local_memory()).Times(1);
         EXPECT_CALL(csvr, get_device_memory()).Times(1);
         EXPECT_CALL(csvr, num_available_devices()).Times(0);
 #if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
@@ -625,11 +645,12 @@ TYPED_TEST(BaseCSVRFit, fit_device_memory_too_small) {
         // clang-format on
 
         // create data set
-        plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };
+        plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
         if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
             // chi-squared is well-defined for non-negative values only
-            if (training_data.labels().has_value()) {
-                training_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(training_data.data()), *training_data.labels() };
+            const auto &labels_opt = training_data.labels();
+            if (labels_opt.has_value()) {
+                training_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
             }
         }
 
@@ -640,12 +661,71 @@ TYPED_TEST(BaseCSVRFit, fit_device_memory_too_small) {
     }
 }
 
+TYPED_TEST(BaseCSVRFit, FitLocalMemoryTooSmall) {
+    using label_type = typename TestFixture::fixture_label_type;
+    constexpr plssvm::solver_type solver = TestFixture::fixture_solver;
+    constexpr plssvm::kernel_function_type kernel = TestFixture::fixture_kernel;
+
+    // create C-SVC: must be done using the mock class since the csvr base class is pure virtual
+    const mock_csvr csvr{ plssvm::parameter{ plssvm::kernel_type = kernel } };
+
+    // override on call
+    constexpr plssvm::detail::memory_size needed_local_mem_size = plssvm::detail::data_distribution::maximum_local_memory_needed();
+    ON_CALL(csvr, get_local_memory()).WillByDefault(::testing::Return((std::vector<std::optional<plssvm::detail::memory_size>>{ std::make_optional(needed_local_mem_size / 2), std::make_optional(needed_local_mem_size / 2) })));
+
+    EXPECT_CALL(csvr, get_local_memory()).Times(1);
+    // this test is only really applicable for the automatic solver type
+    if constexpr (solver == plssvm::solver_type::automatic) {
+        // clang-format off
+        EXPECT_CALL(csvr, get_device_memory()).Times(0);
+        EXPECT_CALL(csvr, num_available_devices()).Times(0);
+#if defined(PLSSVM_ENFORCE_MAX_MEM_ALLOC_SIZE)
+        EXPECT_CALL(csvr, get_max_mem_alloc_size()).Times(0);
+#endif
+        EXPECT_CALL(csvr, assemble_kernel_matrix(
+                                ::testing::An<plssvm::solver_type>(),
+                                ::testing::An<const plssvm::parameter &>(),
+                                ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
+                                ::testing::An<const std::vector<plssvm::real_type> &>(),
+                                ::testing::An<plssvm::real_type>()))
+                            .Times(0);
+        EXPECT_CALL(csvr, blas_level_3(
+                                ::testing::An<plssvm::solver_type>(),
+                                ::testing::An<plssvm::real_type>(),
+                                ::testing::An<const std::vector<plssvm::detail::move_only_any> &>(),
+                                ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
+                                ::testing::An<plssvm::real_type>(),
+                                ::testing::An<plssvm::soa_matrix<plssvm::real_type> &>()))
+                            .Times(0);
+        // clang-format on
+    }
+
+    // create data set
+    plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };  // NOLINT(misc-const-correctness): can't be const for the chi-squared kernel
+    if constexpr (kernel == plssvm::kernel_function_type::chi_squared) {
+        // chi-squared is well-defined for non-negative values only
+        const auto &labels_opt = training_data.labels();
+        if (labels_opt.has_value()) {
+            training_data = plssvm::regression_data_set<label_type>{ util::matrix_abs(training_data.data()), labels_opt.value() };
+        }
+    }
+
+    // call function -> should throw since we are out of resources
+    EXPECT_THROW_WHAT((std::ignore = csvr.fit(training_data, plssvm::solver = solver)),
+                      plssvm::kernel_launch_resources,
+                      fmt::format("At least {} of local memory must be available for the hyperparameter combination THREAD_BLOCK_SIZE={} and INTERNAL_BLOCK_SIZE={}, but available are only {}!",
+                                  needed_local_mem_size,
+                                  plssvm::THREAD_BLOCK_SIZE,
+                                  plssvm::INTERNAL_BLOCK_SIZE,
+                                  needed_local_mem_size / 2));
+}
+
 template <typename T>
 class BaseCSVRPredict : public BaseCSVRMemberBase<T> { };
 
 TYPED_TEST_SUITE(BaseCSVRPredict, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(BaseCSVRPredict, predict) {
+TYPED_TEST(BaseCSVRPredict, Predict) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVR: must be done using the mock class since the csvr base class is pure virtual
@@ -656,6 +736,7 @@ TYPED_TEST(BaseCSVRPredict, predict) {
 
     // mock the predict_values function
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(1);
     EXPECT_CALL(csvr, predict_values(
                             ::testing::An<const plssvm::parameter &>(),
                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -676,7 +757,7 @@ TYPED_TEST(BaseCSVRPredict, predict) {
     EXPECT_EQ(prediction.size(), 6);
 }
 
-TYPED_TEST(BaseCSVRPredict, predict_num_feature_mismatch) {
+TYPED_TEST(BaseCSVRPredict, PredictNumFeatureMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVR: must be done using the mock class since the csvr base class is pure virtual
@@ -684,6 +765,7 @@ TYPED_TEST(BaseCSVRPredict, predict_num_feature_mismatch) {
 
     // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(0);
     EXPECT_CALL(csvr, predict_values(
                             ::testing::An<const plssvm::parameter &>(),
                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -705,7 +787,7 @@ TYPED_TEST(BaseCSVRPredict, predict_num_feature_mismatch) {
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(BaseCSVRPredict, predict_communicator_mismatch) {
+TYPED_TEST(BaseCSVRPredict, PredictCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVR: must be done using the mock class since the csvr base class is pure virtual
@@ -713,6 +795,7 @@ TYPED_TEST(BaseCSVRPredict, predict_communicator_mismatch) {
 
     // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(0);
     EXPECT_CALL(csvr, predict_values(
                             ::testing::An<const plssvm::parameter &>(),
                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -723,7 +806,7 @@ TYPED_TEST(BaseCSVRPredict, predict_communicator_mismatch) {
     // clang-format on
 
     // create mismatching MPI communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -751,7 +834,7 @@ class BaseCSVRScore : public BaseCSVRMemberBase<T> { };
 
 TYPED_TEST_SUITE(BaseCSVRScore, util::regression_label_type_gtest, naming::test_parameter_to_name);
 
-TYPED_TEST(BaseCSVRScore, score_model) {
+TYPED_TEST(BaseCSVRScore, ScoreModel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVR: must be done using the mock class since the csvr base class is pure virtual
@@ -762,6 +845,7 @@ TYPED_TEST(BaseCSVRScore, score_model) {
 
     // mock the predict_values function
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(2);  // once for fit and once for score
     EXPECT_CALL(csvr, predict_values(
                             ::testing::An<const plssvm::parameter &>(),
                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -774,7 +858,7 @@ TYPED_TEST(BaseCSVRScore, score_model) {
     // clang-format on
 
     // create data set
-    plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };
+    const plssvm::regression_data_set<label_type> training_data{ this->get_data_filename() };
 
     // call function
     const plssvm::regression_model<label_type> model = csvr.fit(training_data,
@@ -786,7 +870,7 @@ TYPED_TEST(BaseCSVRScore, score_model) {
     EXPECT_LE(score, plssvm::real_type{ 1.0 });
 }
 
-TYPED_TEST(BaseCSVRScore, score_model_from_file) {
+TYPED_TEST(BaseCSVRScore, ScoreModelFromFile) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVR: must be done using the mock class since the csvr base class is pure virtual
@@ -794,6 +878,7 @@ TYPED_TEST(BaseCSVRScore, score_model_from_file) {
 
     // mock the predict_values function
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(0);
     EXPECT_CALL(csvr, predict_values(
                     ::testing::An<const plssvm::parameter &>(),
                     ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -810,7 +895,7 @@ TYPED_TEST(BaseCSVRScore, score_model_from_file) {
     EXPECT_THROW_WHAT(std::ignore = csvr.score(learned_model), plssvm::invalid_parameter_exception, "The model must have labels to score it! Maybe to model was read from a LIBSVM model file?");
 }
 
-TYPED_TEST(BaseCSVRScore, score_data_set) {
+TYPED_TEST(BaseCSVRScore, ScoreDataSet) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVR: must be done using the mock class since the csvr base class is pure virtual
@@ -821,6 +906,7 @@ TYPED_TEST(BaseCSVRScore, score_data_set) {
 
     // mock the predict_values function
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(1);
     EXPECT_CALL(csvr, predict_values(
                         ::testing::An<const plssvm::parameter &>(),
                         ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -841,7 +927,7 @@ TYPED_TEST(BaseCSVRScore, score_data_set) {
     EXPECT_LE(score, plssvm::real_type{ 1.0 });
 }
 
-TYPED_TEST(BaseCSVRScore, score_data_set_no_label) {
+TYPED_TEST(BaseCSVRScore, ScoreDataSetNoLabel) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVR: must be done using the mock class since the csvr base class is pure virtual
@@ -849,6 +935,7 @@ TYPED_TEST(BaseCSVRScore, score_data_set_no_label) {
 
     // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(0);
     EXPECT_CALL(csvr, predict_values(
                     ::testing::An<const plssvm::parameter &>(),
                     ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -867,7 +954,7 @@ TYPED_TEST(BaseCSVRScore, score_data_set_no_label) {
     EXPECT_THROW_WHAT(std::ignore = csvr.score(learned_model, data_to_score), plssvm::invalid_parameter_exception, "The data set to score must have labels!");
 }
 
-TYPED_TEST(BaseCSVRScore, score_data_set_num_features_mismatch) {
+TYPED_TEST(BaseCSVRScore, ScoreDataSetNumFeaturesMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVR: must be done using the mock class since the csvr base class is pure virtual
@@ -875,6 +962,7 @@ TYPED_TEST(BaseCSVRScore, score_data_set_num_features_mismatch) {
 
     // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(0);
     EXPECT_CALL(csvr, predict_values(
                         ::testing::An<const plssvm::parameter &>(),
                         ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -902,7 +990,7 @@ TYPED_TEST(BaseCSVRScore, score_data_set_num_features_mismatch) {
 
 #if defined(PLSSVM_HAS_MPI_ENABLED)
 
-TYPED_TEST(BaseCSVRScore, predict_communicator_mismatch) {
+TYPED_TEST(BaseCSVRScore, PredictCommMismatch) {
     using label_type = typename TestFixture::fixture_label_type;
 
     // create C-SVR: must be done using the mock class since the csvr base class is pure virtual
@@ -910,6 +998,7 @@ TYPED_TEST(BaseCSVRScore, predict_communicator_mismatch) {
 
     // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
     // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(0);
     EXPECT_CALL(csvr, predict_values(
                             ::testing::An<const plssvm::parameter &>(),
                             ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
@@ -920,7 +1009,7 @@ TYPED_TEST(BaseCSVRScore, predict_communicator_mismatch) {
     // clang-format on
 
     // create mismatching MPI communicator
-    MPI_Comm duplicated_mpi_comm;
+    MPI_Comm duplicated_mpi_comm{};
     MPI_Comm_dup(MPI_COMM_WORLD, &duplicated_mpi_comm);
     const plssvm::mpi::communicator comm{ duplicated_mpi_comm };
 
@@ -942,3 +1031,39 @@ TYPED_TEST(BaseCSVRScore, predict_communicator_mismatch) {
 }
 
 #endif
+
+TYPED_TEST(BaseCSVRScore, PredictLocalMemoryTooSmall) {
+    using label_type = typename TestFixture::fixture_label_type;
+
+    // create C-SVR: must be done using the mock class since the csvc base class is pure virtual
+    const mock_csvr csvr{};
+
+    // override on call
+    constexpr plssvm::detail::memory_size needed_local_mem_size = plssvm::detail::data_distribution::maximum_local_memory_needed();
+    ON_CALL(csvr, get_local_memory()).WillByDefault(::testing::Return((std::vector<std::optional<plssvm::detail::memory_size>>{ std::make_optional(needed_local_mem_size / 2), std::make_optional(needed_local_mem_size / 2) })));
+
+    // mock the predict_values function -> since an exception should be triggered, the mocked function should never be called
+    // clang-format off
+    EXPECT_CALL(csvr, get_local_memory()).Times(1);
+    EXPECT_CALL(csvr, predict_values(
+                            ::testing::An<const plssvm::parameter &>(),
+                            ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>(),
+                            ::testing::An<const plssvm::aos_matrix<plssvm::real_type> &>(),
+                            ::testing::An<const std::vector<plssvm::real_type> &>(),
+                            ::testing::An<plssvm::soa_matrix<plssvm::real_type> &>(),
+                            ::testing::An<const plssvm::soa_matrix<plssvm::real_type> &>())).Times(0);
+    // clang-format on
+
+    // create data set and previously learned model
+    const plssvm::regression_data_set<label_type> data_to_predict{ this->get_data_filename() };
+    const plssvm::regression_model<label_type> learned_model{ this->get_model_filename() };
+
+    // calling the function with mismatching MPI communicators should throw
+    EXPECT_THROW_WHAT(std::ignore = csvr.score(learned_model, data_to_predict),
+                      plssvm::kernel_launch_resources,
+                      fmt::format("At least {} of local memory must be available for the hyperparameter combination THREAD_BLOCK_SIZE={} and INTERNAL_BLOCK_SIZE={}, but available are only {}!",
+                                  needed_local_mem_size,
+                                  plssvm::THREAD_BLOCK_SIZE,
+                                  plssvm::INTERNAL_BLOCK_SIZE,
+                                  needed_local_mem_size / 2));
+}
diff --git a/tests/svm/mock_csvc.hpp b/tests/svm/mock_csvc.hpp
index eebc91d99..629220e27 100644
--- a/tests/svm/mock_csvc.hpp
+++ b/tests/svm/mock_csvc.hpp
@@ -9,8 +9,8 @@
  * @brief MOCK class for the C-SVC base class.
  */
 
-#ifndef PLSSVM_TESTS_MOCK_CSVC_HPP_
-#define PLSSVM_TESTS_MOCK_CSVC_HPP_
+#ifndef PLSSVM_TESTS_CSVC_MOCK_CSVC_HPP_
+#define PLSSVM_TESTS_CSVC_MOCK_CSVC_HPP_
 #pragma once
 
 #include "plssvm/mpi/communicator.hpp"  // plssvm::mpi::communicator
@@ -31,4 +31,4 @@ class mock_csvc final : virtual public plssvm::csvc,
         mock_csvm{ args... } { }
 };
 
-#endif  // PLSSVM_TESTS_MOCK_CSVC_HPP_
+#endif  // PLSSVM_TESTS_CSVC_MOCK_CSVC_HPP_
diff --git a/tests/svm/mock_csvm.hpp b/tests/svm/mock_csvm.hpp
index 6d70f12e1..faa562f51 100644
--- a/tests/svm/mock_csvm.hpp
+++ b/tests/svm/mock_csvm.hpp
@@ -16,7 +16,7 @@
 #include "plssvm/constants.hpp"             // plssvm::real_type
 #include "plssvm/detail/memory_size.hpp"    // plssvm::detail::memory_size, plssvm::detail::literals
 #include "plssvm/detail/move_only_any.hpp"  // plssvm::detail::move_only_any
-#include "plssvm/matrix.hpp"                // plssvm::aos_matrix
+#include "plssvm/matrix.hpp"                // plssvm::aos_matrix, plssvm::soa_matrix
 #include "plssvm/mpi/communicator.hpp"      // plssvm::mpi::communicator
 #include "plssvm/parameter.hpp"             // plssvm::parameter
 #include "plssvm/solver_types.hpp"          // plssvm::solver_type
@@ -24,9 +24,10 @@
 
 #include "gmock/gmock.h"  // MOCK_METHOD, ON_CALL, ::testing::Return
 
-#include <cstddef>  // std::size_t
-#include <utility>  // std::forward
-#include <vector>   // std::vector
+#include <cstddef>   // std::size_t
+#include <optional>  // std::optional
+#include <utility>   // std::forward
+#include <vector>    // std::vector
 
 /**
  * @brief GTest mock class for the base C-SVM class.
@@ -42,16 +43,18 @@ class mock_csvm : virtual public plssvm::csvm {
     // mock pure virtual functions
     MOCK_METHOD((std::vector<plssvm::detail::memory_size>), get_device_memory, (), (const, override));
     MOCK_METHOD((std::vector<plssvm::detail::memory_size>), get_max_mem_alloc_size, (), (const, override));
-    MOCK_METHOD((std::size_t), num_available_devices, (), (const, noexcept, override));
+    MOCK_METHOD((std::vector<std::optional<plssvm::detail::memory_size>>), get_local_memory, (), (const, override));
+    MOCK_METHOD((std::size_t), num_available_devices, (), (const, noexcept, override));  // NOLINT(bugprone-exception-escape): actual function is noexcept and can't throw
     MOCK_METHOD((std::vector<plssvm::detail::move_only_any>), assemble_kernel_matrix, (plssvm::solver_type, const plssvm::parameter &, const plssvm::soa_matrix<plssvm::real_type> &, const std::vector<plssvm::real_type> &, plssvm::real_type), (const, override));
     MOCK_METHOD((void), blas_level_3, (plssvm::solver_type, plssvm::real_type, const std::vector<plssvm::detail::move_only_any> &, const plssvm::soa_matrix<plssvm::real_type> &, plssvm::real_type, plssvm::soa_matrix<plssvm::real_type> &), (const, override));
     MOCK_METHOD((plssvm::aos_matrix<plssvm::real_type>), predict_values, (const plssvm::parameter &, const plssvm::soa_matrix<plssvm::real_type> &, const plssvm::aos_matrix<plssvm::real_type> &, const std::vector<plssvm::real_type> &, plssvm::soa_matrix<plssvm::real_type> &, const plssvm::soa_matrix<plssvm::real_type> &), (const, override));
 
   private:
     void fake_functions() const {
-        using namespace plssvm::detail::literals;
+        using namespace plssvm::detail::literals;  // NOLINT(google-build-using-namespace): only imports custom user-defined literals into this namespace
         ON_CALL(*this, get_device_memory()).WillByDefault(::testing::Return(std::vector<plssvm::detail::memory_size>{ 1_GiB, 1_GiB }));
         ON_CALL(*this, get_max_mem_alloc_size()).WillByDefault(::testing::Return(std::vector<plssvm::detail::memory_size>{ 512_MiB, 256_MiB }));
+        ON_CALL(*this, get_local_memory()).WillByDefault(::testing::Return(std::vector<std::optional<plssvm::detail::memory_size>>{ 512_MiB, 256_MiB }));
         ON_CALL(*this, num_available_devices()).WillByDefault(::testing::Return(2));
     }
 };
diff --git a/tests/svm/mock_csvr.hpp b/tests/svm/mock_csvr.hpp
index 3125ff2be..84f0bffd3 100644
--- a/tests/svm/mock_csvr.hpp
+++ b/tests/svm/mock_csvr.hpp
@@ -9,8 +9,8 @@
  * @brief MOCK class for the C-SVR base class.
  */
 
-#ifndef PLSSVM_TESTS_MOCK_CSVR_HPP_
-#define PLSSVM_TESTS_MOCK_CSVR_HPP_
+#ifndef PLSSVM_TESTS_SVM_MOCK_CSVR_HPP_
+#define PLSSVM_TESTS_SVM_MOCK_CSVR_HPP_
 #pragma once
 
 #include "plssvm/mpi/communicator.hpp"  // plssvm::mpi::communicator
@@ -31,4 +31,4 @@ class mock_csvr final : virtual public plssvm::csvr,
         mock_csvm{ args... } { }
 };
 
-#endif  // PLSSVM_TESTS_MOCK_CSVR_HPP_
+#endif  // PLSSVM_TESTS_SVM_MOCK_CSVR_HPP_
diff --git a/tests/svm_types.cpp b/tests/svm_types.cpp
index 0c97ff096..52028c802 100644
--- a/tests/svm_types.cpp
+++ b/tests/svm_types.cpp
@@ -23,19 +23,19 @@
 #include <vector>       // std::vector
 
 // check whether the plssvm::svm_type -> std::string conversions are correct
-TEST(SvmType, to_string) {
+TEST(SvmType, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::svm_type::csvc, "csvc");
     EXPECT_CONVERSION_TO_STRING(plssvm::svm_type::csvr, "csvr");
 }
 
-TEST(SvmType, to_string_unknown) {
+TEST(SvmType, ToStringUnknown) {
     // check conversions to std::string from unknown svm_type
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::svm_type>(2), "unknown");
 }
 
 // check whether the std::string -> plssvm::svm_type conversions are correct
-TEST(SvmType, from_string) {
+TEST(SvmType, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("CSVC", plssvm::svm_type::csvc);
     EXPECT_CONVERSION_FROM_STRING("csvc", plssvm::svm_type::csvc);
@@ -49,7 +49,7 @@ TEST(SvmType, from_string) {
     EXPECT_CONVERSION_FROM_STRING("1", plssvm::svm_type::csvr);
 }
 
-TEST(SvmType, from_string_unknown) {
+TEST(SvmType, FromStringUnknown) {
     // foo isn't a valid svm_type
     std::istringstream input{ "foo" };
     plssvm::svm_type svm{};
@@ -57,7 +57,7 @@ TEST(SvmType, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(SvmType, minimal_available_svm_types) {
+TEST(SvmType, MinimalAvailableSvmTypes) {
     const std::vector<plssvm::svm_type> svms = plssvm::list_available_svm_types();
 
     // both C-SVM types must be available
@@ -66,7 +66,7 @@ TEST(SvmType, minimal_available_svm_types) {
     EXPECT_THAT(svms, ::testing::Contains(plssvm::svm_type::csvr));
 }
 
-TEST(SvmType, svm_type_to_task_name) {
+TEST(SvmType, SvmTypeToTaskName) {
     // get the task name from a C-SVC
     EXPECT_EQ(plssvm::svm_type_to_task_name(plssvm::svm_type::csvc), std::string_view{ "classification" });
 
@@ -74,12 +74,12 @@ TEST(SvmType, svm_type_to_task_name) {
     EXPECT_EQ(plssvm::svm_type_to_task_name(plssvm::svm_type::csvr), std::string_view{ "regression" });
 }
 
-TEST(SvmType, svm_type_to_task_name_unknown) {
+TEST(SvmType, SvmTypeToTaskNameUnknown) {
     // try converting an unknown SVM type to a task name
     EXPECT_EQ(plssvm::svm_type_to_task_name(static_cast<plssvm::svm_type>(2)), std::string_view{ "unknown" });
 }
 
-TEST(SvmType, svm_type_from_model_file) {
+TEST(SvmType, SvmTypeFromModelFile) {
     // check a classification model file
     EXPECT_EQ(plssvm::svm_type_from_model_file(PLSSVM_TEST_PATH "/data/model/classification/6x4.libsvm.model"), plssvm::svm_type::csvc);
 
@@ -87,14 +87,14 @@ TEST(SvmType, svm_type_from_model_file) {
     EXPECT_EQ(plssvm::svm_type_from_model_file(PLSSVM_TEST_PATH "/data/model/regression/6x4.libsvm.model"), plssvm::svm_type::csvr);
 }
 
-TEST(SvmType, svm_type_from_model_file_missing_svm_type) {
+TEST(SvmType, SvmTypeFromModelFileMissingSvmType) {
     // try getting the SVM type from an empty file won't work
     EXPECT_THROW_WHAT(std::ignore = plssvm::svm_type_from_model_file(PLSSVM_TEST_PATH "/data/model/classification/invalid/missing_svm_type.libsvm.model"),
                       plssvm::invalid_file_format_exception,
                       R"(The provided model file is not a valid LIBSVM model file since "svm_type" is missing!)");
 }
 
-TEST(SvmType, svm_type_from_model_file_empty) {
+TEST(SvmType, SvmTypeFromModelFileEmpty) {
     // try getting the SVM type from an empty file won't work
     EXPECT_THROW_WHAT(std::ignore = plssvm::svm_type_from_model_file(PLSSVM_TEST_PATH "/data/empty.txt"),
                       plssvm::invalid_file_format_exception,
diff --git a/tests/target_platforms.cpp b/tests/target_platforms.cpp
index 87510bb13..469a7a545 100644
--- a/tests/target_platforms.cpp
+++ b/tests/target_platforms.cpp
@@ -19,7 +19,7 @@
 #include <vector>   // std::vector
 
 // check whether the plssvm::target_platform -> std::string conversions are correct
-TEST(TargetPlatform, to_string) {
+TEST(TargetPlatform, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::target_platform::automatic, "automatic");
     EXPECT_CONVERSION_TO_STRING(plssvm::target_platform::cpu, "cpu");
@@ -28,13 +28,13 @@ TEST(TargetPlatform, to_string) {
     EXPECT_CONVERSION_TO_STRING(plssvm::target_platform::gpu_intel, "gpu_intel");
 }
 
-TEST(TargetPlatform, to_string_unknown) {
+TEST(TargetPlatform, ToStringUnknown) {
     // check conversions to std::string from unknown target_platform
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::target_platform>(5), "unknown");
 }
 
 // check whether the std::string -> plssvm::target_platform conversions are correct
-TEST(TargetPlatform, from_string) {
+TEST(TargetPlatform, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("automatic", plssvm::target_platform::automatic);
     EXPECT_CONVERSION_FROM_STRING("AUTOmatic", plssvm::target_platform::automatic);
@@ -50,7 +50,7 @@ TEST(TargetPlatform, from_string) {
     EXPECT_CONVERSION_FROM_STRING("GPU_INTEL", plssvm::target_platform::gpu_intel);
 }
 
-TEST(TargetPlatform, from_string_unknown) {
+TEST(TargetPlatform, FromStringUnknown) {
     // foo isn't a valid target_platform
     std::istringstream input{ "foo" };
     plssvm::target_platform platform{};
@@ -58,7 +58,7 @@ TEST(TargetPlatform, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(TargetPlatform, minimal_available_target_platform) {
+TEST(TargetPlatform, MinimalAvailableTargetPlatforms) {
     // get the available target platforms
     const std::vector<plssvm::target_platform> platform = plssvm::list_available_target_platforms();
 
@@ -69,13 +69,13 @@ TEST(TargetPlatform, minimal_available_target_platform) {
     EXPECT_THAT(platform, ::testing::Contains(plssvm::target_platform::automatic));
 }
 
-TEST(TargetPlatform, determine_default_target_platform) {
+TEST(TargetPlatform, DetermineDefaultTargetPlatform) {
     // the determined default platform must not be target_platform::automatic
     const plssvm::target_platform target = plssvm::determine_default_target_platform();
     EXPECT_NE(target, plssvm::target_platform::automatic);
 }
 
-TEST(TargetPlatform, determine_target_platform) {
+TEST(TargetPlatform, DetermineTargetPlatform) {
     // if only one platform is available, the default platform must be this platform
     EXPECT_EQ(plssvm::determine_default_target_platform({ plssvm::target_platform::gpu_nvidia }), plssvm::target_platform::gpu_nvidia);
     EXPECT_EQ(plssvm::determine_default_target_platform({ plssvm::target_platform::gpu_amd }), plssvm::target_platform::gpu_amd);
diff --git a/tests/types_to_test.hpp b/tests/types_to_test.hpp
index 6257bcf29..87d3229c6 100644
--- a/tests/types_to_test.hpp
+++ b/tests/types_to_test.hpp
@@ -124,7 +124,7 @@ namespace detail {
  * @param[in] tuple the tuple to clone
  */
 template <typename Tuple, std::size_t... Is>
-[[nodiscard]] constexpr auto expand_tuple(std::index_sequence<Is...>, const Tuple &tuple) {
+[[nodiscard]] constexpr auto expand_tuple([[maybe_unused]] std::index_sequence<Is...> indices, const Tuple &tuple) {
     return std::tuple_cat((static_cast<void>(Is), tuple)...);
 }
 
@@ -318,7 +318,7 @@ struct wrap_in_type_list<std::tuple<Types...>> {
 template <typename Tuple>
 using wrap_in_type_list_t = typename wrap_in_type_list<Tuple>::type;
 
-template <typename Tuple, typename CurrentTuple, typename>
+template <typename, typename, typename>
 struct combine_types_impl { };
 
 /**
diff --git a/tests/utility.hpp b/tests/utility.hpp
index 7e9755259..fea29ffc2 100644
--- a/tests/utility.hpp
+++ b/tests/utility.hpp
@@ -27,11 +27,12 @@
 #include "plssvm/svm_types.hpp"                         // plssvm::svm_type
 
 #include "fmt/format.h"   // fmt::format
-#include "fmt/std.h"      // format std::vector<bool>::operator[] proxy type
+#include "fmt/std.h"      // NOLINT: format std::vector<bool>::operator[] proxy type
 #include "gtest/gtest.h"  // FAIL
 
 #if defined(__unix__)
-    #include <cstdlib>  // mkstemp
+    #include <cstdlib>   // mkstemp
+    #include <unistd.h>  // close
 #endif
 
 #include <algorithm>    // std::generate, std::min, std::max
@@ -115,7 +116,7 @@ class redirect_output {
     }
 
   private:
-    std::stringstream buffer_{};
+    std::stringstream buffer_;
     std::streambuf *sbuf_{ nullptr };
 };
 
@@ -141,7 +142,7 @@ class temporary_file {
         }
 #else
         std::random_device device;
-        std::mt19937 gen(device());
+        std::mt19937 gen(static_cast<std::mt19937::result_type>(device()));
         std::uniform_int_distribution<unsigned long long> dist;
         filename = fmt::format("tmpfile_{}", dist(gen));
         while (std::filesystem::exists(std::filesystem::temp_directory_path() / filename)) {
@@ -188,7 +189,7 @@ class temporary_file {
         std::filesystem::remove(filename);
     }
 
-    std::string filename{};
+    std::string filename;
 };
 
 /**
@@ -393,7 +394,7 @@ template <typename T, PLSSVM_REQUIRES(std::is_floating_point_v<T>)>
 
     // fill vectors with random values
     static std::random_device device;
-    static std::mt19937 gen(device());
+    static std::mt19937 gen(static_cast<std::mt19937::result_type>(device()));
     std::uniform_real_distribution<T> dist(range.first, range.second);
     std::generate(vec.begin(), vec.end(), [&]() { return dist(gen); });
 
@@ -413,7 +414,7 @@ template <typename T, PLSSVM_REQUIRES(std::is_integral_v<T> &&std::is_unsigned_v
 
     // fill vectors with random values
     static std::random_device device;
-    static std::mt19937 gen(device());
+    static std::mt19937 gen(static_cast<std::mt19937::result_type>(device()));
     std::uniform_int_distribution<T> dist(range.first, range.second);
     std::generate(vec.begin(), vec.end(), [&]() { return dist(gen); });
 
@@ -433,7 +434,7 @@ template <typename T, PLSSVM_REQUIRES(std::is_integral_v<T> &&std::is_signed_v<T
 
     // fill vectors with random values
     static std::random_device device;
-    static std::mt19937 gen(device());
+    static std::mt19937 gen(static_cast<std::mt19937::result_type>(device()));
     std::uniform_int_distribution<T> dist(range.first, range.second);
     std::generate(vec.begin(), vec.end(), [&]() { return dist(gen); });
 
@@ -454,7 +455,7 @@ template <typename matrix_type, typename real_type = typename matrix_type::value
 
     // create random number generator
     static std::random_device device;
-    static std::mt19937 gen(device());
+    static std::mt19937 gen(static_cast<std::mt19937::result_type>(device()));
     std::uniform_real_distribution<real_type> dist(range.first, range.second);
 
     matrix_type matrix{ shape };
@@ -529,10 +530,9 @@ template <typename matrix_type>
     using real_type = typename matrix_type::value_type;
     static_assert(std::is_floating_point_v<real_type>, "Only floating point types are allowed!");
 
-    // random number generate for range [ 0.0, 1.0 ]
-    std::random_device rd;
-    std::mt19937 gen(rd());
-    std::uniform_int_distribution<std::size_t> dis(0, shape.y - 1);
+    static std::random_device device;
+    static std::mt19937 gen(static_cast<std::mt19937::result_type>(device()));
+    std::uniform_int_distribution<std::size_t> dist(0, shape.y - 1);
 
     // generate sparse matrix
     matrix_type matrix{ shape };
@@ -542,7 +542,7 @@ template <typename matrix_type>
         }
         // remove half of the created values randomly
         for (std::size_t j = 0; j < matrix.num_cols() / 2; ++j) {
-            matrix(i, dis(gen)) = real_type{ 0.0 };
+            matrix(i, dist(gen)) = real_type{ 0.0 };
         }
     }
 
@@ -582,7 +582,7 @@ template <typename label_type>
     label.reserve(num_labels * num_data_points);
 
     static std::random_device device;
-    static std::mt19937 gen(device());
+    static std::mt19937 gen(static_cast<std::mt19937::result_type>(device()));
     std::uniform_real_distribution<plssvm::real_type> dist(plssvm::real_type{ 0.0001 }, plssvm::real_type{ 0.01 });
 
     for (std::size_t l = 0; l < num_labels; ++l) {
@@ -623,10 +623,6 @@ template <typename label_type>
     std::vector<label_type> label{};
     label.reserve(num_data_points);
 
-    static std::random_device device;
-    static std::mt19937 gen(device());
-    std::uniform_real_distribution<plssvm::real_type> dist(plssvm::real_type{ 0.0001 }, plssvm::real_type{ 0.01 });
-
     for (std::size_t i = 0; i < num_data_points; ++i) {
         data.push_back({ static_cast<plssvm::real_type>(i), static_cast<plssvm::real_type>(i) });
         label.push_back(static_cast<label_type>(i));
@@ -650,8 +646,15 @@ template <typename T>
     return ret;
 }
 
-template <typename matrix_type, typename real_type = typename matrix_type::value_type>
+/**
+ * @brief Create a new value similar to @p matr where all values are converted to their absolute values.
+ * @tparam matrix_type the type of the matrix
+ * @param[in] matr the input matrix
+ * @return a matrix with all absolute values (`[[nodiscard]]`)
+ */
+template <typename matrix_type>
 [[nodiscard]] inline matrix_type matrix_abs(const matrix_type &matr) {
+    using real_type = typename matrix_type::value_type;
     static_assert(std::is_floating_point_v<real_type>, "Only floating point types are allowed!");
 
     matrix_type res{ matr.shape(), matr.padding() };
@@ -707,7 +710,7 @@ template <typename T, plssvm::layout_type layout>
  * @return an instance of type @p T (`[[nodiscard]]`)
  */
 template <typename T, typename Tuple, size_t... Is>
-[[nodiscard]] inline T construct_from_tuple(const plssvm::parameter &params, [[maybe_unused]] Tuple tuple, std::index_sequence<Is...>) {
+[[nodiscard]] inline T construct_from_tuple(const plssvm::parameter &params, [[maybe_unused]] Tuple tuple, [[maybe_unused]] std::index_sequence<Is...> indices) {
     return T{ params, (std::get<Is>(tuple).first = std::get<Is>(tuple).second)... };
 }
 
@@ -737,7 +740,7 @@ template <typename T, typename Tuple>
  * @return an instance of type @p T (`[[nodiscard]]`)
  */
 template <typename T, typename Tuple, size_t... Is>
-[[nodiscard]] inline T construct_from_tuple([[maybe_unused]] Tuple tuple, std::index_sequence<Is...>) {
+[[nodiscard]] inline T construct_from_tuple([[maybe_unused]] Tuple tuple, [[maybe_unused]] std::index_sequence<Is...> indices) {
     return T{ (std::get<Is>(tuple).first = std::get<Is>(tuple).second)... };
 }
 
diff --git a/tests/verbosity_levels.cpp b/tests/verbosity_levels.cpp
index 0f5de13a8..87606e428 100644
--- a/tests/verbosity_levels.cpp
+++ b/tests/verbosity_levels.cpp
@@ -13,14 +13,13 @@
 #include "plssvm/detail/utility.hpp"  // plssvm::detail::to_underlying
 
 #include "tests/custom_test_macros.hpp"  // EXPECT_CONVERSION_TO_STRING, EXPECT_CONVERSION_FROM_STRING
-#include "tests/utility.hpp"             // util::redirect_output
 
 #include "gtest/gtest.h"  // TEST, EXPECT_EQ, EXPECT_TRUE
 
 #include <sstream>  // std::istringstream
 
 // check whether the plssvm::verbosity_level values are power of twos
-TEST(VerbosityLevel, values) {
+TEST(VerbosityLevel, Values) {
     EXPECT_EQ(plssvm::detail::to_underlying(plssvm::verbosity_level::quiet), 0b0000);
     EXPECT_EQ(plssvm::detail::to_underlying(plssvm::verbosity_level::libsvm), 0b0001);
     EXPECT_EQ(plssvm::detail::to_underlying(plssvm::verbosity_level::timing), 0b0010);
@@ -29,7 +28,7 @@ TEST(VerbosityLevel, values) {
 }
 
 // check whether the plssvm::verbosity_level -> std::string conversions are correct
-TEST(VerbosityLevel, to_string) {
+TEST(VerbosityLevel, ToString) {
     // check conversions to std::string
     EXPECT_CONVERSION_TO_STRING(plssvm::verbosity_level::quiet, "quiet");
     EXPECT_CONVERSION_TO_STRING(plssvm::verbosity_level::libsvm, "libsvm");
@@ -38,7 +37,7 @@ TEST(VerbosityLevel, to_string) {
     EXPECT_CONVERSION_TO_STRING(plssvm::verbosity_level::full, "full");
 }
 
-TEST(VerbosityLevel, to_string_concatenation) {
+TEST(VerbosityLevel, ToStringConcatenation) {
     // check conversion to std::string for multiple values
     EXPECT_CONVERSION_TO_STRING(plssvm::verbosity_level::full | plssvm::verbosity_level::timing | plssvm::verbosity_level::libsvm,
                                 "libsvm | timing | full");
@@ -54,13 +53,13 @@ TEST(VerbosityLevel, to_string_concatenation) {
                                 "libsvm | warning");
 }
 
-TEST(VerbosityLevel, to_string_unknown) {
+TEST(VerbosityLevel, ToStringUnknown) {
     // check conversions to std::string from unknown backend_type
     EXPECT_CONVERSION_TO_STRING(static_cast<plssvm::verbosity_level>(0b10000), "unknown");
 }
 
 // check whether the std::string -> plssvm::verbosity_level conversions are correct
-TEST(VerbosityLevel, from_string) {
+TEST(VerbosityLevel, FromString) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("quiet", plssvm::verbosity_level::quiet);
     EXPECT_CONVERSION_FROM_STRING("QUIET", plssvm::verbosity_level::quiet);
@@ -74,7 +73,7 @@ TEST(VerbosityLevel, from_string) {
     EXPECT_CONVERSION_FROM_STRING("FULL", plssvm::verbosity_level::full);
 }
 
-TEST(VerbosityLevel, from_string_concatenation) {
+TEST(VerbosityLevel, FromStringConcatenation) {
     // check conversion from std::string
     EXPECT_CONVERSION_FROM_STRING("quiet|libsvm|timing|full", plssvm::verbosity_level::quiet);
     EXPECT_CONVERSION_FROM_STRING("libsvm|timing|warning|full", plssvm::verbosity_level::full | plssvm::verbosity_level::timing | plssvm::verbosity_level::warning | plssvm::verbosity_level::libsvm);
@@ -85,7 +84,7 @@ TEST(VerbosityLevel, from_string_concatenation) {
     EXPECT_CONVERSION_FROM_STRING("libsvm|warning", plssvm::verbosity_level::warning | plssvm::verbosity_level::libsvm);
 }
 
-TEST(VerbosityLevel, from_string_unknown) {
+TEST(VerbosityLevel, FromStringUnknown) {
     // foo isn't a valid backend_type
     std::istringstream input{ "foo" };
     plssvm::verbosity_level verb{};
@@ -93,7 +92,7 @@ TEST(VerbosityLevel, from_string_unknown) {
     EXPECT_TRUE(input.fail());
 }
 
-TEST(VerbosityLevel, bitwise_or) {
+TEST(VerbosityLevel, BitwiseOr) {
     EXPECT_EQ(plssvm::detail::to_underlying(plssvm::verbosity_level::full | plssvm::verbosity_level::warning | plssvm::verbosity_level::timing | plssvm::verbosity_level::libsvm), 0b1111);
     EXPECT_EQ(plssvm::detail::to_underlying(plssvm::verbosity_level::full | plssvm::verbosity_level::timing | plssvm::verbosity_level::libsvm), 0b1011);
     EXPECT_EQ(plssvm::detail::to_underlying(plssvm::verbosity_level::full | plssvm::verbosity_level::timing), 0b1010);
@@ -102,13 +101,13 @@ TEST(VerbosityLevel, bitwise_or) {
     EXPECT_EQ(plssvm::detail::to_underlying(plssvm::verbosity_level::warning | plssvm::verbosity_level::libsvm), 0b0101);
 }
 
-TEST(VerbosityLevel, compound_bitwise_or) {
+TEST(VerbosityLevel, CompoundBitwiseOr) {
     plssvm::verbosity_level verb = plssvm::verbosity_level::full;
     verb |= plssvm::verbosity_level::timing | plssvm::verbosity_level::libsvm;
     EXPECT_EQ(plssvm::detail::to_underlying(verb), 0b1011);
 }
 
-TEST(VerbosityLevel, bitwise_and) {
+TEST(VerbosityLevel, BitwiseAnd) {
     EXPECT_EQ(plssvm::detail::to_underlying(plssvm::verbosity_level::full & plssvm::verbosity_level::full), 0b1000);
     const plssvm::verbosity_level verb = plssvm::verbosity_level::full | plssvm::verbosity_level::libsvm;
     EXPECT_EQ(plssvm::detail::to_underlying(verb & plssvm::verbosity_level::quiet), 0b0000);
@@ -118,7 +117,7 @@ TEST(VerbosityLevel, bitwise_and) {
     EXPECT_EQ(plssvm::detail::to_underlying(verb & plssvm::verbosity_level::full), 0b1000);
 }
 
-TEST(VerbosityLevel, compound_bitwise_and) {
+TEST(VerbosityLevel, CompoundBitwiseAnd) {
     plssvm::verbosity_level verb = plssvm::verbosity_level::full | plssvm::verbosity_level::libsvm;
     verb &= plssvm::verbosity_level::full;
     EXPECT_EQ(plssvm::detail::to_underlying(verb), 0b1000);
diff --git a/tests/version/git_metadata/git_metadata.cpp b/tests/version/git_metadata/git_metadata.cpp
index b46a40b3d..fd89bc7e6 100644
--- a/tests/version/git_metadata/git_metadata.cpp
+++ b/tests/version/git_metadata/git_metadata.cpp
@@ -16,119 +16,117 @@
 #include <regex>   // std::regex, std::regex::extended, std::regex_match
 #include <string>  // std::string
 
-using namespace plssvm::version;
-
-TEST(GitMetadata, author_name) {
-    if (git_metadata::is_populated()) {
+TEST(GitMetadata, AuthorName) {
+    if (plssvm::version::git_metadata::is_populated()) {
         // if we are inside a Git repository, the author name must not be empty
-        EXPECT_FALSE(git_metadata::author_name().empty());
+        EXPECT_FALSE(plssvm::version::git_metadata::author_name().empty());
     } else {
         // if we are outside a Git repository, the author name must be empty
-        EXPECT_TRUE(git_metadata::author_name().empty());
+        EXPECT_TRUE(plssvm::version::git_metadata::author_name().empty());
     }
 }
 
-TEST(GitMetadata, author_email) {
-    if (git_metadata::is_populated()) {
+TEST(GitMetadata, AuthorEmail) {
+    if (plssvm::version::git_metadata::is_populated()) {
         // if we are inside a Git repository, the author email must not be empty
-        EXPECT_FALSE(git_metadata::author_email().empty());
+        EXPECT_FALSE(plssvm::version::git_metadata::author_email().empty());
         // check for a valid email address
-        EXPECT_TRUE(std::regex_match(std::string{ git_metadata::author_email() },
+        EXPECT_TRUE(std::regex_match(std::string{ plssvm::version::git_metadata::author_email() },
                                      std::regex{ "^[[:graph:]]+@[[:graph:]]+\\.[[:graph:]]+$", std::regex::extended }));
     } else {
         // if we are outside a Git repository, the author email must be empty
-        EXPECT_TRUE(git_metadata::author_email().empty());
+        EXPECT_TRUE(plssvm::version::git_metadata::author_email().empty());
     }
 }
 
-TEST(GitMetadata, commit_sha1) {
-    if (git_metadata::is_populated()) {
+TEST(GitMetadata, CommitSha1) {
+    if (plssvm::version::git_metadata::is_populated()) {
         // if we are inside a Git repository, the commit sha1 must not be empty
-        EXPECT_FALSE(git_metadata::commit_sha1().empty());
+        EXPECT_FALSE(plssvm::version::git_metadata::commit_sha1().empty());
         // test for valid commit sha1 characters
-        EXPECT_TRUE(std::regex_match(std::string{ git_metadata::commit_sha1() },
+        EXPECT_TRUE(std::regex_match(std::string{ plssvm::version::git_metadata::commit_sha1() },
                                      std::regex{ "^([0-9a-f]{40})|([0-9a-f]{6,8})$", std::regex::extended }));
     } else {
         // if we are outside a Git repository, the commit sha1 must be empty
-        EXPECT_TRUE(git_metadata::commit_sha1().empty());
+        EXPECT_TRUE(plssvm::version::git_metadata::commit_sha1().empty());
     }
 }
 
-TEST(GitMetadata, commit_date) {
-    if (git_metadata::is_populated()) {
+TEST(GitMetadata, CommitDate) {
+    if (plssvm::version::git_metadata::is_populated()) {
         // if we are inside a Git repository, the commit date must not be empty
-        EXPECT_FALSE(git_metadata::commit_date().empty());
+        EXPECT_FALSE(plssvm::version::git_metadata::commit_date().empty());
     } else {
         // if we are outside a Git repository, the commit date must be empty
-        EXPECT_TRUE(git_metadata::commit_date().empty());
+        EXPECT_TRUE(plssvm::version::git_metadata::commit_date().empty());
     }
 }
 
-TEST(GitMetadata, commit_subject) {
-    if (git_metadata::is_populated()) {
+TEST(GitMetadata, CommitSubject) {
+    if (plssvm::version::git_metadata::is_populated()) {
         // if we are inside a Git repository, the commit subject must not be empty
-        EXPECT_FALSE(git_metadata::commit_subject().empty());
+        EXPECT_FALSE(plssvm::version::git_metadata::commit_subject().empty());
     } else {
         // if we are outside a Git repository, the commit subject must be empty
-        EXPECT_TRUE(git_metadata::commit_subject().empty());
+        EXPECT_TRUE(plssvm::version::git_metadata::commit_subject().empty());
     }
 }
 
-TEST(GitMetadata, commit_body) {
-    if (!git_metadata::is_populated()) {
+TEST(GitMetadata, CommitBody) {
+    if (!plssvm::version::git_metadata::is_populated()) {
         // if we are outside a Git repository, the commit body must be empty
-        EXPECT_TRUE(git_metadata::commit_subject().empty());
+        EXPECT_TRUE(plssvm::version::git_metadata::commit_subject().empty());
     }
 }
 
-TEST(GitMetadata, describe) {
-    if (git_metadata::is_populated()) {
+TEST(GitMetadata, Describe) {
+    if (plssvm::version::git_metadata::is_populated()) {
         // if we are inside a Git repository, the description message must not be empty
-        EXPECT_FALSE(git_metadata::describe().empty());
+        EXPECT_FALSE(plssvm::version::git_metadata::describe().empty());
     } else {
         // if we are outside a Git repository, the description message must be empty
-        EXPECT_TRUE(git_metadata::describe().empty());
+        EXPECT_TRUE(plssvm::version::git_metadata::describe().empty());
     }
 }
 
-TEST(GitMetadata, branch) {
-    if (git_metadata::is_populated()) {
+TEST(GitMetadata, Branch) {
+    if (plssvm::version::git_metadata::is_populated()) {
         // if we are inside a Git repository, the branch must not be empty
-        EXPECT_FALSE(git_metadata::branch().empty());
+        EXPECT_FALSE(plssvm::version::git_metadata::branch().empty());
         // check whether the branch name is valid
         // https://git-scm.com/docs/git-check-ref-format
-        EXPECT_THAT(std::string{ git_metadata::branch() }, ::testing::Not(::testing::StartsWith(".")));    // must not start with a .a
-        EXPECT_THAT(std::string{ git_metadata::branch() }, ::testing::Not(::testing::EndsWith(".lock")));  // must not end with .lock
-        EXPECT_THAT(std::string{ git_metadata::branch() }, ::testing::Not(::testing::EndsWith("..")));     // must not end with .. anywhere
-        // EXPECT_THAT(git_metadata::branch(), ::testing::Not(::testing::ContainsRegex("[\\\040-\\\177]+")));  // not contain an ASCII control character anywhere
-        EXPECT_FALSE(std::regex_match(std::string{ git_metadata::branch() },
+        EXPECT_THAT(std::string{ plssvm::version::git_metadata::branch() }, ::testing::Not(::testing::StartsWith(".")));    // must not start with a .a
+        EXPECT_THAT(std::string{ plssvm::version::git_metadata::branch() }, ::testing::Not(::testing::EndsWith(".lock")));  // must not end with .lock
+        EXPECT_THAT(std::string{ plssvm::version::git_metadata::branch() }, ::testing::Not(::testing::EndsWith("..")));     // must not end with .. anywhere
+        // EXPECT_THAT(plssvm::version::git_metadata::branch(), ::testing::Not(::testing::ContainsRegex("[\\\040-\\\177]+")));  // not contain an ASCII control character anywhere
+        EXPECT_FALSE(std::regex_match(std::string{ plssvm::version::git_metadata::branch() },
                                       std::regex{ "(~|\\^|:)+", std::regex::extended }));  // must not contain a ~, ^ or : anywhere
-        EXPECT_FALSE(std::regex_match(std::string{ git_metadata::branch() },
-                                      std::regex{ "(\\?|\\[|\\*)+", std::regex::extended }));            // must not contain ?, [ or * anywhere
-        EXPECT_THAT(std::string{ git_metadata::branch() }, ::testing::Not(::testing::StartsWith("/")));  // must not start with a /
-        EXPECT_THAT(std::string{ git_metadata::branch() }, ::testing::Not(::testing::EndsWith("/")));    // must not end with a /
-        EXPECT_FALSE(std::regex_match(std::string{ git_metadata::branch() },
+        EXPECT_FALSE(std::regex_match(std::string{ plssvm::version::git_metadata::branch() },
+                                      std::regex{ "(\\?|\\[|\\*)+", std::regex::extended }));                             // must not contain ?, [ or * anywhere
+        EXPECT_THAT(std::string{ plssvm::version::git_metadata::branch() }, ::testing::Not(::testing::StartsWith("/")));  // must not start with a /
+        EXPECT_THAT(std::string{ plssvm::version::git_metadata::branch() }, ::testing::Not(::testing::EndsWith("/")));    // must not end with a /
+        EXPECT_FALSE(std::regex_match(std::string{ plssvm::version::git_metadata::branch() },
                                       std::regex{ "/{2,}", std::regex::extended }));  // must not contain multiple consecutive /
-        EXPECT_FALSE(std::regex_match(std::string{ git_metadata::branch() },
+        EXPECT_FALSE(std::regex_match(std::string{ plssvm::version::git_metadata::branch() },
                                       std::regex{ "(@\\{)+", std::regex::extended }));  // must not contain @{
-        EXPECT_FALSE(std::regex_match(std::string{ git_metadata::branch() },
+        EXPECT_FALSE(std::regex_match(std::string{ plssvm::version::git_metadata::branch() },
                                       std::regex{ "(@|\\\\)+", std::regex::extended }));  // must not contain a single @ or backslash
     } else {
         // if we are outside a Git repository, the branch name is HEAD
-        EXPECT_EQ(git_metadata::branch(), "HEAD");
+        EXPECT_EQ(plssvm::version::git_metadata::branch(), "HEAD");
     }
 }
 
-TEST(GitMetadata, remote_url) {
-    if (git_metadata::is_populated()) {
+TEST(GitMetadata, RemoteURL) {
+    if (plssvm::version::git_metadata::is_populated()) {
         // if we are inside a Git repository, the remote URL must not be empty
-        EXPECT_FALSE(git_metadata::remote_url().empty());
+        EXPECT_FALSE(plssvm::version::git_metadata::remote_url().empty());
         // check whether the remote URL is valid
         // https://github.com/jonschlinkert/is-git-url
-        EXPECT_TRUE(std::regex_match(std::string{ git_metadata::remote_url() },
+        EXPECT_TRUE(std::regex_match(std::string{ plssvm::version::git_metadata::remote_url() },
                                      std::regex{ "^(git|ssh|http|https|git@[A-Za-z0-9_\\.\\-]+):(//)?[A-Za-z0-9_\\.@:/-~\\-]+(\\.git(/)?)?$", std::regex::extended }));
     } else {
         // if we are outside a Git repository, the remote URL must be empty
-        EXPECT_TRUE(git_metadata::remote_url().empty());
+        EXPECT_TRUE(plssvm::version::git_metadata::remote_url().empty());
     }
 }
diff --git a/tests/version/version.cpp b/tests/version/version.cpp
index a6e18d12e..29690cc10 100644
--- a/tests/version/version.cpp
+++ b/tests/version/version.cpp
@@ -23,39 +23,39 @@
 #include <string>    // std::string
 #include <tuple>     // std::tuple
 
-TEST(Version, name_not_empty) {
+TEST(Version, NameNotEmpty) {
     EXPECT_FALSE(plssvm::version::name.empty());
 }
 
-TEST(Version, version_not_empty) {
+TEST(Version, VersionNotEmpty) {
     EXPECT_FALSE(plssvm::version::version.empty());
 }
 
-TEST(Version, version_major_not_negative) {
+TEST(Version, VersionMajorNotNegative) {
     EXPECT_TRUE(plssvm::version::major >= 0);
 }
 
-TEST(Version, version_minor_not_negative) {
+TEST(Version, VersionMinorNotNegative) {
     EXPECT_TRUE(plssvm::version::minor >= 0);
 }
 
-TEST(Version, version_patch_not_negative) {
+TEST(Version, VersionPatchNotNegative) {
     EXPECT_TRUE(plssvm::version::patch >= 0);
 }
 
-TEST(Version, version_string_major_minor_patch) {
+TEST(Version, VersionStringMajorMinorPatch) {
     EXPECT_EQ(plssvm::version::version, fmt::format("{}.{}.{}", plssvm::version::major, plssvm::version::minor, plssvm::version::patch));
 }
 
-TEST(Version, target_platforms_not_empty) {
+TEST(Version, TargetPlatformsNotEmpty) {
     EXPECT_FALSE(plssvm::version::detail::target_platforms.empty());
 }
 
-TEST(Version, copyright_notice_not_empty) {
+TEST(Version, CopyrightNoticeNotEmpty) {
     EXPECT_FALSE(plssvm::version::detail::copyright_notice.empty());
 }
 
-TEST(Version, get_git_info_conditional_empty) {
+TEST(Version, GetGitInfoConditionalEmpty) {
     const std::optional<std::string> git_info = plssvm::version::detail::get_git_info();
     if (plssvm::version::git_metadata::is_populated()) {
         ASSERT_TRUE(git_info.has_value());
@@ -69,7 +69,7 @@ TEST(Version, get_git_info_conditional_empty) {
 
 class VersionGetVersionInfo : public ::testing::TestWithParam<std::tuple<std::string, bool>> { };
 
-TEST_P(VersionGetVersionInfo, get_version_info_not_empty) {
+TEST_P(VersionGetVersionInfo, GetVersionInfoNotEmpty) {
     const auto &[exe_name, with_backend_info] = GetParam();
     const std::string version_info = plssvm::version::detail::get_version_info(exe_name, with_backend_info);
     ASSERT_FALSE(version_info.empty());
diff --git a/utility_scripts/performance_analysis.py b/utility_scripts/performance_analysis.py
index 48a5cb179..b1942104a 100644
--- a/utility_scripts/performance_analysis.py
+++ b/utility_scripts/performance_analysis.py
@@ -112,7 +112,7 @@ def fit_model_with_timeout(csvm, data, eps):
 
         if backend == plssvm.BackendType.SYCL:
             # special case SYCL backend
-            # add all available SYCL implementation and both kernel invocation types
+            # add all available SYCL implementation types and data parallel kernels
             available_sycl_implementations = plssvm.sycl.list_available_sycl_implementations()
             available_sycl_implementations.reverse()
             for sycl_impl in available_sycl_implementations:
@@ -120,7 +120,7 @@ def fit_model_with_timeout(csvm, data, eps):
                 if sycl_impl == plssvm.sycl.ImplementationType.AUTOMATIC:
                     continue
                 available_backends.append((backend, { "sycl_implementation_type":    sycl_impl,
-                                                      "sycl_kernel_invocation_type": plssvm.sycl.KernelInvocationType.WORK_GROUP }))
+                                                      "sycl_data_parallel_kernel": plssvm.sycl.DataParallelKernel.WORK_GROUP }))
         else:
             available_backends.append((backend, { }))