From daa8245c93ce04a73ca314f311eefea8929be3f0 Mon Sep 17 00:00:00 2001
From: Yuuichi Asahi <yuuichi.asahi@cea.fr>
Date: Mon, 23 Jun 2025 11:11:20 +0200
Subject: [PATCH 1/6] Add spline compatibility check helper

---
 include/ddc/kernels/splines.hpp               |   1 +
 include/ddc/kernels/splines/spline_traits.hpp | 119 ++++++++
 tests/splines/CMakeLists.txt                  |   1 +
 tests/splines/spline_traits.cpp               | 281 ++++++++++++++++++
 4 files changed, 402 insertions(+)
 create mode 100644 include/ddc/kernels/splines/spline_traits.hpp
 create mode 100644 tests/splines/spline_traits.cpp

diff --git a/include/ddc/kernels/splines.hpp b/include/ddc/kernels/splines.hpp
index 51e550fad..ca4777461 100644
--- a/include/ddc/kernels/splines.hpp
+++ b/include/ddc/kernels/splines.hpp
@@ -20,6 +20,7 @@
 #include "splines/spline_builder_2d.hpp"
 #include "splines/spline_evaluator.hpp"
 #include "splines/spline_evaluator_2d.hpp"
+#include "splines/spline_traits.hpp"
 #include "splines/splines_linear_problem.hpp"
 #include "splines/splines_linear_problem_2x2_blocks.hpp"
 #include "splines/splines_linear_problem_3x3_blocks.hpp"
diff --git a/include/ddc/kernels/splines/spline_traits.hpp b/include/ddc/kernels/splines/spline_traits.hpp
new file mode 100644
index 000000000..accb9fc44
--- /dev/null
+++ b/include/ddc/kernels/splines/spline_traits.hpp
@@ -0,0 +1,119 @@
+// Copyright (C) The DDC development team, see COPYRIGHT.md file
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cassert>
+#include <cstddef>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <ddc/ddc.hpp>
+#include "spline_builder.hpp"
+#include "spline_builder_2d.hpp"
+#include "spline_evaluator.hpp"
+#include "spline_evaluator_2d.hpp"
+
+namespace ddc {
+template <class T>
+struct is_spline_builder : std::false_type {};
+
+template <
+        class ExecSpace,
+        class MemorySpace,
+        class BSplines,
+        class InterpolationDDim,
+        ddc::BoundCond BcLower,
+        ddc::BoundCond BcUpper,
+        SplineSolver Solver>
+struct is_spline_builder<SplineBuilder<ExecSpace, MemorySpace, BSplines, InterpolationDDim, BcLower, BcUpper, Solver>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_spline_builder_v = is_spline_builder<T>::value;
+
+template <class T>
+struct is_spline_builder2D : std::false_type {};
+
+template <
+        class ExecSpace,
+        class MemorySpace,
+        class BSpline1,
+        class BSpline2,
+        class DDimI1,
+        class DDimI2,
+        ddc::BoundCond BcLower1,
+        ddc::BoundCond BcUpper1,
+        ddc::BoundCond BcLower2,
+        ddc::BoundCond BcUpper2,
+        ddc::SplineSolver Solver>
+struct is_spline_builder2D<SplineBuilder2D<ExecSpace, MemorySpace, BSpline1, BSpline2, DDimI1, DDimI2, BcLower1, BcUpper1, BcLower2, BcUpper2, Solver>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_spline_builder2D_v = is_spline_builder2D<T>::value;
+
+template <class T>
+struct is_spline_evaluator : std::false_type {};
+
+template <
+        class ExecSpace,
+        class MemorySpace,
+        class BSplines,
+        class EvaluationDDim,
+        class LowerExtrapolationRule,
+        class UpperExtrapolationRule>
+struct is_spline_evaluator<SplineEvaluator<ExecSpace, MemorySpace, BSplines, EvaluationDDim, LowerExtrapolationRule, UpperExtrapolationRule>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_spline_evaluator_v = is_spline_evaluator<T>::value;
+
+template <class T>
+struct is_spline_evaluator2D : std::false_type {};
+
+template <
+        class ExecSpace,
+        class MemorySpace,
+        class BSpline1,
+        class BSpline2,
+        class EvaluationDDim1,
+        class EvaluationDDim2,
+        class LowerExtrapolationRule1,
+        class UpperExtrapolationRule1,
+        class LowerExtrapolationRule2,
+        class UpperExtrapolationRule2>
+struct is_spline_evaluator2D<SplineEvaluator2D<ExecSpace, MemorySpace, BSpline1, BSpline2, EvaluationDDim1, EvaluationDDim2, LowerExtrapolationRule1, UpperExtrapolationRule1, LowerExtrapolationRule2, UpperExtrapolationRule2>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_spline_evaluator2D_v = is_spline_evaluator2D<T>::value;
+
+template <class Builder, class Evaluator, class Enable = void>
+struct is_spline_compatible : std::false_type {};
+
+template <class Builder, class Evaluator>
+struct is_spline_compatible<Builder, Evaluator,
+       std::enable_if_t<is_spline_builder_v<Builder> && is_spline_evaluator_v<Evaluator>
+                        || is_spline_builder_v<Evaluator> && is_spline_evaluator_v<Builder> >> {
+       static constexpr bool value = std::is_same_v<typename Builder::exec_space, typename Evaluator::exec_space> && 
+                                     std::is_same_v<typename Builder::memory_space, typename Evaluator::memory_space> &&
+                                     std::is_same_v<typename Builder::bsplines_type, typename Evaluator::bsplines_type>;
+};
+
+template <class Builder, class Evaluator>
+struct is_spline_compatible<Builder, Evaluator,
+       std::enable_if_t<is_spline_builder2D_v<Builder> && is_spline_evaluator2D_v<Evaluator>
+                        || is_spline_builder2D_v<Evaluator> && is_spline_evaluator2D_v<Builder> >> {
+       static constexpr bool value = std::is_same_v<typename Builder::exec_space, typename Evaluator::exec_space> && 
+                                     std::is_same_v<typename Builder::memory_space, typename Evaluator::memory_space> &&
+                                     std::is_same_v<typename Builder::bsplines_type1, typename Evaluator::bsplines_type1> &&
+                                     std::is_same_v<typename Builder::bsplines_type2, typename Evaluator::bsplines_type2>;
+};
+
+template <class Builder, class Evaluator>
+inline constexpr bool is_spline_compatible_v = is_spline_compatible<Builder, Evaluator>::value;
+
+} // namespace ddc
+
diff --git a/tests/splines/CMakeLists.txt b/tests/splines/CMakeLists.txt
index 3e1c99f83..519e4bbe6 100644
--- a/tests/splines/CMakeLists.txt
+++ b/tests/splines/CMakeLists.txt
@@ -16,6 +16,7 @@ add_executable(
     knots_as_interpolation_points.cpp
     splines_linear_problem.cpp
     spline_builder.cpp
+    spline_traits.cpp
     view.cpp
 )
 target_compile_features(splines_tests PUBLIC cxx_std_17)
