BLAS-like base: copy, precision conversion, random and packed storage. More...

Functions/Subroutines
pure subroutine, public	la_slacpy (uplo, m, n, a, lda, b, ldb)
	SLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

pure subroutine, public	la_dlacpy (uplo, m, n, a, lda, b, ldb)
	DLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

pure subroutine, public	la_qlacpy (uplo, m, n, a, lda, b, ldb)
	QLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

pure subroutine, public	la_dlag2s (m, n, a, lda, sa, ldsa, info)
	DLAG2S: converts a DOUBLE PRECISION matrix, SA, to a SINGLE PRECISION matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic DLAG2S checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_qlag2d (m, n, a, lda, sa, ldsa, info)
	QLAG2D: converts a QUAD PRECISION matrix, SA, to a SINGLE PRECISION matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic QLAG2D checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_slaruv (iseed, n, x)
	SLARUV: returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by SLARNV and CLARNV.

pure subroutine, public	la_dlaruv (iseed, n, x)
	DLARUV: returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by DLARNV and ZLARNV.

pure subroutine, public	la_qlaruv (iseed, n, x)
	QLARUV: returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by QLARNV and WLARNV.

pure subroutine, public	la_slaset (uplo, m, n, alpha, beta, a, lda)
	SLASET: initializes an m-by-n matrix A to BETA on the diagonal and ALPHA on the offdiagonals.

pure subroutine, public	la_dlaset (uplo, m, n, alpha, beta, a, lda)
	DLASET: initializes an m-by-n matrix A to BETA on the diagonal and ALPHA on the offdiagonals.

pure subroutine, public	la_qlaset (uplo, m, n, alpha, beta, a, lda)
	QLASET: initializes an m-by-n matrix A to BETA on the diagonal and ALPHA on the offdiagonals.

pure subroutine, public	la_dlat2s (uplo, n, a, lda, sa, ldsa, info)
	DLAT2S: converts a DOUBLE PRECISION triangular matrix, SA, to a SINGLE PRECISION triangular matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic DLAS2S checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_qlat2d (uplo, n, a, lda, sa, ldsa, info)
	QLAT2D: converts a QUAD PRECISION triangular matrix, SA, to a SINGLE PRECISION triangular matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic DLAS2S checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_stfttp (transr, uplo, n, arf, ap, info)
	STFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

pure subroutine, public	la_dtfttp (transr, uplo, n, arf, ap, info)
	DTFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

pure subroutine, public	la_qtfttp (transr, uplo, n, arf, ap, info)
	QTFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

pure subroutine, public	la_stfttr (transr, uplo, n, arf, a, lda, info)
	STFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

pure subroutine, public	la_dtfttr (transr, uplo, n, arf, a, lda, info)
	DTFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

pure subroutine, public	la_qtfttr (transr, uplo, n, arf, a, lda, info)
	QTFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

pure subroutine, public	la_stpttf (transr, uplo, n, ap, arf, info)
	STPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

pure subroutine, public	la_dtpttf (transr, uplo, n, ap, arf, info)
	DTPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

pure subroutine, public	la_qtpttf (transr, uplo, n, ap, arf, info)
	QTPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

pure subroutine, public	la_stpttr (uplo, n, ap, a, lda, info)
	STPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

pure subroutine, public	la_dtpttr (uplo, n, ap, a, lda, info)
	DTPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

pure subroutine, public	la_qtpttr (uplo, n, ap, a, lda, info)
	QTPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

pure subroutine, public	la_strttf (transr, uplo, n, a, lda, arf, info)
	STRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

pure subroutine, public	la_dtrttf (transr, uplo, n, a, lda, arf, info)
	DTRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

pure subroutine, public	la_qtrttf (transr, uplo, n, a, lda, arf, info)
	QTRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

pure subroutine, public	la_strttp (uplo, n, a, lda, ap, info)
	STRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

pure subroutine, public	la_dtrttp (uplo, n, a, lda, ap, info)
	DTRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

pure subroutine, public	la_qtrttp (uplo, n, a, lda, ap, info)
	QTRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

