add the _type suffix to all sparse types

Author: jalvesz

doc/specs/stdlib_sparse.md

@@ -39,7 +39,7 @@ enum, bind(C)
     enumerator :: sparse_upper !! Symmetric Sparse matrix with triangular supperior storage
 end enum
 ```
-In the following, all sparse kinds will be presented in two main flavors: a data-less type `<matrix>_type` useful for topological graph operations. And real/complex valued types `<matrix>_<kind>` containing the `data` buffer for the matrix values. The following rectangular matrix will be used to showcase how each sparse matrix holds the data internally:
+In the following, all sparse kinds will be presented in two main flavors: a data-less type `<matrix>_type` useful for topological graph operations. And real/complex valued types `<matrix>_<kind>_type` containing the `data` buffer for the matrix values. The following rectangular matrix will be used to showcase how each sparse matrix holds the data internally:
 
 $$ M = \begin{bmatrix} 
     9 & 0 & 0  & 0 & -3 \\
@@ -57,7 +57,7 @@ Experimental
 The `COO`, triplet or `ijv` format defines all non-zero elements of the matrix by explicitly allocating the `i,j` index and the value of the matrix. While some implementations use separate `row` and `col` arrays for the index, here we use a 2D array in order to promote fast memory acces to `ij`.
 
 ```Fortran
-type(COO_sp) :: COO
+type(COO_sp_type) :: COO
 call COO%malloc(4,5,10)
 COO%data(:)   = real([9,-3,4,7,8,-1,8,4,5,6])
 COO%index(1:2,1)  = [1,1]
@@ -81,7 +81,7 @@ Experimental
 The Compressed Sparse Row or Yale format `CSR` stores the matrix structure by compressing the row indices with a counter pointer `rowptr` enabling to know the first and last non-zero column index `col` of the given row. 
 
 ```Fortran
-type(CSR_sp) :: CSR
+type(CSR_sp_type) :: CSR
 call CSR%malloc(4,5,10)
 CSR%data(:)   = real([9,-3,4,7,8,-1,8,4,5,6])
 CSR%col(:)    = [1,5,1,2,2,3,4,1,3,4]
@@ -97,7 +97,7 @@ Experimental
 The Compressed Sparse Colum `CSC` is similar to the `CSR` format but values are accesed first by column, thus an index counter is given by `colptr` which enables to know the first and last non-zero row index of a given colum. 
 
 ```Fortran
-type(CSC_sp) :: CSC
+type(CSC_sp_type) :: CSC
 call CSC%malloc(4,5,10)
 CSC%data(:)   = real([9,4,4,7,8,-1,5,8,6,-3])
 CSC%row(:)    = [1,2,4,2,3,3,4,3,4,1]
