Major refactoring of the codebase.

example/ginzburg_landau/Ginzburg_Landau.f90

@@ -9,7 +9,8 @@ module Ginzburg_Landau
   use stdlib_optval, only : optval
   implicit none
 
-  private
+  character*128, parameter, private :: this_module = 'Ginzburg_Landau'
+
   public :: nx
   public :: initialize_parameters
 

example/ginzburg_landau/main.f90

@@ -6,6 +6,8 @@ program demo
   use Ginzburg_Landau
   implicit none
 
+  character*128, parameter :: this_module = 'Example Ginzburg_Landau'
+
   !------------------------------------------------
   !-----     LINEAR OPERATOR INVESTIGATED     -----
   !------------------------------------------------
@@ -56,7 +58,7 @@ program demo
 
   !> Call to LightKrylov.
   call eigs(A, X, lambda, residuals, info)
-  call check_info(info, 'eigs', module='example Ginzburg-Landau', procedure='main')
+  call check_info(info, 'eigs', module=this_module, procedure='main')
 
   !> Transform eigenspectrum from unit-disk to standard complex plane.
   lambda = log(lambda) / tau

src/AbstractLinops.f90

@@ -3,7 +3,8 @@ module lightkrylov_AbstractLinops
     use lightkrylov_utils
     use lightkrylov_AbstractVectors
     implicit none
-    private
+
+    character*128, parameter, private :: this_module = 'Lightkrylov_AbstractLinops'
 
     type, abstract, public :: abstract_linop
     contains

src/AbstractLinops.fypp

@@ -5,7 +5,8 @@ module lightkrylov_AbstractLinops
     use lightkrylov_utils
     use lightkrylov_AbstractVectors
     implicit none
-    private
+
+    character*128, parameter, private :: this_module = 'Lightkrylov_AbstractLinops'
 
     type, abstract, public :: abstract_linop
     contains
@@ -18,46 +19,46 @@ module lightkrylov_AbstractLinops
 
 
 
-    #:for k1, t1 in RC_KINDS_TYPES
+    #:for kind, type in RC_KINDS_TYPES
     !------------------------------------------------------------------------------
-    !-----     Definition of an abstract ${t1}$ operator with kind=${k1}$     -----
+    !-----     Definition of an abstract ${type}$ operator with kind=${kind}$     -----
     !------------------------------------------------------------------------------
-    type, abstract, extends(abstract_linop), public :: abstract_linop_${t1[0]}$${k1}$
+    type, abstract, extends(abstract_linop), public :: abstract_linop_${type[0]}$${kind}$
         !! Base type to define an abstract linear operator. All other types defined in
         !! `LightKrylov` derive from this fundamental one.
     contains
         private
-        procedure(abstract_matvec_${t1[0]}$${k1}$), pass(self), deferred, public :: matvec
+        procedure(abstract_matvec_${type[0]}$${kind}$), pass(self), deferred, public :: matvec
         !! Procedure to compute the matrix-vector product \( \mathbf{y} = \mathbf{Ax} \).
-        procedure(abstract_matvec_${t1[0]}$${k1}$), pass(self), deferred, public :: rmatvec
+        procedure(abstract_matvec_${type[0]}$${kind}$), pass(self), deferred, public :: rmatvec
         !! Procedure to compute the reversed matrix-vector product \( \mathbf{y} = \mathbf{A}^H \mathbf{x} \).
     end type
 
     abstract interface
-        subroutine abstract_matvec_${t1[0]}$${k1}$(self, vec_in, vec_out)
+        subroutine abstract_matvec_${type[0]}$${kind}$(self, vec_in, vec_out)
             !! Interface for the matrix-vector product.
             use lightkrylov_AbstractVectors
-            import abstract_linop_${t1[0]}$${k1}$
-            class(abstract_linop_${t1[0]}$${k1}$) , intent(in)  :: self
+            import abstract_linop_${type[0]}$${kind}$
+            class(abstract_linop_${type[0]}$${kind}$) , intent(in)  :: self
             !! Linear operator \(\mathbf{A}\).
-            class(abstract_vector_${t1[0]}$${k1}$), intent(in)  :: vec_in
+            class(abstract_vector_${type[0]}$${kind}$), intent(in)  :: vec_in
             !! Vector to be multiplied by \(\mathbf{A}\).
-            class(abstract_vector_${t1[0]}$${k1}$), intent(out) :: vec_out
+            class(abstract_vector_${type[0]}$${kind}$), intent(out) :: vec_out
             !! Result of the matrix-vector product.
-        end subroutine abstract_matvec_${t1[0]}$${k1}$
+        end subroutine abstract_matvec_${type[0]}$${kind}$
     end interface
 
-    type, extends(abstract_linop_${t1[0]}$${k1}$), public :: adjoint_linop_${t1[0]}$${k1}$
+    type, extends(abstract_linop_${type[0]}$${kind}$), public :: adjoint_linop_${type[0]}$${kind}$
         !! Utility type to define an adjoint linear operator. The definition of `matvec` and `rmatvec`
         !! are directly inherited from those used to define `A`. Note that this utility does not
         !! compute the adjoint for you. It simply provides a utility to define a new operator
         !! with `matvec` and `rmatvec` being switched.
-        class(abstract_linop_${t1[0]}$${k1}$), allocatable :: A
+        class(abstract_linop_${type[0]}$${kind}$), allocatable :: A
         !! Linear operator whose adjoint needs to be defined.
     contains
         private
