rename with stdlib_ prefix

Author: jalvesz

doc/specs/stdlib_linalg_iterative_solvers.md

@@ -17,7 +17,7 @@ The `stdlib_linalg_iterative_solvers` module provides base implementations for k
 <!-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
 ### The `linop` derived type
 
-The `linop_<kind>_type` derive type is an auxiliary class enabling to abstract the definition of the linear system and the actual implementation of the solvers.
+The `stdlib_linop_<kind>_type` derive type is an auxiliary class enabling to abstract the definition of the linear system and the actual implementation of the solvers.
 
 #### Type-bound procedures
 
@@ -72,7 +72,7 @@ The output is a scalar of `type` and `kind` same as to that of `x` and `y`.
 <!-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
 ### The `solver_workspace` derived type
 
-The `solver_workspace_<kind>_type` derive type is an auxiliary class enabling to hold the data associated to the working arrays needed by the solvers to operate.
+The `stdlib_solver_workspace_<kind>_type` derive type is an auxiliary class enabling to hold the data associated to the working arrays needed by the solvers to operate.
 
 #### Type-bound procedures
 
@@ -91,15 +91,15 @@ Subroutine
 `iter`: scalar of `integer` type giving the current iteration counter. This argument is `intent(in)`.
 
 <!-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
-### `solve_cg_kernel` subroutine
+### `stdlib_solve_cg_kernel` subroutine
 
 #### Description
 
 Implements the Conjugate Gradient (CG) method for solving the linear system \( Ax = b \), where \( A \) is a symmetric positive-definite linear operator defined via the `linop` type. This is the core implementation, allowing flexibility for custom matrix types or parallel environments.
 
 #### Syntax
 
-`call ` [[stdlib_iterative_solvers(module):solve_cg_kernel(interface)]] ` (A, b, x, tol, maxiter, workspace)`
+`call ` [[stdlib_iterative_solvers(module):stdlib_solve_cg_kernel(interface)]] ` (A, b, x, tol, maxiter, workspace)`
 
 #### Status
 
@@ -111,7 +111,7 @@ Subroutine
 
 #### Argument(s)
 
-`A`: `class(linop_<kind>_type)` defining the linear operator. This argument is `intent(in)`.
+`A`: `class(stdlib_linop_<kind>_type)` defining the linear operator. This argument is `intent(in)`.
 
 `b`: 1-D array of `real(<kind>)` defining the loading conditions of the linear system. This argument is `intent(in)`.
 
@@ -121,7 +121,7 @@ Subroutine
 
 `maxiter`: scalar of type `integer` defining the maximum allowed number of iterations. This argument is `intent(in)`.
 
-`workspace`: `type(solver_workspace_<kind>_type)` holding the work temporal array for the solver. This argument is `intent(inout)`.
+`workspace`: `type(stdlib_solver_workspace_<kind>_type)` holding the work temporal array for the solver. This argument is `intent(inout)`.
 
 <!-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
 ### `solve_cg` subroutine
@@ -156,7 +156,7 @@ Subroutine
 
 `maxiter` (optional): scalar of type `integer` defining the maximum allowed number of iterations. If no value is given, a default of `N` is set, where `N = size(b)`. This argument is `intent(in)`.
 
-`workspace` (optional): scalar derived type of `type(solver_workspace_<kind>_type)` holding the work array for the solver. If the user passes its own `workspace`, then a pointer is set internally to it. Otherwise, memory will be internally allocated and deallocated before exiting the procedure. This argument is `intent(inout)`.
+`workspace` (optional): scalar derived type of `type(stdlib_solver_workspace_<kind>_type)` holding the work array for the solver. If the user passes its own `workspace`, then a pointer is set internally to it. Otherwise, memory will be internally allocated and deallocated before exiting the procedure. This argument is `intent(inout)`.
 
 #### Example
 