pure subroutine, public	la_slag2d (m, n, sa, ldsa, a, lda, info)
	SLAG2D: converts a SINGLE PRECISION matrix, SA, to a DOUBLE PRECISION matrix, A. Note that while it is possible to overflow while converting from double to single, it is not possible to overflow when converting from single to double. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_dlag2q (m, n, sa, ldsa, a, lda, info)
	DLAG2Q: converts a SINGLE PRECISION matrix, SA, to a DOUBLE PRECISION matrix, A. Note that while it is possible to overflow while converting from double to single, it is not possible to overflow when converting from single to double. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_slarnv (idist, iseed, n, x)
	SLARNV: returns a vector of n random real numbers from a uniform or normal distribution.

pure subroutine, public	la_dlarnv (idist, iseed, n, x)
	DLARNV: returns a vector of n random real numbers from a uniform or normal distribution.

pure subroutine, public	la_qlarnv (idist, iseed, n, x)
	QLARNV: returns a vector of n random real numbers from a uniform or normal distribution.

pure subroutine, public	la_clag2z (m, n, sa, ldsa, a, lda, info)
	CLAG2Z: converts a COMPLEX matrix, SA, to a COMPLEX*16 matrix, A. Note that while it is possible to overflow while converting from double to single, it is not possible to overflow when converting from single to double. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_zlag2w (m, n, sa, ldsa, a, lda, info)
	ZLAG2W: converts a COMPLEX matrix, SA, to a COMPLEX*16 matrix, A. Note that while it is possible to overflow while converting from double to single, it is not possible to overflow when converting from single to double. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_clacp2 (uplo, m, n, a, lda, b, ldb)
	CLACP2: copies all or part of a real two-dimensional matrix A to a complex matrix B.

pure subroutine, public	la_zlacp2 (uplo, m, n, a, lda, b, ldb)
	ZLACP2: copies all or part of a real two-dimensional matrix A to a complex matrix B.

pure subroutine, public	la_wlacp2 (uplo, m, n, a, lda, b, ldb)
	WLACP2: copies all or part of a real two-dimensional matrix A to a complex matrix B.

pure subroutine, public	la_clacpy (uplo, m, n, a, lda, b, ldb)
	CLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

pure subroutine, public	la_zlacpy (uplo, m, n, a, lda, b, ldb)
	ZLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

pure subroutine, public	la_wlacpy (uplo, m, n, a, lda, b, ldb)
	WLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

pure subroutine, public	la_zlag2c (m, n, a, lda, sa, ldsa, info)
	ZLAG2C: converts a COMPLEX*16 matrix, SA, to a COMPLEX matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic ZLAG2C checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_wlag2z (m, n, a, lda, sa, ldsa, info)
	WLAG2Z: converts a COMPLEX*16 matrix, SA, to a COMPLEX matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic WLAG2Z checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_clarnv (idist, iseed, n, x)
	CLARNV: returns a vector of n random complex numbers from a uniform or normal distribution.

pure subroutine, public	la_zlarnv (idist, iseed, n, x)
	ZLARNV: returns a vector of n random complex numbers from a uniform or normal distribution.

pure subroutine, public	la_wlarnv (idist, iseed, n, x)
	WLARNV: returns a vector of n random complex numbers from a uniform or normal distribution.

pure subroutine, public	la_claset (uplo, m, n, alpha, beta, a, lda)
	CLASET: initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.

pure subroutine, public	la_zlaset (uplo, m, n, alpha, beta, a, lda)
	ZLASET: initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.

pure subroutine, public	la_wlaset (uplo, m, n, alpha, beta, a, lda)
	WLASET: initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.

pure subroutine, public	la_zlat2c (uplo, n, a, lda, sa, ldsa, info)
	ZLAT2C: converts a COMPLEX*16 triangular matrix, SA, to a COMPLEX triangular matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic ZLAT2C checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_wlat2z (uplo, n, a, lda, sa, ldsa, info)
	WLAT2Z: converts a COMPLEX*16 triangular matrix, SA, to a COMPLEX triangular matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic WLAT2Z checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

