Merge pull request #55 from beomki-yeo/rename/getter

change xxx_getter_type to xxx_getter
acts-project · Mar 25, 2022 · cbc4208 · cbc4208
2 parents 0a525dd + 14346fd
commit cbc4208
Show file tree

Hide file tree

Showing 8 changed files with 99 additions and 86 deletions.
diff --git a/frontend/array_cmath/include/algebra/array_cmath.hpp b/frontend/array_cmath/include/algebra/array_cmath.hpp
@@ -77,19 +77,18 @@ template <typename T, std::size_t ROWS, std::size_t COLS>
 using matrix_type = array::matrix_type<T, ROWS, COLS>;
 
 template <typename size_type, typename scalar_t>
-using element_getter_type =
-    cmath::element_getter<size_type, array_type, scalar_t>;
+using element_getter = cmath::element_getter<size_type, array_type, scalar_t>;
 
 template <typename size_type, typename scalar_t>
-using block_getter_type = cmath::block_getter<size_type, array_type, scalar_t>;
+using block_getter = cmath::block_getter<size_type, array_type, scalar_t>;
 
 // matrix actor
 template <typename size_type, typename scalar_t, typename determinant_actor_t,
           typename inverse_actor_t>
 using actor = cmath::matrix::actor<size_type, array_type, matrix_type, scalar_t,
                                    determinant_actor_t, inverse_actor_t,