@@ -165,15 +165,15 @@ Subroutine
 ```
 
 <!-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
-### `solve_pcg_kernel` subroutine
+### `stdlib_solve_pcg_kernel` subroutine
 
 #### Description
 
 Implements the Preconditioned Conjugate Gradient (PCG) method for solving the linear system \( Ax = b \), where \( A \) is a symmetric positive-definite linear operator defined via the `linop` type. This is the core implementation, allowing flexibility for custom matrix types or parallel environments.
 
 #### Syntax
 
-`call ` [[stdlib_iterative_solvers(module):solve_cg_kernel(interface)]] ` (A, M, b, x, tol, maxiter, workspace)`
+`call ` [[stdlib_iterative_solvers(module):stdlib_solve_cg_kernel(interface)]] ` (A, M, b, x, tol, maxiter, workspace)`
 
 #### Status
 
@@ -185,9 +185,9 @@ Subroutine
 
 #### Argument(s)
 
-`A`: `class(linop_<kind>_type)` defining the linear operator. This argument is `intent(in)`.
+`A`: `class(stdlib_linop_<kind>_type)` defining the linear operator. This argument is `intent(in)`.
 
-`M`: `class(linop_<kind>_type)` defining the preconditioner linear operator. This argument is `intent(in)`.
+`M`: `class(stdlib_linop_<kind>_type)` defining the preconditioner linear operator. This argument is `intent(in)`.
 
 `b`: 1-D array of `real(<kind>)` defining the loading conditions of the linear system. This argument is `intent(in)`.
 
@@ -197,7 +197,7 @@ Subroutine
 
 `maxiter`: scalar of type `integer` defining the maximum allowed number of iterations. This argument is `intent(in)`.
 
-`workspace`: scalar derived type  of `type(solver_workspace_<kind>_type)` holding the work array for the solver. This argument is `intent(inout)`.
+`workspace`: scalar derived type  of `type(stdlib_solver_workspace_<kind>_type)` holding the work array for the solver. This argument is `intent(inout)`.
 
 #### Example
 
@@ -206,15 +206,15 @@ Subroutine
 ```
 
 <!-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
-### `solve_pcg` subroutine
+### `stdlib_solve_pcg` subroutine
 
 #### Description
 
 Provides a user-friendly interface to the PCG method for solving \( Ax = b \), supporting `dense` and `CSR_<kind>_type` matrices. It supports optional preconditioners and handles workspace allocation.
 
 #### Syntax
 
-`call ` [[stdlib_iterative_solvers(module):solve_pcg(interface)]] ` (A, b, x [, di, tol, maxiter, restart, precond, M, workspace])`
+`call ` [[stdlib_iterative_solvers(module):stdlib_solve_pcg(interface)]] ` (A, b, x [, di, tol, maxiter, restart, precond, M, workspace])`
 
 #### Status
 
@@ -240,9 +240,9 @@ Subroutine
 
 `precond` (optional): scalar of type `integer` enabling to switch among the default preconditioners available with the following enum (`pc_none`, `pc_jacobi`). If no value is given, no preconditionning will be applied. This argument is `intent(in)`.
 
-`M` (optional): scalar derived type of `class(linop_<kind>_type)` defining a custom preconditioner linear operator. If given, `precond` will have no effect, a pointer is set to this custom preconditioner.
+`M` (optional): scalar derived type of `class(stdlib_linop_<kind>_type)` defining a custom preconditioner linear operator. If given, `precond` will have no effect, a pointer is set to this custom preconditioner.
 
-`workspace` (optional): scalar derived type of `type(solver_workspace_<kind>_type)` holding the work temporal array for the solver. If the user passes its own `workspace`, then internally a pointer is set to it, otherwise, memory will be internally allocated and deallocated before exiting the procedure. This argument is `intent(inout)`.
+`workspace` (optional): scalar derived type of `type(stdlib_solver_workspace_<kind>_type)` holding the work temporal array for the solver. If the user passes its own `workspace`, then internally a pointer is set to it, otherwise, memory will be internally allocated and deallocated before exiting the procedure. This argument is `intent(inout)`.
 
 #### Example
 

example/linalg/example_solve_cg.f90

@@ -1,6 +1,6 @@
 program example_solve_cg
     use stdlib_kinds, only: int8, dp