pure subroutine, public	la_ctfttp (transr, uplo, n, arf, ap, info)
	CTFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

pure subroutine, public	la_ztfttp (transr, uplo, n, arf, ap, info)
	ZTFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

pure subroutine, public	la_wtfttp (transr, uplo, n, arf, ap, info)
	WTFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

pure subroutine, public	la_ctfttr (transr, uplo, n, arf, a, lda, info)
	CTFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

pure subroutine, public	la_ztfttr (transr, uplo, n, arf, a, lda, info)
	ZTFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

pure subroutine, public	la_wtfttr (transr, uplo, n, arf, a, lda, info)
	WTFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

pure subroutine, public	la_ctpttf (transr, uplo, n, ap, arf, info)
	CTPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

pure subroutine, public	la_ztpttf (transr, uplo, n, ap, arf, info)
	ZTPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

pure subroutine, public	la_wtpttf (transr, uplo, n, ap, arf, info)
	WTPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

pure subroutine, public	la_ctpttr (uplo, n, ap, a, lda, info)
	CTPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

pure subroutine, public	la_ztpttr (uplo, n, ap, a, lda, info)
	ZTPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

pure subroutine, public	la_wtpttr (uplo, n, ap, a, lda, info)
	WTPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

pure subroutine, public	la_ctrttf (transr, uplo, n, a, lda, arf, info)
	CTRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

pure subroutine, public	la_ztrttf (transr, uplo, n, a, lda, arf, info)
	ZTRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

pure subroutine, public	la_wtrttf (transr, uplo, n, a, lda, arf, info)
	WTRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

pure subroutine, public	la_ctrttp (uplo, n, a, lda, ap, info)
	CTRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

pure subroutine, public	la_ztrttp (uplo, n, a, lda, ap, info)
	ZTRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

pure subroutine, public	la_wtrttp (uplo, n, a, lda, ap, info)
	WTRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

Detailed Description

BLAS-like base: copy, precision conversion, random and packed storage.

Function/Subroutine Documentation

◆ la_clacp2()

pure subroutine, public la_lapack_blas_like_base::la_clacp2	(	character, intent(in)	uplo,
		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(out)	b,
		integer(ilp), intent(in)	ldb )

CLACP2: copies all or part of a real two-dimensional matrix A to a complex matrix B.

Here is the call graph for this function:

◆ la_clacpy()

pure subroutine, public la_lapack_blas_like_base::la_clacpy	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb )

CLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

Here is the call graph for this function:

◆ la_clag2z()

pure subroutine, public la_lapack_blas_like_base::la_clag2z	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldsa,*), intent(in)	sa,
		integer(ilp), intent(in)	ldsa,
		complex(dp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

CLAG2Z: converts a COMPLEX matrix, SA, to a COMPLEX*16 matrix, A. Note that while it is possible to overflow while converting from double to single, it is not possible to overflow when converting from single to double. This is an auxiliary routine so there is no argument checking.

◆ la_clarnv()

pure subroutine, public la_lapack_blas_like_base::la_clarnv	(	integer(ilp), intent(in)	idist,
		integer(ilp), dimension(4), intent(inout)	iseed,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(out)	x )

CLARNV: returns a vector of n random complex numbers from a uniform or normal distribution.

Here is the call graph for this function:

◆ la_claset()

pure subroutine, public la_lapack_blas_like_base::la_claset	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), intent(in)	beta,
		complex(sp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda )

CLASET: initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.

Here is the call graph for this function:

◆ la_ctfttp()

pure subroutine, public la_lapack_blas_like_base::la_ctfttp	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(0:*), intent(in)	arf,
		complex(sp), dimension(0:*), intent(out)	ap,
		integer(ilp), intent(out)	info )

CTFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

Here is the call graph for this function:

◆ la_ctfttr()