-                                   element_getter_type<size_type, scalar_t>,
-                                   block_getter_type<size_type, scalar_t>>;
+                                   element_getter<size_type, scalar_t>,
+                                   block_getter<size_type, scalar_t>>;
 
 namespace determinant {
 
@@ -100,15 +99,17 @@ using actor =
 
 // determinant::cofactor
 template <typename size_type, typename scalar_t, size_type... Ds>
-using cofactor = cmath::matrix::determinant::cofactor<
-    size_type, matrix_type, scalar_t, element_getter_type<size_type, scalar_t>,
-    Ds...>;
+using cofactor =
+    cmath::matrix::determinant::cofactor<size_type, matrix_type, scalar_t,
+                                         element_getter<size_type, scalar_t>,
+                                         Ds...>;
 
 // determinant::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
-using hard_coded = cmath::matrix::determinant::hard_coded<
-    size_type, matrix_type, scalar_t, element_getter_type<size_type, scalar_t>,
-    Ds...>;
+using hard_coded =
+    cmath::matrix::determinant::hard_coded<size_type, matrix_type, scalar_t,
+                                           element_getter<size_type, scalar_t>,
+                                           Ds...>;
 
 // preset(s) as standard option(s) for user's convenience
 template <typename size_type, typename scalar_t>
@@ -128,14 +129,14 @@ using actor =
 template <typename size_type, typename scalar_t, size_type... Ds>
 using cofactor =
     cmath::matrix::inverse::cofactor<size_type, matrix_type, scalar_t,
-                                     element_getter_type<size_type, scalar_t>,
+                                     element_getter<size_type, scalar_t>,
                                      Ds...>;
 
 // inverse::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
 using hard_coded =
     cmath::matrix::inverse::hard_coded<size_type, matrix_type, scalar_t,
-                                       element_getter_type<size_type, scalar_t>,
+                                       element_getter<size_type, scalar_t>,
                                        Ds...>;
 
 // preset(s) as standard option(s) for user's convenience

diff --git a/frontend/eigen_cmath/include/algebra/eigen_cmath.hpp b/frontend/eigen_cmath/include/algebra/eigen_cmath.hpp
@@ -74,15 +74,15 @@ template <typename T, int N>
 using array_type = eigen::storage_type<T, N>;
 template <typename T, int ROWS, int COLS>
 using matrix_type = eigen::matrix_type<T, ROWS, COLS>;
-using element_getter_type = eigen::math::element_getter;
-using block_getter_type = eigen::math::block_getter;
+using element_getter = eigen::math::element_getter;
+using block_getter = eigen::math::block_getter;
 
 // matrix actor
 template <typename size_type, typename scalar_t, typename determinant_actor_t,
           typename inverse_actor_t>
 using actor = cmath::matrix::actor<size_type, array_type, matrix_type, scalar_t,
                                    determinant_actor_t, inverse_actor_t,
-                                   element_getter_type, block_getter_type>;
+                                   element_getter, block_getter>;
 
 namespace determinant {
 
@@ -95,13 +95,13 @@ using actor =
 template <typename size_type, typename scalar_t, size_type... Ds>
 using cofactor =
     cmath::matrix::determinant::cofactor<size_type, matrix_type, scalar_t,
-                                         element_getter_type, Ds...>;
+                                         element_getter, Ds...>;
 
 // determinant::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
 using hard_coded =
     cmath::matrix::determinant::hard_coded<size_type, matrix_type, scalar_t,
-                                           element_getter_type, Ds...>;
+                                           element_getter, Ds...>;
 
 // preset(s) as standard option(s) for user's convenience
 template <typename size_type, typename scalar_t>
@@ -121,13 +121,13 @@ using actor =
 template <typename size_type, typename scalar_t, size_type... Ds>
 using cofactor =
     cmath::matrix::inverse::cofactor<size_type, matrix_type, scalar_t,
-                                     element_getter_type, Ds...>;
+                                     element_getter, Ds...>;
 
 // inverse::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
 using hard_coded =
     cmath::matrix::inverse::hard_coded<size_type, matrix_type, scalar_t,
-                                       element_getter_type, Ds...>;
+                                       element_getter, Ds...>;
 
 // preset(s) as standard option(s) for user's convenience
 template <typename size_type, typename scalar_t>

diff --git a/frontend/smatrix_cmath/include/algebra/smatrix_cmath.hpp b/frontend/smatrix_cmath/include/algebra/smatrix_cmath.hpp
@@ -69,17 +69,17 @@ using array_type = smatrix::storage_type<T, N>;
 template <typename T, unsigned int ROWS, unsigned int COLS>
 using matrix_type = smatrix::matrix_type<T, ROWS, COLS>;
 template <typename scalar_t>
-using element_getter_type = smatrix::math::element_getter<scalar_t>;
+using element_getter = smatrix::math::element_getter<scalar_t>;
 template <typename scalar_t>
-using block_getter_type = smatrix::math::block_getter<scalar_t>;
+using block_getter = smatrix::math::block_getter<scalar_t>;
 
 // matrix actor
 template <typename size_type, typename scalar_t, typename determinant_actor_t,
           typename inverse_actor_t>
-using actor = cmath::matrix::actor<size_type, array_type, matrix_type, scalar_t,
-                                   determinant_actor_t, inverse_actor_t,
-                                   element_getter_type<scalar_t>,
-                                   block_getter_type<scalar_t>>;
+using actor =
+    cmath::matrix::actor<size_type, array_type, matrix_type, scalar_t,
+                         determinant_actor_t, inverse_actor_t,
+                         element_getter<scalar_t>, block_getter<scalar_t>>;
 
 namespace determinant {
 
@@ -92,12 +92,13 @@ using actor =
 template <typename size_type, typename scalar_t, size_type... Ds>
 using cofactor =
     cmath::matrix::determinant::cofactor<size_type, matrix_type, scalar_t,
-                                         element_getter_type<scalar_t>, Ds...>;
+                                         element_getter<scalar_t>, Ds...>;
 
 // determinant::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
-using hard_coded = cmath::matrix::determinant::hard_coded<
-    size_type, matrix_type, scalar_t, element_getter_type<scalar_t>, Ds...>;
+using hard_coded =
+    cmath::matrix::determinant::hard_coded<size_type, matrix_type, scalar_t,
+                                           element_getter<scalar_t>, Ds...>;
 
 // preset(s) as standard option(s) for user's convenience
 template <typename size_type, typename scalar_t>
@@ -117,13 +118,13 @@ using actor =
 template <typename size_type, typename scalar_t, size_type... Ds>
 using cofactor =
     cmath::matrix::inverse::cofactor<size_type, matrix_type, scalar_t,
-                                     element_getter_type<scalar_t>, Ds...>;
+                                     element_getter<scalar_t>, Ds...>;
 
 // inverse::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
 using hard_coded =
     cmath::matrix::inverse::hard_coded<size_type, matrix_type, scalar_t,
-                                       element_getter_type<scalar_t>, Ds...>;
+                                       element_getter<scalar_t>, Ds...>;
 
 // preset(s) as standard option(s) for user's convenience
 template <typename size_type, typename scalar_t>

diff --git a/frontend/vc_cmath/include/algebra/vc_cmath.hpp b/frontend/vc_cmath/include/algebra/vc_cmath.hpp
@@ -88,19 +88,18 @@ template <typename T, std::size_t ROWS, std::size_t COLS>
 using matrix_type = vc::matrix_type<T, ROWS, COLS>;
 
 template <typename size_type, typename scalar_t>
-using element_getter_type =
-    cmath::element_getter<size_type, array_type, scalar_t>;
+using element_getter = cmath::element_getter<size_type, array_type, scalar_t>;
 
 template <typename size_type, typename scalar_t>
-using block_getter_type = cmath::block_getter<size_type, array_type, scalar_t>;
+using block_getter = cmath::block_getter<size_type, array_type, scalar_t>;
 
 // matrix actor
 template <typename size_type, typename scalar_t, typename determinant_actor_t,
           typename inverse_actor_t>
 using actor = cmath::matrix::actor<size_type, array_type, matrix_type, scalar_t,
                                    determinant_actor_t, inverse_actor_t,
-                                   element_getter_type<size_type, scalar_t>,
-                                   block_getter_type<size_type, scalar_t>>;
+                                   element_getter<size_type, scalar_t>,
+                                   block_getter<size_type, scalar_t>>;
 
 namespace determinant {
 
@@ -111,15 +110,17 @@ using actor =
 
 // determinant::cofactor
 template <typename size_type, typename scalar_t, size_type... Ds>
-using cofactor = cmath::matrix::determinant::cofactor<
-    size_type, matrix_type, scalar_t, element_getter_type<size_type, scalar_t>,
-    Ds...>;
+using cofactor =
+    cmath::matrix::determinant::cofactor<size_type, matrix_type, scalar_t,
+                                         element_getter<size_type, scalar_t>,
+                                         Ds...>;
 
 // determinant::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
-using hard_coded = cmath::matrix::determinant::hard_coded<
-    size_type, matrix_type, scalar_t, element_getter_type<size_type, scalar_t>,
-    Ds...>;
+using hard_coded =
+    cmath::matrix::determinant::hard_coded<size_type, matrix_type, scalar_t,
+                                           element_getter<size_type, scalar_t>,
+                                           Ds...>;
 
 // preset(s) as standard option(s) for user's convenience
 template <typename size_type, typename scalar_t>
@@ -139,14 +140,14 @@ using actor =
 template <typename size_type, typename scalar_t, size_type... Ds>
 using cofactor =
     cmath::matrix::inverse::cofactor<size_type, matrix_type, scalar_t,
-                                     element_getter_type<size_type, scalar_t>,
+                                     element_getter<size_type, scalar_t>,
                                      Ds...>;
 
 // inverse::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
 using hard_coded =
     cmath::matrix::inverse::hard_coded<size_type, matrix_type, scalar_t,
-                                       element_getter_type<size_type, scalar_t>,
+                                       element_getter<size_type, scalar_t>,
                                        Ds...>;
 
 // preset(s) as standard option(s) for user's convenience

diff --git a/frontend/vc_vc/include/algebra/vc_vc.hpp b/frontend/vc_vc/include/algebra/vc_vc.hpp
@@ -155,19 +155,18 @@ template <typename T, std::size_t ROWS, std::size_t COLS>
 using matrix_type = vc::matrix_type<T, ROWS, COLS>;
 
 template <typename size_type, typename scalar_t>
-using element_getter_type =
-    cmath::element_getter<size_type, Vc::array, scalar_t>;
+using element_getter = cmath::element_getter<size_type, Vc::array, scalar_t>;
 
 template <typename size_type, typename scalar_t>
-using block_getter_type = cmath::block_getter<size_type, Vc::array, scalar_t>;
+using block_getter = cmath::block_getter<size_type, Vc::array, scalar_t>;
 
 // matrix actor
 template <typename size_type, typename scalar_t, typename determinant_actor_t,
           typename inverse_actor_t>
 using actor = cmath::matrix::actor<size_type, array_type, matrix_type, scalar_t,
                                    determinant_actor_t, inverse_actor_t,
-                                   element_getter_type<size_type, scalar_t>,
-                                   block_getter_type<size_type, scalar_t>>;
+                                   element_getter<size_type, scalar_t>,
+                                   block_getter<size_type, scalar_t>>;
 
 namespace determinant {
 
@@ -178,15 +177,17 @@ using actor =
 
 // determinant::cofactor
 template <typename size_type, typename scalar_t, size_type... Ds>
-using cofactor = cmath::matrix::determinant::cofactor<
-    size_type, matrix_type, scalar_t, element_getter_type<size_type, scalar_t>,
-    Ds...>;
+using cofactor =
+    cmath::matrix::determinant::cofactor<size_type, matrix_type, scalar_t,
+                                         element_getter<size_type, scalar_t>,
+                                         Ds...>;
 
 // determinant::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
-using hard_coded = cmath::matrix::determinant::hard_coded<
-    size_type, matrix_type, scalar_t, element_getter_type<size_type, scalar_t>,
-    Ds...>;
+using hard_coded =
+    cmath::matrix::determinant::hard_coded<size_type, matrix_type, scalar_t,
+                                           element_getter<size_type, scalar_t>,
+                                           Ds...>;
 
 // preset(s) as standard option(s) for user's convenience
 template <typename size_type, typename scalar_t>
@@ -206,14 +207,14 @@ using actor =
 template <typename size_type, typename scalar_t, size_type... Ds>
 using cofactor =
     cmath::matrix::inverse::cofactor<size_type, matrix_type, scalar_t,
-                                     element_getter_type<size_type, scalar_t>,
+                                     element_getter<size_type, scalar_t>,
                                      Ds...>;
 
 // inverse::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
 using hard_coded =
     cmath::matrix::inverse::hard_coded<size_type, matrix_type, scalar_t,
-                                       element_getter_type<size_type, scalar_t>,
+                                       element_getter<size_type, scalar_t>,
                                        Ds...>;
 
 // preset(s) as standard option(s) for user's convenience

diff --git a/frontend/vecmem_cmath/include/algebra/vecmem_cmath.hpp b/frontend/vecmem_cmath/include/algebra/vecmem_cmath.hpp
@@ -77,19 +77,18 @@ template <typename T, std::size_t ROWS, std::size_t COLS>
 using matrix_type = vecmem::matrix_type<T, ROWS, COLS>;
 
 template <typename size_type, typename scalar_t>
-using element_getter_type =
-    cmath::element_getter<size_type, array_type, scalar_t>;
+using element_getter = cmath::element_getter<size_type, array_type, scalar_t>;
 
 template <typename size_type, typename scalar_t>
-using block_getter_type = cmath::block_getter<size_type, array_type, scalar_t>;
+using block_getter = cmath::block_getter<size_type, array_type, scalar_t>;
 
 // matrix actor
 template <typename size_type, typename scalar_t, typename determinant_actor_t,
           typename inverse_actor_t>
 using actor = cmath::matrix::actor<size_type, array_type, matrix_type, scalar_t,
                                    determinant_actor_t, inverse_actor_t,
-                                   element_getter_type<size_type, scalar_t>,
-                                   block_getter_type<size_type, scalar_t>>;
+                                   element_getter<size_type, scalar_t>,
+                                   block_getter<size_type, scalar_t>>;
 
 namespace determinant {
 
@@ -100,15 +99,17 @@ using actor =
 
 // determinant::cofactor
 template <typename size_type, typename scalar_t, size_type... Ds>
-using cofactor = cmath::matrix::determinant::cofactor<
-    size_type, matrix_type, scalar_t, element_getter_type<size_type, scalar_t>,
-    Ds...>;
+using cofactor =
+    cmath::matrix::determinant::cofactor<size_type, matrix_type, scalar_t,
+                                         element_getter<size_type, scalar_t>,
+                                         Ds...>;
 
 // determinant::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
-using hard_coded = cmath::matrix::determinant::hard_coded<
-    size_type, matrix_type, scalar_t, element_getter_type<size_type, scalar_t>,
-    Ds...>;
+using hard_coded =
+    cmath::matrix::determinant::hard_coded<size_type, matrix_type, scalar_t,
+                                           element_getter<size_type, scalar_t>,
+                                           Ds...>;
 
 // preset(s) as standard option(s) for user's convenience
 template <typename size_type, typename scalar_t>
@@ -128,14 +129,14 @@ using actor =
 template <typename size_type, typename scalar_t, size_type... Ds>
 using cofactor =
     cmath::matrix::inverse::cofactor<size_type, matrix_type, scalar_t,
-                                     element_getter_type<size_type, scalar_t>,
+                                     element_getter<size_type, scalar_t>,
                                      Ds...>;
 
 // inverse::hard_coded
 template <typename size_type, typename scalar_t, size_type... Ds>
 using hard_coded =
     cmath::matrix::inverse::hard_coded<size_type, matrix_type, scalar_t,
-                                       element_getter_type<size_type, scalar_t>,
+                                       element_getter<size_type, scalar_t>,
                                        Ds...>;
 
 // preset(s) as standard option(s) for user's convenience