la_lapack_blas_like_l3 Module Reference

BLAS-like level 3: rank-k updates and solves in RFP storage. More...

Functions/Subroutines
pure subroutine, public	la_slagtm (trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)
	SLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
pure subroutine, public	la_dlagtm (trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)
	DLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
pure subroutine, public	la_qlagtm (trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)
	QLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
pure subroutine, public	la_ssfrk (transr, uplo, trans, n, k, alpha, a, lda, beta, c)
	Level 3 BLAS like routine for C in RFP Format. SSFRK: 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 real 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_dsfrk (transr, uplo, trans, n, k, alpha, a, lda, beta, c)
	Level 3 BLAS like routine for C in RFP Format. DSFRK: 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 real 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_qsfrk (transr, uplo, trans, n, k, alpha, a, lda, beta, c)
	Level 3 BLAS like routine for C in RFP Format. QSFRK: 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 real 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_stfsm (transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)
	Level 3 BLAS like routine for A in RFP Format. STFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.
pure subroutine, public	la_dtfsm (transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)
	Level 3 BLAS like routine for A in RFP Format. DTFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.
pure subroutine, public	la_qtfsm (transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)
	Level 3 BLAS like routine for A in RFP Format. QTFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.
pure subroutine, public	la_chfrk (transr, uplo, trans, n, k, alpha, a, lda, beta, c)
	Level 3 BLAS like routine for C in RFP Format. CHFRK: performs one of the Hermitian rank–k operations C := alpha*A*A**H + beta*C, or C := alpha*A**H*A + beta*C, where alpha and beta are real scalars, C is an n–by–n Hermitian 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_zhfrk (transr, uplo, trans, n, k, alpha, a, lda, beta, c)
	Level 3 BLAS like routine for C in RFP Format. ZHFRK: performs one of the Hermitian rank–k operations C := alpha*A*A**H + beta*C, or C := alpha*A**H*A + beta*C, where alpha and beta are real scalars, C is an n–by–n Hermitian 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_whfrk (transr, uplo, trans, n, k, alpha, a, lda, beta, c)
	Level 3 BLAS like routine for C in RFP Format. WHFRK: performs one of the Hermitian rank–k operations C := alpha*A*A**H + beta*C, or C := alpha*A**H*A + beta*C, where alpha and beta are real scalars, C is an n–by–n Hermitian 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_clacrm (m, n, a, lda, b, ldb, c, ldc, rwork)
	CLACRM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.
pure subroutine, public	la_zlacrm (m, n, a, lda, b, ldb, c, ldc, rwork)
	ZLACRM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.
pure subroutine, public	la_wlacrm (m, n, a, lda, b, ldb, c, ldc, rwork)
	WLACRM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.
pure subroutine, public	la_clagtm (trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)
	CLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
pure subroutine, public	la_zlagtm (trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)
	ZLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
pure subroutine, public	la_wlagtm (trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)
	WLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
pure subroutine, public	la_clarcm (m, n, a, lda, b, ldb, c, ldc, rwork)
	CLARCM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.
pure subroutine, public	la_zlarcm (m, n, a, lda, b, ldb, c, ldc, rwork)
	ZLARCM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.
pure subroutine, public	la_wlarcm (m, n, a, lda, b, ldb, c, ldc, rwork)
	WLARCM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.
pure subroutine, public	la_ctfsm (transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)
	Level 3 BLAS like routine for A in RFP Format. CTFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.
pure subroutine, public	la_ztfsm (transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)
	Level 3 BLAS like routine for A in RFP Format. ZTFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.
pure subroutine, public	la_wtfsm (transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb)
	Level 3 BLAS like routine for A in RFP Format. WTFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

Detailed Description

BLAS-like level 3: rank-k updates and solves in RFP storage.

Function/Subroutine Documentation

la_chfrk()

pure subroutine, public la_lapack_blas_like_l3::la_chfrk	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		real(sp), intent(in)	alpha,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), intent(in)	beta,
		complex(sp), dimension(*), intent(inout)	c )

Level 3 BLAS like routine for C in RFP Format. CHFRK: performs one of the Hermitian rank–k operations C := alpha*A*A**H + beta*C, or C := alpha*A**H*A + beta*C, where alpha and beta are real scalars, C is an n–by–n Hermitian matrix and A is an n–by–k matrix in the first case and a k–by–n matrix in the second case.

Here is the call graph for this function:

la_clacrm()

