shorten factorization procedures names

Author: jalvesz

src/stdlib_linalg_iterative_aux.fypp

@@ -134,7 +134,7 @@ contains
     ! Factorization for preconditioners
     !==============================================================
     #:for k, t, s in R_KINDS_TYPES
-    module subroutine factorize_ssor_dense_${s}$(A, w, L, D)
+    module subroutine ssor_dense_${s}$(A, w, L, D)
         ${t}$, intent(in) :: A(:,:)
         ${t}$, intent(in) :: w
         ${t}$, intent(inout) :: L(:,:)
@@ -161,7 +161,7 @@ contains
     #:endfor
 
     #:for k, t, s in R_KINDS_TYPES
-    module subroutine factorize_ssor_csr_${s}$(A, w, L, D)
+    module subroutine ssor_csr_${s}$(A, w, L, D)
         type(CSR_${s}$_type), intent(in) :: A
         ${t}$, intent(in) :: w
         type(CSR_${s}$_type), intent(inout) :: L
@@ -202,7 +202,7 @@ contains
     !> Bunch-Kaufman factorization of a symmetric positive definite matrix A.
     !> The matrix A is assumed to be symmetric and positive definite.
     #:for k, t, s in R_KINDS_TYPES
-    module subroutine factorize_ldlt_dense_${s}$(A, L, D)
+    module subroutine ldlt_dense_${s}$(A, L, D)
         ${t}$, intent(in) :: A(:,:)
         ${t}$, intent(inout) :: L(:,:)
         ${t}$, intent(inout) :: D(:)
@@ -242,7 +242,7 @@ contains
     #:endfor
 
     #:for k, t, s in R_KINDS_TYPES
-    module subroutine factorize_ldlt_csr_${s}$(A, L, D)
+    module subroutine ldlt_csr_${s}$(A, L, D)
         type(CSR_${s}$_type), intent(in) :: A
         type(CSR_${s}$_type), intent(inout) :: L
         ${t}$, intent(inout) :: D(:)

src/stdlib_linalg_iterative_solvers.fypp

@@ -167,39 +167,39 @@ module stdlib_linalg_iterative_solvers
     end interface
     public :: solve_backward_triangular
 
-    interface factorize_ldlt
+    interface ldlt
         #:for k, t, s in R_KINDS_TYPES
-        module subroutine factorize_ldlt_dense_${s}$(A, L, D)
+        module subroutine ldlt_dense_${s}$(A, L, D)
             ${t}$, intent(in) :: A(:,:)
             ${t}$, intent(inout) :: L(:,:)
             ${t}$, intent(inout) :: D(:)
         end subroutine
-        module subroutine factorize_ldlt_csr_${s}$(A, L, D)
+        module subroutine ldlt_csr_${s}$(A, L, D)
             type(CSR_${s}$_type), intent(in) :: A
             type(CSR_${s}$_type), intent(inout) :: L
             ${t}$, intent(inout) :: D(:)
         end subroutine
         #:endfor    
     end interface
-    public :: factorize_ldlt
+    public :: ldlt
 
-    interface factorize_ssor
+    interface ssor
         #:for k, t, s in R_KINDS_TYPES
-        module subroutine factorize_ssor_dense_${s}$(A, w, L, D)
+        module subroutine ssor_dense_${s}$(A, w, L, D)
             ${t}$, intent(in) :: A(:,:)
             ${t}$, intent(in) :: w
             ${t}$, intent(inout) :: L(:,:)
             ${t}$, intent(inout) :: D(:)
         end subroutine
-        module subroutine factorize_ssor_csr_${s}$(A, w, L, D)
+        module subroutine ssor_csr_${s}$(A, w, L, D)
             type(CSR_${s}$_type), intent(in) :: A
             ${t}$, intent(in) :: w
             type(CSR_${s}$_type), intent(inout) :: L
             ${t}$, intent(inout) :: D(:)
         end subroutine
         #:endfor    
     end interface
-    public :: factorize_ssor
+    public :: ssor
 
 
 contains

src/stdlib_linalg_iterative_solvers_pccg.fypp

@@ -12,10 +12,10 @@ submodule(stdlib_linalg_iterative_solvers) stdlib_linalg_iterative_pccg
     implicit none
 
     enum, bind(c)
-        enumerator :: none = 0
-        enumerator :: jacobi
-        enumerator :: ssor 
-        enumerator :: ldlt
+        enumerator :: pc_none = 0
+        enumerator :: pc_jacobi
+        enumerator :: pc_ssor 
+        enumerator :: pc_ldlt
     end enum
 
 contains
@@ -123,7 +123,7 @@ contains
         maxiter_ = n;       if(present(maxiter)) maxiter_ = maxiter
         restart_ = .true.;  if(present(restart)) restart_ = restart
         tol_ = 1.e-4_${s}$; if(present(tol)) tol_ = tol
-        precond_ = none   ; if(present(precond)) precond_ = precond
+        precond_ = pc_none; if(present(precond)) precond_ = precond
         !-------------------------
         ! internal memory setup
         ! Preconditionner
@@ -134,25 +134,25 @@ contains
             allocate(diagonal(n),source=zero_${s}$)
 
             select case(precond_)
-            case(jacobi)
+            case(pc_jacobi)
                 #:if matrix == "dense"
                 diagonal = diag(A)
                 #:else 
                 call diag(A,diagonal)
                 #:endif
                 M_%apply => precond_jacobi
-            case(ssor)
+            case(pc_ssor)
                 #:if matrix == "dense"
                 diagonal = diag(A)
                 #:else 
                 call diag(A,diagonal)
                 #:endif
                 L = A !> copy A structure to L
-                call factorize_ssor( A , one_${s}$ , L, diagonal )
+                call ssor( A , one_${s}$ , L, diagonal )
                 M_%apply => precond_ldl
-            case(ldlt)
+            case(pc_ldlt)
                 L = A !> copy A structure to L
-                call factorize_ldlt( A , L, diagonal )
+                call ldlt( A , L, diagonal )
                 M_%apply => precond_ldl
             case default
                 M_%apply => precond_none

test/linalg/test_linalg_solve_iterative.fypp

@@ -49,13 +49,12 @@ module test_linalg_solve_iterative
 
         ${t}$ :: L(5,5), D(5)
 
-        call factorize_ldlt(A, L, D)
+        call ldlt(A, L, D)
 
         call check(error, all(abs(L-Lref)<tol), 'LDLt factorization L doesnt match')
         if (allocated(error)) return
         call check(error, all(abs(D-Dref)<tol), 'LDLt factorization D doesnt match')
         if (allocated(error)) return
-        
         end block
 
         #:endfor
@@ -76,7 +75,7 @@ module test_linalg_solve_iterative
         ${t}$ :: Dref(3) = [${t}$ :: 4, 1, 9]
         ${t}$ :: L(3,3), D(3), b(3), x(3), res(3)
 
-        call factorize_ldlt(A, L, D)
+        call ldlt(A, L, D)
 
         call check(error, all(abs(L-Lref)<tol), 'LDLt factorization L doesnt match')
         if (allocated(error)) return