Line data Source code
1 : !!****m* ABINIT/m_spmat_convert
2 : !! NAME
3 : !! m_spmat_convert
4 : !!
5 : !! FUNCTION
6 : !! This module contains the functions to convert between sparse matrix formats
7 : !!
8 : !!
9 : !! Subroutines:
10 : !! - dense_to_LIL
11 : !! - LIL_to_dense
12 : !! - LIL_to_COO
13 : !! - LIL_to_CSR
14 : !! - Dense_to_CSR
15 : !!
16 : !!
17 : !! COPYRIGHT
18 : !! Copyright (C) 2001-2026 ABINIT group (hexu)
19 : !! This file is distributed under the terms of the
20 : !! GNU General Public License, see ~abinit/COPYING
21 : !! or http://www.gnu.org/copyleft/gpl.txt .
22 : !! For the initials of contributors, see ~abinit/doc/developers/contributors.txt .
23 : !!
24 : !! SOURCE
25 :
26 : #if defined HAVE_CONFIG_H
27 : #include "config.h"
28 : #endif
29 : #include "abi_common.h"
30 :
31 :
32 : module m_spmat_convert
33 : use defs_basis
34 : use m_xmpi
35 : use m_abicore
36 : use m_errors
37 : use m_spmat_dense
38 : use m_linked_list
39 : use m_spmat_lil
40 : use m_spmat_csr
41 : use m_spmat_coo
42 : use m_spmat_lco
43 : implicit none
44 : !!****m*
45 : public
46 : !-----------------------------------------------------------------------
47 : !> @brief convert one type of matrix Amat to the other Bmat
48 : !> Note that the dense matrix is not the dense_mat_t because a
49 : !> simple 2d array is more generally used.
50 : !> @param [in] Amat
51 : !> @param [out] Bmat
52 : !-----------------------------------------------------------------------
53 : interface spmat_convert
54 : !procedure dense_to_LIL
55 : procedure LIL_to_dense
56 : procedure LIL_to_COO
57 : procedure LIL_to_CSR
58 : procedure dense_to_CSR
59 : procedure dense_to_COO
60 : procedure COO_to_CSR
61 : !procedure LCO_to_CSR
62 : end interface spmat_convert
63 :
64 : public :: COO_to_dense
65 : contains
66 :
67 : !-----------------------------------------------------------------------
68 : !> @brief dense matrix to LIL matrix
69 : !> @param [in] mat: 2D array
70 : !> @param [out] ll : LIL matrix
71 : !-----------------------------------------------------------------------
72 0 : subroutine dense_to_LIL(mat, ll)
73 : ! check shape
74 : real(dp), intent(in):: mat(:, :)
75 : type(LIL_mat_t), intent(inout) :: ll
76 : integer :: s(2), irow, icol
77 0 : s=shape(mat)
78 0 : call ll%initialize(s)
79 0 : do icol=1, ll%ncol, 1
80 0 : do irow=1, ll%nrow, 1
81 0 : call ll%insert(irow,icol,mat(irow, icol),0)
82 : enddo
83 : enddo
84 0 : end subroutine dense_to_LIL
85 :
86 : !-----------------------------------------------------------------------
87 : !> @brief LIL matrix to dense matrix
88 : !> @param [in] ll : LIL matrix
89 : !> @param [out] mat: 2D array
90 : !-----------------------------------------------------------------------
91 0 : subroutine LIL_to_dense(ll, mat)
92 : class(LIL_mat_t) , intent(inout):: ll
93 : real(dp), intent(out):: mat(ll%nrow,ll%ncol)
94 : integer:: irow
95 0 : mat(:,:)=0.0d0
96 0 : do irow=1, ll%nrow
97 0 : call llist_iter_restart(ll%rows(irow))
98 0 : do while(associated(ll%rows(irow)%iter))
99 0 : mat(irow, ll%rows(irow)%iter%i)=ll%rows(irow)%iter%val
100 0 : ll%rows(irow)%iter=>ll%rows(irow)%iter%next
101 : enddo
102 : enddo
103 0 : end subroutine LIL_to_dense
104 :
105 : !-----------------------------------------------------------------------
106 : !> @brief LIL matrix to COO matrix
107 : !> @param [in] ll : LIL matrix
108 : !> @param [out] csrmat: COO matrix
109 : !-----------------------------------------------------------------------
110 0 : subroutine LIL_to_COO(ll, COO)
111 : class(LIL_mat_t) , intent(inout):: ll
112 : class(COO_mat_t), intent(out):: COO
113 : integer :: irow
114 0 : call COO%initialize(mshape=ll%mshape)
115 0 : do irow=1, ll%nrow
116 0 : call llist_iter_restart(ll%rows(irow))
117 0 : do while(associated(ll%rows(irow)%iter))
118 0 : call coo%add_entry([irow, ll%rows(irow)%iter%i], ll%rows(irow)%iter%val)
119 0 : ll%rows(irow)%iter=>ll%rows(irow)%iter%next
120 : enddo
121 : end do
122 :
123 0 : end subroutine LIL_to_COO
124 :
125 : !-----------------------------------------------------------------------
126 : !> @brief LIL matrix to CSR matrix
127 : !> @param [in] ll : LIL matrix
128 : !> @param [out] csrmat: CSR matrix
129 : !-----------------------------------------------------------------------
130 2 : subroutine LIL_to_CSR(ll, csrmat)
131 : type(LIL_mat_t) , intent(inout):: ll
132 : type(CSR_mat_t), intent(inout):: csrmat
133 : integer:: irow, i, nzrow
134 6 : call csrmat%initialize([ll%nrow, ll%ncol])
135 2 : call csrmat%set(nnz=ll%get_nnz())
136 2 : i=0
137 2 : csrmat%row_shift(1)=1
138 1298 : do irow=1, ll%nrow
139 1296 : nzrow=0
140 1296 : call llist_iter_restart(ll%rows(irow))
141 34992 : do while(associated(ll%rows(irow)%iter))
142 33696 : nzrow=nzrow+1
143 33696 : i=i+1
144 33696 : csrmat%icol(i)=ll%rows(irow)%iter%i
145 33696 : csrmat%val(i)=ll%rows(irow)%iter%val
146 33696 : ll%rows(irow)%iter=>ll%rows(irow)%iter%next
147 : enddo
148 1298 : csrmat%row_shift(irow+1)=csrmat%row_shift(irow)+nzrow
149 : enddo
150 2 : end subroutine LIL_to_CSR
151 :
152 : !-----------------------------------------------------------------------
153 : !> @brief dense matrix to CSR matrix
154 : !> @param [in] mat: dense matrix
155 : !> @param [out] csrmat: CSR matrix
156 : !-----------------------------------------------------------------------
157 0 : subroutine dense_to_CSR(mat, csrmat)
158 : real(dp), intent(in):: mat(:, :)
159 : type(csr_mat_t), intent(out) :: csrmat
160 : !type(lil_mat_t):: lilmat
161 : integer :: i, j, nnz, nrow, ncol, inz, nzrow
162 : !call dense_to_lil(mat, lilmat)
163 : !call lil_to_csr(lilmat, csrmat)
164 : !call lilmat%finalize()
165 0 : nnz=count(mat /= 0.0_dp)
166 0 : nrow=size(mat, 1)
167 0 : ncol=size(mat, 2)
168 0 : call csrmat%initialize([nrow, ncol])
169 0 : call csrmat%set(nnz=nnz)
170 0 : csrmat%row_shift(1)=1
171 0 : inz=0
172 0 : do i=1, nrow
173 : nzrow=0
174 0 : do j=1, ncol
175 0 : if (mat(i, j)/=0.0_dp) then
176 0 : inz=inz+1
177 0 : nzrow=nzrow+1
178 0 : csrmat%icol(inz)=j
179 0 : csrmat%val(inz)=mat(i,j)
180 : end if
181 : end do
182 0 : csrmat%row_shift(i+1)=csrmat%row_shift(i)+nzrow
183 : end do
184 0 : end subroutine dense_to_CSR
185 :
186 : !-------------------------------------------------------------------!
187 : ! dense_to_coo
188 : ! Dense to COO matrix convertion
189 : !-------------------------------------------------------------------!
190 0 : subroutine dense_to_coo(mat, coo)
191 : real(dp), intent(in) :: mat(:,:)
192 : type(coo_mat_t), intent(inout) :: coo
193 : integer:: i, j
194 0 : call coo%initialize(shape(mat))
195 0 : do j=1, size(mat, dim=2)
196 0 : do i=1, size(mat, dim=1)
197 0 : if (abs(mat(i, j)) >tiny(1.0d0) ) then
198 0 : call coo%add_entry(ind=[i,j], val=mat(i,j))
199 : end if
200 : end do
201 : end do
202 0 : end subroutine dense_to_coo
203 :
204 : !-------------------------------------------------------------------!
205 : ! COO_to_CSR:
206 : ! translate COO matrix to CSR matrix
207 : ! NOTE: This can be quite slow when it is large due to the sort algorithm
208 : ! Input:
209 : ! COO matrix
210 : ! Output:
211 : ! CSR matrix
212 : !-------------------------------------------------------------------!
213 1 : subroutine COO_to_CSR(coo, csr)
214 : type(COO_mat_t), intent(inout) :: coo
215 : type(CSR_mat_t), intent(inout) :: csr
216 : integer :: ngroup
217 1 : integer, allocatable :: i1_list(:), istartend(:)
218 2 : integer :: row_nz(coo%mshape(1))
219 : integer :: i, irow
220 1 : call coo%group_by_1dim(ngroup, i1_list, istartend)
221 1 : call csr%initialize(coo%mshape)
222 1 : call csr%set(nnz=coo%nnz)
223 67585 : csr%icol(:)=coo%ind%data(2,1:coo%nnz)
224 67585 : csr%val(:) = coo%val%data(1:coo%nnz)
225 1026 : csr%row_shift(:)=0
226 1025 : row_nz(:)=0
227 1025 : do i=1, ngroup
228 1024 : irow=i1_list(i)
229 1025 : row_nz(irow) = istartend(i+1)-istartend(i)
230 : end do
231 :
232 1 : csr%row_shift(1)=1
233 1025 : do i=2, csr%nrow+1
234 1025 : csr%row_shift(i)= csr%row_shift(i-1)+row_nz(i-1)
235 : end do
236 1 : ABI_SFREE(i1_list)
237 1 : ABI_SFREE(istartend)
238 1 : end subroutine COO_to_CSR
239 :
240 :
241 : !-------------------------------------------------------------------!
242 : ! COO_to_dense
243 : ! COO matrix to dense matrix
244 : ! Input:
245 : ! COO: coo matrix
246 : ! Output:
247 : ! dense: dense matrix
248 : !-------------------------------------------------------------------!
249 0 : subroutine COO_to_dense(coo, dense)
250 : type(COO_mat_t), intent(inout) :: coo
251 : real(dp), intent(inout) :: dense(:,:)
252 : integer :: i, j, inz
253 : real(dp) :: val
254 0 : dense(:,:) =0.0
255 0 : do inz =1, coo%nnz
256 0 : i=coo%ind%data(1, inz)
257 0 : j=coo%ind%data(2, inz)
258 0 : val= coo%val%data(inz)
259 0 : dense(i,j) = dense(i,j) + val
260 : end do
261 0 : end subroutine COO_to_dense
262 :
263 :
264 : ! subroutine LCO_to_CSR(lco, csr)
265 : ! type(LCO_mat_t), intent(inout) :: lco
266 : ! type(CSR_mat_t), intent(inout) :: csr
267 : ! integer, allocatable :: i1_list(:), istartend(:)
268 : ! integer :: row_nz(lco%mshape(1))
269 : ! integer :: i, irow
270 : !
271 : ! end subroutine LCO_to_CSR
272 :
273 :
274 :
275 0 : subroutine spmat_convert_unittest()
276 : real(dp) ::mat(4,4), x(4), b(4)
277 0 : type(coo_mat_t) :: coo
278 0 : type(csr_mat_t) :: csr, csr2
279 : integer :: ngroup
280 0 : integer, allocatable :: i1list(:), ise(:)
281 0 : mat=reshape([1,2,0,0, 8, 3, 0,0, 0,2,0,0, 0,0,0,9], [4,4])*1.0d0
282 0 : call dense_to_coo(mat, coo)
283 0 : call coo%sum_duplicates()
284 0 : call dense_to_csr(mat, csr)
285 0 : call coo%group_by_1dim(ngroup, i1list, ise)
286 0 : call coo%sum_duplicates()
287 0 : ABI_SFREE(i1list)
288 0 : ABI_SFREE(ise)
289 0 : call coo_to_csr(coo, csr2)
290 :
291 0 : x=[1,2,3,4]
292 0 : b=matmul(mat, x)
293 0 : b=0
294 0 : call csr%mv(x, b)
295 0 : b=0
296 0 : call csr2%mv(x, b)
297 :
298 0 : b=0
299 0 : call csr2%mv(x, b)
300 :
301 :
302 :
303 0 : call coo%finalize()
304 0 : call csr%finalize()
305 0 : call csr2%finalize()
306 0 : end subroutine spmat_convert_unittest
307 :
308 :
309 : end module m_spmat_convert
|