pure subroutine, public la_lapack_blas_like_l3::la_clacrm	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldc,*), intent(out)	c,
		integer(ilp), intent(in)	ldc,
		real(sp), dimension(*), intent(out)	rwork )

CLACRM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.

Here is the call graph for this function:

la_clagtm()

pure subroutine, public la_lapack_blas_like_l3::la_clagtm	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), intent(in)	alpha,
		complex(sp), dimension(*), intent(in)	dl,
		complex(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	du,
		complex(sp), dimension(ldx,*), intent(in)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(in)	beta,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

CLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

Here is the call graph for this function:

la_clarcm()

pure subroutine, public la_lapack_blas_like_l3::la_clarcm	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(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), dimension(ldc,*), intent(out)	c,
		integer(ilp), intent(in)	ldc,
		real(sp), dimension(*), intent(out)	rwork )

CLARCM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.

Here is the call graph for this function:

la_ctfsm()

pure subroutine, public la_lapack_blas_like_l3::la_ctfsm	(	character, intent(in)	transr,
		character, intent(in)	side,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), dimension(0:*), intent(in)	a,
		complex(sp), dimension(0:ldb - 1,0:*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

Level 3 BLAS like routine for A in RFP Format. CTFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

Here is the call graph for this function:

la_dlagtm()

pure subroutine, public la_lapack_blas_like_l3::la_dlagtm	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), intent(in)	alpha,
		real(dp), dimension(*), intent(in)	dl,
		real(dp), dimension(*), intent(in)	d,
		real(dp), dimension(*), intent(in)	du,
		real(dp), dimension(ldx,*), intent(in)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(in)	beta,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

DLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

Here is the call graph for this function:

la_dsfrk()

pure subroutine, public la_lapack_blas_like_l3::la_dsfrk	(	character, intent(in)	transr,
		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(*), intent(inout)	c )

Level 3 BLAS like routine for C in RFP Format. DSFRK: 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 real 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.

Here is the call graph for this function:

la_dtfsm()

pure subroutine, public la_lapack_blas_like_l3::la_dtfsm	(	character, intent(in)	transr,
		character, intent(in)	side,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), dimension(0:*), intent(in)	a,
		real(dp), dimension(0:ldb - 1,0:*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

Level 3 BLAS like routine for A in RFP Format. DTFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

Here is the call graph for this function:

la_qlagtm()

pure subroutine, public la_lapack_blas_like_l3::la_qlagtm	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), intent(in)	alpha,
		real(qp), dimension(*), intent(in)	dl,
		real(qp), dimension(*), intent(in)	d,
		real(qp), dimension(*), intent(in)	du,
		real(qp), dimension(ldx,*), intent(in)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(in)	beta,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

QLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

Here is the call graph for this function:

la_qsfrk()

pure subroutine, public la_lapack_blas_like_l3::la_qsfrk	(	character, intent(in)	transr,
		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(*), intent(inout)	c )

Level 3 BLAS like routine for C in RFP Format. QSFRK: 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 real 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.

Here is the call graph for this function:

la_qtfsm()

pure subroutine, public la_lapack_blas_like_l3::la_qtfsm	(	character, intent(in)	transr,
		character, intent(in)	side,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(qp), intent(in)	alpha,
		real(qp), dimension(0:*), intent(in)	a,
		real(qp), dimension(0:ldb - 1,0:*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

Level 3 BLAS like routine for A in RFP Format. QTFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

Here is the call graph for this function:

la_slagtm()

pure subroutine, public la_lapack_blas_like_l3::la_slagtm	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), intent(in)	alpha,
		real(sp), dimension(*), intent(in)	dl,
		real(sp), dimension(*), intent(in)	d,
		real(sp), dimension(*), intent(in)	du,
		real(sp), dimension(ldx,*), intent(in)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(in)	beta,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

SLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

Here is the call graph for this function:

la_ssfrk()

pure subroutine, public la_lapack_blas_like_l3::la_ssfrk	(	character, intent(in)	transr,
		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(*), intent(inout)	c )

Level 3 BLAS like routine for C in RFP Format. SSFRK: 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 real 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.

Here is the call graph for this function:

la_stfsm()

pure subroutine, public la_lapack_blas_like_l3::la_stfsm	(	character, intent(in)	transr,
		character, intent(in)	side,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(sp), intent(in)	alpha,
		real(sp), dimension(0:*), intent(in)	a,
		real(sp), dimension(0:ldb - 1,0:*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

Level 3 BLAS like routine for A in RFP Format. STFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

Here is the call graph for this function:

la_whfrk()

pure subroutine, public la_lapack_blas_like_l3::la_whfrk	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		real(qp), intent(in)	alpha,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(qp), intent(in)	beta,
		complex(qp), dimension(*), intent(inout)	c )

Level 3 BLAS like routine for C in RFP Format. WHFRK: performs one of the Hermitian rank–k operations C := alpha*A*A**H + beta*C, or C := alpha*A**H*A + beta*C, where alpha and beta are real scalars, C is an n–by–n Hermitian matrix and A is an n–by–k matrix in the first case and a k–by–n matrix in the second case.

Here is the call graph for this function:

la_wlacrm()

pure subroutine, public la_lapack_blas_like_l3::la_wlacrm	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldc,*), intent(out)	c,
		integer(ilp), intent(in)	ldc,
		real(qp), dimension(*), intent(out)	rwork )

