Rename accessor_scaled -> scaled_accessor

include/experimental/__p1673_bits/blas3_matrix_product.hpp

@@ -191,8 +191,8 @@ constexpr bool valid_input_blas_accessor()
 
   using def_acc_type = default_accessor<elt_type>;
   using conj_def_acc_type = accessor_conjugate<def_acc_type>;
-  using scal_def_acc_type = accessor_scaled<val_type, def_acc_type>;
-  using scal_conj_acc_type = accessor_scaled<val_type, conj_def_acc_type>;
+  using scal_def_acc_type = scaled_accessor<val_type, def_acc_type>;
+  using scal_conj_acc_type = scaled_accessor<val_type, conj_def_acc_type>;
   using conj_scal_acc_type = accessor_conjugate<scal_def_acc_type>;
 
   // The two matrices' accessor types need not be the same.
@@ -288,12 +288,12 @@ matrix_product_dispatch_to_blas()
 }
 
 template<class Accessor, class ValueType>
-static constexpr bool is_compatible_accessor_scaled_v = false;
+static constexpr bool is_compatible_scaled_accessor_v = false;
 
 template<class ScalingFactor, class NestedAccessor, class ValueType>
-static constexpr bool is_compatible_accessor_scaled_v<
-  accessor_scaled<ScalingFactor, NestedAccessor>, ValueType> =
-    std::is_same_v<typename accessor_scaled<ScalingFactor, NestedAccessor>::value_type, ValueType>;
+static constexpr bool is_compatible_scaled_accessor_v<
+  scaled_accessor<ScalingFactor, NestedAccessor>, ValueType> =
+    std::is_same_v<typename scaled_accessor<ScalingFactor, NestedAccessor>::value_type, ValueType>;
 
 template<class Accessor>
 static constexpr bool is_accessor_conjugate_v = false;
