|
| pure subroutine, public | la_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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_lapack_blas_like_l2::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.
|
| |
1.13.2