diff --git a/tests/splines/spline_traits.cpp b/tests/splines/spline_traits.cpp
new file mode 100644
index 000000000..60b75b583
--- /dev/null
+++ b/tests/splines/spline_traits.cpp
@@ -0,0 +1,281 @@
+// Copyright (C) The DDC development team, see COPYRIGHT.md file
+//
+// SPDX-License-Identifier: MIT
+
+#include <cstddef>
+#include <stdexcept>
+#include <vector>
+
+#include <ddc/ddc.hpp>
+#include <ddc/kernels/splines.hpp>
+
+#include <gtest/gtest.h>
+
+#include <Kokkos_Core.hpp>
+#include "test_utils.hpp"
+
+struct DimX
+{
+    static constexpr bool PERIODIC = true;
+};
+
+struct DDimX : ddc::NonUniformPointSampling<DimX>
+{
+};
+
+struct DimY
+{
+    static constexpr bool PERIODIC = true;
+};
+
+struct DDimY : ddc::NonUniformPointSampling<DimY>
+{
+};
+
+template <typename T>
+struct BSplinesTraits;
+
+template <typename ExecSpace1, std::size_t D1, typename ExecSpace2, std::size_t D2>
+struct BSplinesTraits<std::tuple<ExecSpace1, std::integral_constant<std::size_t, D1>, ExecSpace2, std::integral_constant<std::size_t, D2>>> : public ::testing::Test {
+  using execution_space1 = ExecSpace1;
+  using execution_space2 = ExecSpace2;
+  using memory_space1 = typename ExecSpace1::memory_space;
+  using memory_space2 = typename ExecSpace2::memory_space;
+  static constexpr std::size_t m_spline_degree1 = D1;
+  static constexpr std::size_t m_spline_degree2 = D2;
+
+  struct BSplinesX1 : ddc::UniformBSplines<DimX, D1>
+  {
+  };
+
+  struct BSplinesX2 : ddc::UniformBSplines<DimX, D2>
+  {
+  };
+
+  struct BSplinesY : ddc::UniformBSplines<DimY, D1>
+  {
+  };
+  
+  using Builder1D_1 = ddc::SplineBuilder<
+                    execution_space1,
+                    memory_space1,
+                    BSplinesX1,
+                    DDimX,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::SplineSolver::LAPACK>;
+
+  using Evaluator1D_1 = ddc::SplineEvaluator<
+                    execution_space1,
+                    memory_space1,
+                    BSplinesX1,
+                    DDimX,
+                    ddc::PeriodicExtrapolationRule<DimX>,
+                    ddc::PeriodicExtrapolationRule<DimX>>;
+
+  using Builder1D_2 = ddc::SplineBuilder<
+                    execution_space2,
+                    memory_space2,
+                    BSplinesX2,
+                    DDimX,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::SplineSolver::LAPACK>;
+
+  using Evaluator1D_2 = ddc::SplineEvaluator<
+                    execution_space2,
+                    memory_space2,
+                    BSplinesX2,
+                    DDimX,
+                    ddc::PeriodicExtrapolationRule<DimX>,
+                    ddc::PeriodicExtrapolationRule<DimX>>;
+
+  using Builder2D_1 = ddc::SplineBuilder2D<
+                    execution_space1,
+                    memory_space1,
+                    BSplinesX1,
+                    BSplinesY,
+                    DDimX,
+                    DDimY,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::SplineSolver::LAPACK>;
+
+  using Evaluator2D_1 = ddc::SplineEvaluator2D<
+                    execution_space1,
+                    memory_space1,
+                    BSplinesX1,
+                    BSplinesY,
+                    DDimX,
+                    DDimY,
+                    ddc::PeriodicExtrapolationRule<DimX>,
+                    ddc::PeriodicExtrapolationRule<DimX>,
+                    ddc::PeriodicExtrapolationRule<DimY>,
+                    ddc::PeriodicExtrapolationRule<DimY>>;
+
+  using Builder2D_2 = ddc::SplineBuilder2D<
+                    execution_space2,
+                    memory_space2,
+                    BSplinesX2,
+                    BSplinesY,
+                    DDimX,
+                    DDimY,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::BoundCond::PERIODIC,
+                    ddc::SplineSolver::LAPACK>;
+
+  using Evaluator2D_2 = ddc::SplineEvaluator2D<
+                    execution_space2,
+                    memory_space2,
+                    BSplinesX2,
+                    BSplinesY,
+                    DDimX,
+                    DDimY,
+                    ddc::PeriodicExtrapolationRule<DimX>,
+                    ddc::PeriodicExtrapolationRule<DimX>,
+                    ddc::PeriodicExtrapolationRule<DimY>,
+                    ddc::PeriodicExtrapolationRule<DimY>>;
+};
+
+#if defined(KOKKOS_ENABLE_SERIAL)
+using execution_space_types = std::tuple<Kokkos::Serial, Kokkos::DefaultHostExecutionSpace, Kokkos::DefaultExecutionSpace>;
+#else
+using execution_space_types = std::tuple<Kokkos::DefaultHostExecutionSpace, Kokkos::DefaultExecutionSpace>;
+#endif
+
+using spline_degrees = std::integer_sequence<std::size_t, 2, 3>;
+
+using TestTypes = tuple_to_types_t<cartesian_product_t<execution_space_types, spline_degrees, execution_space_types, spline_degrees>>;
+
+TYPED_TEST_SUITE(BSplinesTraits, TestTypes, );
+
+TYPED_TEST(BSplinesTraits, IsSplineBuilder)
+{
+    using Builder1D = typename TestFixture::Builder1D_1;
+    using Evaluator1D = typename TestFixture::Evaluator1D_1;
+    using Builder2D = typename TestFixture::Builder2D_1;
+    using Evaluator2D = typename TestFixture::Evaluator2D_1;
+    ASSERT_TRUE(ddc::is_spline_builder_v<Builder1D>);
+    ASSERT_FALSE(ddc::is_spline_builder_v<Builder2D>);
+    ASSERT_FALSE(ddc::is_spline_builder_v<Evaluator1D>);
+    ASSERT_FALSE(ddc::is_spline_builder_v<Evaluator2D>);
+}
+
+TYPED_TEST(BSplinesTraits, IsSplineBuilder2D)
+{
+    using Builder1D = typename TestFixture::Builder1D_1;
+    using Evaluator1D = typename TestFixture::Evaluator1D_1;
+    using Builder2D = typename TestFixture::Builder2D_1;
+    using Evaluator2D = typename TestFixture::Evaluator2D_1;
+    ASSERT_FALSE(ddc::is_spline_builder2D_v<Builder1D>);
+    ASSERT_TRUE(ddc::is_spline_builder2D_v<Builder2D>);
+    ASSERT_FALSE(ddc::is_spline_builder2D_v<Evaluator1D>);
+    ASSERT_FALSE(ddc::is_spline_builder2D_v<Evaluator2D>);
+}
+
+TYPED_TEST(BSplinesTraits, IsSplineEvaluator)
+{
+    using Builder1D = typename TestFixture::Builder1D_1;
+    using Evaluator1D = typename TestFixture::Evaluator1D_1;
+    using Builder2D = typename TestFixture::Builder2D_1;
+    using Evaluator2D = typename TestFixture::Evaluator2D_1;
+    ASSERT_FALSE(ddc::is_spline_evaluator_v<Builder1D>);
+    ASSERT_FALSE(ddc::is_spline_evaluator_v<Builder2D>);
+    ASSERT_TRUE(ddc::is_spline_evaluator_v<Evaluator1D>);
+    ASSERT_FALSE(ddc::is_spline_evaluator_v<Evaluator2D>);
+}
+
+TYPED_TEST(BSplinesTraits, IsSplineEvaluator2D)
+{
+    using Builder1D = typename TestFixture::Builder1D_1;
+    using Evaluator1D = typename TestFixture::Evaluator1D_1;
+    using Builder2D = typename TestFixture::Builder2D_1;
+    using Evaluator2D = typename TestFixture::Evaluator2D_1;
+    ASSERT_FALSE(ddc::is_spline_evaluator2D_v<Builder1D>);
+    ASSERT_FALSE(ddc::is_spline_evaluator2D_v<Builder2D>);
+    ASSERT_FALSE(ddc::is_spline_evaluator2D_v<Evaluator1D>);
+    ASSERT_TRUE(ddc::is_spline_evaluator2D_v<Evaluator2D>);
+}
+
+TYPED_TEST(BSplinesTraits, IsCompatible1D)
+{
+    using Builder1D_1 = typename TestFixture::Builder1D_1;
+    using Evaluator1D_1 = typename TestFixture::Evaluator1D_1;
+    using Builder1D_2 = typename TestFixture::Builder1D_2;
+    using Evaluator1D_2 = typename TestFixture::Evaluator1D_2;
+
+    // Builders are not compatible
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_1, Builder1D_1>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_1, Builder1D_2>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_2, Builder1D_1>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_2, Builder1D_2>));
+
+    // Evaluators are not compatible
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_1, Evaluator1D_1>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_1, Evaluator1D_2>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_2, Evaluator1D_1>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_2, Evaluator1D_2>));
+
+    // Compatible builder and evaluator pairs
+    ASSERT_TRUE((ddc::is_spline_compatible_v<Builder1D_1, Evaluator1D_1>));
+    ASSERT_TRUE((ddc::is_spline_compatible_v<Evaluator1D_1, Builder1D_1>));
+    ASSERT_TRUE((ddc::is_spline_compatible_v<Builder1D_2, Evaluator1D_2>));
+    ASSERT_TRUE((ddc::is_spline_compatible_v<Evaluator1D_2, Builder1D_2>));
+
+    // Incompatible builder and evaluator pairs
+    using execution_space1 = typename TestFixture::execution_space1;
+    using execution_space2 = typename TestFixture::execution_space2;
+    std::size_t constexpr m_spline_degree1 = TestFixture::m_spline_degree1;
+    std::size_t constexpr m_spline_degree2 = TestFixture::m_spline_degree2;
+
+    if ((!std::is_same_v<execution_space1, execution_space2>) || (m_spline_degree1 != m_spline_degree2)) {
+      ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_1, Evaluator1D_2>));
+      ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_2, Builder1D_1>));
+      ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_2, Evaluator1D_1>));
+      ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_1, Builder1D_2>));
+    }
+}
+
+TYPED_TEST(BSplinesTraits, IsCompatible2D)
+{
+    using Builder2D_1 = typename TestFixture::Builder2D_1;
+    using Evaluator2D_1 = typename TestFixture::Evaluator2D_1;
+    using Builder2D_2 = typename TestFixture::Builder2D_2;
+    using Evaluator2D_2 = typename TestFixture::Evaluator2D_2;
+
+    // Builders are not compatible
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_1, Builder2D_1>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_1, Builder2D_2>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_2, Builder2D_1>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_2, Builder2D_2>));
+
+    // Evaluators are not compatible
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_1, Evaluator2D_1>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_1, Evaluator2D_2>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_2, Evaluator2D_1>));
+    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_2, Evaluator2D_2>));
+
+    // Compatible builder and evaluator pairs
+    ASSERT_TRUE((ddc::is_spline_compatible_v<Builder2D_1, Evaluator2D_1>));
+    ASSERT_TRUE((ddc::is_spline_compatible_v<Evaluator2D_1, Builder2D_1>));
+    ASSERT_TRUE((ddc::is_spline_compatible_v<Builder2D_2, Evaluator2D_2>));
+    ASSERT_TRUE((ddc::is_spline_compatible_v<Evaluator2D_2, Builder2D_2>));
+
+    // Incompatible builder and evaluator pairs
+    using execution_space1 = typename TestFixture::execution_space1;
+    using execution_space2 = typename TestFixture::execution_space2;
+    std::size_t constexpr m_spline_degree1 = TestFixture::m_spline_degree1;
+    std::size_t constexpr m_spline_degree2 = TestFixture::m_spline_degree2;
+
+    if ((!std::is_same_v<execution_space1, execution_space2>) || (m_spline_degree1 != m_spline_degree2)) {
+      ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_1, Evaluator2D_2>));
+      ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_2, Builder2D_1>));
+      ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_2, Evaluator2D_1>));
+      ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_1, Builder2D_2>));
+    }
+}
+

