clean docstrings

Author: jalvesz

src/stdlib_linalg_iterative_aux.fypp

@@ -63,7 +63,7 @@ contains
                 aux = zero_${s}$
                 do m = L%rowptr(i), L%rowptr(i+1)-1
                     j = L%col(m)
-                    if(j>i) cycle !> skip upper part of the matrix
+                    if(j>i) cycle ! skip upper part of the matrix
                     aux = aux + L%data(m)*x(j)
                 end do
                 x(i) = b(i) - aux
@@ -77,7 +77,7 @@ contains
                 end do
                 x(i) = b(i) - aux
             end do
-        case(sparse_upper) !> treates as lower triangular (thus transpose)
+        case(sparse_upper) ! treates as lower triangular (thus transpose)
             do i = 1, L%nrows
                 x(i) = b(i)
                 do m = L%rowptr(i)+1, L%rowptr(i+1)-1
@@ -104,7 +104,7 @@ contains
                 x(i) = b(i) - baux(i)
                 do m = Lt%rowptr(i), Lt%rowptr(i+1)-1
                     j = Lt%col(m)
-                    if(j<i) cycle !> skip lower part of the matrix
+                    if(j<i) cycle ! skip lower part of the matrix
                     baux(j) = baux(j) + Lt%data(m)*x(i)
                 end do
             end do
@@ -199,8 +199,8 @@ contains
 
     #:endfor
 
-    !> Bunch-Kaufman factorization of a symmetric positive definite matrix A.
-    !> The matrix A is assumed to be symmetric and positive definite.
+    !! 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 ldlt_dense_${s}$(A, L, D)
         ${t}$, intent(in) :: A(:,:)

src/stdlib_linalg_iterative_solvers.fypp

@@ -11,8 +11,7 @@ module stdlib_linalg_iterative_solvers
     implicit none
     private 
 
-    !> brief workspace size for the iterative solvers
-    !> details The size of the workspace is defined by the number of vectors used in the iterative solver.
+    !! workspace sizes: defined by the number of vectors used by the iterative solver.
     enum, bind(c)
         enumerator :: size_wksp_cg = 3
         enumerator :: size_wksp_pcg = 4
@@ -150,7 +149,7 @@ module stdlib_linalg_iterative_solvers
     public :: solve_pcg 
 
     interface solve_forward_triangular
-        !> Solve the system L x = b, where L is a strictly lower triangular matrix (diagonal assumed = 1).
+        ! Solve the system L x = b, where L is a strictly lower triangular matrix (diagonal assumed = 1).
         #:for k, t, s in R_KINDS_TYPES
         module subroutine solve_forward_triangular_dense_${s}$(L,b,x)
             ${t}$, intent(in) :: L(:,:)
@@ -168,7 +167,7 @@ module stdlib_linalg_iterative_solvers
 
 
     interface solve_backward_triangular
-        !> Solve the system U x = b, where U is a strictly upper triangular matrix (diagonal assumed = 1).
+        ! Solve the system U x = b, where U is a strictly upper triangular matrix (diagonal assumed = 1).
         #:for k, t, s in R_KINDS_TYPES
         module subroutine solve_backward_triangular_dense_${s}$(Lt,b,x)
             ${t}$, intent(in) :: Lt(:,:)

src/stdlib_linalg_iterative_solvers_cg.fypp

@@ -34,7 +34,7 @@ contains
             if(associated(workspace%callback)) call workspace%callback(x, norm_sq0, iter)
 
             R = B
-            call A%apply(X, R, alpha= -one_${s}$, beta=one_${s}$) !> R = B - A*X
+            call A%apply(X, R, alpha= -one_${s}$, beta=one_${s}$) ! R = B - A*X
             norm_sq = A%inner_product(R, R)
 
             P = R
@@ -43,7 +43,7 @@ contains
             beta = zero_${s}$
             if(associated(workspace%callback)) call workspace%callback(x, norm_sq, iter)
             do while( norm_sq > tolsq * norm_sq0 .and. iter < maxiter)
-                call A%apply(P,Ap, alpha= one_${s}$, beta=zero_${s}$) !> Ap = A*P
+                call A%apply(P,Ap, alpha= one_${s}$, beta=zero_${s}$) ! Ap = A*P
 
                 alpha = norm_sq / A%inner_product(P, Ap)
 
@@ -111,7 +111,7 @@ contains
         !-------------------------
         ! main call to the solver
         if(restart_) x = zero_${s}$