-        procedure, pass(self), public :: matvec => adjoint_matvec_${t1[0]}$${k1}$
-        procedure, pass(self), public :: rmatvec => adjoint_rmatvec_${t1[0]}$${k1}$
+        procedure, pass(self), public :: matvec => adjoint_matvec_${type[0]}$${kind}$
+        procedure, pass(self), public :: rmatvec => adjoint_rmatvec_${type[0]}$${kind}$
     end type
 
 

src/AbstractVectors.f90

@@ -2,18 +2,23 @@ module lightkrylov_AbstractVectors
     use lightkrylov_constants
     use lightkrylov_utils
     implicit none
-    private
 
-    public :: innerprod_matrix
+    character*128, parameter, private :: this_module = 'Lightkrylov_AbstractVectors'
+
+    public :: innerprod
     public :: linear_combination
     public :: axpby_basis
     public :: zero_basis
     public :: copy_basis
 
-    interface innerprod_matrix
+    interface innerprod
+        module procedure innerprod_vector_rsp
         module procedure innerprod_matrix_rsp
+        module procedure innerprod_vector_rdp
         module procedure innerprod_matrix_rdp
+        module procedure innerprod_vector_csp
         module procedure innerprod_matrix_csp
+        module procedure innerprod_vector_cdp
         module procedure innerprod_matrix_cdp
     end interface
 
@@ -574,6 +579,25 @@ subroutine linear_combination_matrix_rsp(Y, X, B)
         return
     end subroutine linear_combination_matrix_rsp
 
+    subroutine innerprod_vector_rsp(v, X, y)
+        !! Computes the inner product vector \( \mathbf{v} = \mathbf{X}^H \mathbf{v} \) between
+        !! a basis `X` of `abstract_vector` and `v`, a single `abstract_vector`.
+        class(abstract_vector_rsp), intent(in) :: X(:), y
+        !! Bases of `abstract_vector` whose inner products need to be computed.
+        real(sp), intent(out) :: v(size(X))
+        !! Resulting inner-product vector.
+
+        ! Local variables.
+        integer :: i
+
+        v = 0.0_sp
+        do i = 1, size(X)
+            v(i) = X(i)%dot(y)
+        enddo
+
+        return
+    end subroutine innerprod_vector_rsp
+
     subroutine innerprod_matrix_rsp(M, X, Y)
         !! Computes the inner product matrix \( \mathbf{M} = \mathbf{X}^H \mathbf{Y} \) between
         !! two bases of `abstract_vector`.
@@ -718,6 +742,25 @@ subroutine linear_combination_matrix_rdp(Y, X, B)
         return
     end subroutine linear_combination_matrix_rdp
 
+    subroutine innerprod_vector_rdp(v, X, y)
+        !! Computes the inner product vector \( \mathbf{v} = \mathbf{X}^H \mathbf{v} \) between
+        !! a basis `X` of `abstract_vector` and `v`, a single `abstract_vector`.
+        class(abstract_vector_rdp), intent(in) :: X(:), y
+        !! Bases of `abstract_vector` whose inner products need to be computed.
+        real(dp), intent(out) :: v(size(X))
+        !! Resulting inner-product vector.
+
+        ! Local variables.
+        integer :: i
+
+        v = 0.0_dp
+        do i = 1, size(X)
+            v(i) = X(i)%dot(y)
+        enddo
+
+        return
+    end subroutine innerprod_vector_rdp
+
     subroutine innerprod_matrix_rdp(M, X, Y)
         !! Computes the inner product matrix \( \mathbf{M} = \mathbf{X}^H \mathbf{Y} \) between
         !! two bases of `abstract_vector`.
@@ -862,6 +905,25 @@ subroutine linear_combination_matrix_csp(Y, X, B)
         return
     end subroutine linear_combination_matrix_csp
 
+    subroutine innerprod_vector_csp(v, X, y)
+        !! Computes the inner product vector \( \mathbf{v} = \mathbf{X}^H \mathbf{v} \) between
+        !! a basis `X` of `abstract_vector` and `v`, a single `abstract_vector`.
+        class(abstract_vector_csp), intent(in) :: X(:), y
+        !! Bases of `abstract_vector` whose inner products need to be computed.
+        complex(sp), intent(out) :: v(size(X))
+        !! Resulting inner-product vector.
+
+        ! Local variables.
+        integer :: i
+
+        v = 0.0_sp
+        do i = 1, size(X)
+            v(i) = X(i)%dot(y)
+        enddo
+
+        return
+    end subroutine innerprod_vector_csp
+
     subroutine innerprod_matrix_csp(M, X, Y)
         !! Computes the inner product matrix \( \mathbf{M} = \mathbf{X}^H \mathbf{Y} \) between
         !! two bases of `abstract_vector`.
@@ -1006,6 +1068,25 @@ subroutine linear_combination_matrix_cdp(Y, X, B)
         return
     end subroutine linear_combination_matrix_cdp
 
+    subroutine innerprod_vector_cdp(v, X, y)
+        !! Computes the inner product vector \( \mathbf{v} = \mathbf{X}^H \mathbf{v} \) between
+        !! a basis `X` of `abstract_vector` and `v`, a single `abstract_vector`.
+        class(abstract_vector_cdp), intent(in) :: X(:), y
+        !! Bases of `abstract_vector` whose inner products need to be computed.
+        complex(dp), intent(out) :: v(size(X))
+        !! Resulting inner-product vector.
+
+        ! Local variables.
+        integer :: i
+
+        v = 0.0_dp
+        do i = 1, size(X)
+            v(i) = X(i)%dot(y)
+        enddo
+
+        return
+    end subroutine innerprod_vector_cdp
+
     subroutine innerprod_matrix_cdp(M, X, Y)
         !! Computes the inner product matrix \( \mathbf{M} = \mathbf{X}^H \mathbf{Y} \) between
         !! two bases of `abstract_vector`.