From 3481a3f3e54d545dbdec84e44caf09c485f3eabe Mon Sep 17 00:00:00 2001
From: Yuuichi Asahi <yuuichi.asahi@cea.fr>
Date: Mon, 23 Jun 2025 16:20:17 +0200
Subject: [PATCH 2/6] rename and add docstrings

---
 include/ddc/kernels/splines/spline_traits.hpp | 81 +++++++++++++------
 tests/splines/spline_traits.cpp               | 68 ++++++++--------
 2 files changed, 91 insertions(+), 58 deletions(-)

diff --git a/include/ddc/kernels/splines/spline_traits.hpp b/include/ddc/kernels/splines/spline_traits.hpp
index accb9fc44..c3f2e0ece 100644
--- a/include/ddc/kernels/splines/spline_traits.hpp
+++ b/include/ddc/kernels/splines/spline_traits.hpp
@@ -33,7 +33,11 @@ template <
         SplineSolver Solver>
 struct is_spline_builder<SplineBuilder<ExecSpace, MemorySpace, BSplines, InterpolationDDim, BcLower, BcUpper, Solver>> : std::true_type {};
 
-template <typename T>
+/**
+ *  @brief A helper to check if T is a SplineBuilder
+ *  @tparam T The type to be checked if is a SplineBuilder
+ */
+template <class T>
 inline constexpr bool is_spline_builder_v = is_spline_builder<T>::value;
 
 template <class T>
@@ -53,7 +57,11 @@ template <
         ddc::SplineSolver Solver>
 struct is_spline_builder2D<SplineBuilder2D<ExecSpace, MemorySpace, BSpline1, BSpline2, DDimI1, DDimI2, BcLower1, BcUpper1, BcLower2, BcUpper2, Solver>> : std::true_type {};
 
-template <typename T>
+/**
+ *  @brief A helper to check if T is a SplineBuilder2D
+ *  @tparam T The type to be checked if is a SplineBuilder2D
+ */
+template <class T>
 inline constexpr bool is_spline_builder2D_v = is_spline_builder2D<T>::value;
 
 template <class T>
@@ -68,7 +76,11 @@ template <
         class UpperExtrapolationRule>
 struct is_spline_evaluator<SplineEvaluator<ExecSpace, MemorySpace, BSplines, EvaluationDDim, LowerExtrapolationRule, UpperExtrapolationRule>> : std::true_type {};
 
-template <typename T>
+/**
+ *  @brief A helper to check if T is a SplineEvaluator
+ *  @tparam T The type to be checked if is a SplineEvalutor
+ */
+template <class T>
 inline constexpr bool is_spline_evaluator_v = is_spline_evaluator<T>::value;
 
 template <class T>
@@ -87,33 +99,54 @@ template <
         class UpperExtrapolationRule2>
 struct is_spline_evaluator2D<SplineEvaluator2D<ExecSpace, MemorySpace, BSpline1, BSpline2, EvaluationDDim1, EvaluationDDim2, LowerExtrapolationRule1, UpperExtrapolationRule1, LowerExtrapolationRule2, UpperExtrapolationRule2>> : std::true_type {};
 
-template <typename T>
+/**
+ *  @brief A helper to check if T is a SplineEvaluator2D
+ *  @tparam T The type to be checked if is a SplineEvalutor2D
+ */
+template <class T>
 inline constexpr bool is_spline_evaluator2D_v = is_spline_evaluator2D<T>::value;
 
-template <class Builder, class Evaluator, class Enable = void>
-struct is_spline_compatible : std::false_type {};
-
 template <class Builder, class Evaluator>
-struct is_spline_compatible<Builder, Evaluator,
-       std::enable_if_t<is_spline_builder_v<Builder> && is_spline_evaluator_v<Evaluator>
-                        || is_spline_builder_v<Evaluator> && is_spline_evaluator_v<Builder> >> {
-       static constexpr bool value = std::is_same_v<typename Builder::exec_space, typename Evaluator::exec_space> && 
-                                     std::is_same_v<typename Builder::memory_space, typename Evaluator::memory_space> &&
-                                     std::is_same_v<typename Builder::bsplines_type, typename Evaluator::bsplines_type>;
-};
+struct is_evaluator_admissible : std::false_type {};
 