WLACRM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.

Here is the call graph for this function:

la_wlagtm()

pure subroutine, public la_lapack_blas_like_l3::la_wlagtm	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), intent(in)	alpha,
		complex(qp), dimension(*), intent(in)	dl,
		complex(qp), dimension(*), intent(in)	d,
		complex(qp), dimension(*), intent(in)	du,
		complex(qp), dimension(ldx,*), intent(in)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(in)	beta,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

WLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

Here is the call graph for this function:

la_wlarcm()

pure subroutine, public la_lapack_blas_like_l3::la_wlarcm	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(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), dimension(ldc,*), intent(out)	c,
		integer(ilp), intent(in)	ldc,
		real(qp), dimension(*), intent(out)	rwork )

WLARCM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.

Here is the call graph for this function:

la_wtfsm()

pure subroutine, public la_lapack_blas_like_l3::la_wtfsm	(	character, intent(in)	transr,
		character, intent(in)	side,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), intent(in)	alpha,
		complex(qp), dimension(0:*), intent(in)	a,
		complex(qp), dimension(0:ldb - 1,0:*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

Level 3 BLAS like routine for A in RFP Format. WTFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

Here is the call graph for this function:

la_zhfrk()

pure subroutine, public la_lapack_blas_like_l3::la_zhfrk	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		real(dp), intent(in)	alpha,
		complex(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), intent(in)	beta,
		complex(dp), dimension(*), intent(inout)	c )

Level 3 BLAS like routine for C in RFP Format. ZHFRK: performs one of the Hermitian rank–k operations C := alpha*A*A**H + beta*C, or C := alpha*A**H*A + beta*C, where alpha and beta are real scalars, C is an n–by–n Hermitian matrix and A is an n–by–k matrix in the first case and a k–by–n matrix in the second case.

Here is the call graph for this function:

la_zlacrm()

pure subroutine, public la_lapack_blas_like_l3::la_zlacrm	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldc,*), intent(out)	c,
		integer(ilp), intent(in)	ldc,
		real(dp), dimension(*), intent(out)	rwork )

ZLACRM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.

Here is the call graph for this function:

la_zlagtm()

pure subroutine, public la_lapack_blas_like_l3::la_zlagtm	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), intent(in)	alpha,
		complex(dp), dimension(*), intent(in)	dl,
		complex(dp), dimension(*), intent(in)	d,
		complex(dp), dimension(*), intent(in)	du,
		complex(dp), dimension(ldx,*), intent(in)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(in)	beta,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

ZLAGTM: performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.

Here is the call graph for this function:

la_zlarcm()

pure subroutine, public la_lapack_blas_like_l3::la_zlarcm	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(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), dimension(ldc,*), intent(out)	c,
		integer(ilp), intent(in)	ldc,
		real(dp), dimension(*), intent(out)	rwork )

ZLARCM: performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.

Here is the call graph for this function:

la_ztfsm()

pure subroutine, public la_lapack_blas_like_l3::la_ztfsm	(	character, intent(in)	transr,
		character, intent(in)	side,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), intent(in)	alpha,
		complex(dp), dimension(0:*), intent(in)	a,
		complex(dp), dimension(0:ldb - 1,0:*), intent(inout)	b,
		integer(ilp), intent(in)	ldb )

Level 3 BLAS like routine for A in RFP Format. ZTFSM: solves the matrix equation op( A )*X = alpha*B or X*op( A ) = alpha*B where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.

Here is the call graph for this function: