stdlib_intrinsics#

See also the specification page: stdlib_intrinsics.

stdlib_intrinsics (module)#

Alternative implementations of some Fortran intrinsic functions offering either faster and/or more accurate evaluation. (Specification: stdlib_intrinsics)

Interfaces

stdlib_sum (interface)#

stdlib_sum (interface)
Procedures:
pure module function stdlib_sum_1d_int8(a) -> s#
Arguments:
ainteger(kind=int8), intent(in), dimension(:)
Returns:
sinteger(kind=int8)
pure module function stdlib_sum_1d_int8_mask(a, mask) -> s#
Arguments:
ainteger(kind=int8), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
sinteger(kind=int8)
pure module function stdlib_sum_2d_int8(x, mask) -> s#
Arguments:
xinteger(kind=int8), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sinteger(kind=int8)
pure module function stdlib_sum_2d_dim_int8(x, dim, mask) -> s#
Arguments:
xinteger(kind=int8), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sinteger(kind=int8), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_3d_int8(x, mask) -> s#
Arguments:
xinteger(kind=int8), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sinteger(kind=int8)
pure module function stdlib_sum_3d_dim_int8(x, dim, mask) -> s#
Arguments:
xinteger(kind=int8), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sinteger(kind=int8), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_4d_int8(x, mask) -> s#
Arguments:
xinteger(kind=int8), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sinteger(kind=int8)
pure module function stdlib_sum_4d_dim_int8(x, dim, mask) -> s#
Arguments:
xinteger(kind=int8), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sinteger(kind=int8), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)
pure module function stdlib_sum_1d_int16(a) -> s#
Arguments:
ainteger(kind=int16), intent(in), dimension(:)
Returns:
sinteger(kind=int16)
pure module function stdlib_sum_1d_int16_mask(a, mask) -> s#
Arguments:
ainteger(kind=int16), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
sinteger(kind=int16)
pure module function stdlib_sum_2d_int16(x, mask) -> s#
Arguments:
xinteger(kind=int16), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sinteger(kind=int16)
pure module function stdlib_sum_2d_dim_int16(x, dim, mask) -> s#
Arguments:
xinteger(kind=int16), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sinteger(kind=int16), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_3d_int16(x, mask) -> s#
Arguments:
xinteger(kind=int16), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sinteger(kind=int16)
pure module function stdlib_sum_3d_dim_int16(x, dim, mask) -> s#
Arguments:
xinteger(kind=int16), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sinteger(kind=int16), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_4d_int16(x, mask) -> s#
Arguments:
xinteger(kind=int16), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sinteger(kind=int16)
pure module function stdlib_sum_4d_dim_int16(x, dim, mask) -> s#
Arguments:
xinteger(kind=int16), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sinteger(kind=int16), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)
pure module function stdlib_sum_1d_int32(a) -> s#
Arguments:
ainteger(kind=int32), intent(in), dimension(:)
Returns:
sinteger(kind=int32)
pure module function stdlib_sum_1d_int32_mask(a, mask) -> s#
Arguments:
ainteger(kind=int32), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
sinteger(kind=int32)
pure module function stdlib_sum_2d_int32(x, mask) -> s#
Arguments:
xinteger(kind=int32), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sinteger(kind=int32)
pure module function stdlib_sum_2d_dim_int32(x, dim, mask) -> s#
Arguments:
xinteger(kind=int32), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sinteger(kind=int32), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_3d_int32(x, mask) -> s#
Arguments:
xinteger(kind=int32), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sinteger(kind=int32)
pure module function stdlib_sum_3d_dim_int32(x, dim, mask) -> s#
Arguments:
xinteger(kind=int32), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sinteger(kind=int32), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_4d_int32(x, mask) -> s#
Arguments:
xinteger(kind=int32), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sinteger(kind=int32)
pure module function stdlib_sum_4d_dim_int32(x, dim, mask) -> s#
Arguments:
xinteger(kind=int32), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sinteger(kind=int32), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)
pure module function stdlib_sum_1d_int64(a) -> s#
Arguments:
ainteger(kind=int64), intent(in), dimension(:)
Returns:
sinteger(kind=int64)
pure module function stdlib_sum_1d_int64_mask(a, mask) -> s#
Arguments:
ainteger(kind=int64), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
sinteger(kind=int64)
pure module function stdlib_sum_2d_int64(x, mask) -> s#
Arguments:
xinteger(kind=int64), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sinteger(kind=int64)
pure module function stdlib_sum_2d_dim_int64(x, dim, mask) -> s#
Arguments:
xinteger(kind=int64), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sinteger(kind=int64), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_3d_int64(x, mask) -> s#
Arguments:
xinteger(kind=int64), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sinteger(kind=int64)
pure module function stdlib_sum_3d_dim_int64(x, dim, mask) -> s#
Arguments:
xinteger(kind=int64), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sinteger(kind=int64), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_4d_int64(x, mask) -> s#
Arguments:
xinteger(kind=int64), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sinteger(kind=int64)
pure module function stdlib_sum_4d_dim_int64(x, dim, mask) -> s#
Arguments:
xinteger(kind=int64), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sinteger(kind=int64), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)
pure module function stdlib_sum_1d_sp(a) -> s#
Arguments:
areal(kind=sp), intent(in), dimension(:)
Returns:
sreal(kind=sp)
pure module function stdlib_sum_1d_sp_mask(a, mask) -> s#
Arguments:
areal(kind=sp), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
sreal(kind=sp)
pure module function stdlib_sum_2d_sp(x, mask) -> s#
Arguments:
xreal(kind=sp), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sreal(kind=sp)
pure module function stdlib_sum_2d_dim_sp(x, dim, mask) -> s#
Arguments:
xreal(kind=sp), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sreal(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_3d_sp(x, mask) -> s#
Arguments:
xreal(kind=sp), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sreal(kind=sp)
pure module function stdlib_sum_3d_dim_sp(x, dim, mask) -> s#
Arguments:
xreal(kind=sp), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sreal(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_4d_sp(x, mask) -> s#
Arguments:
xreal(kind=sp), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sreal(kind=sp)
pure module function stdlib_sum_4d_dim_sp(x, dim, mask) -> s#
Arguments:
xreal(kind=sp), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sreal(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)
pure module function stdlib_sum_1d_dp(a) -> s#
Arguments:
areal(kind=dp), intent(in), dimension(:)
Returns:
sreal(kind=dp)
pure module function stdlib_sum_1d_dp_mask(a, mask) -> s#
Arguments:
areal(kind=dp), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
sreal(kind=dp)
pure module function stdlib_sum_2d_dp(x, mask) -> s#
Arguments:
xreal(kind=dp), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sreal(kind=dp)
pure module function stdlib_sum_2d_dim_dp(x, dim, mask) -> s#
Arguments:
xreal(kind=dp), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sreal(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_3d_dp(x, mask) -> s#
Arguments:
xreal(kind=dp), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sreal(kind=dp)
pure module function stdlib_sum_3d_dim_dp(x, dim, mask) -> s#
Arguments:
xreal(kind=dp), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sreal(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_4d_dp(x, mask) -> s#
Arguments:
xreal(kind=dp), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sreal(kind=dp)
pure module function stdlib_sum_4d_dim_dp(x, dim, mask) -> s#
Arguments:
xreal(kind=dp), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sreal(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)
pure module function stdlib_sum_1d_csp(a) -> s#
Arguments:
acomplex(kind=sp), intent(in), dimension(:)
Returns:
scomplex(kind=sp)
pure module function stdlib_sum_1d_csp_mask(a, mask) -> s#
Arguments:
acomplex(kind=sp), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
scomplex(kind=sp)
pure module function stdlib_sum_2d_csp(x, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
scomplex(kind=sp)
pure module function stdlib_sum_2d_dim_csp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
scomplex(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_3d_csp(x, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
scomplex(kind=sp)
pure module function stdlib_sum_3d_dim_csp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
scomplex(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_4d_csp(x, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
scomplex(kind=sp)
pure module function stdlib_sum_4d_dim_csp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
scomplex(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)
pure module function stdlib_sum_1d_cdp(a) -> s#
Arguments:
acomplex(kind=dp), intent(in), dimension(:)
Returns:
scomplex(kind=dp)
pure module function stdlib_sum_1d_cdp_mask(a, mask) -> s#
Arguments:
acomplex(kind=dp), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
scomplex(kind=dp)
pure module function stdlib_sum_2d_cdp(x, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
scomplex(kind=dp)
pure module function stdlib_sum_2d_dim_cdp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
scomplex(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_3d_cdp(x, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
scomplex(kind=dp)
pure module function stdlib_sum_3d_dim_cdp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
scomplex(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_4d_cdp(x, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
scomplex(kind=dp)
pure module function stdlib_sum_4d_dim_cdp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
scomplex(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)

Summary

Sum elements of rank N arrays. (Specification: stdlib_intrinsics)

Description

This interface provides standard conforming call for sum of elements of any rank. The 1-D base implementation follows a chunked approach for optimizing performance and increasing accuracy. The N-D interfaces calls upon the (N-1)-D implementation. Supported data types include real, complex and integer.

stdlib_sum_kahan (interface)#

stdlib_sum_kahan (interface)
Procedures:
pure module function stdlib_sum_kahan_1d_sp(a) -> s#
Arguments:
areal(kind=sp), intent(in), dimension(:)
Returns:
sreal(kind=sp)
pure module function stdlib_sum_kahan_1d_sp_mask(a, mask) -> s#
Arguments:
areal(kind=sp), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
sreal(kind=sp)
pure module function stdlib_sum_kahan_2d_sp(x, mask) -> s#
Arguments:
xreal(kind=sp), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sreal(kind=sp)
pure module function stdlib_sum_kahan_2d_dim_sp(x, dim, mask) -> s#
Arguments:
xreal(kind=sp), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sreal(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_kahan_3d_sp(x, mask) -> s#
Arguments:
xreal(kind=sp), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sreal(kind=sp)
pure module function stdlib_sum_kahan_3d_dim_sp(x, dim, mask) -> s#
Arguments:
xreal(kind=sp), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sreal(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_kahan_4d_sp(x, mask) -> s#
Arguments:
xreal(kind=sp), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sreal(kind=sp)
pure module function stdlib_sum_kahan_4d_dim_sp(x, dim, mask) -> s#
Arguments:
xreal(kind=sp), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sreal(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)
pure module function stdlib_sum_kahan_1d_dp(a) -> s#
Arguments:
areal(kind=dp), intent(in), dimension(:)
Returns:
sreal(kind=dp)
pure module function stdlib_sum_kahan_1d_dp_mask(a, mask) -> s#
Arguments:
areal(kind=dp), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
sreal(kind=dp)
pure module function stdlib_sum_kahan_2d_dp(x, mask) -> s#
Arguments:
xreal(kind=dp), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sreal(kind=dp)
pure module function stdlib_sum_kahan_2d_dim_dp(x, dim, mask) -> s#
Arguments:
xreal(kind=dp), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
sreal(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_kahan_3d_dp(x, mask) -> s#
Arguments:
xreal(kind=dp), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sreal(kind=dp)
pure module function stdlib_sum_kahan_3d_dim_dp(x, dim, mask) -> s#
Arguments:
xreal(kind=dp), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
sreal(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_kahan_4d_dp(x, mask) -> s#
Arguments:
xreal(kind=dp), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sreal(kind=dp)
pure module function stdlib_sum_kahan_4d_dim_dp(x, dim, mask) -> s#
Arguments:
xreal(kind=dp), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
sreal(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)
pure module function stdlib_sum_kahan_1d_csp(a) -> s#
Arguments:
acomplex(kind=sp), intent(in), dimension(:)
Returns:
scomplex(kind=sp)
pure module function stdlib_sum_kahan_1d_csp_mask(a, mask) -> s#
Arguments:
acomplex(kind=sp), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
scomplex(kind=sp)
pure module function stdlib_sum_kahan_2d_csp(x, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
scomplex(kind=sp)
pure module function stdlib_sum_kahan_2d_dim_csp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
scomplex(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_kahan_3d_csp(x, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
scomplex(kind=sp)
pure module function stdlib_sum_kahan_3d_dim_csp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
scomplex(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_kahan_4d_csp(x, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
scomplex(kind=sp)
pure module function stdlib_sum_kahan_4d_dim_csp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=sp), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
scomplex(kind=sp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)
pure module function stdlib_sum_kahan_1d_cdp(a) -> s#
Arguments:
acomplex(kind=dp), intent(in), dimension(:)
Returns:
scomplex(kind=dp)
pure module function stdlib_sum_kahan_1d_cdp_mask(a, mask) -> s#
Arguments:
acomplex(kind=dp), intent(in), dimension(:)
masklogical, intent(in), dimension(:)
Returns:
scomplex(kind=dp)
pure module function stdlib_sum_kahan_2d_cdp(x, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :), intent(in), dimension(:,:)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
scomplex(kind=dp)
pure module function stdlib_sum_kahan_2d_dim_cdp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :), intent(in), dimension(:,:)
diminteger, intent(in)
masklogical, (:, :), intent(in), optional, dimension(:,:)
Returns:
scomplex(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim)
pure module function stdlib_sum_kahan_3d_cdp(x, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :, :), intent(in), dimension(:,:,:)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
scomplex(kind=dp)
pure module function stdlib_sum_kahan_3d_dim_cdp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :, :), intent(in), dimension(:,:,:)
diminteger, intent(in)
masklogical, (:, :, :), intent(in), optional, dimension(:,:,:)
Returns:
scomplex(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim)
pure module function stdlib_sum_kahan_4d_cdp(x, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :, :, :), intent(in), dimension(:,:,:,:)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
scomplex(kind=dp)
pure module function stdlib_sum_kahan_4d_dim_cdp(x, dim, mask) -> s#
Arguments:
xcomplex(kind=dp), (:, :, :, :), intent(in), dimension(:,:,:,:)
diminteger, intent(in)
masklogical, (:, :, :, :), intent(in), optional, dimension(:,:,:,:)
Returns:
scomplex(kind=dp), (merge(size(x, 1), size(x, 2), mask=1<dim), merge(size(x, 2), size(x, 3), mask=2<dim), merge(size(x, 3), size(x, 4), mask=3<dim)), dimension(merge(size(x,1),size(x,2),mask=1<dim),merge(size(x,2),size(x,3),mask=2<dim),merge(size(x,3),size(x,4),mask=3<dim)

Summary

Sum elements of rank N arrays. (Specification: stdlib_intrinsics)

Description

This interface provides standard conforming call for sum of elements of any rank. The 1-D base implementation follows a chunked approach combined with a kahan kernel for optimizing performance and increasing accuracy. The N-D interfaces calls upon the (N-1)-D implementation. Supported data types include real and complex.

stdlib_dot_product (interface)#

stdlib_dot_product (interface)
Procedures:
pure module function stdlib_dot_product_int8(a, b) -> p#
Arguments:
ainteger(kind=int8), intent(in), dimension(:)
binteger(kind=int8), intent(in), dimension(:)
Returns:
pinteger(kind=int8)
pure module function stdlib_dot_product_int16(a, b) -> p#
Arguments:
ainteger(kind=int16), intent(in), dimension(:)
binteger(kind=int16), intent(in), dimension(:)
Returns:
pinteger(kind=int16)
pure module function stdlib_dot_product_int32(a, b) -> p#
Arguments:
ainteger(kind=int32), intent(in), dimension(:)
binteger(kind=int32), intent(in), dimension(:)
Returns:
pinteger(kind=int32)
pure module function stdlib_dot_product_int64(a, b) -> p#
Arguments:
ainteger(kind=int64), intent(in), dimension(:)
binteger(kind=int64), intent(in), dimension(:)
Returns:
pinteger(kind=int64)
pure module function stdlib_dot_product_sp(a, b) -> p#
Arguments:
areal(kind=sp), intent(in), dimension(:)
breal(kind=sp), intent(in), dimension(:)
Returns:
preal(kind=sp)
pure module function stdlib_dot_product_dp(a, b) -> p#
Arguments:
areal(kind=dp), intent(in), dimension(:)
breal(kind=dp), intent(in), dimension(:)
Returns:
preal(kind=dp)
pure module function stdlib_dot_product_csp(a, b) -> p#
Arguments:
acomplex(kind=sp), intent(in), dimension(:)
bcomplex(kind=sp), intent(in), dimension(:)
Returns:
pcomplex(kind=sp)
pure module function stdlib_dot_product_cdp(a, b) -> p#
Arguments:
acomplex(kind=dp), intent(in), dimension(:)
bcomplex(kind=dp), intent(in), dimension(:)
Returns:
pcomplex(kind=dp)

Summary

dot_product of rank 1 arrays. (Specification: stdlib_intrinsics)

Description

compute the dot_product of rank 1 arrays. The 1-D base implementation follows a chunked approach for optimizing performance and increasing accuracy. Supported data types include real, complex and integer.

stdlib_dot_product_kahan (interface)#

stdlib_dot_product_kahan (interface)
Procedures:
pure module function stdlib_dot_product_kahan_sp(a, b) -> p#
Arguments:
areal(kind=sp), intent(in), dimension(:)
breal(kind=sp), intent(in), dimension(:)
Returns:
preal(kind=sp)
pure module function stdlib_dot_product_kahan_dp(a, b) -> p#
Arguments:
areal(kind=dp), intent(in), dimension(:)
breal(kind=dp), intent(in), dimension(:)
Returns:
preal(kind=dp)
pure module function stdlib_dot_product_kahan_csp(a, b) -> p#
Arguments:
acomplex(kind=sp), intent(in), dimension(:)
bcomplex(kind=sp), intent(in), dimension(:)
Returns:
pcomplex(kind=sp)
pure module function stdlib_dot_product_kahan_cdp(a, b) -> p#
Arguments:
acomplex(kind=dp), intent(in), dimension(:)
bcomplex(kind=dp), intent(in), dimension(:)
Returns:
pcomplex(kind=dp)

Summary

dot_product of rank 1 arrays. (Specification: stdlib_intrinsics)

Description

compute the dot_product of rank 1 arrays. The implementation follows a chunked approach combined with a kahan kernel for optimizing performance and increasing accuracy. Supported data types include real and complex.

kahan_kernel (interface)#

kahan_kernel (interface)
Procedures:

stdlib_matmul (interface)#

stdlib_matmul (interface)
Procedures:
pure module function stdlib_matmul_pure_sp(m1, m2, m3, m4, m5) -> r#
Arguments:
m1real(kind=sp), (:, :), intent(in), dimension(:,:)
m2real(kind=sp), (:, :), intent(in), dimension(:,:)
m3real(kind=sp), (:, :), intent(in), optional, dimension(:,:)
m4real(kind=sp), (:, :), intent(in), optional, dimension(:,:)
m5real(kind=sp), (:, :), intent(in), optional, dimension(:,:)
Returns:
rreal(kind=sp), allocatable, (:, :), dimension(:,:)
module function stdlib_matmul_sp(m1, m2, m3, m4, m5, err) -> r#
Arguments:
m1real(kind=sp), (:, :), intent(in), dimension(:,:)
m2real(kind=sp), (:, :), intent(in), dimension(:,:)
m3real(kind=sp), (:, :), intent(in), optional, dimension(:,:)
m4real(kind=sp), (:, :), intent(in), optional, dimension(:,:)
m5real(kind=sp), (:, :), intent(in), optional, dimension(:,:)
errtype(linalg_state_type), intent(out)
Returns:
rreal(kind=sp), allocatable, (:, :), dimension(:,:)
pure module function stdlib_matmul_pure_dp(m1, m2, m3, m4, m5) -> r#
Arguments:
m1real(kind=dp), (:, :), intent(in), dimension(:,:)
m2real(kind=dp), (:, :), intent(in), dimension(:,:)
m3real(kind=dp), (:, :), intent(in), optional, dimension(:,:)
m4real(kind=dp), (:, :), intent(in), optional, dimension(:,:)
m5real(kind=dp), (:, :), intent(in), optional, dimension(:,:)
Returns:
rreal(kind=dp), allocatable, (:, :), dimension(:,:)
module function stdlib_matmul_dp(m1, m2, m3, m4, m5, err) -> r#
Arguments:
m1real(kind=dp), (:, :), intent(in), dimension(:,:)
m2real(kind=dp), (:, :), intent(in), dimension(:,:)
m3real(kind=dp), (:, :), intent(in), optional, dimension(:,:)
m4real(kind=dp), (:, :), intent(in), optional, dimension(:,:)
m5real(kind=dp), (:, :), intent(in), optional, dimension(:,:)
errtype(linalg_state_type), intent(out)
Returns:
rreal(kind=dp), allocatable, (:, :), dimension(:,:)
pure module function stdlib_matmul_pure_csp(m1, m2, m3, m4, m5) -> r#
Arguments:
m1complex(kind=sp), (:, :), intent(in), dimension(:,:)
m2complex(kind=sp), (:, :), intent(in), dimension(:,:)
m3complex(kind=sp), (:, :), intent(in), optional, dimension(:,:)
m4complex(kind=sp), (:, :), intent(in), optional, dimension(:,:)
m5complex(kind=sp), (:, :), intent(in), optional, dimension(:,:)
Returns:
rcomplex(kind=sp), allocatable, (:, :), dimension(:,:)
module function stdlib_matmul_csp(m1, m2, m3, m4, m5, err) -> r#
Arguments:
m1complex(kind=sp), (:, :), intent(in), dimension(:,:)
m2complex(kind=sp), (:, :), intent(in), dimension(:,:)
m3complex(kind=sp), (:, :), intent(in), optional, dimension(:,:)
m4complex(kind=sp), (:, :), intent(in), optional, dimension(:,:)
m5complex(kind=sp), (:, :), intent(in), optional, dimension(:,:)
errtype(linalg_state_type), intent(out)
Returns:
rcomplex(kind=sp), allocatable, (:, :), dimension(:,:)
pure module function stdlib_matmul_pure_cdp(m1, m2, m3, m4, m5) -> r#
Arguments:
m1complex(kind=dp), (:, :), intent(in), dimension(:,:)
m2complex(kind=dp), (:, :), intent(in), dimension(:,:)
m3complex(kind=dp), (:, :), intent(in), optional, dimension(:,:)
m4complex(kind=dp), (:, :), intent(in), optional, dimension(:,:)
m5complex(kind=dp), (:, :), intent(in), optional, dimension(:,:)
Returns:
rcomplex(kind=dp), allocatable, (:, :), dimension(:,:)
module function stdlib_matmul_cdp(m1, m2, m3, m4, m5, err) -> r#
Arguments:
m1complex(kind=dp), (:, :), intent(in), dimension(:,:)
m2complex(kind=dp), (:, :), intent(in), dimension(:,:)
m3complex(kind=dp), (:, :), intent(in), optional, dimension(:,:)
m4complex(kind=dp), (:, :), intent(in), optional, dimension(:,:)
m5complex(kind=dp), (:, :), intent(in), optional, dimension(:,:)
errtype(linalg_state_type), intent(out)
Returns:
rcomplex(kind=dp), allocatable, (:, :), dimension(:,:)

Summary

compute the matrix multiplication of more than two matrices with a single function call. (Specification: stdlib_intrinsics)

Description

matrix multiply more than two matrices with a single function call the multiplication with the optimal parenthesization for efficiency of computation is done automatically Supported data types are real and complex.

Note: The matrices must be of compatible shapes to be multiplied

Procedures

kahan_kernel_sp (subroutine)#

elemental subroutine kahan_kernel_sp(a, s, c)
Arguments:
areal(kind=sp), intent(in)
sreal(kind=sp), intent(inout)
creal(kind=sp), intent(inout)

kahan_kernel_m_sp (subroutine)#

elemental subroutine kahan_kernel_m_sp(a, s, c, m)
Arguments:
areal(kind=sp), intent(in)
sreal(kind=sp), intent(inout)
creal(kind=sp), intent(inout)
mlogical, intent(in)

kahan_kernel_dp (subroutine)#

elemental subroutine kahan_kernel_dp(a, s, c)
Arguments:
areal(kind=dp), intent(in)
sreal(kind=dp), intent(inout)
creal(kind=dp), intent(inout)

kahan_kernel_m_dp (subroutine)#

elemental subroutine kahan_kernel_m_dp(a, s, c, m)
Arguments:
areal(kind=dp), intent(in)
sreal(kind=dp), intent(inout)
creal(kind=dp), intent(inout)
mlogical, intent(in)

kahan_kernel_csp (subroutine)#

elemental subroutine kahan_kernel_csp(a, s, c)
Arguments:
acomplex(kind=sp), intent(in)
scomplex(kind=sp), intent(inout)
ccomplex(kind=sp), intent(inout)

kahan_kernel_m_csp (subroutine)#

elemental subroutine kahan_kernel_m_csp(a, s, c, m)
Arguments:
acomplex(kind=sp), intent(in)
scomplex(kind=sp), intent(inout)
ccomplex(kind=sp), intent(inout)
mlogical, intent(in)

kahan_kernel_cdp (subroutine)#

elemental subroutine kahan_kernel_cdp(a, s, c)
Arguments:
acomplex(kind=dp), intent(in)
scomplex(kind=dp), intent(inout)
ccomplex(kind=dp), intent(inout)

kahan_kernel_m_cdp (subroutine)#

elemental subroutine kahan_kernel_m_cdp(a, s, c, m)
Arguments:
acomplex(kind=dp), intent(in)
scomplex(kind=dp), intent(inout)
ccomplex(kind=dp), intent(inout)
mlogical, intent(in)