-template <class Builder, class Evaluator>
-struct is_spline_compatible<Builder, Evaluator,
-       std::enable_if_t<is_spline_builder2D_v<Builder> && is_spline_evaluator2D_v<Evaluator>
-                        || is_spline_builder2D_v<Evaluator> && is_spline_evaluator2D_v<Builder> >> {
-       static constexpr bool value = std::is_same_v<typename Builder::exec_space, typename Evaluator::exec_space> && 
-                                     std::is_same_v<typename Builder::memory_space, typename Evaluator::memory_space> &&
-                                     std::is_same_v<typename Builder::bsplines_type1, typename Evaluator::bsplines_type1> &&
-                                     std::is_same_v<typename Builder::bsplines_type2, typename Evaluator::bsplines_type2>;
-};
+template <
+        class ExecSpace,
+        class MemorySpace,
+        class BSplines,
+        class InterpolationDDim,
+        ddc::BoundCond BcLower,
+        ddc::BoundCond BcUpper,
+        SplineSolver Solver,
+        class LowerExtrapolationRule,
+        class UpperExtrapolationRule>
+struct is_evaluator_admissible<SplineBuilder<ExecSpace, MemorySpace, BSplines, InterpolationDDim, BcLower, BcUpper, Solver>, SplineEvaluator<ExecSpace, MemorySpace, BSplines, InterpolationDDim, LowerExtrapolationRule, UpperExtrapolationRule>> : std::true_type {};
 
+template <
+        class ExecSpace,
+        class MemorySpace,
+        class BSplines1,
+        class BSplines2,
+        class DDimI1,
+        class DDimI2,
+        ddc::BoundCond BcLower1,
+        ddc::BoundCond BcUpper1,
+        ddc::BoundCond BcLower2,
+        ddc::BoundCond BcUpper2,
+        SplineSolver Solver,
+        class LowerExtrapolationRule1,
+        class UpperExtrapolationRule1,
+        class LowerExtrapolationRule2,
+        class UpperExtrapolationRule2>
+struct is_evaluator_admissible<SplineBuilder2D<ExecSpace, MemorySpace, BSplines1, BSplines2, DDimI1, DDimI2, BcLower1, BcUpper1, BcLower2, BcUpper2, Solver>,
+                               SplineEvaluator2D<ExecSpace, MemorySpace, BSplines1, BSplines2, DDimI1, DDimI2, LowerExtrapolationRule1, UpperExtrapolationRule1, LowerExtrapolationRule2, UpperExtrapolationRule2>> : std::true_type {};
+
+/**
+ *  @brief A helper to check if SplineEvalutor is admissible for SplineBuilder
+ *  @tparam Builder The builder type to be checked if it is admissible for Evaluator
+ *  @tparam Evaluator The evaluator type to be checked if it is admissible for Builder
+ */
 template <class Builder, class Evaluator>
-inline constexpr bool is_spline_compatible_v = is_spline_compatible<Builder, Evaluator>::value;
+inline constexpr bool is_evaluator_admissible_v = is_evaluator_admissible<Builder, Evaluator>::value;
 
 } // namespace ddc
 
diff --git a/tests/splines/spline_traits.cpp b/tests/splines/spline_traits.cpp
index 60b75b583..31769a7c2 100644
--- a/tests/splines/spline_traits.cpp
+++ b/tests/splines/spline_traits.cpp
@@ -201,7 +201,7 @@ TYPED_TEST(BSplinesTraits, IsSplineEvaluator2D)
     ASSERT_TRUE(ddc::is_spline_evaluator2D_v<Evaluator2D>);
 }
 
-TYPED_TEST(BSplinesTraits, IsCompatible1D)
+TYPED_TEST(BSplinesTraits, IsAdmissible1D)
 {
     using Builder1D_1 = typename TestFixture::Builder1D_1;
     using Evaluator1D_1 = typename TestFixture::Evaluator1D_1;
@@ -209,22 +209,22 @@ TYPED_TEST(BSplinesTraits, IsCompatible1D)
     using Evaluator1D_2 = typename TestFixture::Evaluator1D_2;
 
     // Builders are not compatible
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_1, Builder1D_1>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_1, Builder1D_2>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_2, Builder1D_1>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_2, Builder1D_2>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder1D_1, Builder1D_1>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder1D_1, Builder1D_2>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder1D_2, Builder1D_1>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder1D_2, Builder1D_2>));
 
     // Evaluators are not compatible
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_1, Evaluator1D_1>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_1, Evaluator1D_2>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_2, Evaluator1D_1>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_2, Evaluator1D_2>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_1, Evaluator1D_1>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_1, Evaluator1D_2>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_2, Evaluator1D_1>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_2, Evaluator1D_2>));
 
     // Compatible builder and evaluator pairs
-    ASSERT_TRUE((ddc::is_spline_compatible_v<Builder1D_1, Evaluator1D_1>));
-    ASSERT_TRUE((ddc::is_spline_compatible_v<Evaluator1D_1, Builder1D_1>));
-    ASSERT_TRUE((ddc::is_spline_compatible_v<Builder1D_2, Evaluator1D_2>));
-    ASSERT_TRUE((ddc::is_spline_compatible_v<Evaluator1D_2, Builder1D_2>));
+    ASSERT_TRUE((ddc::is_evaluator_admissible_v<Builder1D_1, Evaluator1D_1>));
+    ASSERT_TRUE((ddc::is_evaluator_admissible_v<Builder1D_2, Evaluator1D_2>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_1, Builder1D_1>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_2, Builder1D_2>));
 
     // Incompatible builder and evaluator pairs
     using execution_space1 = typename TestFixture::execution_space1;
@@ -233,14 +233,14 @@ TYPED_TEST(BSplinesTraits, IsCompatible1D)
     std::size_t constexpr m_spline_degree2 = TestFixture::m_spline_degree2;
 
     if ((!std::is_same_v<execution_space1, execution_space2>) || (m_spline_degree1 != m_spline_degree2)) {
-      ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_1, Evaluator1D_2>));
-      ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_2, Builder1D_1>));
-      ASSERT_FALSE((ddc::is_spline_compatible_v<Builder1D_2, Evaluator1D_1>));
-      ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator1D_1, Builder1D_2>));
+      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder1D_1, Evaluator1D_2>));
+      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_2, Builder1D_1>));
+      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder1D_2, Evaluator1D_1>));
+      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_1, Builder1D_2>));
     }
 }
 
-TYPED_TEST(BSplinesTraits, IsCompatible2D)
+TYPED_TEST(BSplinesTraits, IsAdmissible2D)
 {
     using Builder2D_1 = typename TestFixture::Builder2D_1;
     using Evaluator2D_1 = typename TestFixture::Evaluator2D_1;
@@ -248,22 +248,22 @@ TYPED_TEST(BSplinesTraits, IsCompatible2D)
     using Evaluator2D_2 = typename TestFixture::Evaluator2D_2;
 
     // Builders are not compatible
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_1, Builder2D_1>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_1, Builder2D_2>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_2, Builder2D_1>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_2, Builder2D_2>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder2D_1, Builder2D_1>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder2D_1, Builder2D_2>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder2D_2, Builder2D_1>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder2D_2, Builder2D_2>));
 
     // Evaluators are not compatible
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_1, Evaluator2D_1>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_1, Evaluator2D_2>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_2, Evaluator2D_1>));
-    ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_2, Evaluator2D_2>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_1, Evaluator2D_1>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_1, Evaluator2D_2>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_2, Evaluator2D_1>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_2, Evaluator2D_2>));
 
     // Compatible builder and evaluator pairs
-    ASSERT_TRUE((ddc::is_spline_compatible_v<Builder2D_1, Evaluator2D_1>));
-    ASSERT_TRUE((ddc::is_spline_compatible_v<Evaluator2D_1, Builder2D_1>));
-    ASSERT_TRUE((ddc::is_spline_compatible_v<Builder2D_2, Evaluator2D_2>));
-    ASSERT_TRUE((ddc::is_spline_compatible_v<Evaluator2D_2, Builder2D_2>));
+    ASSERT_TRUE((ddc::is_evaluator_admissible_v<Builder2D_1, Evaluator2D_1>));
+    ASSERT_TRUE((ddc::is_evaluator_admissible_v<Builder2D_2, Evaluator2D_2>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_1, Builder2D_1>));
+    ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_2, Builder2D_2>));
 
     // Incompatible builder and evaluator pairs
     using execution_space1 = typename TestFixture::execution_space1;