@@ -309,12 +309,12 @@ extractScalingFactor(in_matrix_t A,
   using acc_t = typename in_matrix_t::accessor_type;
   using val_t = typename in_matrix_t::value_type;
 
-  if constexpr (is_compatible_accessor_scaled_v<acc_t, val_t>) {
+  if constexpr (is_compatible_scaled_accessor_v<acc_t, val_t>) {
     return A.accessor.scale_factor();
   } else if constexpr (is_accessor_conjugate_v<acc_t>) {
     // conjugated(scaled(alpha, A)) means that both alpha and A are conjugated.
     using nested_acc_t = decltype(A.accessor().nested_accessor());
-    if constexpr (is_compatible_accessor_scaled_v<nested_acc_t>) {
+    if constexpr (is_compatible_scaled_accessor_v<nested_acc_t>) {
       return impl::conj_if_needed(extractScalingFactor(A.accessor.nested_accessor()));
     } else {
       return defaultValue;

include/experimental/__p1673_bits/scaled.hpp

@@ -51,15 +51,15 @@ inline namespace __p1673_version_0 {
 namespace linalg {
 
 template<class ScalingFactor, class Accessor>
-class accessor_scaled {
+class scaled_accessor {
 public:
   using element_type = decltype(std::declval<ScalingFactor>() * std::declval<typename Accessor::element_type>());
   using reference = element_type;
   using data_handle_type = typename Accessor::data_handle_type;
   using offset_policy =
-    accessor_scaled<ScalingFactor, typename Accessor::offset_policy>;
+    scaled_accessor<ScalingFactor, typename Accessor::offset_policy>;
 
-  accessor_scaled(const ScalingFactor& scaling_factor, const Accessor& accessor) :
+  scaled_accessor(const ScalingFactor& scaling_factor, const Accessor& accessor) :
     scaling_factor_(scaling_factor),
     accessor_(accessor)
   {}
@@ -72,7 +72,7 @@ class accessor_scaled {
       std::is_constructible_v<ScalingFactor, OtherScalingFactor>
     )
   )
-  accessor_scaled(const accessor_scaled<OtherScalingFactor, OtherNestedAccessor>& other) :
+  scaled_accessor(const scaled_accessor<OtherScalingFactor, OtherNestedAccessor>& other) :
     scaling_factor_(other.scaling_factor()),
     accessor_(other.nested_accessor())
   {}
@@ -104,7 +104,7 @@ namespace impl {
 template<class ScalingFactor,
          class Accessor>
 using scaled_element_type =
-  std::add_const_t<typename accessor_scaled<ScalingFactor, Accessor>::element_type>;
+  std::add_const_t<typename scaled_accessor<ScalingFactor, Accessor>::element_type>;
 
 } // namespace impl
 
@@ -116,11 +116,11 @@ template<class ScalingFactor,
 mdspan<impl::scaled_element_type<ScalingFactor, Accessor>,
        Extents,
        Layout,
-       accessor_scaled<ScalingFactor, Accessor>>
+       scaled_accessor<ScalingFactor, Accessor>>
 scaled(ScalingFactor scaling_factor,
        mdspan<ElementType, Extents, Layout, Accessor> x)
 {
-  using acc_type = accessor_scaled<ScalingFactor, Accessor>;
+  using acc_type = scaled_accessor<ScalingFactor, Accessor>;
   return {x.data_handle(), x.mapping(), acc_type{scaling_factor, x.accessor()}};
 }
 

tests/native/scaled.cpp

@@ -7,9 +7,9 @@ namespace {
   using std::experimental::linalg::scaled;
 
   template<class ScalingFactor, class OriginalValueType>
-  void test_accessor_scaled_element_constification()
+  void test_scaled_accessor_element_constification()
   {
-    using std::experimental::linalg::accessor_scaled;
+    using std::experimental::linalg::scaled_accessor;
     using std::experimental::linalg::scaled_scalar;
 
     using nc_def_acc_type = default_accessor<OriginalValueType>;
@@ -18,8 +18,8 @@ namespace {
     nc_def_acc_type nc_acc;
     c_def_acc_type c_acc;
 
-    using as_nc_type = accessor_scaled<ScalingFactor, nc_def_acc_type>;
-    using as_c_type = accessor_scaled<ScalingFactor, c_def_acc_type>;
+    using as_nc_type = scaled_accessor<ScalingFactor, nc_def_acc_type>;
+    using as_c_type = scaled_accessor<ScalingFactor, c_def_acc_type>;
     ScalingFactor scal{};
     as_nc_type acc_scal_nc(scal, nc_acc);
     as_c_type acc_scal_c0(scal, c_acc);
@@ -28,12 +28,12 @@ namespace {
     as_c_type acc_scal_c1(scal, nc_acc);
   }
 
-  TEST(accessor_scaled, element_constification)
+  TEST(scaled_accessor, element_constification)
   {
-    test_accessor_scaled_element_constification<double, double>();
-    test_accessor_scaled_element_constification<int, int>();
-    test_accessor_scaled_element_constification<std::complex<double>, std::complex<double>>();
-    test_accessor_scaled_element_constification<std::complex<float>, std::complex<float>>();
+    test_scaled_accessor_element_constification<double, double>();
+    test_scaled_accessor_element_constification<int, int>();
+    test_scaled_accessor_element_constification<std::complex<double>, std::complex<double>>();
+    test_scaled_accessor_element_constification<std::complex<float>, std::complex<float>>();
   }
 
   // scaled(1 << 20, scaled(1 << 20, x)) with x having value_type double
@@ -81,12 +81,12 @@ namespace {
 
     const scaling_factor_type scalingFactor (-3.0);
 
-    // Make sure that accessor_scaled compiles
+    // Make sure that scaled_accessor compiles
     {
       using accessor_t = vector_t::accessor_type;
-      using std::experimental::linalg::accessor_scaled;
+      using std::experimental::linalg::scaled_accessor;
       using scaled_accessor_t =
-        accessor_scaled<scaling_factor_type, accessor_t>;
+        scaled_accessor<scaling_factor_type, accessor_t>;
       scaled_accessor_t accessor0{scalingFactor, y.accessor()};
     }
 

tpl-implementations/include/experimental/__p1673_bits/kokkos-kernels/blas2_gemv_kk.hpp

@@ -14,7 +14,7 @@ T get_scaling_factor(Accessor /*a*/, T /*v*/) {
 }
 
 template<class Accessor, class S, class T>
-auto get_scaling_factor(std::experimental::linalg::accessor_scaled<Accessor,S> a,
+auto get_scaling_factor(std::experimental::linalg::scaled_accessor<Accessor,S> a,
       T /*v*/)
 {
   return T(a.scale_factor());