BLAS level 3: symmetric matrix-matrix operations. More...
Functions/Subroutines | |
| pure subroutine, public | la_ssymm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) |
| SSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices. | |
| pure subroutine, public | la_dsymm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) |
| DSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices. | |
| pure subroutine, public | la_qsymm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) |
| QSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices. | |
| pure subroutine, public | la_ssyr2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| SSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case. | |
| pure subroutine, public | la_dsyr2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| DSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case. | |
| pure subroutine, public | la_qsyr2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| QSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case. | |
| pure subroutine, public | la_ssyrk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc) |
| SSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case. | |
| pure subroutine, public | la_dsyrk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc) |
| DSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case. | |
| pure subroutine, public | la_qsyrk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc) |
| QSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case. | |
| pure subroutine, public | la_csymm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) |
| CSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices. | |
| pure subroutine, public | la_zsymm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) |
| ZSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices. | |
| pure subroutine, public | la_wsymm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) |
| WSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices. | |
| pure subroutine, public | la_csyr2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| CSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case. | |
| pure subroutine, public | la_zsyr2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| ZSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case. | |
| pure subroutine, public | la_wsyr2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| WSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case. | |
| pure subroutine, public | la_csyrk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc) |
| CSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case. | |
| pure subroutine, public | la_zsyrk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc) |
| ZSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case. | |
| pure subroutine, public | la_wsyrk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc) |
| WSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case. | |
Detailed Description
BLAS level 3: symmetric matrix-matrix operations.
Function/Subroutine Documentation
◆ la_csymm()
| pure subroutine, public la_blas_level3_sym::la_csymm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | m, | ||
| 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(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
CSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices.
◆ la_csyr2k()
| pure subroutine, public la_blas_level3_sym::la_csyr2k | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
CSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
◆ la_csyrk()
| pure subroutine, public la_blas_level3_sym::la_csyrk | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
CSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
◆ la_dsymm()
| pure subroutine, public la_blas_level3_sym::la_dsymm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| 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(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
DSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices.
◆ la_dsyr2k()
| pure subroutine, public la_blas_level3_sym::la_dsyr2k | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(dp), intent(in) | alpha, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
DSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
◆ la_dsyrk()
| pure subroutine, public la_blas_level3_sym::la_dsyrk | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(dp), intent(in) | alpha, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
DSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
◆ la_qsymm()
| pure subroutine, public la_blas_level3_sym::la_qsymm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| 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(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
QSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices.
◆ la_qsyr2k()
| pure subroutine, public la_blas_level3_sym::la_qsyr2k | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
QSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
◆ la_qsyrk()
| pure subroutine, public la_blas_level3_sym::la_qsyrk | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
QSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
◆ la_ssymm()
| pure subroutine, public la_blas_level3_sym::la_ssymm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| 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(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
SSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices.
◆ la_ssyr2k()
| pure subroutine, public la_blas_level3_sym::la_ssyr2k | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
SSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
◆ la_ssyrk()
| pure subroutine, public la_blas_level3_sym::la_ssyrk | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
SSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
◆ la_wsymm()
| pure subroutine, public la_blas_level3_sym::la_wsymm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | m, | ||
| 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(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), intent(in) | beta, | ||
| complex(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
WSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices.
◆ la_wsyr2k()
| pure subroutine, public la_blas_level3_sym::la_wsyr2k | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(qp), intent(in) | alpha, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), intent(in) | beta, | ||
| complex(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
WSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
◆ la_wsyrk()
| pure subroutine, public la_blas_level3_sym::la_wsyrk | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(qp), intent(in) | alpha, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), intent(in) | beta, | ||
| complex(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
WSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
◆ la_zsymm()
| pure subroutine, public la_blas_level3_sym::la_zsymm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | m, | ||
| 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(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), intent(in) | beta, | ||
| complex(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
ZSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices.
◆ la_zsyr2k()
| pure subroutine, public la_blas_level3_sym::la_zsyr2k | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(dp), intent(in) | alpha, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), intent(in) | beta, | ||
| complex(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
ZSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
◆ la_zsyrk()
| pure subroutine, public la_blas_level3_sym::la_zsyrk | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(dp), intent(in) | alpha, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), intent(in) | beta, | ||
| complex(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
ZSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