pure subroutine, public la_lapack_blas_like_base::la_ctfttr	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(0:*), intent(in)	arf,
		complex(sp), dimension(0:lda - 1,0:*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

CTFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

Here is the call graph for this function:

◆ la_ctpttf()

pure subroutine, public la_lapack_blas_like_base::la_ctpttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(0:*), intent(in)	ap,
		complex(sp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

CTPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

Here is the call graph for this function:

◆ la_ctpttr()

pure subroutine, public la_lapack_blas_like_base::la_ctpttr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

CTPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

Here is the call graph for this function:

◆ la_ctrttf()

pure subroutine, public la_lapack_blas_like_base::la_ctrttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(0:lda - 1,0:*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

CTRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

Here is the call graph for this function:

◆ la_ctrttp()

pure subroutine, public la_lapack_blas_like_base::la_ctrttp	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	ap,
		integer(ilp), intent(out)	info )

CTRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

Here is the call graph for this function:

◆ la_dlacpy()

pure subroutine, public la_lapack_blas_like_base::la_dlacpy	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb )

DLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

Here is the call graph for this function:

◆ la_dlag2q()

pure subroutine, public la_lapack_blas_like_base::la_dlag2q	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(dp), dimension(ldsa,*), intent(in)	sa,
		integer(ilp), intent(in)	ldsa,
		real(qp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

DLAG2Q: converts a SINGLE PRECISION matrix, SA, to a DOUBLE PRECISION matrix, A. Note that while it is possible to overflow while converting from double to single, it is not possible to overflow when converting from single to double. This is an auxiliary routine so there is no argument checking.

◆ la_dlag2s()

pure subroutine, public la_lapack_blas_like_base::la_dlag2s	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(ldsa,*), intent(out)	sa,
		integer(ilp), intent(in)	ldsa,
		integer(ilp), intent(out)	info )

DLAG2S: converts a DOUBLE PRECISION matrix, SA, to a SINGLE PRECISION matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic DLAG2S checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

Here is the call graph for this function:

◆ la_dlarnv()

pure subroutine, public la_lapack_blas_like_base::la_dlarnv	(	integer(ilp), intent(in)	idist,
		integer(ilp), dimension(4), intent(inout)	iseed,
		integer(ilp), intent(in)	n,
		real(dp), dimension(*), intent(out)	x )

DLARNV: returns a vector of n random real numbers from a uniform or normal distribution.

Here is the call graph for this function:

◆ la_dlaruv()

pure subroutine, public la_lapack_blas_like_base::la_dlaruv	(	integer(ilp), dimension(4), intent(inout)	iseed,
		integer(ilp), intent(in)	n,
		real(dp), dimension(n), intent(out)	x )

DLARUV: returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by DLARNV and ZLARNV.

◆ la_dlaset()

pure subroutine, public la_lapack_blas_like_base::la_dlaset	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), intent(in)	beta,
		real(dp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda )

DLASET: initializes an m-by-n matrix A to BETA on the diagonal and ALPHA on the offdiagonals.

Here is the call graph for this function:

◆ la_dlat2s()

pure subroutine, public la_lapack_blas_like_base::la_dlat2s	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(ldsa,*), intent(out)	sa,
		integer(ilp), intent(in)	ldsa,
		integer(ilp), intent(out)	info )

DLAT2S: converts a DOUBLE PRECISION triangular matrix, SA, to a SINGLE PRECISION triangular matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic DLAS2S checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

Here is the call graph for this function:

◆ la_dtfttp()

pure subroutine, public la_lapack_blas_like_base::la_dtfttp	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), dimension(0:*), intent(in)	arf,
		real(dp), dimension(0:*), intent(out)	ap,
		integer(ilp), intent(out)	info )

DTFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

Here is the call graph for this function:

◆ la_dtfttr()

pure subroutine, public la_lapack_blas_like_base::la_dtfttr	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), dimension(0:*), intent(in)	arf,
		real(dp), dimension(0:lda - 1,0:*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

DTFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

Here is the call graph for this function:

◆ la_dtpttf()

pure subroutine, public la_lapack_blas_like_base::la_dtpttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), dimension(0:*), intent(in)	ap,
		real(dp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

DTPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

Here is the call graph for this function:

◆ la_dtpttr()

pure subroutine, public la_lapack_blas_like_base::la_dtpttr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), dimension(*), intent(in)	ap,
		real(dp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

DTPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

Here is the call graph for this function:

◆ la_dtrttf()

pure subroutine, public la_lapack_blas_like_base::la_dtrttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), dimension(0:lda - 1,0:*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

DTRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

Here is the call graph for this function:

◆ la_dtrttp()

pure subroutine, public la_lapack_blas_like_base::la_dtrttp	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(*), intent(out)	ap,
		integer(ilp), intent(out)	info )

DTRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

Here is the call graph for this function:

◆ la_qlacpy()

pure subroutine, public la_lapack_blas_like_base::la_qlacpy	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb )

QLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

Here is the call graph for this function:

◆ la_qlag2d()

pure subroutine, public la_lapack_blas_like_base::la_qlag2d	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldsa,*), intent(out)	sa,
		integer(ilp), intent(in)	ldsa,
		integer(ilp), intent(out)	info )

QLAG2D: converts a QUAD PRECISION matrix, SA, to a SINGLE PRECISION matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic QLAG2D checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

Here is the call graph for this function:

◆ la_qlarnv()

pure subroutine, public la_lapack_blas_like_base::la_qlarnv	(	integer(ilp), intent(in)	idist,
		integer(ilp), dimension(4), intent(inout)	iseed,
		integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(out)	x )

QLARNV: returns a vector of n random real numbers from a uniform or normal distribution.

Here is the call graph for this function:

◆ la_qlaruv()

pure subroutine, public la_lapack_blas_like_base::la_qlaruv	(	integer(ilp), dimension(4), intent(inout)	iseed,
		integer(ilp), intent(in)	n,
		real(qp), dimension(n), intent(out)	x )

QLARUV: returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by QLARNV and WLARNV.

◆ la_qlaset()

pure subroutine, public la_lapack_blas_like_base::la_qlaset	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(qp), intent(in)	alpha,
		real(qp), intent(in)	beta,
		real(qp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda )

QLASET: initializes an m-by-n matrix A to BETA on the diagonal and ALPHA on the offdiagonals.

Here is the call graph for this function:

◆ la_qlat2d()

pure subroutine, public la_lapack_blas_like_base::la_qlat2d	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldsa,*), intent(out)	sa,
		integer(ilp), intent(in)	ldsa,
		integer(ilp), intent(out)	info )

QLAT2D: converts a QUAD PRECISION triangular matrix, SA, to a SINGLE PRECISION triangular matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic DLAS2S checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

Here is the call graph for this function:

◆ la_qtfttp()

pure subroutine, public la_lapack_blas_like_base::la_qtfttp	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(0:*), intent(in)	arf,
		real(qp), dimension(0:*), intent(out)	ap,
		integer(ilp), intent(out)	info )

QTFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

Here is the call graph for this function:

◆ la_qtfttr()