-    use stdlib_linalg_iterative_solvers, only: solve_cg
+    use stdlib_linalg_iterative_solvers, only: stdlib_solve_cg
 
     real(dp) :: matrix(2,2)
     real(dp) :: x(2), rhs(2)
@@ -11,7 +11,7 @@ program example_solve_cg
     x   = dble( [2,1] ) !> initial guess
     rhs = dble( [1,2] ) !> rhs vector
 
-    call solve_cg(matrix, rhs, x, restart=.false.)
+    call stdlib_solve_cg(matrix, rhs, x, restart=.false.)
     print *, x !> solution: [0.0909, 0.6364]
 
 end program

example/linalg/example_solve_custom.f90

@@ -1,30 +1,30 @@
 module custom_solver
     use stdlib_kinds, only: int8, dp
     use stdlib_sparse, only: CSR_dp_type, spmv, diag
-    use stdlib_linalg_iterative_solvers, only: linop_dp_type, &
-                    solver_workspace_dp_type, &
-                    solve_pcg_kernel, &
+    use stdlib_linalg_iterative_solvers, only: stdlib_linop_dp_type, &
+                    stdlib_solver_workspace_dp_type, &
+                    stdlib_solve_pcg_kernel, &
                     stdlib_size_wksp_pcg
     use stdlib_optval, only: optval
     implicit none
     private
-    public :: solve_pcg_custom
+    public :: stdlib_solve_pcg_custom
 
 contains
 
-    subroutine solve_pcg_custom(A,b,x,di,tol,maxiter,restart,workspace)
+    subroutine stdlib_solve_pcg_custom(A,b,x,di,tol,maxiter,restart,workspace)
         type(CSR_dp_type), intent(in) :: A
         real(dp), intent(in) :: b(:)
         real(dp), intent(inout) :: x(:)
         real(dp), intent(in), optional :: tol
         logical(int8), intent(in), optional, target  :: di(:)
         integer, intent(in), optional  :: maxiter
         logical, intent(in), optional  :: restart
-        type(solver_workspace_dp_type), optional, intent(inout), target :: workspace
+        type(stdlib_solver_workspace_dp_type), optional, intent(inout), target :: workspace
         !-------------------------
-        type(linop_dp_type) :: op
-        type(linop_dp_type) :: M
-        type(solver_workspace_dp_type), pointer :: workspace_
+        type(stdlib_linop_dp_type) :: op
+        type(stdlib_linop_dp_type) :: M
+        type(stdlib_solver_workspace_dp_type), pointer :: workspace_
         integer :: n, maxiter_
         real(dp) :: tol_
         logical :: restart_
@@ -61,7 +61,7 @@ subroutine solve_pcg_custom(A,b,x,di,tol,maxiter,restart,workspace)
         where(abs(diagonal)>epsilon(0._dp)) diagonal = 1._dp/diagonal
         !-------------------------
         ! main call to the solver
-        call solve_pcg_kernel(op,M,b,x,tol_,maxiter_,workspace_)
+        call stdlib_solve_pcg_kernel(op,M,b,x,tol_,maxiter_,workspace_)
 
         !-------------------------
         ! internal memory cleanup
@@ -135,7 +135,7 @@ program example_solve_custom
     dirichlet = .false._1 
     dirichlet([1,5]) = .true._1
 
-    call solve_pcg_custom(laplacian_csr, rhs, x, tol=1.d-6, di=dirichlet)
+    call stdlib_solve_pcg_custom(laplacian_csr, rhs, x, tol=1.d-6, di=dirichlet)
     print *, x !> solution: [0.0, 2.5, 5.0, 2.5, 0.0]
 
 end program example_solve_custom

example/linalg/example_solve_pcg.f90

@@ -1,7 +1,7 @@
 program example_solve_pcg
     use stdlib_kinds, only: int8, dp
     use stdlib_sparse
-    use stdlib_linalg_iterative_solvers, only: solve_pcg
+    use stdlib_linalg_iterative_solvers, only: stdlib_solve_pcg
 
     type(CSR_dp_type) :: laplacian_csr
     type(COO_dp_type) :: COO
