rename full matrix to dense matrix

Signed-off-by: Yuuichi Asahi <y.asahi@nr.titech.ac.jp>

Author: Yuuichi Asahi

batched/dense/unit_test/Test_Batched_DenseUtils.hpp

@@ -146,13 +146,13 @@ void create_diagonal_matrix(InViewType& in, OutViewType& out, int k = 0) {
 }
 
 /// \brief Creates a positive definite symmetric (PDS) matrix.
-/// Takes a full random matrix and converts it to a full pds matrix.
+/// Takes a dense random matrix and converts it to a dense pds matrix.
 ///
 /// \tparam InViewType: Input type for the matrix, needs to be a 3D view
 /// \tparam OutViewType: Output type for the matrix, needs to be a 3D view
 ///
-/// \param in [in]: Input batched banded matrix, a rank 3 view
-/// \param out [out]: Output batched full matrix, a rank 3 view
+/// \param in [in]: Input batched dense matrix, a rank 3 view
+/// \param out [out]: Output batched dense matrix, a rank 3 view
 ///
 template <typename InViewType, typename OutViewType>
 void random_to_pds(InViewType& in, OutViewType& out) {
@@ -198,15 +198,15 @@ void random_to_pds(InViewType& in, OutViewType& out) {
 }
 
 /// \brief Creates a banded positive definite symmetric (PDS) matrix.
-/// Takes a full diagonal dominant matrix and converts it to a banded pds matrix either
-/// in banded or full storage.
+/// Takes a dense diagonal dominant matrix and converts it to a banded pds matrix either
+/// in banded or conventional storage.
 ///
 /// \tparam InViewType: Input type for the matrix, needs to be a 3D view
 /// \tparam OutViewType: Output type for the matrix, needs to be a 3D view
 /// \tparam UploType: Type indicating whether the matrix is upper or lower triangular
 ///
 /// \param in [in]: Input batched banded matrix, a rank 3 view
-/// \param out [out]: Output batched full matrix, a rank 3 view
+/// \param out [out]: Output batched dense matrix, a rank 3 view
 /// \param k [in]: Number of sub/super-diagonals for lower/upper triangular (default is 1)
 /// \param band_storage [in]: Boolean flag indicating whether the output should be in banded storage format (default is
 /// true)
@@ -268,20 +268,20 @@ void create_banded_pds_matrix(InViewType& in, OutViewType& out, int k = 1, bool
   Kokkos::deep_copy(out, h_out);
 }
 
-/// \brief Converts a banded matrix to a full matrix.
+/// \brief Converts a tridiagonal matrix from band storage to conventional storage.
 /// Takes a upper/lower triangular banded matrix in banded storage
-/// and converts it to a full matrix.
+/// and converts it to a conventional storage
 ///
 /// \tparam InViewType: Input type for the matrix, needs to be a 3D view
 /// \tparam OutViewType: Output type for the matrix, needs to be a 3D view
 /// \tparam UploType: Type indicating whether the matrix is upper or lower triangular
 ///
 /// \param in [in]: Input batched banded matrix, a rank 3 view
-/// \param out [out]: Output batched full matrix, a rank 3 view
+/// \param out [out]: Output batched dense matrix, a rank 3 view
 /// \param k [in]: Number of sub/super-diagonals for lower/upper triangular (default is 1)
 ///
 template <typename InViewType, typename OutViewType, typename UploType>
-void banded_to_full(InViewType& in, OutViewType& out, int k = 1) {
+void banded_to_dense(InViewType& in, OutViewType& out, int k = 1) {
   auto h_in   = Kokkos::create_mirror_view(in);
   auto h_out  = Kokkos::create_mirror_view(out);
   const int N = in.extent(0), BlkSize = in.extent(2);
@@ -310,19 +310,19 @@ void banded_to_full(InViewType& in, OutViewType& out, int k = 1) {
   Kokkos::deep_copy(out, h_out);
 }
 
-/// \brief Converts a banded matrix to a full matrix.
-/// Takes a banded matrix in banded storage and converts it to a full matrix.
+/// \brief Converts a matrix from band storage to conventional storage.
+/// Takes a banded matrix in banded storage and converts it to a conventional storage.
 ///
 /// \tparam InViewType: Input type for the matrix, needs to be a 3D view
 /// \tparam OutViewType: Output type for the matrix, needs to be a 3D view
 ///
 /// \param in [in]: Input batched banded matrix, a rank 3 view
-/// \param out [out]: Output batched full matrix, a rank 3 view
+/// \param out [out]: Output batched dense matrix, a rank 3 view
 /// \param kl [in]: Number of subdiagonals for within the band of A (default is 1)
 /// \param ku [in]: Number of superdiagonals for within the band of A (default is 1)
 ///
 template <typename InViewType, typename OutViewType>
-void banded_to_full(InViewType& in, OutViewType& out, int kl = 1, int ku = 1) {
+void banded_to_dense(InViewType& in, OutViewType& out, int kl = 1, int ku = 1) {
   auto h_in    = Kokkos::create_mirror_view(in);
   auto h_out   = Kokkos::create_mirror_view(out);
   const int Nb = out.extent(0), m = out.extent(1), n = out.extent(2);
@@ -343,19 +343,19 @@ void banded_to_full(InViewType& in, OutViewType& out, int kl = 1, int ku = 1) {
   Kokkos::deep_copy(out, h_out);
 }
 
-/// \brief Converts a full matrix to a banded matrix.
-/// Takes a full matrix and converts it to a banded matrix.
+/// \brief Converts a matrix from conventional storage to band storage
+/// Takes a band matrix in conventional storage and converts it to a banded storage.
 ///
 /// \tparam InViewType: Input type for the matrix, needs to be a 3D view
 /// \tparam OutViewType: Output type for the matrix, needs to be a 3D view
 ///
-/// \param in [in]: Input batched full matrix, a rank 3 view
+/// \param in [in]: Input batched dense matrix, a rank 3 view
 /// \param out [out]: Output batched banded matrix, a rank 3 view
 /// \param kl [in]: Number of subdiagonals for within the band of A (default is 1)
 /// \param ku [in]: Number of superdiagonals for within the band of A (default is 1)
 ///
 template <typename InViewType, typename OutViewType>
-void full_to_banded(InViewType& in, OutViewType& out, int kl = 1, int ku = 1) {
+void dense_to_banded(InViewType& in, OutViewType& out, int kl = 1, int ku = 1) {
   auto h_in    = Kokkos::create_mirror_view(in);
   auto h_out   = Kokkos::create_mirror_view(out);
   const int Nb = in.extent(0), m = in.extent(1), n = in.extent(2);
@@ -368,7 +368,7 @@ void full_to_banded(InViewType& in, OutViewType& out, int kl = 1, int ku = 1) {
   for (int i0 = 0; i0 < Nb; i0++) {
     for (int i1 = 0; i1 < m; i1++) {
       for (int i2 = Kokkos::max(0, i1 - ku); i2 < Kokkos::min(n, i1 + kl + 1); i2++) {
-        // Do not use the element from the full matrix if it is outside the band
+        // Do not use the element from the dense matrix if it is outside the band
         auto row_in_banded           = kl + ku + i1 - i2;
         h_out(i0, row_in_banded, i2) = h_in(i0, i1, i2);
       }

batched/dense/unit_test/Test_Batched_SerialGbtrf.hpp

@@ -88,7 +88,6 @@ struct Functor_BatchedSerialGetrf {
 /// \brief Implementation details of batched gbtrf analytical test
 ///
 /// \param Nb [in] Batch size of matrices
-/// \param BlkSize [in] Block size of matrix A
 ///        4x4 matrix
 ///        which satisfies PA = LU
 ///        P = [[0, 0, 1, 0],
@@ -265,9 +264,9 @@ void impl_test_batched_gbtrf_analytical(const int Nb) {
   Kokkos::deep_copy(h_ipiv1_ref, h_ipiv2_m3);
 
   // Convert into banded storage
-  full_to_banded(A0, AB0, kl, ku);
-  full_to_banded(A1, AB1, kl, ku);
-  full_to_banded(A2, AB2, kl, ku);
+  dense_to_banded(A0, AB0, kl, ku);
+  dense_to_banded(A1, AB1, kl, ku);
+  dense_to_banded(A2, AB2, kl, ku);
 
   // gbtrf to factorize matrix A = P * L * U
   auto info0 =
@@ -285,10 +284,10 @@ void impl_test_batched_gbtrf_analytical(const int Nb) {
   EXPECT_EQ(info2, 0);
 
   // Extract matrix U and L from AB
-  // first convert it to the full matrix (stored in A)
-  banded_to_full<View3DType, View3DType>(AB0, A0, kl, ku);
-  banded_to_full<View3DType, View3DType>(AB1, A1, kl, ku);
-  banded_to_full<View3DType, View3DType>(AB2, A2, kl, ku);
+  // first convert it to the dense matrix (stored in A)
+  banded_to_dense<View3DType, View3DType>(AB0, A0, kl, ku);
+  banded_to_dense<View3DType, View3DType>(AB1, A1, kl, ku);
+  banded_to_dense<View3DType, View3DType>(AB2, A2, kl, ku);
 
   // Copy upper triangular components to U
   create_triangular_matrix<View3DType, View3DType, KokkosBatched::Uplo::Upper, KokkosBatched::Diag::NonUnit>(A0, U0);
@@ -348,16 +347,16 @@ void impl_test_batched_gbtrf_analytical(const int Nb) {
       EXPECT_EQ(h_ipiv0(ib, j), h_ipiv0_ref(ib, j));
       EXPECT_EQ(h_ipiv2(ib, j), h_ipiv2_ref(ib, j));
       for (int i = 0; i < BlkSize; i++) {
-        EXPECT_NEAR_KK(h_U0(ib, i, j), h_U0_ref(ib, i, j), eps, "h_U0");
-        EXPECT_NEAR_KK(h_NL0(ib, i, j), h_NL0_ref(ib, i, j), eps, "h_NL0");
+        EXPECT_NEAR_KK(h_U0(ib, i, j), h_U0_ref(ib, i, j), eps);
+        EXPECT_NEAR_KK(h_NL0(ib, i, j), h_NL0_ref(ib, i, j), eps);
       }
       for (int i = 0; i < BlkSize - 1; i++) {
-        EXPECT_NEAR_KK(h_U1(ib, i, j), h_U1_ref(ib, i, j), eps, "h_U1");
-        EXPECT_NEAR_KK(h_NL1(ib, i, j), h_NL1_ref(ib, i, j), eps, "h_NL1");
+        EXPECT_NEAR_KK(h_U1(ib, i, j), h_U1_ref(ib, i, j), eps);
+        EXPECT_NEAR_KK(h_NL1(ib, i, j), h_NL1_ref(ib, i, j), eps);
       }
       for (int i = 0; i < BlkSize + 1; i++) {
-        EXPECT_NEAR_KK(h_U2(ib, i, j), h_U2_ref(ib, i, j), eps, "h_U2");
-        EXPECT_NEAR_KK(h_NL2(ib, i, j), h_NL2_ref(ib, i, j), eps, "h_NL2");
+        EXPECT_NEAR_KK(h_U2(ib, i, j), h_U2_ref(ib, i, j), eps);
+        EXPECT_NEAR_KK(h_NL2(ib, i, j), h_NL2_ref(ib, i, j), eps);
       }
     }
     for (int j = 0; j < BlkSize - 1; j++) {
@@ -368,8 +367,7 @@ void impl_test_batched_gbtrf_analytical(const int Nb) {
 
 /// \brief Implementation details of batched gbtrf test
 ///
-/// \param N [in] Batch size of RHS (banded matrix can also be batched matrix)
-/// \param k [in] Number of superdiagonals or subdiagonals of matrix A
+/// \param N [in] Batch size of matrix A
 /// \param BlkSize [in] Block size of matrix A
 template <typename DeviceType, typename ScalarType, typename LayoutType, typename AlgoTagType>
 void impl_test_batched_gbtrf(const int Nb, const int BlkSize) {
@@ -395,17 +393,17 @@ void impl_test_batched_gbtrf(const int Nb, const int BlkSize) {
   KokkosKernels::Impl::getRandomBounds(1.0, randStart, randEnd);
   Kokkos::fill_random(LU, rand_pool, randStart, randEnd);
 
-  full_to_banded(LU, AB, kl, ku);  // In banded storage
-  banded_to_full(AB, A, kl, ku);   // In full storage
+  dense_to_banded(LU, AB, kl, ku);  // In banded storage
+  banded_to_dense(AB, A, kl, ku);   // In conventional storage
 
   Kokkos::deep_copy(LU, A);  // for getrf
 
   // gbtrf to factorize matrix A = P * L * U
   Functor_BatchedSerialGbtrf<DeviceType, View3DType, PivView2DType, AlgoTagType>(AB, ipiv, kl, ku, BlkSize).run();
 
   // Extract matrix U and L from AB
-  // first convert it to the full matrix (stored in A)
-  banded_to_full<View3DType, View3DType>(AB, A, kl, ku);
+  // first convert it to the dense matrix (stored in A)
+  banded_to_dense<View3DType, View3DType>(AB, A, kl, ku);
 
   // Copy upper triangular components to U
   create_triangular_matrix<View3DType, View3DType, KokkosBatched::Uplo::Upper, KokkosBatched::Diag::NonUnit>(A, U);

batched/dense/unit_test/Test_Batched_SerialPbtrf.hpp

@@ -94,7 +94,7 @@ struct Functor_BatchedSerialGemm {
 
 /// \brief Implementation details of batched pbtrf analytical test
 ///        Confirm A = U**H * U or L * L**H, where
-///        For full storage,
+///        For conventional storage,
 ///        A: [[4, 1],
 ///            [1, 4]]
 ///        L: [[sqrt(4), 0],
@@ -140,7 +140,7 @@ void impl_test_batched_pbtrf_analytical(const int N) {
   create_banded_triangular_matrix<View3DType, View3DType, ArgUplo>(A, Ab, k, true);
 
   // Make a reference using the naive Cholesky decomposition
-  // Cholesky decomposition for full storage
+  // Cholesky decomposition for conventional storage
   // l_kk = np.sqrt( a_kk - sum_{i=1}^{k-1}( l_ik^2 ) )
   // l_ik = 1/l_kk * ( a_ik - sum_{j=1}^{k-1}( l_ij * l_kj ) )
   auto h_Ab_ref = Kokkos::create_mirror_view(Ab_ref);
@@ -222,14 +222,14 @@ void impl_test_batched_pbtrf(const int N, const int k, const int BlkSize) {
   if (std::is_same_v<typename ParamTagType::uplo, KokkosBatched::Uplo::Upper>) {
     // A = U**H * U
     View3DType U("U", N, BlkSize, BlkSize);
-    banded_to_full<View3DType, View3DType, ArgUplo>(Ab, U, k);
+    banded_to_dense<View3DType, View3DType, ArgUplo>(Ab, U, k);
     Functor_BatchedSerialGemm<DeviceType, ScalarType, View3DType, View3DType, View3DType, Trans::ConjTranspose,
                               Trans::NoTranspose>(1.0, U, U, 0.0, A_reconst)
         .run();
   } else {
     // A = L * L**H
     View3DType L("L", N, BlkSize, BlkSize);
-    banded_to_full<View3DType, View3DType, ArgUplo>(Ab, L, k);
+    banded_to_dense<View3DType, View3DType, ArgUplo>(Ab, L, k);
     Functor_BatchedSerialGemm<DeviceType, ScalarType, View3DType, View3DType, View3DType, Trans::NoTranspose,
                               Trans::ConjTranspose>(1.0, L, L, 0.0, A_reconst)
         .run();