@@ -272,10 +272,10 @@ TYPED_TEST(BSplinesTraits, IsCompatible2D)
     std::size_t constexpr m_spline_degree2 = TestFixture::m_spline_degree2;
 
     if ((!std::is_same_v<execution_space1, execution_space2>) || (m_spline_degree1 != m_spline_degree2)) {
-      ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_1, Evaluator2D_2>));
-      ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_2, Builder2D_1>));
-      ASSERT_FALSE((ddc::is_spline_compatible_v<Builder2D_2, Evaluator2D_1>));
-      ASSERT_FALSE((ddc::is_spline_compatible_v<Evaluator2D_1, Builder2D_2>));
+      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder2D_1, Evaluator2D_2>));
+      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_2, Builder2D_1>));
+      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder2D_2, Evaluator2D_1>));
+      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_1, Builder2D_2>));
     }
 }
 

From db1b69ab92bef4db8ea8aa4de9451c3852ee613c Mon Sep 17 00:00:00 2001
From: Yuuichi Asahi <yuuichi.asahi@cea.fr>
Date: Mon, 23 Jun 2025 16:28:32 +0200
Subject: [PATCH 3/6] Fix: typo

---
 include/ddc/kernels/splines/spline_traits.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/ddc/kernels/splines/spline_traits.hpp b/include/ddc/kernels/splines/spline_traits.hpp
index c3f2e0ece..7363da10f 100644
--- a/include/ddc/kernels/splines/spline_traits.hpp
+++ b/include/ddc/kernels/splines/spline_traits.hpp
@@ -78,7 +78,7 @@ struct is_spline_evaluator<SplineEvaluator<ExecSpace, MemorySpace, BSplines, Eva
 
 /**
  *  @brief A helper to check if T is a SplineEvaluator
- *  @tparam T The type to be checked if is a SplineEvalutor
+ *  @tparam T The type to be checked if is a SplineEvaluator
  */
 template <class T>
 inline constexpr bool is_spline_evaluator_v = is_spline_evaluator<T>::value;
@@ -101,7 +101,7 @@ struct is_spline_evaluator2D<SplineEvaluator2D<ExecSpace, MemorySpace, BSpline1,
 
 /**
  *  @brief A helper to check if T is a SplineEvaluator2D
- *  @tparam T The type to be checked if is a SplineEvalutor2D
+ *  @tparam T The type to be checked if is a SplineEvaluator2D
  */
 template <class T>
 inline constexpr bool is_spline_evaluator2D_v = is_spline_evaluator2D<T>::value;
@@ -141,7 +141,7 @@ struct is_evaluator_admissible<SplineBuilder2D<ExecSpace, MemorySpace, BSplines1
                                SplineEvaluator2D<ExecSpace, MemorySpace, BSplines1, BSplines2, DDimI1, DDimI2, LowerExtrapolationRule1, UpperExtrapolationRule1, LowerExtrapolationRule2, UpperExtrapolationRule2>> : std::true_type {};
 
 /**
- *  @brief A helper to check if SplineEvalutor is admissible for SplineBuilder
+ *  @brief A helper to check if SplineEvaluator is admissible for SplineBuilder
  *  @tparam Builder The builder type to be checked if it is admissible for Evaluator
  *  @tparam Evaluator The evaluator type to be checked if it is admissible for Builder
  */

From 8c2c7ba32a47eb749eb0b311a65d41714474e7ae Mon Sep 17 00:00:00 2001
From: Thomas Padioleau <thomas.padioleau@cea.fr>
Date: Mon, 23 Jun 2025 16:29:17 +0200
Subject: [PATCH 4/6] Format

---
 include/ddc/kernels/splines/spline_traits.hpp | 122 ++++++++-
 tests/splines/spline_traits.cpp               | 247 +++++++++---------
 2 files changed, 238 insertions(+), 131 deletions(-)

diff --git a/include/ddc/kernels/splines/spline_traits.hpp b/include/ddc/kernels/splines/spline_traits.hpp
index 7363da10f..c4f1632ac 100644
--- a/include/ddc/kernels/splines/spline_traits.hpp
+++ b/include/ddc/kernels/splines/spline_traits.hpp
@@ -14,6 +14,7 @@
 #include <utility>
 
 #include <ddc/ddc.hpp>
+
 #include "spline_builder.hpp"
 #include "spline_builder_2d.hpp"
 #include "spline_evaluator.hpp"
@@ -21,7 +22,9 @@
 
 namespace ddc {
 template <class T>
-struct is_spline_builder : std::false_type {};
+struct is_spline_builder : std::false_type
+{
+};
 
 template <
         class ExecSpace,
@@ -31,7 +34,16 @@ template <
         ddc::BoundCond BcLower,
         ddc::BoundCond BcUpper,
         SplineSolver Solver>
-struct is_spline_builder<SplineBuilder<ExecSpace, MemorySpace, BSplines, InterpolationDDim, BcLower, BcUpper, Solver>> : std::true_type {};
+struct is_spline_builder<SplineBuilder<
+        ExecSpace,
+        MemorySpace,
+        BSplines,
+        InterpolationDDim,
+        BcLower,
+        BcUpper,
+        Solver>> : std::true_type
+{
+};
 
 /**
  *  @brief A helper to check if T is a SplineBuilder
@@ -41,7 +53,9 @@ template <class T>
 inline constexpr bool is_spline_builder_v = is_spline_builder<T>::value;
 
 template <class T>
-struct is_spline_builder2D : std::false_type {};
+struct is_spline_builder2D : std::false_type
+{
+};
 
 template <
         class ExecSpace,
@@ -55,7 +69,20 @@ template <
         ddc::BoundCond BcLower2,
         ddc::BoundCond BcUpper2,
         ddc::SplineSolver Solver>
-struct is_spline_builder2D<SplineBuilder2D<ExecSpace, MemorySpace, BSpline1, BSpline2, DDimI1, DDimI2, BcLower1, BcUpper1, BcLower2, BcUpper2, Solver>> : std::true_type {};
+struct is_spline_builder2D<SplineBuilder2D<
+        ExecSpace,
+        MemorySpace,
+        BSpline1,
+        BSpline2,
+        DDimI1,
+        DDimI2,
+        BcLower1,
+        BcUpper1,
+        BcLower2,
+        BcUpper2,
+        Solver>> : std::true_type
+{
+};
 
 /**
  *  @brief A helper to check if T is a SplineBuilder2D
@@ -65,7 +92,9 @@ template <class T>
 inline constexpr bool is_spline_builder2D_v = is_spline_builder2D<T>::value;
 
 template <class T>
-struct is_spline_evaluator : std::false_type {};
+struct is_spline_evaluator : std::false_type
+{
+};
 
 template <
         class ExecSpace,
@@ -74,7 +103,15 @@ template <
         class EvaluationDDim,
         class LowerExtrapolationRule,
         class UpperExtrapolationRule>
-struct is_spline_evaluator<SplineEvaluator<ExecSpace, MemorySpace, BSplines, EvaluationDDim, LowerExtrapolationRule, UpperExtrapolationRule>> : std::true_type {};
+struct is_spline_evaluator<SplineEvaluator<
+        ExecSpace,
+        MemorySpace,
+        BSplines,
+        EvaluationDDim,
+        LowerExtrapolationRule,
+        UpperExtrapolationRule>> : std::true_type
+{
+};
 
 /**
  *  @brief A helper to check if T is a SplineEvaluator
@@ -84,7 +121,9 @@ template <class T>
 inline constexpr bool is_spline_evaluator_v = is_spline_evaluator<T>::value;
 
 template <class T>
-struct is_spline_evaluator2D : std::false_type {};
+struct is_spline_evaluator2D : std::false_type
+{
+};
 
 template <
         class ExecSpace,
@@ -97,7 +136,19 @@ template <
         class UpperExtrapolationRule1,
         class LowerExtrapolationRule2,
         class UpperExtrapolationRule2>
-struct is_spline_evaluator2D<SplineEvaluator2D<ExecSpace, MemorySpace, BSpline1, BSpline2, EvaluationDDim1, EvaluationDDim2, LowerExtrapolationRule1, UpperExtrapolationRule1, LowerExtrapolationRule2, UpperExtrapolationRule2>> : std::true_type {};
+struct is_spline_evaluator2D<SplineEvaluator2D<
+        ExecSpace,
+        MemorySpace,
+        BSpline1,
+        BSpline2,
+        EvaluationDDim1,
+        EvaluationDDim2,
+        LowerExtrapolationRule1,
+        UpperExtrapolationRule1,
+        LowerExtrapolationRule2,
+        UpperExtrapolationRule2>> : std::true_type
+{
+};
 
 /**
  *  @brief A helper to check if T is a SplineEvaluator2D
@@ -107,7 +158,9 @@ template <class T>
 inline constexpr bool is_spline_evaluator2D_v = is_spline_evaluator2D<T>::value;
 
 template <class Builder, class Evaluator>
-struct is_evaluator_admissible : std::false_type {};
+struct is_evaluator_admissible : std::false_type
+{
+};
 
 template <
         class ExecSpace,
@@ -119,7 +172,24 @@ template <
         SplineSolver Solver,
         class LowerExtrapolationRule,
         class UpperExtrapolationRule>
-struct is_evaluator_admissible<SplineBuilder<ExecSpace, MemorySpace, BSplines, InterpolationDDim, BcLower, BcUpper, Solver>, SplineEvaluator<ExecSpace, MemorySpace, BSplines, InterpolationDDim, LowerExtrapolationRule, UpperExtrapolationRule>> : std::true_type {};
+struct is_evaluator_admissible<
+        SplineBuilder<
+                ExecSpace,
+                MemorySpace,
+                BSplines,
+                InterpolationDDim,
+                BcLower,
+                BcUpper,
+                Solver>,
+        SplineEvaluator<
+                ExecSpace,
+                MemorySpace,
+                BSplines,
+                InterpolationDDim,
+                LowerExtrapolationRule,
+                UpperExtrapolationRule>> : std::true_type
+{
+};
 
 template <
         class ExecSpace,
@@ -137,8 +207,32 @@ template <
         class UpperExtrapolationRule1,
         class LowerExtrapolationRule2,
         class UpperExtrapolationRule2>
-struct is_evaluator_admissible<SplineBuilder2D<ExecSpace, MemorySpace, BSplines1, BSplines2, DDimI1, DDimI2, BcLower1, BcUpper1, BcLower2, BcUpper2, Solver>,
-                               SplineEvaluator2D<ExecSpace, MemorySpace, BSplines1, BSplines2, DDimI1, DDimI2, LowerExtrapolationRule1, UpperExtrapolationRule1, LowerExtrapolationRule2, UpperExtrapolationRule2>> : std::true_type {};
+struct is_evaluator_admissible<
+        SplineBuilder2D<
+                ExecSpace,
+                MemorySpace,
+                BSplines1,
+                BSplines2,
+                DDimI1,
+                DDimI2,
+                BcLower1,
+                BcUpper1,
+                BcLower2,
+                BcUpper2,
+                Solver>,
+        SplineEvaluator2D<
+                ExecSpace,
+                MemorySpace,
+                BSplines1,
+                BSplines2,
+                DDimI1,
+                DDimI2,
+                LowerExtrapolationRule1,
+                UpperExtrapolationRule1,
+                LowerExtrapolationRule2,
+                UpperExtrapolationRule2>> : std::true_type
+{
+};
 
 /**
  *  @brief A helper to check if SplineEvaluator is admissible for SplineBuilder
@@ -146,7 +240,7 @@ struct is_evaluator_admissible<SplineBuilder2D<ExecSpace, MemorySpace, BSplines1
  *  @tparam Evaluator The evaluator type to be checked if it is admissible for Builder
  */
 template <class Builder, class Evaluator>
-inline constexpr bool is_evaluator_admissible_v = is_evaluator_admissible<Builder, Evaluator>::value;
+inline constexpr bool is_evaluator_admissible_v
+        = is_evaluator_admissible<Builder, Evaluator>::value;
 
 } // namespace ddc
-
diff --git a/tests/splines/spline_traits.cpp b/tests/splines/spline_traits.cpp
index 31769a7c2..78ea4c9cd 100644
--- a/tests/splines/spline_traits.cpp
+++ b/tests/splines/spline_traits.cpp
@@ -12,6 +12,7 @@
 #include <gtest/gtest.h>
 
 #include <Kokkos_Core.hpp>
+
 #include "test_utils.hpp"
 
 struct DimX
@@ -36,120 +37,131 @@ template <typename T>
 struct BSplinesTraits;
 
 template <typename ExecSpace1, std::size_t D1, typename ExecSpace2, std::size_t D2>
-struct BSplinesTraits<std::tuple<ExecSpace1, std::integral_constant<std::size_t, D1>, ExecSpace2, std::integral_constant<std::size_t, D2>>> : public ::testing::Test {
-  using execution_space1 = ExecSpace1;
-  using execution_space2 = ExecSpace2;
-  using memory_space1 = typename ExecSpace1::memory_space;
-  using memory_space2 = typename ExecSpace2::memory_space;
-  static constexpr std::size_t m_spline_degree1 = D1;
-  static constexpr std::size_t m_spline_degree2 = D2;
-
-  struct BSplinesX1 : ddc::UniformBSplines<DimX, D1>
-  {
-  };
-
-  struct BSplinesX2 : ddc::UniformBSplines<DimX, D2>
-  {
-  };
-
-  struct BSplinesY : ddc::UniformBSplines<DimY, D1>
-  {
-  };
-  
-  using Builder1D_1 = ddc::SplineBuilder<
-                    execution_space1,
-                    memory_space1,
-                    BSplinesX1,
-                    DDimX,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::SplineSolver::LAPACK>;
-
-  using Evaluator1D_1 = ddc::SplineEvaluator<
-                    execution_space1,
-                    memory_space1,
-                    BSplinesX1,
-                    DDimX,
-                    ddc::PeriodicExtrapolationRule<DimX>,
-                    ddc::PeriodicExtrapolationRule<DimX>>;
-
-  using Builder1D_2 = ddc::SplineBuilder<
-                    execution_space2,
-                    memory_space2,
-                    BSplinesX2,
-                    DDimX,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::SplineSolver::LAPACK>;
-
-  using Evaluator1D_2 = ddc::SplineEvaluator<
-                    execution_space2,
-                    memory_space2,
-                    BSplinesX2,
-                    DDimX,
-                    ddc::PeriodicExtrapolationRule<DimX>,
-                    ddc::PeriodicExtrapolationRule<DimX>>;
-
-  using Builder2D_1 = ddc::SplineBuilder2D<
-                    execution_space1,
-                    memory_space1,
-                    BSplinesX1,
-                    BSplinesY,
-                    DDimX,
-                    DDimY,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::SplineSolver::LAPACK>;
-
-  using Evaluator2D_1 = ddc::SplineEvaluator2D<
-                    execution_space1,
-                    memory_space1,
-                    BSplinesX1,
-                    BSplinesY,
-                    DDimX,
-                    DDimY,
-                    ddc::PeriodicExtrapolationRule<DimX>,
-                    ddc::PeriodicExtrapolationRule<DimX>,
-                    ddc::PeriodicExtrapolationRule<DimY>,
-                    ddc::PeriodicExtrapolationRule<DimY>>;
-
-  using Builder2D_2 = ddc::SplineBuilder2D<
-                    execution_space2,
-                    memory_space2,
-                    BSplinesX2,
-                    BSplinesY,
-                    DDimX,
-                    DDimY,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::BoundCond::PERIODIC,
-                    ddc::SplineSolver::LAPACK>;
-
-  using Evaluator2D_2 = ddc::SplineEvaluator2D<
-                    execution_space2,
-                    memory_space2,
-                    BSplinesX2,
-                    BSplinesY,
-                    DDimX,
-                    DDimY,
-                    ddc::PeriodicExtrapolationRule<DimX>,
-                    ddc::PeriodicExtrapolationRule<DimX>,
-                    ddc::PeriodicExtrapolationRule<DimY>,
-                    ddc::PeriodicExtrapolationRule<DimY>>;
+struct BSplinesTraits<std::tuple<
+        ExecSpace1,
+        std::integral_constant<std::size_t, D1>,
+        ExecSpace2,
+        std::integral_constant<std::size_t, D2>>> : public ::testing::Test
+{
+    using execution_space1 = ExecSpace1;
+    using execution_space2 = ExecSpace2;
+    using memory_space1 = typename ExecSpace1::memory_space;
+    using memory_space2 = typename ExecSpace2::memory_space;
+    static constexpr std::size_t m_spline_degree1 = D1;
+    static constexpr std::size_t m_spline_degree2 = D2;
+
+    struct BSplinesX1 : ddc::UniformBSplines<DimX, D1>
+    {
+    };
+
+    struct BSplinesX2 : ddc::UniformBSplines<DimX, D2>
+    {
+    };
+
+    struct BSplinesY : ddc::UniformBSplines<DimY, D1>
+    {
+    };
+
+    using Builder1D_1 = ddc::SplineBuilder<
+            execution_space1,
+            memory_space1,
+            BSplinesX1,
+            DDimX,
+            ddc::BoundCond::PERIODIC,
+            ddc::BoundCond::PERIODIC,
+            ddc::SplineSolver::LAPACK>;
+
+    using Evaluator1D_1 = ddc::SplineEvaluator<
+            execution_space1,
+            memory_space1,
+            BSplinesX1,
+            DDimX,
+            ddc::PeriodicExtrapolationRule<DimX>,
+            ddc::PeriodicExtrapolationRule<DimX>>;
+
+    using Builder1D_2 = ddc::SplineBuilder<
+            execution_space2,
+            memory_space2,
+            BSplinesX2,
+            DDimX,
+            ddc::BoundCond::PERIODIC,
+            ddc::BoundCond::PERIODIC,
+            ddc::SplineSolver::LAPACK>;
+
+    using Evaluator1D_2 = ddc::SplineEvaluator<
+            execution_space2,
+            memory_space2,
+            BSplinesX2,
+            DDimX,
+            ddc::PeriodicExtrapolationRule<DimX>,
+            ddc::PeriodicExtrapolationRule<DimX>>;
+
+    using Builder2D_1 = ddc::SplineBuilder2D<
+            execution_space1,
+            memory_space1,
+            BSplinesX1,
+            BSplinesY,
+            DDimX,
+            DDimY,
+            ddc::BoundCond::PERIODIC,
+            ddc::BoundCond::PERIODIC,
+            ddc::BoundCond::PERIODIC,
+            ddc::BoundCond::PERIODIC,
+            ddc::SplineSolver::LAPACK>;
+
+    using Evaluator2D_1 = ddc::SplineEvaluator2D<
+            execution_space1,
+            memory_space1,
+            BSplinesX1,
+            BSplinesY,
+            DDimX,
+            DDimY,
+            ddc::PeriodicExtrapolationRule<DimX>,
+            ddc::PeriodicExtrapolationRule<DimX>,
+            ddc::PeriodicExtrapolationRule<DimY>,
+            ddc::PeriodicExtrapolationRule<DimY>>;
+
+    using Builder2D_2 = ddc::SplineBuilder2D<
+            execution_space2,
+            memory_space2,
+            BSplinesX2,
+            BSplinesY,
+            DDimX,
+            DDimY,
+            ddc::BoundCond::PERIODIC,
+            ddc::BoundCond::PERIODIC,
+            ddc::BoundCond::PERIODIC,
+            ddc::BoundCond::PERIODIC,
+            ddc::SplineSolver::LAPACK>;
+
+    using Evaluator2D_2 = ddc::SplineEvaluator2D<
+            execution_space2,
+            memory_space2,
+            BSplinesX2,
+            BSplinesY,
+            DDimX,
+            DDimY,
+            ddc::PeriodicExtrapolationRule<DimX>,
+            ddc::PeriodicExtrapolationRule<DimX>,
+            ddc::PeriodicExtrapolationRule<DimY>,
+            ddc::PeriodicExtrapolationRule<DimY>>;
 };
 
 #if defined(KOKKOS_ENABLE_SERIAL)
-using execution_space_types = std::tuple<Kokkos::Serial, Kokkos::DefaultHostExecutionSpace, Kokkos::DefaultExecutionSpace>;
+using execution_space_types = std::
+        tuple<Kokkos::Serial, Kokkos::DefaultHostExecutionSpace, Kokkos::DefaultExecutionSpace>;
 #else
-using execution_space_types = std::tuple<Kokkos::DefaultHostExecutionSpace, Kokkos::DefaultExecutionSpace>;
+using execution_space_types
+        = std::tuple<Kokkos::DefaultHostExecutionSpace, Kokkos::DefaultExecutionSpace>;
 #endif
 
 using spline_degrees = std::integer_sequence<std::size_t, 2, 3>;
 
-using TestTypes = tuple_to_types_t<cartesian_product_t<execution_space_types, spline_degrees, execution_space_types, spline_degrees>>;
+using TestTypes = tuple_to_types_t<cartesian_product_t<
+        execution_space_types,
+        spline_degrees,
+        execution_space_types,
+        spline_degrees>>;
 
 TYPED_TEST_SUITE(BSplinesTraits, TestTypes, );
 
@@ -232,11 +244,12 @@ TYPED_TEST(BSplinesTraits, IsAdmissible1D)
     std::size_t constexpr m_spline_degree1 = TestFixture::m_spline_degree1;
     std::size_t constexpr m_spline_degree2 = TestFixture::m_spline_degree2;
 
-    if ((!std::is_same_v<execution_space1, execution_space2>) || (m_spline_degree1 != m_spline_degree2)) {
-      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder1D_1, Evaluator1D_2>));
-      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_2, Builder1D_1>));
-      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder1D_2, Evaluator1D_1>));
-      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_1, Builder1D_2>));
+    if ((!std::is_same_v<execution_space1, execution_space2>)
+        || (m_spline_degree1 != m_spline_degree2)) {
+        ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder1D_1, Evaluator1D_2>));
+        ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_2, Builder1D_1>));
+        ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder1D_2, Evaluator1D_1>));
+        ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator1D_1, Builder1D_2>));
     }
 }
 
@@ -271,11 +284,11 @@ TYPED_TEST(BSplinesTraits, IsAdmissible2D)
     std::size_t constexpr m_spline_degree1 = TestFixture::m_spline_degree1;
     std::size_t constexpr m_spline_degree2 = TestFixture::m_spline_degree2;
 
-    if ((!std::is_same_v<execution_space1, execution_space2>) || (m_spline_degree1 != m_spline_degree2)) {
-      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder2D_1, Evaluator2D_2>));
-      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_2, Builder2D_1>));
-      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder2D_2, Evaluator2D_1>));
-      ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_1, Builder2D_2>));
+    if ((!std::is_same_v<execution_space1, execution_space2>)
+        || (m_spline_degree1 != m_spline_degree2)) {
+        ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder2D_1, Evaluator2D_2>));
+        ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_2, Builder2D_1>));
+        ASSERT_FALSE((ddc::is_evaluator_admissible_v<Builder2D_2, Evaluator2D_1>));
+        ASSERT_FALSE((ddc::is_evaluator_admissible_v<Evaluator2D_1, Builder2D_2>));
     }
 }
-

From 497af685b0446ce7f073f7bcea233eda738d5672 Mon Sep 17 00:00:00 2001
From: Yuuichi Asahi <y.asahi@nr.titech.ac.jp>
Date: Tue, 24 Jun 2025 13:55:36 +0900
Subject: [PATCH 5/6] cleanup unused headers

---
 include/ddc/kernels/splines/spline_traits.hpp | 20 ++++++----------
 tests/splines/spline_traits.cpp               | 24 +++++++++----------
 2 files changed, 19 insertions(+), 25 deletions(-)

diff --git a/include/ddc/kernels/splines/spline_traits.hpp b/include/ddc/kernels/splines/spline_traits.hpp
index c4f1632ac..6918e0120 100644
--- a/include/ddc/kernels/splines/spline_traits.hpp
+++ b/include/ddc/kernels/splines/spline_traits.hpp
@@ -4,14 +4,7 @@
 
 #pragma once
 
-#include <cassert>
-#include <cstddef>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 #include <ddc/ddc.hpp>
 
@@ -21,6 +14,7 @@
 #include "spline_evaluator_2d.hpp"
 
 namespace ddc {
+
 template <class T>
 struct is_spline_builder : std::false_type
 {
@@ -53,7 +47,7 @@ template <class T>
 inline constexpr bool is_spline_builder_v = is_spline_builder<T>::value;
 
 template <class T>
-struct is_spline_builder2D : std::false_type
+struct is_spline_builder2d : std::false_type
 {
 };
 
@@ -69,7 +63,7 @@ template <
         ddc::BoundCond BcLower2,
         ddc::BoundCond BcUpper2,
         ddc::SplineSolver Solver>
-struct is_spline_builder2D<SplineBuilder2D<
+struct is_spline_builder2d<SplineBuilder2D<
         ExecSpace,
         MemorySpace,
         BSpline1,
@@ -89,7 +83,7 @@ struct is_spline_builder2D<SplineBuilder2D<
  *  @tparam T The type to be checked if is a SplineBuilder2D
  */
 template <class T>
-inline constexpr bool is_spline_builder2D_v = is_spline_builder2D<T>::value;
+inline constexpr bool is_spline_builder2d_v = is_spline_builder2d<T>::value;
 
 template <class T>
 struct is_spline_evaluator : std::false_type
@@ -121,7 +115,7 @@ template <class T>
 inline constexpr bool is_spline_evaluator_v = is_spline_evaluator<T>::value;
 
 template <class T>
-struct is_spline_evaluator2D : std::false_type
+struct is_spline_evaluator2d : std::false_type
 {
 };
 
@@ -136,7 +130,7 @@ template <
         class UpperExtrapolationRule1,
         class LowerExtrapolationRule2,
         class UpperExtrapolationRule2>
-struct is_spline_evaluator2D<SplineEvaluator2D<
+struct is_spline_evaluator2d<SplineEvaluator2D<
         ExecSpace,
         MemorySpace,
         BSpline1,
@@ -155,7 +149,7 @@ struct is_spline_evaluator2D<SplineEvaluator2D<
  *  @tparam T The type to be checked if is a SplineEvaluator2D
  */
 template <class T>
-inline constexpr bool is_spline_evaluator2D_v = is_spline_evaluator2D<T>::value;
+inline constexpr bool is_spline_evaluator2d_v = is_spline_evaluator2d<T>::value;
 
 template <class Builder, class Evaluator>
 struct is_evaluator_admissible : std::false_type
diff --git a/tests/splines/spline_traits.cpp b/tests/splines/spline_traits.cpp
index 78ea4c9cd..cae4c44b9 100644
--- a/tests/splines/spline_traits.cpp
+++ b/tests/splines/spline_traits.cpp
@@ -2,10 +2,6 @@
 //
 // SPDX-License-Identifier: MIT
 
-#include <cstddef>
-#include <stdexcept>
-#include <vector>
-
 #include <ddc/ddc.hpp>
 #include <ddc/kernels/splines.hpp>
 
@@ -15,6 +11,8 @@
 
 #include "test_utils.hpp"
 
+inline namespace anonymous_namespace_workaround_spline_traits_cpp {
+
 struct DimX
 {
     static constexpr bool PERIODIC = true;
@@ -163,6 +161,8 @@ using TestTypes = tuple_to_types_t<cartesian_product_t<
         execution_space_types,
         spline_degrees>>;
 
+} // namespace anonymous_namespace_workaround_spline_traits_cpp
+
 TYPED_TEST_SUITE(BSplinesTraits, TestTypes, );
 
 TYPED_TEST(BSplinesTraits, IsSplineBuilder)
@@ -183,10 +183,10 @@ TYPED_TEST(BSplinesTraits, IsSplineBuilder2D)
     using Evaluator1D = typename TestFixture::Evaluator1D_1;
     using Builder2D = typename TestFixture::Builder2D_1;
     using Evaluator2D = typename TestFixture::Evaluator2D_1;
-    ASSERT_FALSE(ddc::is_spline_builder2D_v<Builder1D>);
-    ASSERT_TRUE(ddc::is_spline_builder2D_v<Builder2D>);
-    ASSERT_FALSE(ddc::is_spline_builder2D_v<Evaluator1D>);
-    ASSERT_FALSE(ddc::is_spline_builder2D_v<Evaluator2D>);
+    ASSERT_FALSE(ddc::is_spline_builder2d_v<Builder1D>);
+    ASSERT_TRUE(ddc::is_spline_builder2d_v<Builder2D>);
+    ASSERT_FALSE(ddc::is_spline_builder2d_v<Evaluator1D>);
+    ASSERT_FALSE(ddc::is_spline_builder2d_v<Evaluator2D>);
 }
 
 TYPED_TEST(BSplinesTraits, IsSplineEvaluator)
@@ -207,10 +207,10 @@ TYPED_TEST(BSplinesTraits, IsSplineEvaluator2D)
     using Evaluator1D = typename TestFixture::Evaluator1D_1;
     using Builder2D = typename TestFixture::Builder2D_1;
     using Evaluator2D = typename TestFixture::Evaluator2D_1;
-    ASSERT_FALSE(ddc::is_spline_evaluator2D_v<Builder1D>);
-    ASSERT_FALSE(ddc::is_spline_evaluator2D_v<Builder2D>);
-    ASSERT_FALSE(ddc::is_spline_evaluator2D_v<Evaluator1D>);
-    ASSERT_TRUE(ddc::is_spline_evaluator2D_v<Evaluator2D>);
+    ASSERT_FALSE(ddc::is_spline_evaluator2d_v<Builder1D>);
+    ASSERT_FALSE(ddc::is_spline_evaluator2d_v<Builder2D>);
+    ASSERT_FALSE(ddc::is_spline_evaluator2d_v<Evaluator1D>);
+    ASSERT_TRUE(ddc::is_spline_evaluator2d_v<Evaluator2D>);
 }
 
 TYPED_TEST(BSplinesTraits, IsAdmissible1D)

From 8e8fc2cfd4d27118fb3e998fad7fe39c94efb2fd Mon Sep 17 00:00:00 2001
From: Yuuichi Asahi <y.asahi@nr.titech.ac.jp>
Date: Tue, 24 Jun 2025 15:42:33 +0900
Subject: [PATCH 6/6] add headers in tests

---
 tests/splines/spline_traits.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/splines/spline_traits.cpp b/tests/splines/spline_traits.cpp
index cae4c44b9..0c009c5bf 100644
--- a/tests/splines/spline_traits.cpp
+++ b/tests/splines/spline_traits.cpp
@@ -2,6 +2,10 @@
 //
 // SPDX-License-Identifier: MIT
 
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
 #include <ddc/ddc.hpp>
 #include <ddc/kernels/splines.hpp>