@@ -23,10 +23,10 @@ program example_solve_pcg
     dirichlet = .false._int8
     dirichlet([1,5]) = .true._int8
 
-    call solve_pcg(laplacian, rhs, x, tol=1.d-6, di=dirichlet)
+    call stdlib_solve_pcg(laplacian, rhs, x, tol=1.d-6, di=dirichlet)
     print *, x !> solution: [0.0, 2.5, 5.0, 2.5, 0.0]
     x = 0._dp
 
-    call solve_pcg(laplacian_csr, rhs, x, tol=1.d-6, di=dirichlet)
+    call stdlib_solve_pcg(laplacian_csr, rhs, x, tol=1.d-6, di=dirichlet)
     print *, x !> solution: [0.0, 2.5, 5.0, 2.5, 0.0]
 end program

src/stdlib_linalg_iterative_solvers.fypp

@@ -23,7 +23,7 @@ module stdlib_linalg_iterative_solvers
     !! linop type holding the linear operator and its associated methods.
     !! The `linop` type is used to define the linear operator for the iterative solvers.
     #:for k, t, s in R_KINDS_TYPES
-    type, public :: linop_${s}$_type
+    type, public :: stdlib_linop_${s}$_type
         procedure(vector_sub_${s}$), nopass, pointer    :: matvec => null()
         procedure(reduction_sub_${s}$), nopass, pointer :: inner_product => default_dot_${s}$
     end type
@@ -33,7 +33,7 @@ module stdlib_linalg_iterative_solvers
     !!
     !! solver_workspace type holding temporal array data for the iterative solvers.
     #:for k, t, s in R_KINDS_TYPES
-    type, public :: solver_workspace_${s}$_type
+    type, public :: stdlib_solver_workspace_${s}$_type
         ${t}$, allocatable :: tmp(:,:)
         procedure(logger_sub_${s}$), pointer, nopass :: callback => null()
     end type 
@@ -66,26 +66,26 @@ module stdlib_linalg_iterative_solvers
 
     !! version: experimental
     !!
-    !! solve_cg_kernel interface for the conjugate gradient method.
-    !! [Specifications](../page/specs/stdlib_linalg_iterative_solvers.html#solve_cg_kernel)
-    interface solve_cg_kernel
+    !! stdlib_solve_cg_kernel interface for the conjugate gradient method.
+    !! [Specifications](../page/specs/stdlib_linalg_iterative_solvers.html#stdlib_solve_cg_kernel)
+    interface stdlib_solve_cg_kernel
         #:for k, t, s in R_KINDS_TYPES
-        module subroutine solve_cg_kernel_${s}$(A,b,x,tol,maxiter,workspace)
-            class(linop_${s}$_type), intent(in) :: A !! linear operator
+        module subroutine stdlib_solve_cg_kernel_${s}$(A,b,x,tol,maxiter,workspace)
+            class(stdlib_linop_${s}$_type), intent(in) :: A !! linear operator
             ${t}$, intent(in) :: b(:) !! right-hand side vector
             ${t}$, intent(inout) :: x(:) !! solution vector and initial guess
             ${t}$, intent(in) :: tol !! tolerance for convergence
             integer, intent(in) :: maxiter !! maximum number of iterations
-            type(solver_workspace_${s}$_type), intent(inout) :: workspace !! workspace for the solver
+            type(stdlib_solver_workspace_${s}$_type), intent(inout) :: workspace !! workspace for the solver
         end subroutine
         #:endfor
     end interface
-    public :: solve_cg_kernel
+    public :: stdlib_solve_cg_kernel
 
-    interface solve_cg
+    interface stdlib_solve_cg
         #:for matrix in MATRIX_TYPES
         #:for k, t, s in R_KINDS_TYPES
-        module subroutine solve_cg_${matrix}$_${s}$(A,b,x,di,tol,maxiter,restart,workspace)
+        module subroutine stdlib_solve_cg_${matrix}$_${s}$(A,b,x,di,tol,maxiter,restart,workspace)
             !! linear operator matrix
             #:if matrix == "dense"
             ${t}$, intent(in) :: A(:,:) 
@@ -98,36 +98,36 @@ module stdlib_linalg_iterative_solvers
             logical(1), intent(in), optional, target  :: di(:) !! dirichlet conditions mask
             integer, intent(in), optional :: maxiter !! maximum number of iterations
             logical, intent(in), optional :: restart !! restart flag
-            type(solver_workspace_${s}$_type), optional, intent(inout), target :: workspace !! workspace for the solver
+            type(stdlib_solver_workspace_${s}$_type), optional, intent(inout), target :: workspace !! workspace for the solver
         end subroutine
         #:endfor
         #:endfor
     end interface
-    public :: solve_cg
+    public :: stdlib_solve_cg
 
     !! version: experimental
     !!
-    !! solve_pcg_kernel interface for the preconditionned conjugate gradient method.
-    !! [Specifications](../page/specs/stdlib_linalg_iterative_solvers.html#solve_pcg_kernel)
-    interface solve_pcg_kernel
+    !! stdlib_solve_pcg_kernel interface for the preconditionned conjugate gradient method.
+    !! [Specifications](../page/specs/stdlib_linalg_iterative_solvers.html#stdlib_solve_pcg_kernel)
+    interface stdlib_solve_pcg_kernel
         #:for k, t, s in R_KINDS_TYPES
-        module subroutine solve_pcg_kernel_${s}$(A,M,b,x,tol,maxiter,workspace)
-            class(linop_${s}$_type), intent(in) :: A !! linear operator
-            class(linop_${s}$_type), intent(in) :: M !! preconditioner linear operator
+        module subroutine stdlib_solve_pcg_kernel_${s}$(A,M,b,x,tol,maxiter,workspace)
+            class(stdlib_linop_${s}$_type), intent(in) :: A !! linear operator
+            class(stdlib_linop_${s}$_type), intent(in) :: M !! preconditioner linear operator
             ${t}$, intent(in) :: b(:) !! right-hand side vector
             ${t}$, intent(inout) :: x(:) !! solution vector and initial guess
             ${t}$, intent(in) :: tol !! tolerance for convergence
             integer, intent(in) :: maxiter !! maximum number of iterations
-            type(solver_workspace_${s}$_type), intent(inout) :: workspace !! workspace for the solver
+            type(stdlib_solver_workspace_${s}$_type), intent(inout) :: workspace !! workspace for the solver
         end subroutine
         #:endfor
     end interface
-    public :: solve_pcg_kernel
+    public :: stdlib_solve_pcg_kernel
 
-    interface solve_pcg
+    interface stdlib_solve_pcg
         #:for matrix in MATRIX_TYPES
         #:for k, t, s in R_KINDS_TYPES
-        module subroutine solve_pcg_${matrix}$_${s}$(A,b,x,di,tol,maxiter,restart,precond,M,workspace)
+        module subroutine stdlib_solve_pcg_${matrix}$_${s}$(A,b,x,di,tol,maxiter,restart,precond,M,workspace)
             !! linear operator matrix
             #:if matrix == "dense"
             ${t}$, intent(in) :: A(:,:)
@@ -141,13 +141,13 @@ module stdlib_linalg_iterative_solvers
             integer, intent(in), optional  :: maxiter !! maximum number of iterations
             logical, intent(in), optional :: restart !! restart flag
             integer, intent(in), optional  :: precond !! preconditioner method enumerator
-            class(linop_${s}$_type), optional , intent(in), target :: M !! preconditioner linear operator
-            type(solver_workspace_${s}$_type), optional, intent(inout), target :: workspace !! workspace for the solver
+            class(stdlib_linop_${s}$_type), optional , intent(in), target :: M !! preconditioner linear operator
+            type(stdlib_solver_workspace_${s}$_type), optional, intent(inout), target :: workspace !! workspace for the solver
         end subroutine
         #:endfor
         #:endfor
     end interface
-    public :: solve_pcg 
+    public :: stdlib_solve_pcg 
 
 contains