pure subroutine, public la_lapack_blas_like_base::la_qtfttr	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(0:*), intent(in)	arf,
		real(qp), dimension(0:lda - 1,0:*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

QTFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

Here is the call graph for this function:

◆ la_qtpttf()

pure subroutine, public la_lapack_blas_like_base::la_qtpttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(0:*), intent(in)	ap,
		real(qp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

QTPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

Here is the call graph for this function:

◆ la_qtpttr()

pure subroutine, public la_lapack_blas_like_base::la_qtpttr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(in)	ap,
		real(qp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

QTPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

Here is the call graph for this function:

◆ la_qtrttf()

pure subroutine, public la_lapack_blas_like_base::la_qtrttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(0:lda - 1,0:*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

QTRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

Here is the call graph for this function:

◆ la_qtrttp()

pure subroutine, public la_lapack_blas_like_base::la_qtrttp	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(*), intent(out)	ap,
		integer(ilp), intent(out)	info )

QTRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

Here is the call graph for this function:

◆ la_slacpy()

pure subroutine, public la_lapack_blas_like_base::la_slacpy	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb )

SLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

Here is the call graph for this function:

◆ la_slag2d()

pure subroutine, public la_lapack_blas_like_base::la_slag2d	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(sp), dimension(ldsa,*), intent(in)	sa,
		integer(ilp), intent(in)	ldsa,
		real(dp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

SLAG2D: converts a SINGLE PRECISION matrix, SA, to a DOUBLE PRECISION matrix, A. Note that while it is possible to overflow while converting from double to single, it is not possible to overflow when converting from single to double. This is an auxiliary routine so there is no argument checking.

◆ la_slarnv()

pure subroutine, public la_lapack_blas_like_base::la_slarnv	(	integer(ilp), intent(in)	idist,
		integer(ilp), dimension(4), intent(inout)	iseed,
		integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(out)	x )

SLARNV: returns a vector of n random real numbers from a uniform or normal distribution.

Here is the call graph for this function:

◆ la_slaruv()

pure subroutine, public la_lapack_blas_like_base::la_slaruv	(	integer(ilp), dimension(4), intent(inout)	iseed,
		integer(ilp), intent(in)	n,
		real(sp), dimension(n), intent(out)	x )

SLARUV: returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by SLARNV and CLARNV.

◆ la_slaset()

pure subroutine, public la_lapack_blas_like_base::la_slaset	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(sp), intent(in)	alpha,
		real(sp), intent(in)	beta,
		real(sp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda )

SLASET: initializes an m-by-n matrix A to BETA on the diagonal and ALPHA on the offdiagonals.

Here is the call graph for this function:

◆ la_stfttp()

pure subroutine, public la_lapack_blas_like_base::la_stfttp	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(sp), dimension(0:*), intent(in)	arf,
		real(sp), dimension(0:*), intent(out)	ap,
		integer(ilp), intent(out)	info )

STFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

Here is the call graph for this function:

◆ la_stfttr()

pure subroutine, public la_lapack_blas_like_base::la_stfttr	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(sp), dimension(0:*), intent(in)	arf,
		real(sp), dimension(0:lda - 1,0:*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

STFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

Here is the call graph for this function:

◆ la_stpttf()

pure subroutine, public la_lapack_blas_like_base::la_stpttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(sp), dimension(0:*), intent(in)	ap,
		real(sp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

STPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

Here is the call graph for this function:

◆ la_stpttr()

pure subroutine, public la_lapack_blas_like_base::la_stpttr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(in)	ap,
		real(sp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

STPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

Here is the call graph for this function:

◆ la_strttf()

pure subroutine, public la_lapack_blas_like_base::la_strttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(sp), dimension(0:lda - 1,0:*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

STRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

Here is the call graph for this function:

◆ la_strttp()

pure subroutine, public la_lapack_blas_like_base::la_strttp	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	ap,
		integer(ilp), intent(out)	info )

STRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

Here is the call graph for this function:

◆ la_wlacp2()

pure subroutine, public la_lapack_blas_like_base::la_wlacp2	(	character, intent(in)	uplo,
		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(out)	b,
		integer(ilp), intent(in)	ldb )

WLACP2: copies all or part of a real two-dimensional matrix A to a complex matrix B.

Here is the call graph for this function:

◆ la_wlacpy()

pure subroutine, public la_lapack_blas_like_base::la_wlacpy	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb )

WLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

Here is the call graph for this function:

◆ la_wlag2z()

pure subroutine, public la_lapack_blas_like_base::la_wlag2z	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(ldsa,*), intent(out)	sa,
		integer(ilp), intent(in)	ldsa,
		integer(ilp), intent(out)	info )

WLAG2Z: converts a COMPLEX*16 matrix, SA, to a COMPLEX matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic WLAG2Z checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

Here is the call graph for this function:

◆ la_wlarnv()

pure subroutine, public la_lapack_blas_like_base::la_wlarnv	(	integer(ilp), intent(in)	idist,
		integer(ilp), dimension(4), intent(inout)	iseed,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(out)	x )

WLARNV: returns a vector of n random complex numbers from a uniform or normal distribution.

Here is the call graph for this function:

◆ la_wlaset()

pure subroutine, public la_lapack_blas_like_base::la_wlaset	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), intent(in)	alpha,
		complex(qp), intent(in)	beta,
		complex(qp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda )

WLASET: initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.

Here is the call graph for this function:

◆ la_wlat2z()

pure subroutine, public la_lapack_blas_like_base::la_wlat2z	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(ldsa,*), intent(out)	sa,
		integer(ilp), intent(in)	ldsa,
		integer(ilp), intent(out)	info )

WLAT2Z: converts a COMPLEX*16 triangular matrix, SA, to a COMPLEX triangular matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic WLAT2Z checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

Here is the call graph for this function:

◆ la_wtfttp()

pure subroutine, public la_lapack_blas_like_base::la_wtfttp	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(0:*), intent(in)	arf,
		complex(qp), dimension(0:*), intent(out)	ap,
		integer(ilp), intent(out)	info )

WTFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

Here is the call graph for this function:

◆ la_wtfttr()

pure subroutine, public la_lapack_blas_like_base::la_wtfttr	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(0:*), intent(in)	arf,
		complex(qp), dimension(0:lda - 1,0:*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

WTFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

Here is the call graph for this function:

◆ la_wtpttf()

pure subroutine, public la_lapack_blas_like_base::la_wtpttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(0:*), intent(in)	ap,
		complex(qp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

WTPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

Here is the call graph for this function:

◆ la_wtpttr()

pure subroutine, public la_lapack_blas_like_base::la_wtpttr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(in)	ap,
		complex(qp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

WTPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

Here is the call graph for this function:

◆ la_wtrttf()

pure subroutine, public la_lapack_blas_like_base::la_wtrttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(0:lda - 1,0:*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

WTRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

Here is the call graph for this function:

◆ la_wtrttp()

pure subroutine, public la_lapack_blas_like_base::la_wtrttp	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(*), intent(out)	ap,
		integer(ilp), intent(out)	info )

WTRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

Here is the call graph for this function:

◆ la_zlacp2()

pure subroutine, public la_lapack_blas_like_base::la_zlacp2	(	character, intent(in)	uplo,
		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(out)	b,
		integer(ilp), intent(in)	ldb )

ZLACP2: copies all or part of a real two-dimensional matrix A to a complex matrix B.

Here is the call graph for this function:

◆ la_zlacpy()

pure subroutine, public la_lapack_blas_like_base::la_zlacpy	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb )

ZLACPY: copies all or part of a two-dimensional matrix A to another matrix B.

Here is the call graph for this function:

◆ la_zlag2c()

pure subroutine, public la_lapack_blas_like_base::la_zlag2c	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldsa,*), intent(out)	sa,
		integer(ilp), intent(in)	ldsa,
		integer(ilp), intent(out)	info )

ZLAG2C: converts a COMPLEX*16 matrix, SA, to a COMPLEX matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic ZLAG2C checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

Here is the call graph for this function:

◆ la_zlag2w()

pure subroutine, public la_lapack_blas_like_base::la_zlag2w	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(ldsa,*), intent(in)	sa,
		integer(ilp), intent(in)	ldsa,
		complex(qp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

ZLAG2W: converts a COMPLEX matrix, SA, to a COMPLEX*16 matrix, A. Note that while it is possible to overflow while converting from double to single, it is not possible to overflow when converting from single to double. This is an auxiliary routine so there is no argument checking.

◆ la_zlarnv()

pure subroutine, public la_lapack_blas_like_base::la_zlarnv	(	integer(ilp), intent(in)	idist,
		integer(ilp), dimension(4), intent(inout)	iseed,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(*), intent(out)	x )

ZLARNV: returns a vector of n random complex numbers from a uniform or normal distribution.

Here is the call graph for this function:

◆ la_zlaset()

pure subroutine, public la_lapack_blas_like_base::la_zlaset	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), intent(in)	alpha,
		complex(dp), intent(in)	beta,
		complex(dp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda )

ZLASET: initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.

Here is the call graph for this function:

◆ la_zlat2c()

pure subroutine, public la_lapack_blas_like_base::la_zlat2c	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldsa,*), intent(out)	sa,
		integer(ilp), intent(in)	ldsa,
		integer(ilp), intent(out)	info )

