change names to stdlib_*

Author: jalvesz

doc/specs/stdlib_intrinsics.md

@@ -11,17 +11,17 @@ title: intrinsics
 The `stdlib_intrinsics` module provides replacements for some of the well known intrinsic functions found in Fortran compilers for which either a faster and/or more accurate implementation is found which has also proven of interest to the Fortran community.
 
 <!-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
-### `fsum` function
+### `stdlib_sum` function
 
 #### Description
 
-The `fsum` function can replace the intrinsic `sum` for `real` or `complex` arrays. It follows a chunked implementation which maximizes vectorization potential as well as reducing the round-off error. This procedure is recommended when summing large arrays, for repetitive summation of smaller arrays consider the classical `sum`.
+The `stdlib_sum` function can replace the intrinsic `sum` for `real` or `complex` arrays. It follows a chunked implementation which maximizes vectorization potential as well as reducing the round-off error. This procedure is recommended when summing large arrays, for repetitive summation of smaller arrays consider the classical `sum`.
 
 #### Syntax
 
-`res = ` [[stdlib_intrinsics(module):fsum(interface)]] ` (x [,mask] )`
+`res = ` [[stdlib_intrinsics(module):stdlib_sum(interface)]] ` (x [,mask] )`
 
-`res = ` [[stdlib_intrinsics(module):fsum(interface)]] ` (x, dim [,mask] )`
+`res = ` [[stdlib_intrinsics(module):stdlib_sum(interface)]] ` (x, dim [,mask] )`
 
 #### Status
 
@@ -44,11 +44,11 @@ Pure function.
 If `dim` is absent, the output is a scalar of the same `type` and `kind` as to that of `x`. Otherwise, an array of rank n-1, where n equals the rank of `x`, and a shape similar to that of `x` with dimension `dim` dropped is returned.
 
 <!-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
-### `fsum_kahan` function
+### `stdlib_sum_kahan` function
 
 #### Description
 
