diff --git a/tests/common/common_vec.h b/tests/common/common_vec.h
index d07752960..6ccce7b2c 100644
--- a/tests/common/common_vec.h
+++ b/tests/common/common_vec.h
@@ -72,7 +72,7 @@ bool check_vector_values(sycl::vec<vecType, numOfElems> vector,
  *        for division result are accurate enough
  */
 template <typename vecType, int numOfElems>
-typename std::enable_if<is_sycl_floating_point<vecType>::value, bool>::type
+typename std::enable_if<is_sycl_scalar_floating_point<vecType>::value, bool>::type
 check_vector_values_div(sycl::vec<vecType, numOfElems> vector,
                         vecType *vals) {
   for (int i = 0; i < numOfElems; i++) {
@@ -95,7 +95,7 @@ check_vector_values_div(sycl::vec<vecType, numOfElems> vector,
  * @brief Helper function to check that vector values for division are correct
  */
 template <typename vecType, int numOfElems>
-typename std::enable_if<!is_sycl_floating_point<vecType>::value, bool>::type
+typename std::enable_if<!is_sycl_scalar_floating_point<vecType>::value, bool>::type
 check_vector_values_div(sycl::vec<vecType, numOfElems> vector,
                         vecType *vals) {
   return check_vector_values(vector, vals);
@@ -123,7 +123,7 @@ bool check_single_vector_op(vectorType vector1, lambdaFunc lambda) {
 
 template <typename sourceType, typename targetType>
 static constexpr bool if_FP_to_non_FP_conv_v =
-    is_sycl_floating_point<sourceType>::value && !is_sycl_floating_point<targetType>::value;
+    is_sycl_scalar_floating_point<sourceType>::value && !is_sycl_scalar_floating_point<targetType>::value;
 
 template <typename vecType, int N, typename convertType>
 sycl::vec<convertType, N> convert_vec(sycl::vec<vecType, N> inputVec) {
@@ -196,7 +196,7 @@ sycl::vec<convertType, N> rtn(sycl::vec<vecType, N> inputVec) {
 // values instead.
 template <typename vecType, int N, typename convertType>
 void handleFPToUnsignedConv(sycl::vec<vecType, N>& inputVec) {
-  if constexpr (is_sycl_floating_point<vecType>::value &&
+  if constexpr (is_sycl_scalar_floating_point<vecType>::value &&
                 std::is_unsigned_v<convertType>) {
     for (size_t i = 0; i < N; ++i) {
       vecType elem = inputVec[i];
@@ -247,7 +247,7 @@ bool check_vector_convert_result_impl(sycl::vec<vecType, N> inputVec,
   sycl::vec<convertType, N> expectedVec;
   switch (mode) {
     case sycl::rounding_mode::automatic:
-      if constexpr (is_sycl_floating_point<vecType>::value) {
+      if constexpr (is_sycl_scalar_floating_point<vecType>::value) {
         expectedVec = rte<vecType, N, convertType>(inputVec);
       } else {
         expectedVec = rtz<vecType, N, convertType>(inputVec);
diff --git a/tests/group_functions/group_functions_common.h b/tests/group_functions/group_functions_common.h
index 725297edc..498bbce82 100644
--- a/tests/group_functions/group_functions_common.h
+++ b/tests/group_functions/group_functions_common.h
@@ -259,7 +259,7 @@ template <typename T>
 inline auto get_op_types() {
 #if SYCL_CTS_ENABLE_FULL_CONFORMANCE
   static const auto types = []() {
-    if constexpr (is_sycl_floating_point_v<T>) {
+    if constexpr (is_sycl_scalar_floating_point_v<T>) {
       // Bitwise operations are not defined for floating point types.
       return named_type_pack<sycl::plus<T>, sycl::multiplies<T>,
                              sycl::logical_and<T>, sycl::logical_or<T>,
diff --git a/tests/marray_basic/marray_operators.h b/tests/marray_basic/marray_operators.h
index 9a8f171b8..0a2117ce8 100644
--- a/tests/marray_basic/marray_operators.h
+++ b/tests/marray_basic/marray_operators.h
@@ -56,7 +56,7 @@ template <typename OpT, typename ElemT>
 struct skip_result_check
     : std::bool_constant<
           (std::is_same_v<OpT, op_div> || std::is_same_v<OpT, op_assign_div>) &&
-              is_sycl_floating_point_v<ElemT>> {};
+              is_sycl_scalar_floating_point_v<ElemT>> {};
 
 template <typename OpT, typename ElemT>
 constexpr bool skip_result_check_v = skip_result_check<OpT, ElemT>::value;
@@ -67,10 +67,10 @@ bool are_equal_ignore_division(const T1& lhs, const T1& rhs) {
   // similar to native::divide we can skip checking them here.
   constexpr bool is_div =
       std::is_same_v<OpT, op_div> || std::is_same_v<OpT, op_assign_div>;
-  constexpr bool is_sycl_floating_point = std::is_same_v<ElemT, float> ||
+  constexpr bool is_sycl_scalar_floating_point = std::is_same_v<ElemT, float> ||
                                           std::is_same_v<ElemT, double> ||
                                           std::is_same_v<ElemT, sycl::half>;
-  if constexpr (is_div && is_sycl_floating_point) return true;
+  if constexpr (is_div && is_sycl_scalar_floating_point) return true;
   return value_operations::are_equal(lhs, rhs);
 }
 
diff --git a/tests/math_builtin_api/math_builtin.h b/tests/math_builtin_api/math_builtin.h
index fa950d91e..15ee47911 100644
--- a/tests/math_builtin_api/math_builtin.h
+++ b/tests/math_builtin_api/math_builtin.h
@@ -100,7 +100,7 @@ bool verify(sycl_cts::util::logger& log, T a, T b, float accuracy,
             AccuracyMode accuracy_mode, const std::string& comment);
 
 template <typename T>
-std::enable_if_t<is_sycl_floating_point_v<T>, bool>
+std::enable_if_t<is_sycl_scalar_floating_point_v<T>, bool>
 verify(sycl_cts::util::logger& log, T value, sycl_cts::resultRef<T> r,
        float accuracy, AccuracyMode accuracy_mode, const std::string& comment) {
   const T reference = r.res;
diff --git a/tests/reduction/identity_helper.h b/tests/reduction/identity_helper.h
index 179dfd544..29d89bc83 100644
--- a/tests/reduction/identity_helper.h
+++ b/tests/reduction/identity_helper.h
@@ -110,7 +110,7 @@ AccumulatorT get_identity() {
 template <typename AccumulatorT, typename OperatorT,
           std::enable_if_t<
               std::is_same_v<OperatorT, sycl::minimum<AccumulatorT>> &&
-                  is_sycl_floating_point_v<AccumulatorT>,
+                  is_sycl_scalar_floating_point_v<AccumulatorT>,
               bool> = true>
 AccumulatorT get_identity() {
   return std::numeric_limits<AccumulatorT>::infinity();
diff --git a/tests/reduction/reduction_without_identity_param_common.h b/tests/reduction/reduction_without_identity_param_common.h
index 968ff6352..9e10e7972 100644
--- a/tests/reduction/reduction_without_identity_param_common.h
+++ b/tests/reduction/reduction_without_identity_param_common.h
@@ -301,7 +301,7 @@ template <typename VariableT, bool UseCombineFlagT, bool UsePropertyFlag,
 void run_test_for_all_reductions_types(FunctorT functor, RangeT& range,
                                        sycl::queue& queue,
                                        const std::string& type_name) {
-  if constexpr (is_sycl_floating_point<VariableT>::value &&
+  if constexpr (is_sycl_scalar_floating_point<VariableT>::value &&
                 (std::is_same<FunctorT, sycl::bit_and<VariableT>>::value ||
                  std::is_same<FunctorT, sycl::bit_or<VariableT>>::value ||
                  std::is_same<FunctorT, sycl::bit_xor<VariableT>>::value)) {
diff --git a/util/type_traits.h b/util/type_traits.h
index 68b4e0293..cf9842fee 100644
--- a/util/type_traits.h
+++ b/util/type_traits.h
@@ -50,7 +50,7 @@ using has_atomic_support = contains<T, int, unsigned int, long, unsigned long,
  * @brief Checks whether T is a floating-point sycl type
  */
 template <typename T>
-using is_sycl_floating_point =
+using is_sycl_scalar_floating_point =
 #if SYCL_CTS_ENABLE_HALF_TESTS
     std::bool_constant<std::is_floating_point_v<T> ||
                        std::is_same_v<std::remove_cv_t<T>, sycl::half>>;
@@ -59,8 +59,8 @@ using is_sycl_floating_point =
 #endif
 
 template <typename T>
-inline constexpr bool is_sycl_floating_point_v{
-    is_sycl_floating_point<T>::value};
+inline constexpr bool is_sycl_scalar_floating_point_v{
+    is_sycl_scalar_floating_point<T>::value};
 
 template <typename T>
 using is_nonconst_rvalue_reference =
@@ -410,10 +410,10 @@ using is_legal_operator = std::bool_constant<
      std::is_same_v<std::remove_cv_t<T>, bool>) ||
     (std::is_same_v<OperatorT, sycl::minimum<T>> && std::is_integral_v<T>) ||
     (std::is_same_v<OperatorT, sycl::minimum<T>> &&
-     is_sycl_floating_point_v<T>) ||
+     is_sycl_scalar_floating_point_v<T>) ||
     (std::is_same_v<OperatorT, sycl::maximum<T>> && std::is_integral_v<T>) ||
     (std::is_same_v<OperatorT, sycl::maximum<T>> &&
-     is_sycl_floating_point_v<T>)>;
+     is_sycl_scalar_floating_point_v<T>)>;
 
 /**
  Checks whether \p T and \p OperatorT form a valid SYCL operator. */