-        x = merge( b, x, di_ ) !> copy dirichlet load conditions encoded in B and indicated by di
+        x = merge( b, x, di_ ) ! copy dirichlet load conditions encoded in B and indicated by di
         call solve_cg_kernel(op,b,x,tol_,maxiter_,workspace_)
 
         !-------------------------

src/stdlib_linalg_iterative_solvers_pcg.fypp

@@ -45,25 +45,25 @@ contains
         if ( norm_sq0 > zero_${s}$ ) then
 
             R = B
-            call A%apply(X, R, alpha= -one_${s}$, beta=one_${s}$) !> R = B - A*X
+            call A%apply(X, R, alpha= -one_${s}$, beta=one_${s}$) ! R = B - A*X
 
-            call M%apply(R,P, alpha= one_${s}$, beta=zero_${s}$) !> P = M^{-1}*R
+            call M%apply(R,P, alpha= one_${s}$, beta=zero_${s}$) ! P = M^{-1}*R
 
             tolsq = tol*tol
 
             zr1 = zero_${s}$
             zr2 = one_${s}$
             do while ( (iter < maxiter) .AND. (norm_sq > tolsq * norm_sq0) )
 
-                call M%apply(R,S, alpha= one_${s}$, beta=zero_${s}$) !> S = M^{-1}*R
+                call M%apply(R,S, alpha= one_${s}$, beta=zero_${s}$) ! S = M^{-1}*R
                 zr2 = A%inner_product( R, S )
 
                 if (iter>0) then
                     beta = zr2 / zr1
                     P = S + beta * P
                 end if
 
-                call A%apply(P, Q, alpha= one_${s}$, beta=zero_${s}$) !> Q = A*P
+                call A%apply(P, Q, alpha= one_${s}$, beta=zero_${s}$) ! Q = A*P
                 zv2 = A%inner_product( P, Q )
 
                 alpha = zr2 / zv2
@@ -114,9 +114,9 @@ contains
         integer :: precond_
         ${t}$, allocatable :: diagonal(:)
         #:if matrix == "dense"
-        ${t}$, allocatable:: L(:,:) !> lower triangular
+        ${t}$, allocatable:: L(:,:) ! lower triangular
         #:else 
-        type(${matrix}$_${s}$_type) :: L !> lower triangular
+        type(${matrix}$_${s}$_type) :: L ! lower triangular
         #:endif
         !-------------------------
         n = size(b)
@@ -147,11 +147,11 @@ contains
                 #:else 
                 call diag(A,diagonal)
                 #:endif
-                L = A !> copy A structure to L
+                L = A ! copy A structure to L
                 call ssor( A , one_${s}$ , L, diagonal )
                 M_%apply => precond_ldlt
             case(pc_ldlt)
-                L = A !> copy A structure to L
+                L = A ! copy A structure to L
                 call ldlt( A , L, diagonal )
                 M_%apply => precond_ldlt
             case default
@@ -179,7 +179,7 @@ contains
         !-------------------------
         ! main call to the solver
         if(restart_) x = zero_${s}$
-        x = merge( b, x, di_ ) !> copy dirichlet load conditions encoded in B and indicated by di
+        x = merge( b, x, di_ ) ! copy dirichlet load conditions encoded in B and indicated by di
         call solve_pcg_kernel(op,M_,b,x,tol_,maxiter_,workspace_)
 
         !-------------------------
@@ -220,15 +220,15 @@ contains
             ${t}$, intent(inout) :: y(:)
             ${t}$, intent(in) :: alpha
             ${t}$, intent(in) :: beta
-            y = merge( zero_${s}$, diagonal * x, di_ ) !> inverted diagonal
+            y = merge( zero_${s}$, diagonal * x, di_ ) ! inverted diagonal
         end subroutine
         subroutine precond_ldlt(x,y,alpha,beta)
             ${t}$, intent(in)  :: x(:)
             ${t}$, intent(inout) :: y(:)
             ${t}$, intent(in) :: alpha
             ${t}$, intent(in) :: beta
             call solve_forward_triangular( L , x , y )
-            y = merge( zero_${s}$, diagonal * y, di_ ) !> inverted diagonal
+            y = merge( zero_${s}$, diagonal * y, di_ ) ! inverted diagonal
             call solve_backward_triangular( L , y , y )
         end subroutine
     end subroutine