-The `fsum_kahan` function can replace the intrinsic `sum` for 1D `real` or `complex` arrays. It follows a chunked implementation which maximizes vectorization potential, complemented by an `elemental` kernel based on the [kahan summation](https://en.wikipedia.org/wiki/Kahan_summation_algorithm) strategy to reduce the round-off error:
+The `stdlib_sum_kahan` function can replace the intrinsic `sum` for 1D `real` or `complex` arrays. It follows a chunked implementation which maximizes vectorization potential, complemented by an `elemental` kernel based on the [kahan summation](https://en.wikipedia.org/wiki/Kahan_summation_algorithm) strategy to reduce the round-off error:
 
 ```fortran
 elemental subroutine kahan_kernel_<kind>(a,s,c)
@@ -65,7 +65,7 @@ end subroutine
 
 #### Syntax
 
-`res = ` [[stdlib_intrinsics(module):fsum_kahan(interface)]] ` (x [,mask] )`
+`res = ` [[stdlib_intrinsics(module):stdlib_sum_kahan(interface)]] ` (x [,mask] )`
 
 #### Status
 
@@ -92,15 +92,15 @@ The output is a scalar of `type` and `kind` same as to that of `x`.
 ```
 
 <!-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
-### `fprod` function
+### `stdlib_dot_product` function
 
 #### Description
 
-The `fprod` function can replace the intrinsic `dot_product` for 1D `real` or `complex` arrays. It follows a chunked implementation which maximizes vectorization potential as well as reducing the round-off error. This procedure is recommended when crunching large arrays, for repetitive products of smaller arrays consider the classical `dot_product`.
+The `stdlib_dot_product` function can replace the intrinsic `dot_product` for 1D `real` or `complex` arrays. It follows a chunked implementation which maximizes vectorization potential as well as reducing the round-off error. This procedure is recommended when crunching large arrays, for repetitive products of smaller arrays consider the classical `dot_product`.
 
 #### Syntax
 
-`res = ` [[stdlib_intrinsics(module):fprod(interface)]] ` (x, y)`
+`res = ` [[stdlib_intrinsics(module):stdlib_dot_product(interface)]] ` (x, y)`
 
 #### Status
 
@@ -121,15 +121,15 @@ Pure function.
 The output is a scalar of `type` and `kind` same as to that of `x` and `y`.
 
 <!-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
-### `fprod_kahan` function
+### `stdlib_dot_product_kahan` function
 
 #### Description
 
-The `fprod_kahan` function can replace the intrinsic `dot_product` for 1D `real` or `complex` arrays. It follows a chunked implementation which maximizes vectorization potential , complemented by the same `elemental` kernel based on the [kahan summation](https://en.wikipedia.org/wiki/Kahan_summation_algorithm) used for `fsum` to reduce the round-off error.
+The `stdlib_dot_product_kahan` function can replace the intrinsic `dot_product` for 1D `real` or `complex` arrays. It follows a chunked implementation which maximizes vectorization potential , complemented by the same `elemental` kernel based on the [kahan summation](https://en.wikipedia.org/wiki/Kahan_summation_algorithm) used for `stdlib_sum` to reduce the round-off error.
 
 #### Syntax
 
-`res = ` [[stdlib_intrinsics(module):fprod_kahan(interface)]] ` (x, y)`
+`res = ` [[stdlib_intrinsics(module):stdlib_dot_product_kahan(interface)]] ` (x, y)`
 
 #### Status
 

example/intrinsics/example_dot_product.f90

@@ -1,6 +1,6 @@
 program example_dot_product
     use stdlib_kinds, only: sp
-    use stdlib_intrinsics, only: fprod, fprod_kahan
+    use stdlib_intrinsics, only: stdlib_dot_product, stdlib_dot_product_kahan
     implicit none
 
     real(sp), allocatable :: x(:), y(:)
@@ -11,8 +11,8 @@ program example_dot_product
     call random_number(y)
 
     total_prod(1) = dot_product(x,y) !> compiler intrinsic
-    total_prod(2) = fprod(x,y)       !> chunked summation over inner product
-    total_prod(3) = fprod_kahan(x,y) !> chunked kahan summation over inner product
+    total_prod(2) = stdlib_dot_product(x,y)       !> chunked summation over inner product
+    total_prod(3) = stdlib_dot_product_kahan(x,y) !> chunked kahan summation over inner product
     print *, total_prod(1:3)
 
 end program example_dot_product

example/intrinsics/example_sum.f90

@@ -1,6 +1,6 @@
 program example_sum
     use stdlib_kinds, only: sp
-    use stdlib_intrinsics, only: fsum, fsum_kahan
+    use stdlib_intrinsics, only: stdlib_sum, stdlib_sum_kahan
     implicit none
 
     real(sp), allocatable :: x(:)
@@ -10,8 +10,8 @@ program example_sum
     call random_number(x)
 
     total_sum(1) = sum(x)       !> compiler intrinsic
-    total_sum(2) = fsum(x)      !> chunked summation
-    total_sum(3) = fsum_kahan(x)!> chunked kahan summation
+    total_sum(2) = stdlib_sum(x)      !> chunked summation
+    total_sum(3) = stdlib_sum_kahan(x)!> chunked kahan summation
     print *, total_sum(1:3)
 
 end program example_sum

src/stdlib_intrinsics.fypp

@@ -12,24 +12,24 @@ module stdlib_intrinsics
     implicit none
     private
 
-    interface fsum 
+    interface stdlib_sum 
         #:for rk, rt, rs in RC_KINDS_TYPES
-        pure module function fsum_1d_${rs}$(a) result(s)
+        pure module function stdlib_sum_1d_${rs}$(a) result(s)
             ${rt}$, intent(in) :: a(:)
             ${rt}$ :: s
         end function
-        pure module function fsum_1d_${rs}$_mask(a,mask) result(s)
+        pure module function stdlib_sum_1d_${rs}$_mask(a,mask) result(s)
             ${rt}$, intent(in) :: a(:)
             logical, intent(in) :: mask(:)
             ${rt}$ :: s
         end function
         #:for rank in RANKS
-        pure module function fsum_${rank}$d_${rs}$( x, mask ) result( s )
+        pure module function stdlib_sum_${rank}$d_${rs}$( x, mask ) result( s )
             ${rt}$, intent(in) :: x${ranksuffix(rank)}$
             logical, intent(in), optional :: mask${ranksuffix(rank)}$
             ${rt}$ :: s
         end function
-        pure module function fsum_${rank}$d_dim_${rs}$( x , dim, mask ) result( s )
+        pure module function stdlib_sum_${rank}$d_dim_${rs}$( x , dim, mask ) result( s )
             ${rt}$, intent(in) :: x${ranksuffix(rank)}$
             integer, intent(in):: dim
             logical, intent(in), optional :: mask${ranksuffix(rank)}$
@@ -38,44 +38,44 @@ module stdlib_intrinsics
         #:endfor
         #:endfor
     end interface
-    public :: fsum
+    public :: stdlib_sum
 
-    interface fsum_kahan
+    interface stdlib_sum_kahan
         #:for rk, rt, rs in RC_KINDS_TYPES
-        pure module function fsum_kahan_1d_${rs}$(a) result(s)
+        pure module function stdlib_sum_kahan_1d_${rs}$(a) result(s)
             ${rt}$, intent(in) :: a(:)
             ${rt}$ :: s
         end function
-        pure module function fsum_kahan_1d_${rs}$_mask(a,mask) result(s)
+        pure module function stdlib_sum_kahan_1d_${rs}$_mask(a,mask) result(s)
             ${rt}$, intent(in) :: a(:)
             logical, intent(in) :: mask(:)
             ${rt}$ :: s
         end function
         #:endfor
     end interface
-    public :: fsum_kahan
+    public :: stdlib_sum_kahan
 
-    interface fprod
+    interface stdlib_dot_product
         #:for rk, rt, rs in RC_KINDS_TYPES
-        pure module function fprod_${rs}$(a,b) result(p)
+        pure module function stdlib_dot_product_${rs}$(a,b) result(p)
             ${rt}$, intent(in) :: a(:)
             ${rt}$, intent(in) :: b(:)
             ${rt}$ :: p
         end function
         #:endfor
     end interface
-    public :: fprod
+    public :: stdlib_dot_product
 
-    interface fprod_kahan
+    interface stdlib_dot_product_kahan
         #:for rk, rt, rs in RC_KINDS_TYPES
-        pure module function fprod_kahan_${rs}$(a,b) result(p)
+        pure module function stdlib_dot_product_kahan_${rs}$(a,b) result(p)
             ${rt}$, intent(in) :: a(:)
             ${rt}$, intent(in) :: b(:)
             ${rt}$ :: p
         end function
         #:endfor
     end interface
-    public :: fprod_kahan
+    public :: stdlib_dot_product_kahan
 
     interface kahan_kernel 
         #:for rk, rt, rs in RC_KINDS_TYPES

src/stdlib_intrinsics_dot_product.fypp

@@ -24,7 +24,7 @@ submodule(stdlib_intrinsics) stdlib_intrinsics_dot_product
 contains
 
 #:for k1, t1, s1 in RC_KINDS_TYPES
-pure module function fprod_${s1}$(a,b) result(p)
+pure module function stdlib_dot_product_${s1}$(a,b) result(p)
     ${t1}$, intent(in) :: a(:)
     ${t1}$, intent(in) :: b(:)
     ${t1}$ :: p
@@ -48,7 +48,7 @@ end function
 #:endfor
 
 #:for k1, t1, s1 in RC_KINDS_TYPES
-pure module function fprod_kahan_${s1}$(a,b) result(p)
+pure module function stdlib_dot_product_kahan_${s1}$(a,b) result(p)
     ${t1}$, intent(in) :: a(:)
     ${t1}$, intent(in) :: b(:)
     ${t1}$ :: p

src/stdlib_intrinsics_sum.fypp

@@ -18,7 +18,7 @@ contains
 
 !================= 1D Base implementations ============
 #:for rk, rt, rs in RC_KINDS_TYPES
-pure module function fsum_1d_${rs}$(a) result(s)
+pure module function stdlib_sum_1d_${rs}$(a) result(s)
     ${rt}$, intent(in) :: a(:)
     ${rt}$ :: s
     ${rt}$ :: abatch(chunk)
@@ -39,7 +39,7 @@ pure module function fsum_1d_${rs}$(a) result(s)
     end do
 end function
 
-pure module function fsum_1d_${rs}$_mask(a,mask) result(s)
+pure module function stdlib_sum_1d_${rs}$_mask(a,mask) result(s)
     ${rt}$, intent(in) :: a(:)
     logical, intent(in) :: mask(:)
     ${rt}$ :: s
@@ -61,7 +61,7 @@ pure module function fsum_1d_${rs}$_mask(a,mask) result(s)
     end do
 end function
 
-pure module function fsum_kahan_1d_${rs}$(a) result(s)
+pure module function stdlib_sum_kahan_1d_${rs}$(a) result(s)
     ${rt}$, intent(in) :: a(:)
     ${rt}$ :: s
     ${rt}$ :: sbatch(chunk)
@@ -83,7 +83,7 @@ pure module function fsum_kahan_1d_${rs}$(a) result(s)
     end do
 end function
 
-pure module function fsum_kahan_1d_${rs}$_mask(a,mask) result(s)
+pure module function stdlib_sum_kahan_1d_${rs}$_mask(a,mask) result(s)
     ${rt}$, intent(in) :: a(:)
     logical, intent(in) :: mask(:)
     ${rt}$ :: s
@@ -110,7 +110,7 @@ end function
 !================= N-D implementations ============
 #:for rk, rt, rs in RC_KINDS_TYPES
 #:for rank in RANKS
-pure module function fsum_${rank}$d_${rs}$( x , mask ) result( s )
+pure module function stdlib_sum_${rank}$d_${rs}$( x , mask ) result( s )
     ${rt}$, intent(in) :: x${ranksuffix(rank)}$
     logical, intent(in), optional :: mask${ranksuffix(rank)}$
     ${rt}$ :: s
@@ -123,17 +123,17 @@ contains
     pure ${rt}$ function sum_recast(b,n)
       integer, intent(in) :: n
       ${rt}$, intent(in) :: b(n)
-      sum_recast = fsum(b)
+      sum_recast = stdlib_sum(b)
     end function
     pure ${rt}$ function sum_recast_mask(b,m,n)
       integer, intent(in) :: n
       ${rt}$, intent(in) :: b(n)
       logical, intent(in) :: m(n)
-      sum_recast_mask = fsum(b,m)
+      sum_recast_mask = stdlib_sum(b,m)
     end function
 end function
 
-pure module function fsum_${rank}$d_dim_${rs}$( x , dim, mask ) result( s )
+pure module function stdlib_sum_${rank}$d_dim_${rs}$( x , dim, mask ) result( s )
     ${rt}$, intent(in) :: x${ranksuffix(rank)}$
     integer, intent(in):: dim
     logical, intent(in), optional :: mask${ranksuffix(rank)}$
@@ -144,35 +144,35 @@ pure module function fsum_${rank}$d_dim_${rs}$( x , dim, mask ) result( s )
         if(dim<${rank}$)then
             do j = 1, size(x,dim=${rank}$)
                 #:if rank == 2
-                s${select_subarray(rank-1, [(rank-1, 'j')])}$ = fsum( x${select_subarray(rank, [(rank, 'j')])}$ )
+                s${select_subarray(rank-1, [(rank-1, 'j')])}$ = stdlib_sum( x${select_subarray(rank, [(rank, 'j')])}$ )
                 #:else
-                s${select_subarray(rank-1, [(rank-1, 'j')])}$ = fsum( x${select_subarray(rank, [(rank, 'j')])}$, dim=dim )
+                s${select_subarray(rank-1, [(rank-1, 'j')])}$ = stdlib_sum( x${select_subarray(rank, [(rank, 'j')])}$, dim=dim )
                 #:endif
             end do
         else
             do j = 1, size(x,dim=1)
                 #:if rank == 2
-                s${select_subarray(rank-1, [(1, 'j')])}$ = fsum( x${select_subarray(rank, [(1, 'j')])}$ )
+                s${select_subarray(rank-1, [(1, 'j')])}$ = stdlib_sum( x${select_subarray(rank, [(1, 'j')])}$ )
                 #:else
-                s${select_subarray(rank-1, [(1, 'j')])}$ = fsum( x${select_subarray(rank, [(1, 'j')])}$, dim=${rank-1}$ )
+                s${select_subarray(rank-1, [(1, 'j')])}$ = stdlib_sum( x${select_subarray(rank, [(1, 'j')])}$, dim=${rank-1}$ )
                 #:endif
             end do
         end if
     else 
         if(dim<${rank}$)then
             do j = 1, size(x,dim=${rank}$)
                 #:if rank == 2
-                s${select_subarray(rank-1, [(rank-1, 'j')])}$ = fsum( x${select_subarray(rank, [(rank, 'j')])}$, mask=mask${select_subarray(rank, [(rank, 'j')])}$ )
+                s${select_subarray(rank-1, [(rank-1, 'j')])}$ = stdlib_sum( x${select_subarray(rank, [(rank, 'j')])}$, mask=mask${select_subarray(rank, [(rank, 'j')])}$ )
                 #:else
-                s${select_subarray(rank-1, [(rank-1, 'j')])}$ = fsum( x${select_subarray(rank, [(rank, 'j')])}$, dim=dim, mask=mask${select_subarray(rank, [(rank, 'j')])}$ )
+                s${select_subarray(rank-1, [(rank-1, 'j')])}$ = stdlib_sum( x${select_subarray(rank, [(rank, 'j')])}$, dim=dim, mask=mask${select_subarray(rank, [(rank, 'j')])}$ )
                 #:endif
             end do
         else
             do j = 1, size(x,dim=1)
                 #:if rank == 2
-                s${select_subarray(rank-1, [(1, 'j')])}$ = fsum( x${select_subarray(rank, [(1, 'j')])}$, mask=mask${select_subarray(rank, [(1, 'j')])}$ )
+                s${select_subarray(rank-1, [(1, 'j')])}$ = stdlib_sum( x${select_subarray(rank, [(1, 'j')])}$, mask=mask${select_subarray(rank, [(1, 'j')])}$ )
                 #:else
-                s${select_subarray(rank-1, [(1, 'j')])}$ = fsum( x${select_subarray(rank, [(1, 'j')])}$, dim=${rank-1}$, mask=mask${select_subarray(rank, [(1, 'j')])}$ )
+                s${select_subarray(rank-1, [(1, 'j')])}$ = stdlib_sum( x${select_subarray(rank, [(1, 'j')])}$, dim=${rank-1}$, mask=mask${select_subarray(rank, [(1, 'j')])}$ )
                 #:endif
             end do
         end if