@@ -113,7 +113,7 @@ Experimental
 The `ELL` format stores data in a dense matrix of $nrows \times K$ in column major order. By imposing a constant number of elements per row $K$, this format will incur in additional zeros being stored, but it enables efficient vectorization as memory acces is carried out by constant sized strides. 
 
 ```Fortran
-type(ELL_sp) :: ELL
+type(ELL_sp_type) :: ELL
 call ELL%malloc(num_rows=4,num_cols=5,num_nz_row=3)
 ELL%data(1,1:3)   = real([9,-3,0])
 ELL%data(2,1:3)   = real([4,7,0])

example/linalg/example_sparse_data_accessors.f90

@@ -5,8 +5,8 @@ program example_sparse_data_accessors
 
     real(dp) :: mat(2,2)
     real(dp), allocatable :: dense(:,:)
-    type(CSR_dp) :: CSR
-    type(COO_dp) :: COO
+    type(CSR_dp_type) :: CSR
+    type(COO_dp_type) :: COO
     integer :: i, j, locdof(2)
 
     ! Initial data

example/linalg/example_sparse_from_ijv.f90

@@ -5,9 +5,9 @@ program example_sparse_from_ijv
 
     integer :: row(10), col(10)
     real(dp) :: data(10)
-    type(COO_dp) :: COO
-    type(CSR_dp) :: CSR
-    type(ELL_dp) :: ELL
+    type(COO_dp_type) :: COO
+    type(CSR_dp_type) :: CSR
+    type(ELL_dp_type) :: ELL
     integer :: i, j
 
     ! Initial data

example/linalg/example_sparse_spmv.f90

@@ -7,8 +7,8 @@ program example_sparse_spmv
     real(dp) :: A(m,n), x(n)
     real(dp) :: y_dense(m), y_coo(m), y_csr(m)
     real(dp) :: alpha, beta
-    type(COO_dp) :: COO
-    type(CSR_dp) :: CSR
+    type(COO_dp_type) :: COO
+    type(CSR_dp_type) :: CSR
 
     call random_number(A)
     ! Convert from dense to COO and CSR matrices

src/stdlib_sparse_conversion.fypp

@@ -23,7 +23,7 @@ contains
     #:for k1, t1, s1 in (KINDS_TYPES)
     module subroutine dense2coo_${s1}$(dense,COO)
         ${t1}$, intent(in) :: dense(:,:)
-        type(COO_${s1}$), intent(out) :: COO
+        type(COO_${s1}$_type), intent(out) :: COO
         integer(ilp) :: num_rows, num_cols, nnz
         integer(ilp) :: i, j, idx
 
@@ -50,7 +50,7 @@ contains
 
     #:for k1, t1, s1 in (KINDS_TYPES)
     module subroutine coo2dense_${s1}$(COO,dense)
-        type(COO_${s1}$), intent(in) :: COO
+        type(COO_${s1}$_type), intent(in) :: COO
         ${t1}$, allocatable, intent(out) :: dense(:,:)
         integer(ilp) :: idx
 
@@ -64,8 +64,8 @@ contains
 
     #:for k1, t1, s1 in (KINDS_TYPES)
     module subroutine coo2csr_${s1}$(COO,CSR)
-        type(COO_${s1}$), intent(in)  :: COO
-        type(CSR_${s1}$), intent(out) :: CSR
+        type(COO_${s1}$_type), intent(in)  :: COO
+        type(CSR_${s1}$_type), intent(out) :: CSR
         integer(ilp) :: i
 
         CSR%nnz = COO%nnz; CSR%nrows = COO%nrows; CSR%ncols = COO%ncols
@@ -94,7 +94,7 @@ contains
 
     #:for k1, t1, s1 in (KINDS_TYPES)
     module subroutine csr2dense_${s1}$(CSR,dense)
-        type(CSR_${s1}$), intent(in) :: CSR
+        type(CSR_${s1}$_type), intent(in) :: CSR
         ${t1}$, allocatable, intent(out) :: dense(:,:)
         integer(ilp) :: i, j
 
@@ -120,8 +120,8 @@ contains
 
     #:for k1, t1, s1 in (KINDS_TYPES)
     module subroutine csr2coo_${s1}$(CSR,COO)
-        type(CSR_${s1}$), intent(in)  :: CSR
-        type(COO_${s1}$), intent(out) :: COO
+        type(CSR_${s1}$_type), intent(in)  :: CSR
+        type(COO_${s1}$_type), intent(out) :: COO
         integer(ilp) :: i, j
 
         COO%nnz = CSR%nnz; COO%nrows = CSR%nrows; COO%ncols = CSR%ncols
@@ -146,8 +146,8 @@ contains
 
     #:for k1, t1, s1 in (KINDS_TYPES)
     module subroutine csr2ell_${s1}$(CSR,ELL,num_nz_rows)
-        type(CSR_${s1}$), intent(in)  :: CSR
-        type(ELL_${s1}$), intent(out) :: ELL
+        type(CSR_${s1}$_type), intent(in)  :: CSR
+        type(ELL_${s1}$_type), intent(out) :: ELL
         integer, intent(in), optional :: num_nz_rows !! number of non zeros per row
 
         integer(ilp) :: i, j, num_nz_rows_, adr1, adr2
@@ -178,8 +178,8 @@ contains
     module subroutine csr2sellc_${s1}$(CSR,SELLC,chunk)
         !! csr2sellc: This function enables transfering data from a CSR matrix to a SELL-C matrix
         !! This algorithm was gracefully provided by Ivan Privec and adapted by Jose Alves
-        type(CSR_${s1}$), intent(in)    :: CSR
-        type(SELLC_${s1}$), intent(out) :: SELLC
+        type(CSR_${s1}$_type), intent(in)    :: CSR
+        type(SELLC_${s1}$_type), intent(out) :: SELLC
         integer, intent(in), optional :: chunk
         ${t1}$, parameter :: zero = zero_${s1}$
         integer(ilp) :: i, j, num_chunks
@@ -402,7 +402,7 @@ contains
             type is( COO_type )
                 call sort_coo(COO%index, COO%nnz, COO%nrows, COO%ncols)
             #:for k1, t1, s1 in (KINDS_TYPES)
-            type is( COO_${s1}$ )
+            type is( COO_${s1}$_type )
                 block
                 ${t1}$, allocatable :: temp(:)
                 if( sort_data_ ) then