BLAS-like level 2: matrix-vector products, scaling, rank updates. More...
Functions/Subroutines | |
| pure subroutine, public | la_sla_wwaddw (n, x, y, w) |
| SLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal. | |
| pure subroutine, public | la_dla_wwaddw (n, x, y, w) |
| DLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal. | |
| pure subroutine, public | la_qla_wwaddw (n, x, y, w) |
| QLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal. | |
| subroutine, public | la_sla_gbamv (trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy) |
| SLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_dla_gbamv (trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy) |
| DLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_qla_gbamv (trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy) |
| QLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_sla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) |
| SLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_dla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) |
| DLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_qla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) |
| QLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| pure subroutine, public | la_slascl (type, kl, ku, cfrom, cto, m, n, a, lda, info) |
| SLASCL: multiplies the M by N real matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded. | |
| pure subroutine, public | la_dlascl (type, kl, ku, cfrom, cto, m, n, a, lda, info) |
| DLASCL: multiplies the M by N real matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded. | |
| pure subroutine, public | la_qlascl (type, kl, ku, cfrom, cto, m, n, a, lda, info) |
| QLASCL: multiplies the M by N real matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded. | |
| subroutine, public | la_cla_gbamv (trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy) |
| CLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_zla_gbamv (trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy) |
| ZLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_wla_gbamv (trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy) |
| WLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_cla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) |
| CLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_zla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) |
| ZLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_wla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) |
| WLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_cla_heamv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| CLA_SYAMV performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_zla_heamv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| ZLA_SYAMV performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| subroutine, public | la_wla_heamv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| WLA_SYAMV performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| pure subroutine, public | la_cla_wwaddw (n, x, y, w) |
| CLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal. | |
| pure subroutine, public | la_zla_wwaddw (n, x, y, w) |
| ZLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal. | |
| pure subroutine, public | la_wla_wwaddw (n, x, y, w) |
| WLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal. | |
| pure subroutine, public | la_clascl (type, kl, ku, cfrom, cto, m, n, a, lda, info) |
| CLASCL: multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded. | |
| pure subroutine, public | la_zlascl (type, kl, ku, cfrom, cto, m, n, a, lda, info) |
| ZLASCL: multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded. | |
| pure subroutine, public | la_wlascl (type, kl, ku, cfrom, cto, m, n, a, lda, info) |
| WLASCL: multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded. | |
| pure subroutine, public | la_cspmv (uplo, n, alpha, ap, x, incx, beta, y, incy) |
| CSPMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form. | |
| pure subroutine, public | la_zspmv (uplo, n, alpha, ap, x, incx, beta, y, incy) |
| ZSPMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form. | |
| pure subroutine, public | la_wspmv (uplo, n, alpha, ap, x, incx, beta, y, incy) |
| WSPMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form. | |
| pure subroutine, public | la_cspr (uplo, n, alpha, x, incx, ap) |
| CSPR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form. | |
| pure subroutine, public | la_zspr (uplo, n, alpha, x, incx, ap) |
| ZSPR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form. | |
| pure subroutine, public | la_wspr (uplo, n, alpha, x, incx, ap) |
| WSPR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form. | |
| pure subroutine, public | la_csymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| CSYMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix. | |
| pure subroutine, public | la_zsymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| ZSYMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix. | |
| pure subroutine, public | la_wsymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| WSYMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix. | |
| pure subroutine, public | la_csyr (uplo, n, alpha, x, incx, a, lda) |
| CSYR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix. | |
| pure subroutine, public | la_zsyr (uplo, n, alpha, x, incx, a, lda) |
| ZSYR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix. | |
| pure subroutine, public | la_wsyr (uplo, n, alpha, x, incx, a, lda) |
| WSYR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix. | |
Detailed Description
BLAS-like level 2: matrix-vector products, scaling, rank updates.
Function/Subroutine Documentation
◆ la_cla_gbamv()
| subroutine, public la_lapack_blas_like_l2::la_cla_gbamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), intent(in) | alpha, | ||
| complex(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
CLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_cla_geamv()
| subroutine, public la_lapack_blas_like_l2::la_cla_geamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
CLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_cla_heamv()
| subroutine, public la_lapack_blas_like_l2::la_cla_heamv | ( | integer(ilp), intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
CLA_SYAMV performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_cla_wwaddw()
| pure subroutine, public la_lapack_blas_like_l2::la_cla_wwaddw | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(*), intent(inout) | x, | ||
| complex(sp), dimension(*), intent(inout) | y, | ||
| complex(sp), dimension(*), intent(in) | w ) |
CLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
◆ la_clascl()
| pure subroutine, public la_lapack_blas_like_l2::la_clascl | ( | character, intent(in) | type, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), intent(in) | cfrom, | ||
| real(sp), intent(in) | cto, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
CLASCL: multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
◆ la_cspmv()
| pure subroutine, public la_lapack_blas_like_l2::la_cspmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(*), intent(in) | ap, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
CSPMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.
◆ la_cspr()
| pure subroutine, public la_lapack_blas_like_l2::la_cspr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(inout) | ap ) |
CSPR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.
◆ la_csymv()
| pure subroutine, public la_lapack_blas_like_l2::la_csymv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
CSYMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.
◆ la_csyr()
| pure subroutine, public la_lapack_blas_like_l2::la_csyr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
CSYR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.
◆ la_dla_gbamv()
| subroutine, public la_lapack_blas_like_l2::la_dla_gbamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), intent(in) | alpha, | ||
| real(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
DLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_dla_geamv()
| subroutine, public la_lapack_blas_like_l2::la_dla_geamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), intent(in) | alpha, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
DLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_dla_wwaddw()
| pure subroutine, public la_lapack_blas_like_l2::la_dla_wwaddw | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(*), intent(inout) | x, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| real(dp), dimension(*), intent(in) | w ) |
DLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
◆ la_dlascl()
| pure subroutine, public la_lapack_blas_like_l2::la_dlascl | ( | character, intent(in) | type, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), intent(in) | cfrom, | ||
| real(dp), intent(in) | cto, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
DLASCL: multiplies the M by N real matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
◆ la_qla_gbamv()
| subroutine, public la_lapack_blas_like_l2::la_qla_gbamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
QLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_qla_geamv()
| subroutine, public la_lapack_blas_like_l2::la_qla_geamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
QLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_qla_wwaddw()
| pure subroutine, public la_lapack_blas_like_l2::la_qla_wwaddw | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(inout) | x, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| real(qp), dimension(*), intent(in) | w ) |
QLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
◆ la_qlascl()
| pure subroutine, public la_lapack_blas_like_l2::la_qlascl | ( | character, intent(in) | type, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), intent(in) | cfrom, | ||
| real(qp), intent(in) | cto, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
QLASCL: multiplies the M by N real matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
◆ la_sla_gbamv()
| subroutine, public la_lapack_blas_like_l2::la_sla_gbamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
SLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_sla_geamv()
| subroutine, public la_lapack_blas_like_l2::la_sla_geamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
SLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_sla_wwaddw()
| pure subroutine, public la_lapack_blas_like_l2::la_sla_wwaddw | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(inout) | x, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| real(sp), dimension(*), intent(in) | w ) |
SLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
◆ la_slascl()
| pure subroutine, public la_lapack_blas_like_l2::la_slascl | ( | character, intent(in) | type, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), intent(in) | cfrom, | ||
| real(sp), intent(in) | cto, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
SLASCL: multiplies the M by N real matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
◆ la_wla_gbamv()
| subroutine, public la_lapack_blas_like_l2::la_wla_gbamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), intent(in) | alpha, | ||
| complex(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
WLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_wla_geamv()
| subroutine, public la_lapack_blas_like_l2::la_wla_geamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
WLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_wla_heamv()
| subroutine, public la_lapack_blas_like_l2::la_wla_heamv | ( | integer(ilp), intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
WLA_SYAMV performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_wla_wwaddw()
| pure subroutine, public la_lapack_blas_like_l2::la_wla_wwaddw | ( | integer(ilp), intent(in) | n, |
| complex(qp), dimension(*), intent(inout) | x, | ||
| complex(qp), dimension(*), intent(inout) | y, | ||
| complex(qp), dimension(*), intent(in) | w ) |
WLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
◆ la_wlascl()
| pure subroutine, public la_lapack_blas_like_l2::la_wlascl | ( | character, intent(in) | type, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), intent(in) | cfrom, | ||
| real(qp), intent(in) | cto, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
WLASCL: multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
◆ la_wspmv()
| pure subroutine, public la_lapack_blas_like_l2::la_wspmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), intent(in) | alpha, | ||
| complex(qp), dimension(*), intent(in) | ap, | ||
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(qp), intent(in) | beta, | ||
| complex(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
WSPMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.
◆ la_wspr()
| pure subroutine, public la_lapack_blas_like_l2::la_wspr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), intent(in) | alpha, | ||
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(qp), dimension(*), intent(inout) | ap ) |
WSPR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.
◆ la_wsymv()
| pure subroutine, public la_lapack_blas_like_l2::la_wsymv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), intent(in) | alpha, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(qp), intent(in) | beta, | ||
| complex(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
WSYMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.
◆ la_wsyr()
| pure subroutine, public la_lapack_blas_like_l2::la_wsyr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), intent(in) | alpha, | ||
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
WSYR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.
◆ la_zla_gbamv()
| subroutine, public la_lapack_blas_like_l2::la_zla_gbamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), intent(in) | alpha, | ||
| complex(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
ZLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_zla_geamv()
| subroutine, public la_lapack_blas_like_l2::la_zla_geamv | ( | integer(ilp), intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), intent(in) | alpha, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
ZLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_zla_heamv()
| subroutine, public la_lapack_blas_like_l2::la_zla_heamv | ( | integer(ilp), intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), intent(in) | alpha, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
ZLA_SYAMV performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
◆ la_zla_wwaddw()
| pure subroutine, public la_lapack_blas_like_l2::la_zla_wwaddw | ( | integer(ilp), intent(in) | n, |
| complex(dp), dimension(*), intent(inout) | x, | ||
| complex(dp), dimension(*), intent(inout) | y, | ||
| complex(dp), dimension(*), intent(in) | w ) |
ZLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
◆ la_zlascl()
| pure subroutine, public la_lapack_blas_like_l2::la_zlascl | ( | character, intent(in) | type, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), intent(in) | cfrom, | ||
| real(dp), intent(in) | cto, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
ZLASCL: multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
◆ la_zspmv()
| pure subroutine, public la_lapack_blas_like_l2::la_zspmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), intent(in) | alpha, | ||
| complex(dp), dimension(*), intent(in) | ap, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(dp), intent(in) | beta, | ||
| complex(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
ZSPMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.
◆ la_zspr()
| pure subroutine, public la_lapack_blas_like_l2::la_zspr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), intent(in) | alpha, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(dp), dimension(*), intent(inout) | ap ) |
ZSPR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.
◆ la_zsymv()
| pure subroutine, public la_lapack_blas_like_l2::la_zsymv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), intent(in) | alpha, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(dp), intent(in) | beta, | ||
| complex(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
ZSYMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.
◆ la_zsyr()
| pure subroutine, public la_lapack_blas_like_l2::la_zsyr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), intent(in) | alpha, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
ZSYR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.