ZLAT2C: converts a COMPLEX*16 triangular matrix, SA, to a COMPLEX triangular matrix, A. RMAX is the overflow for the SINGLE PRECISION arithmetic ZLAT2C checks that all the entries of A are between -RMAX and RMAX. If not the conversion is aborted and a flag is raised. This is an auxiliary routine so there is no argument checking.

Here is the call graph for this function:

◆ la_ztfttp()

pure subroutine, public la_lapack_blas_like_base::la_ztfttp	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(0:*), intent(in)	arf,
		complex(dp), dimension(0:*), intent(out)	ap,
		integer(ilp), intent(out)	info )

ZTFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).

Here is the call graph for this function:

◆ la_ztfttr()

pure subroutine, public la_lapack_blas_like_base::la_ztfttr	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(0:*), intent(in)	arf,
		complex(dp), dimension(0:lda - 1,0:*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

ZTFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).

Here is the call graph for this function:

◆ la_ztpttf()

pure subroutine, public la_lapack_blas_like_base::la_ztpttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(0:*), intent(in)	ap,
		complex(dp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

ZTPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

Here is the call graph for this function:

◆ la_ztpttr()

pure subroutine, public la_lapack_blas_like_base::la_ztpttr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(*), intent(in)	ap,
		complex(dp), dimension(lda,*), intent(out)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info )

ZTPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR).

Here is the call graph for this function:

◆ la_ztrttf()

pure subroutine, public la_lapack_blas_like_base::la_ztrttf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(0:lda - 1,0:*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(0:*), intent(out)	arf,
		integer(ilp), intent(out)	info )

ZTRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .

Here is the call graph for this function:

◆ la_ztrttp()

pure subroutine, public la_lapack_blas_like_base::la_ztrttp	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(*), intent(out)	ap,
		integer(ilp), intent(out)	info )

ZTRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP).

Here is the call graph for this function:

Functions/Subroutines

Detailed Description

Function/Subroutine Documentation

◆ la_clacp2()

◆ la_clacpy()

◆ la_clag2z()

◆ la_clarnv()

◆ la_claset()

◆ la_ctfttp()

◆ la_ctfttr()

◆ la_ctpttf()

◆ la_ctpttr()

◆ la_ctrttf()

◆ la_ctrttp()

◆ la_dlacpy()

◆ la_dlag2q()

◆ la_dlag2s()

◆ la_dlarnv()

◆ la_dlaruv()

◆ la_dlaset()

◆ la_dlat2s()

◆ la_dtfttp()

◆ la_dtfttr()

◆ la_dtpttf()

◆ la_dtpttr()

◆ la_dtrttf()

◆ la_dtrttp()

◆ la_qlacpy()

◆ la_qlag2d()

◆ la_qlarnv()

◆ la_qlaruv()

◆ la_qlaset()

◆ la_qlat2d()

◆ la_qtfttp()

◆ la_qtfttr()

◆ la_qtpttf()

◆ la_qtpttr()

◆ la_qtrttf()

◆ la_qtrttp()

◆ la_slacpy()

◆ la_slag2d()

◆ la_slarnv()

◆ la_slaruv()

◆ la_slaset()

◆ la_stfttp()

◆ la_stfttr()

◆ la_stpttf()

◆ la_stpttr()

◆ la_strttf()

◆ la_strttp()

◆ la_wlacp2()

◆ la_wlacpy()

◆ la_wlag2z()

◆ la_wlarnv()

◆ la_wlaset()

◆ la_wlat2z()

◆ la_wtfttp()

◆ la_wtfttr()

◆ la_wtpttf()

◆ la_wtpttr()

◆ la_wtrttf()

◆ la_wtrttp()

◆ la_zlacp2()

◆ la_zlacpy()

◆ la_zlag2c()

◆ la_zlag2w()

◆ la_zlarnv()

◆ la_zlaset()

◆ la_zlat2c()

◆ la_ztfttp()

◆ la_ztfttr()

◆ la_ztpttf()

◆ la_ztpttr()

◆ la_ztrttf()

◆ la_ztrttp()