Functions/Subroutines
pure subroutine, public	la_cgbequ (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)
	CGBEQU: computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

pure subroutine, public	la_cgbequb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)
	CGBEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

pure subroutine, public	la_cgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info)
	CGBTF2: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_cgebak (job, side, n, ilo, ihi, scale, m, v, ldv, info)
	CGEBAK: forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by CGEBAL.

pure subroutine, public	la_cgebal (job, n, a, lda, ilo, ihi, scale, info)
	CGEBAL: balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

pure subroutine, public	la_cgeequ (m, n, a, lda, r, c, rowcnd, colcnd, amax, info)
	CGEEQU: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

pure subroutine, public	la_cgeequb (m, n, a, lda, r, c, rowcnd, colcnd, amax, info)
	CGEEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

pure subroutine, public	la_cgetc2 (n, a, lda, ipiv, jpiv, info)
	CGETC2: computes an LU factorization, using complete pivoting, of the n-by-n matrix A. The factorization has the form A = P * L * U * Q, where P and Q are permutation matrices, L is lower triangular with unit diagonal elements and U is upper triangular. This is a level 1 BLAS version of the algorithm.

pure subroutine, public	la_cgetf2 (m, n, a, lda, ipiv, info)
	CGETF2: computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 2 BLAS version of the algorithm.

pure subroutine, public	la_cggbak (job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)
	CGGBAK: forms the right or left eigenvectors of a complex generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by CGGBAL.

pure subroutine, public	la_cggbal (job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)
	CGGBAL: balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

pure subroutine, public	la_cgtsv (n, nrhs, dl, d, du, b, ldb, info)
	CGTSV: solves the equation AX = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation AT X = B may be solved by interchanging the order of the arguments DU and DL.

pure subroutine, public	la_cgttrf (n, dl, d, du, du2, ipiv, info)
	CGTTRF: computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.

pure subroutine, public	la_cgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb)
	CGTTS2: solves one of the systems of equations A * X = B, A*T X = B, or A*H X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF.

pure subroutine, public	la_cheswapr (uplo, n, a, lda, i1, i2)
	CHESWAPR: applies an elementary permutation on the rows and the columns of a hermitian matrix.

pure subroutine, public	la_chetf2 (uplo, n, a, lda, ipiv, info)
	CHETF2: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method: A = UDU*H or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*H is the conjugate transpose of U, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_chetf2_rk (uplo, n, a, lda, e, ipiv, info)
	CHETF2_RK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(P*T) or A = PLD(L*H)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, PT is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

pure subroutine, public	la_chetf2_rook (uplo, n, a, lda, ipiv, info)
	CHETF2_ROOK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*H or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*H is the conjugate transpose of U, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_chetri (uplo, n, a, lda, ipiv, work, info)
	CHETRI: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDU*H or A = LDL*H computed by CHETRF.

pure subroutine, public	la_chetri_rook (uplo, n, a, lda, ipiv, work, info)
	CHETRI_ROOK: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDU*H or A = LDL*H computed by CHETRF_ROOK.

pure subroutine, public	la_chetrs_3 (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)
	CHETRS_3: solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by CHETRF_RK or CHETRF_BK: A = PUD(UH)(P*T) or A = PLD(L*H)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, PT is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

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 := alphaAA*H + betaC, or C := alphaAHA + 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_chpgst (itype, uplo, n, ap, bp, info)
	CHPGST: reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by CPPTRF.

pure subroutine, public	la_chptrf (uplo, n, ap, ipiv, info)
	CHPTRF: computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = UDU*H or A = LDL*H where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

pure subroutine, public	la_chptri (uplo, n, ap, ipiv, work, info)
	CHPTRI: computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = UDU*H or A = LDL*H computed by CHPTRF.

subroutine, public	la_cla_gbamv (trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy)
	CLA_GBAMV: performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)*Tabs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

pure real(sp) function, public	la_cla_gbrpvgrw (n, kl, ku, ncols, ab, ldab, afb, ldafb)
	CLA_GBRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

subroutine, public	la_cla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
	CLA_GEAMV: performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)*Tabs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

pure real(sp) function, public	la_cla_gerpvgrw (n, ncols, a, lda, af, ldaf)
	CLA_GERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

subroutine, public	la_cla_heamv (uplo, n, alpha, a, lda, x, incx, beta, y, incy)
	CLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

pure subroutine, public	la_cla_lin_berr (n, nz, nrhs, res, ayb, berr)
	CLA_LIN_BERR: computes componentwise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the componentwise absolute value of the matrix or vector Z.

real(sp) function, public	la_cla_porpvgrw (uplo, ncols, a, lda, af, ldaf, work)
	CLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

subroutine, public	la_cla_syamv (uplo, n, alpha, a, lda, x, incx, beta, y, incy)
	CLA_SYAMV: performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

pure subroutine, public	la_cla_wwaddw (n, x, y, w)
	CLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.

pure subroutine, public	la_clacgv (n, x, incx)
	CLACGV: conjugates a complex vector of length N.

pure subroutine, public	la_clacn2 (n, v, x, est, kase, isave)
	CLACN2: estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products.

subroutine, public	la_clacon (n, v, x, est, kase)
	CLACON: estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products.

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_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_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_clacrt (n, cx, incx, cy, incy, c, s)
	CLACRT: performs the operation ( c s )( x ) ==> ( x ) ( -s c )( y ) ( y ) where c and s are complex and the vectors x and y are complex.

pure complex(sp) function, public	la_cladiv (x, y)
	CLADIV: := X / Y, where X and Y are complex. The computation of X / Y will not overflow on an intermediary step unless the results overflows.

pure subroutine, public	la_claed8 (k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlamda, q2, ldq2, w, indxp, indx, indxq, perm, givptr, givcol, givnum, info)
	CLAED8: merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.

pure subroutine, public	la_claesy (a, b, c, rt1, rt2, evscal, cs1, sn1)
	CLAESY: computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ].

pure subroutine, public	la_claev2 (a, b, c, rt1, rt2, cs1, sn1)
	CLAEV2: computes the eigendecomposition of a 2-by-2 Hermitian matrix [ A B ] [ CONJG(B) C ]. On return, RT1 is the eigenvalue of larger absolute value, RT2 is the eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right eigenvector for RT1, giving the decomposition [ CS1 CONJG(SN1) ] [ A B ] [ CS1 -CONJG(SN1) ] = [ RT1 0 ] [-SN1 CS1 ] [ CONJG(B) C ] [ SN1 CS1 ] [ 0 RT2 ].

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_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_clahef (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	CLAHEF: computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. CLAHEF is an auxiliary routine called by CHETRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_clahef_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	CLAHEF_RK: computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLAHEF_RK is an auxiliary routine called by CHETRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_clahef_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	CLAHEF_ROOK: computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. CLAHEF_ROOK is an auxiliary routine called by CHETRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_claic1 (job, j, x, sest, w, gamma, sestpr, s, c)
	CLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then CLAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w*H gamma ] in the sense that twonorm(Lhatxhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]H and sestpr2 is an eigenpair of the system diag(sestsest, 0) + [alpha gamma] [ conjg(alpha) ] [ conjg(gamma) ] where alpha = x*Hw.

pure subroutine, public	la_clapmr (forwrd, m, n, x, ldx, k)
	CLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.

pure subroutine, public	la_clapmt (forwrd, m, n, x, ldx, k)
	CLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.

pure subroutine, public	la_claqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed)
	CLAQGB: equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.

pure subroutine, public	la_claqge (m, n, a, lda, r, c, rowcnd, colcnd, amax, equed)
	CLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.

pure subroutine, public	la_claqhb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
	CLAQHB: equilibrates an Hermitian band matrix A using the scaling factors in the vector S.

pure subroutine, public	la_claqhe (uplo, n, a, lda, s, scond, amax, equed)
	CLAQHE: equilibrates a Hermitian matrix A using the scaling factors in the vector S.

pure subroutine, public	la_claqhp (uplo, n, ap, s, scond, amax, equed)
	CLAQHP: equilibrates a Hermitian matrix A using the scaling factors in the vector S.

pure subroutine, public	la_claqr1 (n, h, ldh, s1, s2, v)
	Given a 2-by-2 or 3-by-3 matrix H, CLAQR1: sets v to a scalar multiple of the first column of the product () K = (H - s1I)(H - s2I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.

pure subroutine, public	la_claqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
	CLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

pure subroutine, public	la_claqsp (uplo, n, ap, s, scond, amax, equed)
	CLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S.

pure subroutine, public	la_claqsy (uplo, n, a, lda, s, scond, amax, equed)
	CLAQSY: equilibrates a symmetric matrix A using the scaling factors in the vector S.

pure subroutine, public	la_clar1v (n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work)
	CLAR1V: computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.

pure subroutine, public	la_clar2v (n, x, y, z, incx, c, s, incc)
	CLAR2V: applies a vector of complex plane rotations with real cosines from both sides to a sequence of 2-by-2 complex Hermitian matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( conjg(z(i)) y(i) ) ( c(i) conjg(s(i)) ) ( x(i) z(i) ) ( c(i) -conjg(s(i)) ) ( -s(i) c(i) ) ( conjg(z(i)) y(i) ) ( s(i) c(i) )

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_clarf (side, m, n, v, incv, tau, c, ldc, work)
	CLARF: applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau.

pure subroutine, public	la_clarfb (side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork)
	CLARFB: applies a complex block reflector H or its transpose H**H to a complex M-by-N matrix C, from either the left or the right.

pure subroutine, public	la_clarfb_gett (ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)
	CLARFB_GETT: applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

pure subroutine, public	la_clarfg (n, alpha, x, incx, tau)
	CLARFG: generates a complex elementary reflector H of order n, such that H*H ( alpha ) = ( beta ), H*H H = I. ( x ) ( 0 ) where alpha and beta are scalars, with beta real, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1 .

subroutine, public	la_clarfgp (n, alpha, x, incx, tau)
	CLARFGP: generates a complex elementary reflector H of order n, such that H*H ( alpha ) = ( beta ), H*H H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is real and non-negative, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix.

pure subroutine, public	la_clarft (direct, storev, n, k, v, ldv, tau, t, ldt)
	CLARFT: forms the triangular factor T of a complex block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V.

pure subroutine, public	la_clarfx (side, m, n, v, tau, c, ldc, work)
	CLARFX: applies a complex elementary reflector H to a complex m by n matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**H where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix This version uses inline code if H has order < 11.

pure subroutine, public	la_clarfy (uplo, n, v, incv, tau, c, ldc, work)
	CLARFY: applies an elementary reflector, or Householder matrix, H, to an n x n Hermitian matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.

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_clartg (f, g, c, s, r)
	!

pure subroutine, public	la_clartv (n, x, incx, y, incy, c, s, incc)
	CLARTV: applies a vector of complex plane rotations with real cosines to elements of the complex vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -conjg(s(i)) c(i) ) ( y(i) )

pure subroutine, public	la_clarz (side, m, n, l, v, incv, tau, c, ldc, work)
	CLARZ: applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by CTZRZF.

pure subroutine, public	la_clarzb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork)
	CLARZB: applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

pure subroutine, public	la_clarzt (direct, storev, n, k, v, ldv, tau, t, ldt)
	CLARZT: forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

pure subroutine, public	la_clascl (type, kl, ku, cfrom, cto, m, n, a, lda, info)
	CLASCL: multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.

pure subroutine, public	la_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_clasr (side, pivot, direct, m, n, c, s, a, lda)
	CLASR: applies a sequence of real plane rotations to a complex matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.

pure subroutine, public	la_classq (n, x, incx, scl, sumsq)
	!

pure subroutine, public	la_claswp (n, a, lda, k1, k2, ipiv, incx)
	CLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

pure subroutine, public	la_clasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	CLASYF: computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. CLASYF is an auxiliary routine called by CSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_clasyf_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	CLASYF_RK: computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLASYF_RK is an auxiliary routine called by CSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_clasyf_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	CLASYF_ROOK: computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLASYF_ROOK is an auxiliary routine called by CSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_clatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
	CLATBS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.

pure subroutine, public	la_clatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
	CLATPS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, AH denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.

pure subroutine, public	la_clatrd (uplo, n, nb, a, lda, e, tau, w, ldw)
	CLATRD: reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q*H A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', CLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', CLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by CHETRD.

pure subroutine, public	la_clatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
	CLATRS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, AH denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.

pure subroutine, public	la_clatrz (m, n, l, a, lda, tau, work)
	CLATRZ: factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.

pure recursive subroutine, public	la_claunhr_col_getrfnp2 (m, n, a, lda, d, info)
	CLAUNHR_COL_GETRFNP2: computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 \| B12 ] where B11 is n1 by n1, B = [ --—\|--— ] B21 is (m-n1) by n1, [ B21 \| B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. CLAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine CLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, CLAUNHR_COL_GETRFNP2 is self-sufficient and can be used without CLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

pure subroutine, public	la_clauu2 (uplo, n, a, lda, info)
	CLAUU2: computes the product U * UH or LH * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the unblocked form of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_clauum (uplo, n, a, lda, info)
	CLAUUM: computes the product U * UH or LH * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_cpbequ (uplo, n, kd, ab, ldab, s, scond, amax, info)
	CPBEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

pure subroutine, public	la_cpbstf (uplo, n, kd, ab, ldab, info)
	CPBSTF: computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with CHBGST. The factorization has the form A = S*HS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.

pure subroutine, public	la_cpbtf2 (uplo, n, kd, ab, ldab, info)
	CPBTF2: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U*H U , if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix, UH is the conjugate transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_cpbtrs (uplo, n, kd, nrhs, ab, ldab, b, ldb, info)
	CPBTRS: solves a system of linear equations AX = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPBTRF.

pure subroutine, public	la_cpoequ (n, a, lda, s, scond, amax, info)
	CPOEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

pure subroutine, public	la_cpoequb (n, a, lda, s, scond, amax, info)
	CPOEQUB: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from CPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

pure subroutine, public	la_cpotf2 (uplo, n, a, lda, info)
	CPOTF2: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U*H U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure recursive subroutine, public	la_cpotrf2 (uplo, n, a, lda, info)
	CPOTRF2: computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = U*H U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 \| A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—\|--— ] with n1 = n/2 [ A21 \| A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.

pure subroutine, public	la_cpotrs (uplo, n, nrhs, a, lda, b, ldb, info)
	CPOTRS: solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPOTRF.

pure subroutine, public	la_cppequ (uplo, n, ap, s, scond, amax, info)
	CPPEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

pure subroutine, public	la_cpptrf (uplo, n, ap, info)
	CPPTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = U*H U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

pure subroutine, public	la_cpptrs (uplo, n, nrhs, ap, b, ldb, info)
	CPPTRS: solves a system of linear equations AX = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = UHU or A = LL*H computed by CPPTRF.

pure subroutine, public	la_cpstf2 (uplo, n, a, lda, piv, rank, tol, work, info)
	CPSTF2: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P*T A * P = U*H U , if UPLO = 'U', P*T A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS.

pure subroutine, public	la_cpstrf (uplo, n, a, lda, piv, rank, tol, work, info)
	CPSTRF: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P*T A * P = U*H U , if UPLO = 'U', P*T A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.

pure subroutine, public	la_cptcon (n, d, e, anorm, rcond, rwork, info)
	CPTCON: computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = LDLH or A = UHDU computed by CPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

pure subroutine, public	la_cpttrf (n, d, e, info)
	CPTTRF: computes the LDLH factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UH DU.

pure subroutine, public	la_cptts2 (iuplo, n, nrhs, d, e, b, ldb)
	CPTTS2: solves a tridiagonal system of the form A * X = B using the factorization A = U*HDU or A = LDL*H computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.

pure subroutine, public	la_crot (n, cx, incx, cy, incy, c, s)
	CROT: applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

pure subroutine, public	la_cspmv (uplo, n, alpha, ap, x, incx, beta, y, incy)
	CSPMV: performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

pure subroutine, public	la_cspr (uplo, n, alpha, x, incx, ap)
	CSPR: performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.

pure subroutine, public	la_csptrf (uplo, n, ap, ipiv, info)
	CSPTRF: computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDU*T or A = LDL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

pure subroutine, public	la_csptri (uplo, n, ap, ipiv, work, info)
	CSPTRI: computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = UDU*T or A = LDL*T computed by CSPTRF.

pure subroutine, public	la_csptrs (uplo, n, nrhs, ap, ipiv, b, ldb, info)
	CSPTRS: solves a system of linear equations AX = B with a complex symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by CSPTRF.

pure subroutine, public	la_csrscl (n, sa, sx, incx)
	CSRSCL: multiplies an n-element complex vector x by the real scalar 1/a. This is done without overflow or underflow as long as the final result x/a does not overflow or underflow.

pure subroutine, public	la_cstein (n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)
	CSTEIN: computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5). Although the eigenvectors are real, they are stored in a complex array, which may be passed to CUNMTR or CUPMTR for back transformation to the eigenvectors of a complex Hermitian matrix which was reduced to tridiagonal form.

pure subroutine, public	la_csteqr (compz, n, d, e, z, ldz, work, info)
	CSTEQR: computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form.

pure subroutine, public	la_csyconv (uplo, way, n, a, lda, ipiv, e, info)
	CSYCONV: convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.

pure subroutine, public	la_csyconvf (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': CSYCONVF: converts the factorization output format used in CSYTRF provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF into the format used in CSYTRF_RK (or CSYTRF_BK). If parameter WAY = 'R': CSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF_RK (or CSYTRF_BK) into the format used in CSYTRF. CSYCONVF can also convert in Hermitian matrix case, i.e. between formats used in CHETRF and CHETRF_RK (or CHETRF_BK).

pure subroutine, public	la_csyconvf_rook (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': CSYCONVF_ROOK: converts the factorization output format used in CSYTRF_ROOK provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': CSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF_ROOK that is stored on exit in parameter A. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. CSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in CHETRF_ROOK and CHETRF_RK (or CHETRF_BK).

pure subroutine, public	la_csyequb (uplo, n, a, lda, s, scond, amax, work, info)
	CSYEQUB: computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

pure subroutine, public	la_csymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy)
	CSYMV: performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.

pure subroutine, public	la_csyr (uplo, n, alpha, x, incx, a, lda)
	CSYR: performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.

pure subroutine, public	la_csyswapr (uplo, n, a, lda, i1, i2)
	CSYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix.

pure subroutine, public	la_csytf2 (uplo, n, a, lda, ipiv, info)
	CSYTF2: computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method: A = UDU*T or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_csytf2_rk (uplo, n, a, lda, e, ipiv, info)
	CSYTF2_RK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

pure subroutine, public	la_csytf2_rook (uplo, n, a, lda, ipiv, info)
	CSYTF2_ROOK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*T or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_csytrf (uplo, n, a, lda, ipiv, work, lwork, info)
	CSYTRF: computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDU*T or A = LDL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_csytrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	CSYTRF_RK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

pure subroutine, public	la_csytrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	CSYTRF_ROOK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDU*T or A = LDL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_csytri (uplo, n, a, lda, ipiv, work, info)
	CSYTRI: computes the inverse of a complex symmetric indefinite matrix A using the factorization A = UDU*T or A = LDL*T computed by CSYTRF.

pure subroutine, public	la_csytri_rook (uplo, n, a, lda, ipiv, work, info)
	CSYTRI_ROOK: computes the inverse of a complex symmetric matrix A using the factorization A = UDU*T or A = LDL*T computed by CSYTRF_ROOK.

pure subroutine, public	la_csytrs (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	CSYTRS: solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF.

pure subroutine, public	la_csytrs2 (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)
	CSYTRS2: solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF and converted by CSYCONV.

pure subroutine, public	la_csytrs_3 (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)
	CSYTRS_3: solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by CSYTRF_RK or CSYTRF_BK: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

pure subroutine, public	la_csytrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	CSYTRS_AA: solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by CSYTRF_AA.

pure subroutine, public	la_csytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	CSYTRS_ROOK: solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF_ROOK.

pure subroutine, public	la_ctbrfs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CTBRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by CTBTRS or some other means before entering this routine. CTBRFS does not do iterative refinement because doing so cannot improve the backward error.

pure subroutine, public	la_ctbtrs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)
	CTBTRS: solves a triangular system of the form A * X = B, A*T X = B, or A*H X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

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 = alphaB or Xop( A ) = alphaB 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_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_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_ctgevc (side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)
	CTGEVC: computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = QSZ*H, B = QPZH as computed by CGGHRD + CHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (y*H)S = w(yH)P, where y*H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and Q*Y are the matrices of right and left eigenvectors of (A,B).

pure subroutine, public	la_ctgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, info)
	CTGEX2: swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22) in an upper triangular matrix pair (A, B) by an unitary equivalence transformation. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)*H = Q(out) A(out) * Z(out)*H Q(in) B(in) * Z(in)*H = Q(out) B(out) * Z(out)**H.

pure subroutine, public	la_ctgexc (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info)
	CTGEXC: reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * Z*H, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) A(in) * Z(in)*H = Q(out) A(out) * Z(out)*H Q(in) B(in) * Z(in)*H = Q(out) B(out) * Z(out)**H.

pure subroutine, public	la_ctplqt2 (m, n, l, a, lda, b, ldb, t, ldt, info)
	CTPLQT2: computes a LQ a factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_ctpqrt2 (m, n, l, a, lda, b, ldb, t, ldt, info)
	CTPQRT2: computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_ctprfb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)
	CTPRFB: applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.

pure subroutine, public	la_ctprfs (uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CTPRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by CTPTRS or some other means before entering this routine. CTPRFS does not do iterative refinement because doing so cannot improve the backward error.

pure subroutine, public	la_ctptri (uplo, diag, n, ap, info)
	CTPTRI: computes the inverse of a complex upper or lower triangular matrix A stored in packed format.

pure subroutine, public	la_ctptrs (uplo, trans, diag, n, nrhs, ap, b, ldb, info)
	CTPTRS: solves a triangular system of the form A * X = B, A*T X = B, or A*H X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

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_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_ctrevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)
	CTREVC: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQ*H, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and Q*Y are the matrices of right and left eigenvectors of A.

pure subroutine, public	la_ctrevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, rwork, lrwork, info)
	CTREVC3: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQ*H, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

pure subroutine, public	la_ctrexc (compq, n, t, ldt, q, ldq, ifst, ilst, info)
	CTREXC: reorders the Schur factorization of a complex matrix A = QTQH, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation ZHTZ, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.

pure subroutine, public	la_ctrrfs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CTRRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by CTRTRS or some other means before entering this routine. CTRRFS does not do iterative refinement because doing so cannot improve the backward error.

pure subroutine, public	la_ctrsna (job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info)
	CTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix QTQ**H with Q unitary).

pure subroutine, public	la_ctrti2 (uplo, diag, n, a, lda, info)
	CTRTI2: computes the inverse of a complex upper or lower triangular matrix. This is the Level 2 BLAS version of the algorithm.

pure subroutine, public	la_ctrtri (uplo, diag, n, a, lda, info)
	CTRTRI: computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

pure subroutine, public	la_ctrtrs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)
	CTRTRS: solves a triangular system of the form A * X = B, A*T X = B, or A*H X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

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_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_ctzrzf (m, n, a, lda, tau, work, lwork, info)
	CTZRZF: reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.

subroutine, public	la_cunbdb (trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info)
	CUNBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 \| B12 0 0 ] [ X11 \| X12 ] [ P1 \| ] [ 0 \| 0 -I 0 ] [ Q1 \| ]**H X = [--------—] = [------—] [-------------—] [------—] . [ X21 \| X22 ] [ \| P2 ] [ B21 \| B22 0 0 ] [ \| Q2 ] [ 0 \| 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

pure subroutine, public	la_cunbdb6 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)
	CUNBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.

pure subroutine, public	la_cung2l (m, n, k, a, lda, tau, work, info)
	CUNG2L: generates an m by n complex matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by CGEQLF.

pure subroutine, public	la_cung2r (m, n, k, a, lda, tau, work, info)
	CUNG2R: generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by CGEQRF.

pure subroutine, public	la_cungl2 (m, n, k, a, lda, tau, work, info)
	CUNGL2: generates an m-by-n complex matrix Q with orthonormal rows, which is defined as the first m rows of a product of k elementary reflectors of order n Q = H(k)H . . . H(2)H H(1)**H as returned by CGELQF.

pure subroutine, public	la_cunglq (m, n, k, a, lda, tau, work, lwork, info)
	CUNGLQ: generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k)H . . . H(2)H H(1)**H as returned by CGELQF.

pure subroutine, public	la_cungql (m, n, k, a, lda, tau, work, lwork, info)
	CUNGQL: generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by CGEQLF.

pure subroutine, public	la_cungqr (m, n, k, a, lda, tau, work, lwork, info)
	CUNGQR: generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by CGEQRF.

pure subroutine, public	la_cungr2 (m, n, k, a, lda, tau, work, info)
	CUNGR2: generates an m by n complex matrix Q with orthonormal rows, which is defined as the last m rows of a product of k elementary reflectors of order n Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF.

pure subroutine, public	la_cungrq (m, n, k, a, lda, tau, work, lwork, info)
	CUNGRQ: generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF.

pure subroutine, public	la_cungtsqr_row (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	CUNGTSQR_ROW: generates an M-by-N complex matrix Q_out with orthonormal columns from the output of CLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by CLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of CLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine CLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which CLATSQR generates the output blocks.

pure subroutine, public	la_cunm22 (side, trans, m, n, n1, n2, q, ldq, c, ldc, work, lwork, info)

pure subroutine, public	la_cunm2l (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	CUNM2L: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_cunm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	CUNM2R: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_cunml2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	CUNML2: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H . . . H(2)H H(1)H as returned by CGELQF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_cunmlq (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	CUNMLQ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H . . . H(2)H H(1)H as returned by CGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_cunmql (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	CUNMQL: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_cunmqr (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	CUNMQR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_cunmr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	CUNMR2: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)H as returned by CGERQF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_cunmr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info)
	CUNMR3: overwrites the general complex m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_cunmrq (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	CUNMRQ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)H as returned by CGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_cunmrz (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info)
	CUNMRZ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_cbbcsd (jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, rwork, lrwork, info)
	CBBCSD: computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 \| B12 0 0 ] [ 0 \| 0 -I 0 ] X = [-------------—] [ B21 \| B22 0 0 ] [ 0 \| 0 0 I ] [ C \| -S 0 0 ] [ U1 \| ] [ 0 \| 0 -I 0 ] [ V1 \| ]**H = [------—] [------------—] [------—] . [ \| U2 ] [ S \| C 0 0 ] [ \| V2 ] [ 0 \| 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.

pure subroutine, public	la_cbdsqr (uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info)
	CBDSQR: computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * P*H where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns UQ instead of Q, and, if right singular vectors are requested, this subroutine returns P*HVT instead of P*H, for given complex input matrices U and VT. When U and VT are the unitary matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by CGEBRD, then A = (UQ) * S * (P*HVT) is the SVD of A. Optionally, the subroutine may also compute Q*HC for a given complex input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.

pure subroutine, public	la_cgbcon (norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info)
	CGBCON: estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

pure subroutine, public	la_cgbtrf (m, n, kl, ku, ab, ldab, ipiv, info)
	CGBTRF: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_cgbtrs (trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)
	CGBTRS: solves a system of linear equations A * X = B, A*T X = B, or A*H X = B with a general band matrix A using the LU factorization computed by CGBTRF.

pure subroutine, public	la_cgebd2 (m, n, a, lda, d, e, tauq, taup, work, info)
	CGEBD2: reduces a complex general m by n matrix A to upper or lower real bidiagonal form B by a unitary transformation: Q*H A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

pure subroutine, public	la_cgecon (norm, n, a, lda, anorm, rcond, work, rwork, info)
	CGECON: estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

pure subroutine, public	la_cgehd2 (n, ilo, ihi, a, lda, tau, work, info)
	CGEHD2: reduces a complex general matrix A to upper Hessenberg form H by a unitary similarity transformation: Q*H A * Q = H .

pure subroutine, public	la_cgelq2 (m, n, a, lda, tau, work, info)
	CGELQ2: computes an LQ factorization of a complex m-by-n matrix A: A = ( L 0 ) * Q where: Q is a n-by-n orthogonal matrix; L is a lower-triangular m-by-m matrix; 0 is a m-by-(n-m) zero matrix, if m < n.

pure subroutine, public	la_cgelqf (m, n, a, lda, tau, work, lwork, info)
	CGELQF: computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

pure recursive subroutine, public	la_cgelqt3 (m, n, a, lda, t, ldt, info)
	CGELQT3: recursively computes a LQ factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

pure subroutine, public	la_cgemlqt (side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info)
	CGEMLQT: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex unitary matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_cgemqrt (side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)
	CGEMQRT: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_cgeql2 (m, n, a, lda, tau, work, info)
	CGEQL2: computes a QL factorization of a complex m by n matrix A: A = Q * L.

pure subroutine, public	la_cgeqlf (m, n, a, lda, tau, work, lwork, info)
	CGEQLF: computes a QL factorization of a complex M-by-N matrix A: A = Q * L.

pure subroutine, public	la_cgeqr2 (m, n, a, lda, tau, work, info)
	CGEQR2: computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix; 0 is a (m-n)-by-n zero matrix, if m > n.

subroutine, public	la_cgeqr2p (m, n, a, lda, tau, work, info)
	CGEQR2P: computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

pure subroutine, public	la_cgeqrf (m, n, a, lda, tau, work, lwork, info)
	CGEQRF: computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

subroutine, public	la_cgeqrfp (m, n, a, lda, tau, work, lwork, info)
	CGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_cgeqrt2 (m, n, a, lda, t, ldt, info)
	CGEQRT2: computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.

pure recursive subroutine, public	la_cgeqrt3 (m, n, a, lda, t, ldt, info)
	CGEQRT3: recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

pure subroutine, public	la_cgerq2 (m, n, a, lda, tau, work, info)
	CGERQ2: computes an RQ factorization of a complex m by n matrix A: A = R * Q.

pure subroutine, public	la_cgerqf (m, n, a, lda, tau, work, lwork, info)
	CGERQF: computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.

pure subroutine, public	la_cgesc2 (n, a, lda, rhs, ipiv, jpiv, scale)
	CGESC2: solves a system of linear equations A * X = scale* RHS with a general N-by-N matrix A using the LU factorization with complete pivoting computed by CGETC2.

pure recursive subroutine, public	la_cgetrf2 (m, n, a, lda, ipiv, info)
	CGETRF2: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 \| A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—\|--— ] with n1 = min(m,n)/2 [ A21 \| A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ — ], [ A12 ] [ A12 ] do the swaps on [ — ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

pure subroutine, public	la_cgetri (n, a, lda, ipiv, work, lwork, info)
	CGETRI: computes the inverse of a matrix using the LU factorization computed by CGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

pure subroutine, public	la_cgetrs (trans, n, nrhs, a, lda, ipiv, b, ldb, info)
	CGETRS: solves a system of linear equations A * X = B, A*T X = B, or A*H X = B with a general N-by-N matrix A using the LU factorization computed by CGETRF.

pure subroutine, public	la_cgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)
	CGGHRD: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Hx. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*H = (Q1Q) * H * (Z1Z)H Q1 B * Z1*H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaBx, then CGGHRD reduces the original problem to generalized Hessenberg form.

pure subroutine, public	la_cggqrf (n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)
	CGGQRF: computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZH (inv(T)*R) where inv(B) denotes the inverse of the matrix B, and Z' denotes the conjugate transpose of matrix Z.

pure subroutine, public	la_cggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)
	CGGRQF: computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZH where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of the matrix Z.

pure subroutine, public	la_cgttrs (trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info)
	CGTTRS: solves one of the systems of equations A * X = B, A*T X = B, or A*H X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF.

pure subroutine, public	la_chb2st_kernels (uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)
	CHB2ST_KERNELS: is an internal routine used by the CHETRD_HB2ST subroutine.

pure subroutine, public	la_cheequb (uplo, n, a, lda, s, scond, amax, work, info)
	CHEEQUB: computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

pure subroutine, public	la_chegs2 (itype, uplo, n, a, lda, b, ldb, info)
	CHEGS2: reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LH AL. B must have been previously factorized as UH U or LL*H by ZPOTRF.

pure subroutine, public	la_chegst (itype, uplo, n, a, lda, b, ldb, info)
	CHEGST: reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by CPOTRF.

pure subroutine, public	la_chetd2 (uplo, n, a, lda, d, e, tau, info)
	CHETD2: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q*H A * Q = T.

pure subroutine, public	la_chetrd (uplo, n, a, lda, d, e, tau, work, lwork, info)
	CHETRD: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q*H A * Q = T.

pure subroutine, public	la_chetrd_hb2st (stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)
	CHETRD_HB2ST: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q*H A * Q = T.

pure subroutine, public	la_chetrd_he2hb (uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)
	CHETRD_HE2HB: reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q*H A * Q = AB.

pure subroutine, public	la_chetrf (uplo, n, a, lda, ipiv, work, lwork, info)
	CHETRF: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDU*H or A = LDL*H where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_chetrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	CHETRF_RK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(P*T) or A = PLD(L*H)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, PT is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

pure subroutine, public	la_chetrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	CHETRF_ROOK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDU*T or A = LDL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_chetrs (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	CHETRS: solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF.

pure subroutine, public	la_chetrs2 (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)
	CHETRS2: solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF and converted by CSYCONV.

pure subroutine, public	la_chetrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	CHETRS_AA: solves a system of linear equations AX = B with a complex hermitian matrix A using the factorization A = UHTU or A = LTL*H computed by CHETRF_AA.

pure subroutine, public	la_chetrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	CHETRS_ROOK: solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF_ROOK.

pure subroutine, public	la_chptrd (uplo, n, ap, d, e, tau, info)
	CHPTRD: reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q*H A * Q = T.

pure subroutine, public	la_chptrs (uplo, n, nrhs, ap, ipiv, b, ldb, info)
	CHPTRS: solves a system of linear equations AX = B with a complex Hermitian matrix A stored in packed format using the factorization A = UDUH or A = LDL*H computed by CHPTRF.

real(sp) function, public	la_cla_gbrcond_c (trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, rwork)
	CLA_GBRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

real(sp) function, public	la_cla_gercond_c (trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)
	CLA_GERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

real(sp) function, public	la_cla_hercond_c (uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)
	CLA_HERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

real(sp) function, public	la_cla_herpvgrw (uplo, n, info, a, lda, af, ldaf, ipiv, work)
	CLA_HERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

real(sp) function, public	la_cla_porcond_c (uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork)
	CLA_PORCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

real(sp) function, public	la_cla_syrcond_c (uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork)
	CLA_SYRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

real(sp) function, public	la_cla_syrpvgrw (uplo, n, info, a, lda, af, ldaf, ipiv, work)
	CLA_SYRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

pure subroutine, public	la_clabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)
	CLABRD: reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q*H A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by CGEBRD.

pure subroutine, public	la_claed7 (n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho, indxq, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, rwork, iwork, info)
	CLAED7: computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense or banded Hermitian matrix that has been reduced to tridiagonal form. T = Q(in) ( D(in) + RHO * ZZH ) QH(in) = Q(out) D(out) * QH(out) where Z = QHu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine SLAED4 (as called by SLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.

pure subroutine, public	la_claein (rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info)
	CLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.

pure subroutine, public	la_clags2 (upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq)
	CLAGS2: computes 2-by-2 unitary matrices U, V and Q, such that if ( UPPER ) then U*H AQ = UH ( A1 A2 )Q = ( x 0 ) ( 0 A3 ) ( x x ) and VHBQ = VH ( B1 B2 )Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then UH AQ = UH ( A1 0 )Q = ( x x ) ( A2 A3 ) ( 0 x ) and VH BQ = VH ( B1 0 )Q = ( x x ) ( B2 B3 ) ( 0 x ) where U = ( CSU SNU ), V = ( CSV SNV ), ( -SNUH CSU ) ( -SNVH CSV ) Q = ( CSQ SNQ ) ( -SNQ*H CSQ ) The rows of the transformed A and B are parallel. Moreover, if the input 2-by-2 matrix A is not zero, then the transformed (1,1) entry of A is not zero. If the input matrices A and B are both not zero, then the transformed (2,2) element of B is not zero, except when the first rows of input A and B are parallel and the second rows are zero.

pure subroutine, public	la_clahqr (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info)
	CLAHQR: is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.

pure subroutine, public	la_clahr2 (n, k, nb, a, lda, tau, t, ldt, y, ldy)
	CLAHR2: reduces the first NB columns of A complex general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an unitary similarity transformation Q*H A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - VTv*H, and also the matrix Y = A V * T. This is an auxiliary routine called by CGEHRD.

pure subroutine, public	la_clals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info)
	CLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).

pure subroutine, public	la_clalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info)
	CLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, CLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, CLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by CLALSA.

pure subroutine, public	la_clalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info)
	CLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

real(sp) function, public	la_clangb (norm, n, kl, ku, ab, ldab, work)
	CLANGB: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.

real(sp) function, public	la_clange (norm, m, n, a, lda, work)
	CLANGE: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex matrix A.

pure real(sp) function, public	la_clangt (norm, n, dl, d, du)
	CLANGT: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex tridiagonal matrix A.

real(sp) function, public	la_clanhb (norm, uplo, n, k, ab, ldab, work)
	CLANHB: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n hermitian band matrix A, with k super-diagonals.

real(sp) function, public	la_clanhe (norm, uplo, n, a, lda, work)
	CLANHE: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A.

real(sp) function, public	la_clanhf (norm, transr, uplo, n, a, work)
	CLANHF: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix A in RFP format.

real(sp) function, public	la_clanhp (norm, uplo, n, ap, work)
	CLANHP: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A, supplied in packed form.

real(sp) function, public	la_clanhs (norm, n, a, lda, work)
	CLANHS: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.

pure real(sp) function, public	la_clanht (norm, n, d, e)
	CLANHT: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian tridiagonal matrix A.

real(sp) function, public	la_clansb (norm, uplo, n, k, ab, ldab, work)
	CLANSB: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.

real(sp) function, public	la_clansp (norm, uplo, n, ap, work)
	CLANSP: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A, supplied in packed form.

real(sp) function, public	la_clansy (norm, uplo, n, a, lda, work)
	CLANSY: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A.

real(sp) function, public	la_clantb (norm, uplo, diag, n, k, ab, ldab, work)
	CLANTB: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.

real(sp) function, public	la_clantp (norm, uplo, diag, n, ap, work)
	CLANTP: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.

real(sp) function, public	la_clantr (norm, uplo, diag, m, n, a, lda, work)
	CLANTR: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.

pure subroutine, public	la_clapll (n, x, incx, y, incy, ssmin)
	Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.

pure subroutine, public	la_claqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
	CLAQP2: computes a QR factorization with column pivoting of the block A(OFFSET+1:M,1:N). The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_claqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
	CLAQPS: computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_claqr5 (wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh)
	CLAQR5: called by CLAQR0 performs a single small-bulge multi-shift QR sweep.

pure subroutine, public	la_claqz1 (ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz)
	CLAQZ1: chases a 1x1 shift bulge in a matrix pencil down a single position.

pure subroutine, public	la_claqz3 (ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, alpha, beta, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info)
	CLAQZ3: Executes a single multishift QZ sweep.

pure subroutine, public	la_clargv (n, x, incx, y, incy, c, incc)
	CLARGV: generates a vector of complex plane rotations with real cosines, determined by elements of the complex vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( r(i) ) ( -conjg(s(i)) c(i) ) ( y(i) ) = ( 0 ) where c(i)2 + ABS(s(i))2 = 1 The following conventions are used (these are the same as in CLARTG, but differ from the BLAS1 routine CROTG): If y(i)=0, then c(i)=1 and s(i)=0. If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real.

pure subroutine, public	la_clarrv (n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info)
	CLARRV: computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by SLARRE.

pure subroutine, public	la_clatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)
	CLATDF: computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by CGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by CGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.

pure subroutine, public	la_claunhr_col_getrfnp (m, n, a, lda, d, info)
	CLAUNHR_COL_GETRFNP: computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine CLAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

pure subroutine, public	la_cpbcon (uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info)
	CPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U*HU or A = LLH computed by CPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_cpbrfs (uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_cpbtrf (uplo, n, kd, ab, ldab, info)
	CPBTRF: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U*H U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

pure subroutine, public	la_cpftrs (transr, uplo, n, nrhs, a, b, ldb, info)
	CPFTRS: solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPFTRF.

pure subroutine, public	la_cpocon (uplo, n, a, lda, anorm, rcond, work, rwork, info)
	CPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = U*HU or A = LLH computed by CPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_cporfs (uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_cpotrf (uplo, n, a, lda, info)
	CPOTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U*H U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_cpotri (uplo, n, a, lda, info)
	CPOTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U*HU or A = LL*H computed by CPOTRF.

pure subroutine, public	la_cppcon (uplo, n, ap, anorm, rcond, work, rwork, info)
	CPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = U*HU or A = LLH computed by CPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_cpprfs (uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_cppsv (uplo, n, nrhs, ap, b, ldb, info)
	CPPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U*H U, if UPLO = 'U', or A = L * L*H, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A X = B.

subroutine, public	la_cppsvx (fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CPPSVX: uses the Cholesky factorization A = U*HU or A = LLH to compute the solution to a complex system of linear equations A X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_cpptri (uplo, n, ap, info)
	CPPTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U*HU or A = LL*H computed by CPPTRF.

pure subroutine, public	la_cpteqr (compz, n, d, e, z, ldz, work, info)
	CPTEQR: computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using SPTTRF and then calling CBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band positive definite Hermitian matrix can also be found if CHETRD, CHPTRD, or CHBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)

pure subroutine, public	la_cpttrs (uplo, n, nrhs, d, e, b, ldb, info)
	CPTTRS: solves a tridiagonal system of the form A * X = B using the factorization A = U*HDU or A = LDL*H computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.

pure subroutine, public	la_cspcon (uplo, n, ap, ipiv, anorm, rcond, work, info)
	CSPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = UDU*T or A = LDLT computed by CSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_csprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CSPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_cspsv (uplo, n, nrhs, ap, ipiv, b, ldb, info)
	CSPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * U*T, if UPLO = 'U', or A = L D * L*T, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A X = B.

subroutine, public	la_cspsvx (fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CSPSVX: uses the diagonal pivoting factorization A = UDU*T or A = LDLT to compute the solution to a complex system of linear equations A X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_cstemr (jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info)
	CSTEMR: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see:

pure subroutine, public	la_csycon (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
	CSYCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDU*T or A = LDLT computed by CSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_csycon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
	CSYCON_ROOK: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDU*T or A = LDLT computed by CSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_csyrfs (uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CSYRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_csysv (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	CSYSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * U*T, if UPLO = 'U', or A = L D * L*T, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A X = B.

pure subroutine, public	la_csysv_rk (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)
	CSYSV_RK: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(P*T), if UPLO = 'U', or A = PLD(L*T)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_RK is called to compute the factorization of a complex symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CSYTRS_3.

pure subroutine, public	la_csysv_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	CSYSV_ROOK: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * U*T, if UPLO = 'U', or A = L D * L*T, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_ROOK is called to compute the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A X = B by calling CSYTRS_ROOK.

subroutine, public	la_csysvx (fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info)
	CSYSVX: uses the diagonal pivoting factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_ctbcon (norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info)
	CTBCON: estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

pure subroutine, public	la_ctftri (transr, uplo, diag, n, a, info)
	CTFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

pure subroutine, public	la_ctgsja (jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info)
	CTGSJA: computes the generalized singular value decomposition (GSVD) of two complex upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine CGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, U*H AQ = D1( 0 R ), V*H BQ = D2( 0 R ), where U, V and Q are unitary matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are `‘diagonal’' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the unitary transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.

pure subroutine, public	la_ctgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, info)
	CTGSY2: solves the generalized Sylvester equation A * R - L * B = scale * C (1) D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Zx = scale * b, where Z is defined as Z = [ kron(In, A) -kron(BH, Im) ] (2) [ kron(In, D) -kron(EH, Im) ], Ik is the identity matrix of size k and XH is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system ZHy = scaleb is solved for, which is equivalent to solve for R and L in A*H R + D*H L = scale * C (3) R * B*H + L E*H = scale -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = = sigma_min(Z) using reverse communication with CLACON. CTGSY2 also (IJOB >= 1) contributes to the computation in CTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of two matrix pairs in CTGSYL.

pure subroutine, public	la_ctgsyl (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info)
	CTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scaleb, where Z is defined as Z = [ kron(In, A) -kron(BH, Im) ] (2) [ kron(In, D) -kron(EH, Im) ], Here Ix is the identity matrix of size x and XH is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system ZH y = scaleb is solved for, which is equivalent to solve for R and L in AH R + D*H L = scale * C (3) R * B*H + L E*H = scale -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using CLACON. If IJOB >= 1, CTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.

subroutine, public	la_ctpcon (norm, uplo, diag, n, ap, rcond, work, rwork, info)
	CTPCON: estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

pure subroutine, public	la_ctplqt (m, n, l, mb, a, lda, b, ldb, t, ldt, work, info)
	CTPLQT: computes a blocked LQ factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_ctpmlqt (side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info)
	CTPMLQT: applies a complex unitary matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

pure subroutine, public	la_ctpmqrt (side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)
	CTPMQRT: applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

pure subroutine, public	la_ctpqrt (m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)
	CTPQRT: computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

subroutine, public	la_ctrcon (norm, uplo, diag, n, a, lda, rcond, work, rwork, info)
	CTRCON: estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

subroutine, public	la_ctrsyl (trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)
	CTRSYL: solves the complex Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.

pure subroutine, public	la_cunbdb5 (m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info)
	CUNBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.

recursive subroutine, public	la_cuncsd (jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, rwork, lrwork, iwork, info)
	CUNCSD: computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 \| 0 0 0 ] [ 0 C 0 \| 0 -S 0 ] [ X11 \| X12 ] [ U1 \| ] [ 0 0 0 \| 0 0 -I ] [ V1 \| ]**H X = [--------—] = [------—] [------------------—] [------—] . [ X21 \| X22 ] [ \| U2 ] [ 0 0 0 \| I 0 0 ] [ \| V2 ] [ 0 S 0 \| 0 C 0 ] [ 0 0 I \| 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).

pure subroutine, public	la_cunghr (n, ilo, ihi, a, lda, tau, work, lwork, info)
	CUNGHR: generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

pure subroutine, public	la_cungtr (uplo, n, a, lda, tau, work, lwork, info)
	CUNGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by CHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

pure subroutine, public	la_cunhr_col (m, n, nb, a, lda, t, ldt, d, info)
	CUNHR_COL: takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as CGEQRT).

pure subroutine, public	la_cunmhr (side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info)
	CUNMHR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

pure subroutine, public	la_cunmtr (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)
	CUNMTR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

pure subroutine, public	la_cupgtr (uplo, n, ap, tau, q, ldq, work, info)
	CUPGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

pure subroutine, public	la_cupmtr (side, uplo, trans, m, n, ap, tau, c, ldc, work, info)
	CUPMTR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

pure subroutine, public	la_cgbbrd (vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, rwork, info)
	CGBBRD: reduces a complex general m-by-n band matrix A to real upper bidiagonal form B by a unitary transformation: Q*H A * P = B. The routine computes B, and optionally forms Q or PH, or computes QH*C for a given matrix C.

pure subroutine, public	la_cgbrfs (trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CGBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_cgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)
	CGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

subroutine, public	la_cgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_cgebrd (m, n, a, lda, d, e, tauq, taup, work, lwork, info)
	CGEBRD: reduces a general complex M-by-N matrix A to upper or lower bidiagonal form B by a unitary transformation: Q*H A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

pure subroutine, public	la_cgehrd (n, ilo, ihi, a, lda, tau, work, lwork, info)
	CGEHRD: reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q*H A * Q = H .

pure subroutine, public	la_cgelqt (m, n, mb, a, lda, t, ldt, work, info)
	CGELQT: computes a blocked LQ factorization of a complex M-by-N matrix A using the compact WY representation of Q.

subroutine, public	la_cgels (trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)
	CGELS: solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, or its conjugate-transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided:

pure subroutine, public	la_cgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, rwork, info)
	CGEQP3: computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS.

pure subroutine, public	la_cgeqrt (m, n, nb, a, lda, t, ldt, work, info)
	CGEQRT: computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.

pure subroutine, public	la_cgerfs (trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_cgetrf (m, n, a, lda, ipiv, info)
	CGETRF: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

pure subroutine, public	la_cggglm (n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)
	CGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize \|\| y \|\|_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize \|\| inv(B)(d-A*x) \|\|_2 x where inv(B) denotes the inverse of B.

pure subroutine, public	la_cgghd3 (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, info)
	CGGHD3: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Hx. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*H = (Q1Q) * H * (Z1Z)H Q1 B * Z1*H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaBx, then CGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of CGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

pure subroutine, public	la_cgglse (m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)
	CGGLSE: solves the linear equality-constrained least squares (LSE) problem: minimize \|\| c - Ax \|\|_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.

pure subroutine, public	la_cgtcon (norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info)
	CGTCON: estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by CGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

pure subroutine, public	la_cgtrfs (trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CGTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_cgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_chbgst (vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info)
	CHBGST: reduces a complex Hermitian-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as SHS by CPBSTF, using a split Cholesky factorization. A is overwritten by C = X*HAX, where X = S(-1)Q and Q is a unitary matrix chosen to preserve the bandwidth of A.

pure subroutine, public	la_chbtrd (vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info)
	CHBTRD: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q*H A * Q = T.

pure subroutine, public	la_checon (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
	CHECON: estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDU*H or A = LDLH computed by CHETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_checon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
	CHECON_ROOK: estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDU*H or A = LDLH computed by CHETRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

subroutine, public	la_cheev (jobz, uplo, n, a, lda, w, work, lwork, rwork, info)
	CHEEV: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

subroutine, public	la_cheevr (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info)
	CHEEVR: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. CHEEVR first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, CHEEVR calls CSTEMR to compute the eigenspectrum using Relatively Robust Representations. CSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see CSTEMR's documentation and:

subroutine, public	la_cheevx (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info)
	CHEEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

subroutine, public	la_chegv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info)
	CHEGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite.

subroutine, public	la_chegvx (itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info)
	CHEGVX: computes selected eigenvalues, and optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

pure subroutine, public	la_cherfs (uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CHERFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_chesv (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	CHESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * U*H, if UPLO = 'U', or A = L D * L*H, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A X = B.

pure subroutine, public	la_chesv_rk (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info)
	CHESV_RK: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UH)(P*T), if UPLO = 'U', or A = PLD(L*H)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, PT is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_RK is called to compute the factorization of a complex Hermitian matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CHETRS_3.

pure subroutine, public	la_chesv_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	CHESV_ROOK: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman ("rook") diagonal pivoting method is used to factor A as A = U * D * U*T, if UPLO = 'U', or A = L D * L*T, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_ROOK is called to compute the factorization of a complex Hermition matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A X = B by calling CHETRS_ROOK (uses BLAS 2).

subroutine, public	la_chesvx (fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info)
	CHESVX: uses the diagonal pivoting factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_chgeqz (job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info)
	CHGEQZ: computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1HZ1*H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices and S and P are upper triangular. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = B*y. The values of alpha and beta for the i-th eigenvalue can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241–256.

pure subroutine, public	la_chpcon (uplo, n, ap, ipiv, anorm, rcond, work, info)
	CHPCON: estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = UDU*H or A = LDLH computed by CHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

subroutine, public	la_chpev (jobz, uplo, n, ap, w, z, ldz, work, rwork, info)
	CHPEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.

subroutine, public	la_chpevx (jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
	CHPEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. Eigenvalues/vectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

subroutine, public	la_chpgv (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info)
	CHPGV: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.

subroutine, public	la_chpgvx (itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
	CHPGVX: computes selected eigenvalues and, optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

pure subroutine, public	la_chprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CHPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_chpsv (uplo, n, nrhs, ap, ipiv, b, ldb, info)
	CHPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * U*H, if UPLO = 'U', or A = L D * L*H, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A X = B.

subroutine, public	la_chpsvx (fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CHPSVX: uses the diagonal pivoting factorization A = UDU*H or A = LDLH to compute the solution to a complex system of linear equations A X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_chsein (side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info)
	CHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y*h H = w * yh where yh denotes the conjugate transpose of the vector y.

pure subroutine, public	la_claed0 (qsiz, n, d, e, q, ldq, qstore, ldqs, rwork, iwork, info)
	Using the divide and conquer method, CLAED0: computes all eigenvalues of a symmetric tridiagonal matrix which is one diagonal block of those from reducing a dense or band Hermitian matrix and corresponding eigenvectors of the dense or band matrix.

pure subroutine, public	la_clamswlq (side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)
	CLAMSWLQ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CLASWLQ)

pure subroutine, public	la_clamtsqr (side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)
	CLAMTSQR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CLATSQR)

pure subroutine, public	la_claqr2 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork)
	CLAQR2: is identical to CLAQR3 except that it avoids recursion by calling CLAHQR instead of CLAQR4. Aggressive early deflation: This subroutine accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.

pure subroutine, public	la_claswlq (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	CLASWLQ: computes a blocked Tall-Skinny LQ factorization of a complex M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.

pure subroutine, public	la_clatsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	CLATSQR: computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

pure subroutine, public	la_cpbsv (uplo, n, kd, nrhs, ab, ldab, b, ldb, info)
	CPBSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U*H U, if UPLO = 'U', or A = L * L*H, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A X = B.

subroutine, public	la_cpbsvx (fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CPBSVX: uses the Cholesky factorization A = U*HU or A = LLH to compute the solution to a complex system of linear equations A X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_cpftrf (transr, uplo, n, a, info)
	CPFTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U*H U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_cpftri (transr, uplo, n, a, info)
	CPFTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U*HU or A = LL*H computed by CPFTRF.

pure subroutine, public	la_cposv (uplo, n, nrhs, a, lda, b, ldb, info)
	CPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U*H U, if UPLO = 'U', or A = L * L*H, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A X = B.

subroutine, public	la_cposvx (fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CPOSVX: uses the Cholesky factorization A = U*HU or A = LLH to compute the solution to a complex system of linear equations A X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_cptrfs (uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_cptsv (n, nrhs, d, e, b, ldb, info)
	CPTSV: computes the solution to a complex system of linear equations AX = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*H, and the factored form of A is then used to solve the system of equations.

pure subroutine, public	la_cptsvx (fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CPTSVX: uses the factorization A = LDL*H to compute the solution to a complex system of linear equations AX = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_cstedc (compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
	CSTEDC: computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See SLAED3 for details.

pure subroutine, public	la_cstegr (jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)
	CSTEGR: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. CSTEGR is a compatibility wrapper around the improved CSTEMR routine. See SSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : CSTEGR and CSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.

pure subroutine, public	la_ctgsen (ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)
	CTGSEN: reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q*H (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. CTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.

pure subroutine, public	la_ctgsna (job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info)
	CTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.

subroutine, public	la_ctrsen (job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info)
	CTRSEN: reorders the Schur factorization of a complex matrix A = QTQ**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.

subroutine, public	la_cunbdb1 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)
	CUNBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 \| ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ \| P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines CUNBDB2, CUNBDB3, and CUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

subroutine, public	la_cunbdb2 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)
	CUNBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 \| ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ \| P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines CUNBDB1, CUNBDB3, and CUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.

subroutine, public	la_cunbdb3 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, lwork, info)
	CUNBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 \| ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ \| P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines CUNBDB1, CUNBDB2, and CUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.

subroutine, public	la_cunbdb4 (m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, work, lwork, info)
	CUNBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 \| ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ \| P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines CUNBDB1, CUNBDB2, and CUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.

subroutine, public	la_cuncsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, rwork, lrwork, iwork, info)
	CUNCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 \| ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ \| U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

pure subroutine, public	la_cungbr (vect, m, n, k, a, lda, tau, work, lwork, info)
	CUNGBR: generates one of the complex unitary matrices Q or P*H determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q B * PH. Q and PH are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and CUNGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and CUNGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PH is of order N: if k < n, PH = G(k) . . . G(2) G(1) and CUNGBR returns the first m rows of PH, where n >= m >= k; if k >= n, PH = G(n-1) . . . G(2) G(1) and CUNGBR returns P**H as an N-by-N matrix.

pure subroutine, public	la_cungtsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	CUNGTSQR: generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by CLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for CLATSQR.

pure subroutine, public	la_cunmbr (vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	If VECT = 'Q', CUNMBR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q*H If VECT = 'P', CUNMBR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P C C * P TRANS = 'C': P*H C C * PH Here Q and PH are the unitary matrices determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the unitary matrix Q or P**H that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

pure subroutine, public	la_cgelq (m, n, a, lda, t, tsize, work, lwork, info)
	CGELQ: computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

subroutine, public	la_cgelsd (m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info)
	CGELSD: computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(\| b - A*x \|) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

subroutine, public	la_cgelss (m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info)
	CGELSS: computes the minimum norm solution to a complex linear least squares problem: Minimize 2-norm(\| b - A*x \|). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.

subroutine, public	la_cgelsy (m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info)
	CGELSY: computes the minimum-norm solution to a complex linear least squares problem: minimize \|\| A * X - B \|\| using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by unitary transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * Z*H [ inv(T11)Q1*HB ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The permutation of matrix B (the right hand side) is faster and more simple. o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3.

pure subroutine, public	la_cgemlq (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)
	CGEMLQ: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CGELQ)

pure subroutine, public	la_cgemqr (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)
	CGEMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CGEQR)

pure subroutine, public	la_cgeqr (m, n, a, lda, t, tsize, work, lwork, info)
	CGEQR: computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

subroutine, public	la_cgesdd (jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info)
	CGESDD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

pure subroutine, public	la_cgesv (n, nrhs, a, lda, ipiv, b, ldb, info)
	CGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

subroutine, public	la_cgesvd (jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info)
	CGESVD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.

subroutine, public	la_cgesvdq (joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, cwork, lcwork, rwork, lrwork, info)
	CGESVDQ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^, [++] = [xx] [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

subroutine, public	la_cgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_cgetsls (trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info)
	CGETSLS: solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided:

pure subroutine, public	la_cgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
	CGETSQRHRT: computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in CGEQRT (Q is in blocked compact WY-representation). See the documentation of CGEQRT for more details on the format.

subroutine, public	la_cgges (jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info)
	CGGES: computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)*H, (VSL)T(VSR)H ) where (VSR)H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an unitary basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver CGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - wB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if S and T are upper triangular and, in addition, the diagonal elements of T are non-negative real numbers.

subroutine, public	la_cggesx (jobvsl, jobvsr, sort, selctg, sense, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, rwork, iwork, liwork, bwork, info)
	CGGESX: computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the complex Schur form (S,T), and, optionally, the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL) S (VSR)H, (VSL) T (VSR)H ) where (VSR)*H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T; computes a reciprocal condition number for the average of the selected eigenvalues (RCONDE); and computes a reciprocal condition number for the right and left deflating subspaces corresponding to the selected eigenvalues (RCONDV). The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - wB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0 or for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if T is upper triangular with non-negative diagonal and S is upper triangular.

subroutine, public	la_cggev (jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, lwork, rwork, info)
	CGGEV: computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right generalized eigenvector v(j) corresponding to the generalized eigenvalue lambda(j) of (A,B) satisfies A v(j) = lambda(j) * B * v(j). The left generalized eigenvector u(j) corresponding to the generalized eigenvalues lambda(j) of (A,B) satisfies u(j)*H A = lambda(j) * u(j)*H B where u(j)**H is the conjugate-transpose of u(j).

subroutine, public	la_cggevx (balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, rwork, iwork, bwork, info)
	CGGEVX: computes for a pair of N-by-N complex nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. Optionally, it also computes a balancing transformation to improve the conditioning of the eigenvalues and eigenvectors (ILO, IHI, LSCALE, RSCALE, ABNRM, and BBNRM), reciprocal condition numbers for the eigenvalues (RCONDE), and reciprocal condition numbers for the right eigenvectors (RCONDV). A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right eigenvector v(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies A v(j) = lambda(j) * B * v(j) . The left eigenvector u(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies u(j)*H A = lambda(j) * u(j)*H B. where u(j)**H is the conjugate-transpose of u(j).

subroutine, public	la_chbev (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info)
	CHBEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.

subroutine, public	la_chbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
	CHBEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

subroutine, public	la_chbevx (jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
	CHBEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

pure subroutine, public	la_chbgv (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info)
	CHBGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.

pure subroutine, public	la_chbgvd (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
	CHBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

pure subroutine, public	la_chbgvx (jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
	CHBGVX: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either all eigenvalues, a range of values or a range of indices for the desired eigenvalues.

subroutine, public	la_cheevd (jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info)
	CHEEVD: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

subroutine, public	la_chegvd (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info)
	CHEGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

subroutine, public	la_chpevd (jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
	CHPEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

subroutine, public	la_chpgvd (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
	CHPGVD: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

subroutine, public	la_cgees (jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info)
	CGEES: computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z**H). Optionally, it also orders the eigenvalues on the diagonal of the Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A complex matrix is in Schur form if it is upper triangular.

subroutine, public	la_cgeesx (jobvs, sort, select, sense, n, a, lda, sdim, w, vs, ldvs, rconde, rcondv, work, lwork, rwork, bwork, info)
	CGEESX: computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z**H). Optionally, it also orders the eigenvalues on the diagonal of the Schur form so that selected eigenvalues are at the top left; computes a reciprocal condition number for the average of the selected eigenvalues (RCONDE); and computes a reciprocal condition number for the right invariant subspace corresponding to the selected eigenvalues (RCONDV). The leading columns of Z form an orthonormal basis for this invariant subspace. For further explanation of the reciprocal condition numbers RCONDE and RCONDV, see Section 4.10_sp of the LAPACK Users' Guide (where these quantities are called s and sep respectively). A complex matrix is in Schur form if it is upper triangular.

subroutine, public	la_cgeev (jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info)
	CGEEV: computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)*H A = lambda(j) * u(j)H where u(j)H denotes the conjugate transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.

subroutine, public	la_cgeevx (balanc, jobvl, jobvr, sense, n, a, lda, w, vl, ldvl, vr, ldvr, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, rwork, info)
	CGEEVX: computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. Optionally also, it computes a balancing transformation to improve the conditioning of the eigenvalues and eigenvectors (ILO, IHI, SCALE, and ABNRM), reciprocal condition numbers for the eigenvalues (RCONDE), and reciprocal condition numbers for the right eigenvectors (RCONDV). The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)*H A = lambda(j) * u(j)H where u(j)H denotes the conjugate transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real. Balancing a matrix means permuting the rows and columns to make it more nearly upper triangular, and applying a diagonal similarity transformation D * A * D**(-1), where D is a diagonal matrix, to make its rows and columns closer in norm and the condition numbers of its eigenvalues and eigenvectors smaller. The computed reciprocal condition numbers correspond to the balanced matrix. Permuting rows and columns will not change the condition numbers (in exact arithmetic) but diagonal scaling will. For further explanation of balancing, see section 4.10.2_sp of the LAPACK Users' Guide.

pure subroutine, public	la_cgejsv (joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, cwork, lwork, rwork, lrwork, iwork, info)
	CGEJSV: computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.

pure subroutine, public	la_cgesvj (joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, cwork, lwork, rwork, lrwork, info)
	CGESVJ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^, [++] = [xx] [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

subroutine, public	la_cgges3 (jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info)
	CGGES3: computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)*H, (VSL)T(VSR)H ) where (VSR)H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an unitary basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver CGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - wB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if S and T are upper triangular and, in addition, the diagonal elements of T are non-negative real numbers.

subroutine, public	la_cggev3 (jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, lwork, rwork, info)
	CGGEV3: computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right generalized eigenvector v(j) corresponding to the generalized eigenvalue lambda(j) of (A,B) satisfies A v(j) = lambda(j) * B * v(j). The left generalized eigenvector u(j) corresponding to the generalized eigenvalues lambda(j) of (A,B) satisfies u(j)*H A = lambda(j) * u(j)*H B where u(j)**H is the conjugate-transpose of u(j).

pure subroutine, public	la_cgsvj0 (jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)
	CGSVJ0: is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.

pure subroutine, public	la_cgsvj1 (jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info)
	CGSVJ1: is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ CGSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: \| * * * [x] [x] [x]\| \| * * * [x] [x] [x]\| Row-cycling in the nblr-by-nblc [x] blocks. \| * * * [x] [x] [x]\| Row-cyclic pivoting inside each [x] block. \|[x] [x] [x] * * * \| \|[x] [x] [x] * * * \| \|[x] [x] [x] * * * \| In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.

pure subroutine, public	la_chesv_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	CHESV_AA: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = U*H T * U, if UPLO = 'U', or A = L * T * L*H, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is Hermitian and tridiagonal. The factored form of A is then used to solve the system of equations A X = B.

pure subroutine, public	la_chetrf_aa (uplo, n, a, lda, ipiv, work, lwork, info)
	CHETRF_AA: computes the factorization of a complex hermitian matrix A using the Aasen's algorithm. The form of the factorization is A = U*HTU or A = LTL*H where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a hermitian tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_chseqr (job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info)
	CHSEQR: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z*H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)T(QZ)*H.

pure subroutine, public	la_clahef_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	CLAHEF_AA: factorizes a panel of a complex hermitian matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

pure subroutine, public	la_claqr0 (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info)
	CLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z*H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)*H.

pure subroutine, public	la_claqr3 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork)
	Aggressive early deflation: CLAQR3: accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.

pure subroutine, public	la_claqr4 (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info)
	CLAQR4: implements one level of recursion for CLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by CLAQR0 and, for large enough deflation window size, it may be called by CLAQR3. This subroutine is identical to CLAQR0 except that it calls CLAQR2 instead of CLAQR3. CLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z*H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)*H.

recursive subroutine, public	la_claqz0 (wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, rec, info)
	CLAQZ0: computes the eigenvalues of a matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a matrix pair (A,B): A = Q1HZ1*H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = B*y. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241–256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199–227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation".

recursive subroutine, public	la_claqz2 (ilschur, ilq, ilz, n, ilo, ihi, nw, a, lda, b, ldb, q, ldq, z, ldz, ns, nd, alpha, beta, qc, ldqc, zc, ldzc, work, lwork, rwork, rec, info)
	CLAQZ2: performs AED.

pure subroutine, public	la_clasyf_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

pure subroutine, public	la_csysv_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	CSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = U*T T * U, if UPLO = 'U', or A = L * T * L*T, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A X = B.

pure subroutine, public	la_csytrf_aa (uplo, n, a, lda, ipiv, work, lwork, info)
	CSYTRF_AA: computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = U*TTU or A = LTL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

Function/Subroutine Documentation

◆ la_cbbcsd()

pure subroutine, public la_lapack_c::la_cbbcsd	(	character, intent(in)	jobu1,
		character, intent(in)	jobu2,
		character, intent(in)	jobv1t,
		character, intent(in)	jobv2t,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		integer(ilp), intent(in)	q,
		real(sp), dimension(*), intent(inout)	theta,
		real(sp), dimension(*), intent(inout)	phi,
		complex(sp), dimension(ldu1,*), intent(inout)	u1,
		integer(ilp), intent(in)	ldu1,
		complex(sp), dimension(ldu2,*), intent(inout)	u2,
		integer(ilp), intent(in)	ldu2,
		complex(sp), dimension(ldv1t,*), intent(inout)	v1t,
		integer(ilp), intent(in)	ldv1t,
		complex(sp), dimension(ldv2t,*), intent(inout)	v2t,
		integer(ilp), intent(in)	ldv2t,
		real(sp), dimension(*), intent(out)	b11d,
		real(sp), dimension(*), intent(out)	b11e,
		real(sp), dimension(*), intent(out)	b12d,
		real(sp), dimension(*), intent(out)	b12e,
		real(sp), dimension(*), intent(out)	b21d,
		real(sp), dimension(*), intent(out)	b21e,
		real(sp), dimension(*), intent(out)	b22d,
		real(sp), dimension(*), intent(out)	b22e,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info
	)

CBBCSD: computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [-------------—] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [------—] [------------—] [------—] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.

Here is the call graph for this function:

◆ la_cbdsqr()

pure subroutine, public la_lapack_c::la_cbdsqr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ncvt,
		integer(ilp), intent(in)	nru,
		integer(ilp), intent(in)	ncc,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	e,
		complex(sp), dimension(ldvt,*), intent(inout)	vt,
		integer(ilp), intent(in)	ldvt,
		complex(sp), dimension(ldu,*), intent(inout)	u,
		integer(ilp), intent(in)	ldu,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CBDSQR: computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * P**H where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns P**H*VT instead of P**H, for given complex input matrices U and VT. When U and VT are the unitary matrices that reduce a general matrix A to bidiagonal form: A = U*B*VT, as computed by CGEBRD, then A = (U*Q) * S * (P**H*VT) is the SVD of A. Optionally, the subroutine may also compute Q**H*C for a given complex input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.

Here is the call graph for this function:

◆ la_cgbbrd()

pure subroutine, public la_lapack_c::la_cgbbrd	(	character, intent(in)	vect,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ncc,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	d,
		real(sp), dimension(*), intent(out)	e,
		complex(sp), dimension(ldq,*), intent(out)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldpt,*), intent(out)	pt,
		integer(ilp), intent(in)	ldpt,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGBBRD: reduces a complex general m-by-n band matrix A to real upper bidiagonal form B by a unitary transformation: Q**H * A * P = B. The routine computes B, and optionally forms Q or P**H, or computes Q**H*C for a given matrix C.

Here is the call graph for this function:

◆ la_cgbcon()

pure subroutine, public la_lapack_c::la_cgbcon	(	character, intent(in)	norm,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGBCON: estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_cgbequ()

pure subroutine, public la_lapack_c::la_cgbequ	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	r,
		real(sp), dimension(*), intent(out)	c,
		real(sp), intent(out)	rowcnd,
		real(sp), intent(out)	colcnd,
		real(sp), intent(out)	amax,
		integer(ilp), intent(out)	info
	)

CGBEQU: computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

Here is the call graph for this function:

◆ la_cgbequb()

pure subroutine, public la_lapack_c::la_cgbequb	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	r,
		real(sp), dimension(*), intent(out)	c,
		real(sp), intent(out)	rowcnd,
		real(sp), intent(out)	colcnd,
		real(sp), intent(out)	amax,
		integer(ilp), intent(out)	info
	)

CGBEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

Here is the call graph for this function:

◆ la_cgbrfs()

pure subroutine, public la_lapack_c::la_cgbrfs	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldafb,*), intent(in)	afb,
		integer(ilp), intent(in)	ldafb,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_cgbsv()

pure subroutine, public la_lapack_c::la_cgbsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_cgbsvx()

subroutine, public la_lapack_c::la_cgbsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	r,
		real(sp), dimension(*), intent(inout)	c,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_cgbtf2()

pure subroutine, public la_lapack_c::la_cgbtf2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CGBTF2: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the unblocked version of the algorithm, calling Level 2 BLAS.

◆ la_cgbtrf()

pure subroutine, public la_lapack_c::la_cgbtrf	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CGBTRF: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_cgbtrs()

pure subroutine, public la_lapack_c::la_cgbtrs	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CGBTRS: solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general band matrix A using the LU factorization computed by CGBTRF.

Here is the call graph for this function:

◆ la_cgebak()

pure subroutine, public la_lapack_c::la_cgebak	(	character, intent(in)	job,
		character, intent(in)	side,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		real(sp), dimension(*), intent(in)	scale,
		integer(ilp), intent(in)	m,
		complex(sp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	info
	)

CGEBAK: forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by CGEBAL.

◆ la_cgebal()

pure subroutine, public la_lapack_c::la_cgebal	(	character, intent(in)	job,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	ilo,
		integer(ilp), intent(out)	ihi,
		real(sp), dimension(*), intent(out)	scale,
		integer(ilp), intent(out)	info
	)

CGEBAL: balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

Here is the call graph for this function:

◆ la_cgebd2()

pure subroutine, public la_lapack_c::la_cgebd2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	d,
		real(sp), dimension(*), intent(out)	e,
		complex(sp), dimension(*), intent(out)	tauq,
		complex(sp), dimension(*), intent(out)	taup,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGEBD2: reduces a complex general m by n matrix A to upper or lower real bidiagonal form B by a unitary transformation: Q**H * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

Here is the call graph for this function:

◆ la_cgebrd()

pure subroutine, public la_lapack_c::la_cgebrd	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	d,
		real(sp), dimension(*), intent(out)	e,
		complex(sp), dimension(*), intent(out)	tauq,
		complex(sp), dimension(*), intent(out)	taup,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGEBRD: reduces a general complex M-by-N matrix A to upper or lower bidiagonal form B by a unitary transformation: Q**H * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.

Here is the call graph for this function:

◆ la_cgecon()

pure subroutine, public la_lapack_c::la_cgecon	(	character, intent(in)	norm,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGECON: estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_cgeequ()

pure subroutine, public la_lapack_c::la_cgeequ	(	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(*), intent(out)	r,
		real(sp), dimension(*), intent(out)	c,
		real(sp), intent(out)	rowcnd,
		real(sp), intent(out)	colcnd,
		real(sp), intent(out)	amax,
		integer(ilp), intent(out)	info
	)

CGEEQU: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

Here is the call graph for this function:

◆ la_cgeequb()

pure subroutine, public la_lapack_c::la_cgeequb	(	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(*), intent(out)	r,
		real(sp), dimension(*), intent(out)	c,
		real(sp), intent(out)	rowcnd,
		real(sp), intent(out)	colcnd,
		real(sp), intent(out)	amax,
		integer(ilp), intent(out)	info
	)

CGEEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

Here is the call graph for this function:

◆ la_cgees()

subroutine, public la_lapack_c::la_cgees	(	character, intent(in)	jobvs,
		character, intent(in)	sort,
		procedure(la_select_c)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	sdim,
		complex(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldvs,*), intent(out)	vs,
		integer(ilp), intent(in)	ldvs,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		logical(lk), dimension(*), intent(out)	bwork,
		integer(ilp), intent(out)	info
	)

CGEES: computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = Z*T*(Z**H). Optionally, it also orders the eigenvalues on the diagonal of the Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A complex matrix is in Schur form if it is upper triangular.

Here is the call graph for this function:

◆ la_cgeesx()

subroutine, public la_lapack_c::la_cgeesx	(	character, intent(in)	jobvs,
		character, intent(in)	sort,
		procedure(la_select_c)	select,
		character, intent(in)	sense,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	sdim,
		complex(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldvs,*), intent(out)	vs,
		integer(ilp), intent(in)	ldvs,
		real(sp), intent(out)	rconde,
		real(sp), intent(out)	rcondv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		logical(lk), dimension(*), intent(out)	bwork,
		integer(ilp), intent(out)	info
	)

CGEESX: computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = Z*T*(Z**H). Optionally, it also orders the eigenvalues on the diagonal of the Schur form so that selected eigenvalues are at the top left; computes a reciprocal condition number for the average of the selected eigenvalues (RCONDE); and computes a reciprocal condition number for the right invariant subspace corresponding to the selected eigenvalues (RCONDV). The leading columns of Z form an orthonormal basis for this invariant subspace. For further explanation of the reciprocal condition numbers RCONDE and RCONDV, see Section 4.10_sp of the LAPACK Users' Guide (where these quantities are called s and sep respectively). A complex matrix is in Schur form if it is upper triangular.

Here is the call graph for this function:

◆ la_cgeev()

subroutine, public la_lapack_c::la_cgeev	(	character, intent(in)	jobvl,
		character, intent(in)	jobvr,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldvl,*), intent(out)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(out)	vr,
		integer(ilp), intent(in)	ldvr,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGEEV: computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)**H * A = lambda(j) * u(j)**H where u(j)**H denotes the conjugate transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.

Here is the call graph for this function:

◆ la_cgeevx()

subroutine, public la_lapack_c::la_cgeevx	(	character, intent(in)	balanc,
		character, intent(in)	jobvl,
		character, intent(in)	jobvr,
		character, intent(in)	sense,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldvl,*), intent(out)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(out)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(out)	ilo,
		integer(ilp), intent(out)	ihi,
		real(sp), dimension(*), intent(out)	scale,
		real(sp), intent(out)	abnrm,
		real(sp), dimension(*), intent(out)	rconde,
		real(sp), dimension(*), intent(out)	rcondv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGEEVX: computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. Optionally also, it computes a balancing transformation to improve the conditioning of the eigenvalues and eigenvectors (ILO, IHI, SCALE, and ABNRM), reciprocal condition numbers for the eigenvalues (RCONDE), and reciprocal condition numbers for the right eigenvectors (RCONDV). The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)**H * A = lambda(j) * u(j)**H where u(j)**H denotes the conjugate transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real. Balancing a matrix means permuting the rows and columns to make it more nearly upper triangular, and applying a diagonal similarity transformation D * A * D**(-1), where D is a diagonal matrix, to make its rows and columns closer in norm and the condition numbers of its eigenvalues and eigenvectors smaller. The computed reciprocal condition numbers correspond to the balanced matrix. Permuting rows and columns will not change the condition numbers (in exact arithmetic) but diagonal scaling will. For further explanation of balancing, see section 4.10.2_sp of the LAPACK Users' Guide.

Here is the call graph for this function:

◆ la_cgehd2()

pure subroutine, public la_lapack_c::la_cgehd2	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGEHD2: reduces a complex general matrix A to upper Hessenberg form H by a unitary similarity transformation: Q**H * A * Q = H .

Here is the call graph for this function:

◆ la_cgehrd()

pure subroutine, public la_lapack_c::la_cgehrd	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGEHRD: reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H .

Here is the call graph for this function:

◆ la_cgejsv()

pure subroutine, public la_lapack_c::la_cgejsv	(	character, intent(in)	joba,
		character, intent(in)	jobu,
		character, intent(in)	jobv,
		character, intent(in)	jobr,
		character, intent(in)	jobt,
		character, intent(in)	jobp,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(n), intent(out)	sva,
		complex(sp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		complex(sp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(lwork), intent(out)	cwork,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(lrwork), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CGEJSV: computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.

Here is the call graph for this function:

◆ la_cgelq()

pure subroutine, public la_lapack_c::la_cgelq	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	t,
		integer(ilp), intent(in)	tsize,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGELQ: computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

Here is the call graph for this function:

◆ la_cgelq2()

pure subroutine, public la_lapack_c::la_cgelq2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGELQ2: computes an LQ factorization of a complex m-by-n matrix A: A = ( L 0 ) * Q where: Q is a n-by-n orthogonal matrix; L is a lower-triangular m-by-m matrix; 0 is a m-by-(n-m) zero matrix, if m < n.

Here is the call graph for this function:

◆ la_cgelqf()

pure subroutine, public la_lapack_c::la_cgelqf	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGELQF: computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.

Here is the call graph for this function:

◆ la_cgelqt()

pure subroutine, public la_lapack_c::la_cgelqt	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	mb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGELQT: computes a blocked LQ factorization of a complex M-by-N matrix A using the compact WY representation of Q.

Here is the call graph for this function:

◆ la_cgelqt3()

pure recursive subroutine, public la_lapack_c::la_cgelqt3	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		integer(ilp), intent(out)	info
	)

CGELQT3: recursively computes a LQ factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

Here is the call graph for this function:

◆ la_cgels()

subroutine, public la_lapack_c::la_cgels	(	character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGELS: solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, or its conjugate-transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided:

If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*X ||.
If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B.
If TRANS = 'C' and m >= n: find the minimum norm solution of an underdetermined system A**H * X = B.
If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A**H * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

Here is the call graph for this function:

◆ la_cgelsd()

subroutine, public la_lapack_c::la_cgelsd	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(*), intent(out)	s,
		real(sp), intent(in)	rcond,
		integer(ilp), intent(out)	rank,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CGELSD: computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Here is the call graph for this function:

◆ la_cgelss()

subroutine, public la_lapack_c::la_cgelss	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(*), intent(out)	s,
		real(sp), intent(in)	rcond,
		integer(ilp), intent(out)	rank,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGELSS: computes the minimum norm solution to a complex linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.

Here is the call graph for this function:

◆ la_cgelsy()

subroutine, public la_lapack_c::la_cgelsy	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), dimension(*), intent(inout)	jpvt,
		real(sp), intent(in)	rcond,
		integer(ilp), intent(out)	rank,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGELSY: computes the minimum-norm solution to a complex linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by unitary transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * Z**H [ inv(T11)*Q1**H*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The permutation of matrix B (the right hand side) is faster and more simple. o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3.

Here is the call graph for this function:

◆ la_cgemlq()

pure subroutine, public la_lapack_c::la_cgemlq	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	t,
		integer(ilp), intent(in)	tsize,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGEMLQ: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CGELQ)

Here is the call graph for this function:

◆ la_cgemlqt()

pure subroutine, public la_lapack_c::la_cgemlqt	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	mb,
		complex(sp), dimension(ldv,*), intent(in)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGEMLQT: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': Q**H C C Q**H where Q is a complex unitary matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cgemqr()

pure subroutine, public la_lapack_c::la_cgemqr	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	t,
		integer(ilp), intent(in)	tsize,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGEMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CGEQR)

Here is the call graph for this function:

◆ la_cgemqrt()

pure subroutine, public la_lapack_c::la_cgemqrt	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(ldv,*), intent(in)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGEMQRT: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': Q**H C C Q**H where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cgeql2()

pure subroutine, public la_lapack_c::la_cgeql2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGEQL2: computes a QL factorization of a complex m by n matrix A: A = Q * L.

Here is the call graph for this function:

◆ la_cgeqlf()

pure subroutine, public la_lapack_c::la_cgeqlf	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGEQLF: computes a QL factorization of a complex M-by-N matrix A: A = Q * L.

Here is the call graph for this function:

◆ la_cgeqp3()

pure subroutine, public la_lapack_c::la_cgeqp3	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(inout)	jpvt,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGEQP3: computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.

Here is the call graph for this function:

◆ la_cgeqr()

pure subroutine, public la_lapack_c::la_cgeqr	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	t,
		integer(ilp), intent(in)	tsize,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGEQR: computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

Here is the call graph for this function:

◆ la_cgeqr2()

pure subroutine, public la_lapack_c::la_cgeqr2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGEQR2: computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix; 0 is a (m-n)-by-n zero matrix, if m > n.

Here is the call graph for this function:

◆ la_cgeqr2p()

subroutine, public la_lapack_c::la_cgeqr2p	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGEQR2P: computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

Here is the call graph for this function:

◆ la_cgeqrf()

pure subroutine, public la_lapack_c::la_cgeqrf	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGEQRF: computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

Here is the call graph for this function:

◆ la_cgeqrfp()

subroutine, public la_lapack_c::la_cgeqrfp	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

Here is the call graph for this function:

◆ la_cgeqrt()

pure subroutine, public la_lapack_c::la_cgeqrt	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGEQRT: computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.

Here is the call graph for this function:

◆ la_cgeqrt2()

pure subroutine, public la_lapack_c::la_cgeqrt2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		integer(ilp), intent(out)	info
	)

CGEQRT2: computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.

Here is the call graph for this function:

◆ la_cgeqrt3()

pure recursive subroutine, public la_lapack_c::la_cgeqrt3	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		integer(ilp), intent(out)	info
	)

CGEQRT3: recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

Here is the call graph for this function:

◆ la_cgerfs()

pure subroutine, public la_lapack_c::la_cgerfs	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_cgerq2()

pure subroutine, public la_lapack_c::la_cgerq2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGERQ2: computes an RQ factorization of a complex m by n matrix A: A = R * Q.

Here is the call graph for this function:

◆ la_cgerqf()

pure subroutine, public la_lapack_c::la_cgerqf	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGERQF: computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.

Here is the call graph for this function:

◆ la_cgesc2()

pure subroutine, public la_lapack_c::la_cgesc2	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(inout)	rhs,
		integer(ilp), dimension(*), intent(in)	ipiv,
		integer(ilp), dimension(*), intent(in)	jpiv,
		real(sp), intent(out)	scale
	)

CGESC2: solves a system of linear equations A * X = scale* RHS with a general N-by-N matrix A using the LU factorization with complete pivoting computed by CGETC2.

Here is the call graph for this function:

◆ la_cgesdd()

subroutine, public la_lapack_c::la_cgesdd	(	character, intent(in)	jobz,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		complex(sp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		complex(sp), dimension(ldvt,*), intent(out)	vt,
		integer(ilp), intent(in)	ldvt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CGESDD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Here is the call graph for this function:

◆ la_cgesv()

pure subroutine, public la_lapack_c::la_cgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_cgesvd()

subroutine, public la_lapack_c::la_cgesvd	(	character, intent(in)	jobu,
		character, intent(in)	jobvt,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		complex(sp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		complex(sp), dimension(ldvt,*), intent(out)	vt,
		integer(ilp), intent(in)	ldvt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGESVD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.

Here is the call graph for this function:

◆ la_cgesvdq()

subroutine, public la_lapack_c::la_cgesvdq	(	character, intent(in)	joba,
		character, intent(in)	jobp,
		character, intent(in)	jobr,
		character, intent(in)	jobu,
		character, intent(in)	jobv,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		complex(sp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		complex(sp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	numrank,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		complex(sp), dimension(*), intent(out)	cwork,
		integer(ilp), intent(inout)	lcwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info
	)

CGESVDQ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

Here is the call graph for this function:

◆ la_cgesvj()

pure subroutine, public la_lapack_c::la_cgesvj	(	character, intent(in)	joba,
		character, intent(in)	jobu,
		character, intent(in)	jobv,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(n), intent(out)	sva,
		integer(ilp), intent(in)	mv,
		complex(sp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(lwork), intent(inout)	cwork,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(lrwork), intent(inout)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info
	)

CGESVJ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

Here is the call graph for this function:

◆ la_cgesvx()

subroutine, public la_lapack_c::la_cgesvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	r,
		real(sp), dimension(*), intent(inout)	c,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_cgetc2()

pure subroutine, public la_lapack_c::la_cgetc2	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), dimension(*), intent(out)	jpiv,
		integer(ilp), intent(out)	info
	)

CGETC2: computes an LU factorization, using complete pivoting, of the n-by-n matrix A. The factorization has the form A = P * L * U * Q, where P and Q are permutation matrices, L is lower triangular with unit diagonal elements and U is upper triangular. This is a level 1 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_cgetf2()

pure subroutine, public la_lapack_c::la_cgetf2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CGETF2: computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 2 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_cgetrf()

pure subroutine, public la_lapack_c::la_cgetrf	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CGETRF: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_cgetrf2()

pure recursive subroutine, public la_lapack_c::la_cgetrf2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CGETRF2: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ — ], [ A12 ] [ A12 ] do the swaps on [ — ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

Here is the call graph for this function:

◆ la_cgetri()

pure subroutine, public la_lapack_c::la_cgetri	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGETRI: computes the inverse of a matrix using the LU factorization computed by CGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

Here is the call graph for this function:

◆ la_cgetrs()

pure subroutine, public la_lapack_c::la_cgetrs	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CGETRS: solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by CGETRF.

Here is the call graph for this function:

◆ la_cgetsls()

subroutine, public la_lapack_c::la_cgetsls	(	character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGETSLS: solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided:

If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*X ||.
If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B.
If TRANS = 'C' and m >= n: find the minimum norm solution of an undetermined system A**T * X = B.
If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A**T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

Here is the call graph for this function:

◆ la_cgetsqrhrt()

pure subroutine, public la_lapack_c::la_cgetsqrhrt	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	mb1,
		integer(ilp), intent(in)	nb1,
		integer(ilp), intent(in)	nb2,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGETSQRHRT: computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in CGEQRT (Q is in blocked compact WY-representation). See the documentation of CGEQRT for more details on the format.

Here is the call graph for this function:

◆ la_cggbak()

pure subroutine, public la_lapack_c::la_cggbak	(	character, intent(in)	job,
		character, intent(in)	side,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		real(sp), dimension(*), intent(in)	lscale,
		real(sp), dimension(*), intent(in)	rscale,
		integer(ilp), intent(in)	m,
		complex(sp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	info
	)

CGGBAK: forms the right or left eigenvectors of a complex generalized eigenvalue problem A*x = lambda*B*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by CGGBAL.

◆ la_cggbal()

pure subroutine, public la_lapack_c::la_cggbal	(	character, intent(in)	job,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	ilo,
		integer(ilp), intent(out)	ihi,
		real(sp), dimension(*), intent(out)	lscale,
		real(sp), dimension(*), intent(out)	rscale,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGGBAL: balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem A*x = lambda*B*x.

Here is the call graph for this function:

◆ la_cgges()

subroutine, public la_lapack_c::la_cgges	(	character, intent(in)	jobvsl,
		character, intent(in)	jobvsr,
		character, intent(in)	sort,
		procedure(la_selctg_c)	selctg,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	sdim,
		complex(sp), dimension(*), intent(out)	alpha,
		complex(sp), dimension(*), intent(out)	beta,
		complex(sp), dimension(ldvsl,*), intent(out)	vsl,
		integer(ilp), intent(in)	ldvsl,
		complex(sp), dimension(ldvsr,*), intent(out)	vsr,
		integer(ilp), intent(in)	ldvsr,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		logical(lk), dimension(*), intent(out)	bwork,
		integer(ilp), intent(out)	info
	)

CGGES: computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)*S*(VSR)**H, (VSL)*T*(VSR)**H ) where (VSR)**H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an unitary basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver CGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - w*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if S and T are upper triangular and, in addition, the diagonal elements of T are non-negative real numbers.

Here is the call graph for this function:

◆ la_cgges3()

subroutine, public la_lapack_c::la_cgges3	(	character, intent(in)	jobvsl,
		character, intent(in)	jobvsr,
		character, intent(in)	sort,
		procedure(la_selctg_c)	selctg,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	sdim,
		complex(sp), dimension(*), intent(out)	alpha,
		complex(sp), dimension(*), intent(out)	beta,
		complex(sp), dimension(ldvsl,*), intent(out)	vsl,
		integer(ilp), intent(in)	ldvsl,
		complex(sp), dimension(ldvsr,*), intent(out)	vsr,
		integer(ilp), intent(in)	ldvsr,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		logical(lk), dimension(*), intent(out)	bwork,
		integer(ilp), intent(out)	info
	)

CGGES3: computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)*S*(VSR)**H, (VSL)*T*(VSR)**H ) where (VSR)**H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an unitary basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver CGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - w*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if S and T are upper triangular and, in addition, the diagonal elements of T are non-negative real numbers.

Here is the call graph for this function:

◆ la_cggesx()

subroutine, public la_lapack_c::la_cggesx	(	character, intent(in)	jobvsl,
		character, intent(in)	jobvsr,
		character, intent(in)	sort,
		procedure(la_selctg_c)	selctg,
		character, intent(in)	sense,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	sdim,
		complex(sp), dimension(*), intent(out)	alpha,
		complex(sp), dimension(*), intent(out)	beta,
		complex(sp), dimension(ldvsl,*), intent(out)	vsl,
		integer(ilp), intent(in)	ldvsl,
		complex(sp), dimension(ldvsr,*), intent(out)	vsr,
		integer(ilp), intent(in)	ldvsr,
		real(sp), dimension(2), intent(out)	rconde,
		real(sp), dimension(2), intent(out)	rcondv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		logical(lk), dimension(*), intent(out)	bwork,
		integer(ilp), intent(out)	info
	)

CGGESX: computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the complex Schur form (S,T), and, optionally, the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL) S (VSR)**H, (VSL) T (VSR)**H ) where (VSR)**H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T; computes a reciprocal condition number for the average of the selected eigenvalues (RCONDE); and computes a reciprocal condition number for the right and left deflating subspaces corresponding to the selected eigenvalues (RCONDV). The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - w*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0 or for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if T is upper triangular with non-negative diagonal and S is upper triangular.

Here is the call graph for this function:

◆ la_cggev()

subroutine, public la_lapack_c::la_cggev	(	character, intent(in)	jobvl,
		character, intent(in)	jobvr,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	alpha,
		complex(sp), dimension(*), intent(out)	beta,
		complex(sp), dimension(ldvl,*), intent(out)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(out)	vr,
		integer(ilp), intent(in)	ldvr,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGGEV: computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambda*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right generalized eigenvector v(j) corresponding to the generalized eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left generalized eigenvector u(j) corresponding to the generalized eigenvalues lambda(j) of (A,B) satisfies u(j)**H * A = lambda(j) * u(j)**H * B where u(j)**H is the conjugate-transpose of u(j).

Here is the call graph for this function:

◆ la_cggev3()

subroutine, public la_lapack_c::la_cggev3	(	character, intent(in)	jobvl,
		character, intent(in)	jobvr,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	alpha,
		complex(sp), dimension(*), intent(out)	beta,
		complex(sp), dimension(ldvl,*), intent(out)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(out)	vr,
		integer(ilp), intent(in)	ldvr,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGGEV3: computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambda*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right generalized eigenvector v(j) corresponding to the generalized eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left generalized eigenvector u(j) corresponding to the generalized eigenvalues lambda(j) of (A,B) satisfies u(j)**H * A = lambda(j) * u(j)**H * B where u(j)**H is the conjugate-transpose of u(j).

Here is the call graph for this function:

◆ la_cggevx()

subroutine, public la_lapack_c::la_cggevx	(	character, intent(in)	balanc,
		character, intent(in)	jobvl,
		character, intent(in)	jobvr,
		character, intent(in)	sense,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	alpha,
		complex(sp), dimension(*), intent(out)	beta,
		complex(sp), dimension(ldvl,*), intent(out)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(out)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(out)	ilo,
		integer(ilp), intent(out)	ihi,
		real(sp), dimension(*), intent(out)	lscale,
		real(sp), dimension(*), intent(out)	rscale,
		real(sp), intent(out)	abnrm,
		real(sp), intent(out)	bbnrm,
		real(sp), dimension(*), intent(out)	rconde,
		real(sp), dimension(*), intent(out)	rcondv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		logical(lk), dimension(*), intent(out)	bwork,
		integer(ilp), intent(out)	info
	)

CGGEVX: computes for a pair of N-by-N complex nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. Optionally, it also computes a balancing transformation to improve the conditioning of the eigenvalues and eigenvectors (ILO, IHI, LSCALE, RSCALE, ABNRM, and BBNRM), reciprocal condition numbers for the eigenvalues (RCONDE), and reciprocal condition numbers for the right eigenvectors (RCONDV). A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambda*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right eigenvector v(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j) . The left eigenvector u(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies u(j)**H * A = lambda(j) * u(j)**H * B. where u(j)**H is the conjugate-transpose of u(j).

Here is the call graph for this function:

◆ la_cggglm()

pure subroutine, public la_lapack_c::la_cggglm	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(*), intent(out)	x,
		complex(sp), dimension(*), intent(out)	y,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGGGLM: solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = A*x + B*y x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q*(R), B = Q*T*Z. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)*(d-A*x) ||_2 x where inv(B) denotes the inverse of B.

Here is the call graph for this function:

◆ la_cgghd3()

pure subroutine, public la_lapack_c::la_cgghd3	(	character, intent(in)	compq,
		character, intent(in)	compz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGGHD3: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**H*A*Z = H and transforms B to another upper triangular matrix T: Q**H*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**H*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H If Q1 is the unitary matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then CGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of CGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

Here is the call graph for this function:

◆ la_cgghrd()

pure subroutine, public la_lapack_c::la_cgghrd	(	character, intent(in)	compq,
		character, intent(in)	compz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), intent(out)	info
	)

CGGHRD: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**H*A*Z = H and transforms B to another upper triangular matrix T: Q**H*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**H*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H If Q1 is the unitary matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then CGGHRD reduces the original problem to generalized Hessenberg form.

Here is the call graph for this function:

◆ la_cgglse()

pure subroutine, public la_lapack_c::la_cgglse	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	p,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(inout)	c,
		complex(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(*), intent(out)	x,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGGLSE: solves the linear equality-constrained least squares (LSE) problem: minimize || c - A*x ||_2 subject to B*x = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)*Q, A = Z*T*Q.

Here is the call graph for this function:

◆ la_cggqrf()

pure subroutine, public la_lapack_c::la_cggqrf	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	taua,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	taub,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGGQRF: computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = Q*R, B = Q*T*Z, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)*A: inv(B)*A = Z**H * (inv(T)*R) where inv(B) denotes the inverse of the matrix B, and Z' denotes the conjugate transpose of matrix Z.

Here is the call graph for this function:

◆ la_cggrqf()

pure subroutine, public la_lapack_c::la_cggrqf	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	taua,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	taub,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGGRQF: computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = R*Q, B = Z*T*Q, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of A*inv(B): A*inv(B) = (R*inv(T))*Z**H where inv(B) denotes the inverse of the matrix B, and Z**H denotes the conjugate transpose of the matrix Z.

Here is the call graph for this function:

◆ la_cgsvj0()

pure subroutine, public la_lapack_c::la_cgsvj0	(	character, intent(in)	jobv,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(n), intent(inout)	d,
		real(sp), dimension(n), intent(inout)	sva,
		integer(ilp), intent(in)	mv,
		complex(sp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		real(sp), intent(in)	eps,
		real(sp), intent(in)	sfmin,
		real(sp), intent(in)	tol,
		integer(ilp), intent(in)	nsweep,
		complex(sp), dimension(lwork), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGSVJ0: is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.

Here is the call graph for this function:

◆ la_cgsvj1()

pure subroutine, public la_lapack_c::la_cgsvj1	(	character, intent(in)	jobv,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	n1,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(n), intent(inout)	d,
		real(sp), dimension(n), intent(inout)	sva,
		integer(ilp), intent(in)	mv,
		complex(sp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		real(sp), intent(in)	eps,
		real(sp), intent(in)	sfmin,
		real(sp), intent(in)	tol,
		integer(ilp), intent(in)	nsweep,
		complex(sp), dimension(lwork), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CGSVJ1: is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ CGSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.

Here is the call graph for this function:

◆ la_cgtcon()

pure subroutine, public la_lapack_c::la_cgtcon	(	character, intent(in)	norm,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	dl,
		complex(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	du,
		complex(sp), dimension(*), intent(in)	du2,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CGTCON: estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by CGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_cgtrfs()

pure subroutine, public la_lapack_c::la_cgtrfs	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	dl,
		complex(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	du,
		complex(sp), dimension(*), intent(in)	dlf,
		complex(sp), dimension(*), intent(in)	df,
		complex(sp), dimension(*), intent(in)	duf,
		complex(sp), dimension(*), intent(in)	du2,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_cgtsv()

pure subroutine, public la_lapack_c::la_cgtsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(inout)	dl,
		complex(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(*), intent(inout)	du,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CGTSV: solves the equation A*X = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T *X = B may be solved by interchanging the order of the arguments DU and DL.

◆ la_cgtsvx()

pure subroutine, public la_lapack_c::la_cgtsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	dl,
		complex(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	du,
		complex(sp), dimension(*), intent(inout)	dlf,
		complex(sp), dimension(*), intent(inout)	df,
		complex(sp), dimension(*), intent(inout)	duf,
		complex(sp), dimension(*), intent(inout)	du2,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_cgttrf()

pure subroutine, public la_lapack_c::la_cgttrf	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	dl,
		complex(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(*), intent(inout)	du,
		complex(sp), dimension(*), intent(out)	du2,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CGTTRF: computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.

◆ la_cgttrs()

pure subroutine, public la_lapack_c::la_cgttrs	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	dl,
		complex(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	du,
		complex(sp), dimension(*), intent(in)	du2,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CGTTRS: solves one of the systems of equations A * X = B, A**T * X = B, or A**H * X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF.

Here is the call graph for this function:

◆ la_cgtts2()

pure subroutine, public la_lapack_c::la_cgtts2	(	integer(ilp), intent(in)	itrans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	dl,
		complex(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	du,
		complex(sp), dimension(*), intent(in)	du2,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb
	)

CGTTS2: solves one of the systems of equations A * X = B, A**T * X = B, or A**H * X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF.

◆ la_chb2st_kernels()

pure subroutine, public la_lapack_c::la_chb2st_kernels	(	character, intent(in)	uplo,
		logical(lk), intent(in)	wantz,
		integer(ilp), intent(in)	ttype,
		integer(ilp), intent(in)	st,
		integer(ilp), intent(in)	ed,
		integer(ilp), intent(in)	sweep,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		integer(ilp), intent(in)	ib,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	v,
		complex(sp), dimension(*), intent(out)	tau,
		integer(ilp), intent(in)	ldvt,
		complex(sp), dimension(*), intent(out)	work
	)

CHB2ST_KERNELS: is an internal routine used by the CHETRD_HB2ST subroutine.

Here is the call graph for this function:

◆ la_chbev()

subroutine, public la_lapack_c::la_chbev	(	character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHBEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.

Here is the call graph for this function:

◆ la_chbevd()

subroutine, public la_lapack_c::la_chbevd	(	character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CHBEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Here is the call graph for this function:

◆ la_chbevx()

subroutine, public la_lapack_c::la_chbevx	(	character, intent(in)	jobz,
		character, intent(in)	range,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldq,*), intent(out)	q,
		integer(ilp), intent(in)	ldq,
		real(sp), intent(in)	vl,
		real(sp), intent(in)	vu,
		integer(ilp), intent(in)	il,
		integer(ilp), intent(in)	iu,
		real(sp), intent(in)	abstol,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), dimension(*), intent(out)	ifail,
		integer(ilp), intent(out)	info
	)

CHBEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_chbgst()

pure subroutine, public la_lapack_c::la_chbgst	(	character, intent(in)	vect,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ka,
		integer(ilp), intent(in)	kb,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldbb,*), intent(in)	bb,
		integer(ilp), intent(in)	ldbb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHBGST: reduces a complex Hermitian-definite banded generalized eigenproblem A*x = lambda*B*x to standard form C*y = lambda*y, such that C has the same bandwidth as A. B must have been previously factorized as S**H*S by CPBSTF, using a split Cholesky factorization. A is overwritten by C = X**H*A*X, where X = S**(-1)*Q and Q is a unitary matrix chosen to preserve the bandwidth of A.

Here is the call graph for this function:

◆ la_chbgv()

pure subroutine, public la_lapack_c::la_chbgv	(	character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ka,
		integer(ilp), intent(in)	kb,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldbb,*), intent(inout)	bb,
		integer(ilp), intent(in)	ldbb,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHBGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.

Here is the call graph for this function:

◆ la_chbgvd()

pure subroutine, public la_lapack_c::la_chbgvd	(	character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ka,
		integer(ilp), intent(in)	kb,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldbb,*), intent(inout)	bb,
		integer(ilp), intent(in)	ldbb,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CHBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Here is the call graph for this function:

◆ la_chbgvx()

pure subroutine, public la_lapack_c::la_chbgvx	(	character, intent(in)	jobz,
		character, intent(in)	range,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ka,
		integer(ilp), intent(in)	kb,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldbb,*), intent(inout)	bb,
		integer(ilp), intent(in)	ldbb,
		complex(sp), dimension(ldq,*), intent(out)	q,
		integer(ilp), intent(in)	ldq,
		real(sp), intent(in)	vl,
		real(sp), intent(in)	vu,
		integer(ilp), intent(in)	il,
		integer(ilp), intent(in)	iu,
		real(sp), intent(in)	abstol,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), dimension(*), intent(out)	ifail,
		integer(ilp), intent(out)	info
	)

CHBGVX: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either all eigenvalues, a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_chbtrd()

pure subroutine, public la_lapack_c::la_chbtrd	(	character, intent(in)	vect,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	d,
		real(sp), dimension(*), intent(out)	e,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CHBTRD: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_checon()

pure subroutine, public la_lapack_c::la_checon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CHECON: estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_checon_rook()

pure subroutine, public la_lapack_c::la_checon_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CHECON_ROOK: estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_cheequb()

pure subroutine, public la_lapack_c::la_cheequb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		real(sp), intent(out)	scond,
		real(sp), intent(out)	amax,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CHEEQUB: computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

Here is the call graph for this function:

◆ la_cheev()

subroutine, public la_lapack_c::la_cheev	(	character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHEEV: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

Here is the call graph for this function:

◆ la_cheevd()

subroutine, public la_lapack_c::la_cheevd	(	character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CHEEVD: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Here is the call graph for this function:

◆ la_cheevr()

subroutine, public la_lapack_c::la_cheevr	(	character, intent(in)	jobz,
		character, intent(in)	range,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), intent(in)	vl,
		real(sp), intent(in)	vu,
		integer(ilp), intent(in)	il,
		integer(ilp), intent(in)	iu,
		real(sp), intent(in)	abstol,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), dimension(*), intent(out)	isuppz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CHEEVR: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. CHEEVR first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, CHEEVR calls CSTEMR to compute the eigenspectrum using Relatively Robust Representations. CSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see CSTEMR's documentation and:

Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,

Also LAPACK Working Note 154.

Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : CHEEVR calls CSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. CHEEVR calls SSTEBZ and CSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of CSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.

Here is the call graph for this function:

◆ la_cheevx()

subroutine, public la_lapack_c::la_cheevx	(	character, intent(in)	jobz,
		character, intent(in)	range,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), intent(in)	vl,
		real(sp), intent(in)	vu,
		integer(ilp), intent(in)	il,
		integer(ilp), intent(in)	iu,
		real(sp), intent(in)	abstol,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), dimension(*), intent(out)	ifail,
		integer(ilp), intent(out)	info
	)

CHEEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_chegs2()

pure subroutine, public la_lapack_c::la_chegs2	(	integer(ilp), intent(in)	itype,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CHEGS2: reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H *A*L. B must have been previously factorized as U**H *U or L*L**H by ZPOTRF.

Here is the call graph for this function:

◆ la_chegst()

pure subroutine, public la_lapack_c::la_chegst	(	integer(ilp), intent(in)	itype,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CHEGST: reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by CPOTRF.

Here is the call graph for this function:

◆ la_chegv()

subroutine, public la_lapack_c::la_chegv	(	integer(ilp), intent(in)	itype,
		character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHEGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite.

Here is the call graph for this function:

◆ la_chegvd()

subroutine, public la_lapack_c::la_chegvd	(	integer(ilp), intent(in)	itype,
		character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CHEGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Here is the call graph for this function:

◆ la_chegvx()

subroutine, public la_lapack_c::la_chegvx	(	integer(ilp), intent(in)	itype,
		character, intent(in)	jobz,
		character, intent(in)	range,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), intent(in)	vl,
		real(sp), intent(in)	vu,
		integer(ilp), intent(in)	il,
		integer(ilp), intent(in)	iu,
		real(sp), intent(in)	abstol,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), dimension(*), intent(out)	ifail,
		integer(ilp), intent(out)	info
	)

CHEGVX: computes selected eigenvalues, and optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_cherfs()

pure subroutine, public la_lapack_c::la_cherfs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHERFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_chesv()

pure subroutine, public la_lapack_c::la_chesv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * U**H, if UPLO = 'U', or A = L * D * L**H, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_chesv_aa()

pure subroutine, public la_lapack_c::la_chesv_aa	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHESV_AA: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = U**H * T * U, if UPLO = 'U', or A = L * T * L**H, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is Hermitian and tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_chesv_rk()

pure subroutine, public la_lapack_c::la_chesv_rk	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	e,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHESV_RK: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = P*U*D*(U**H)*(P**T), if UPLO = 'U', or A = P*L*D*(L**H)*(P**T), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, U**H (or L**H) is the conjugate of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_RK is called to compute the factorization of a complex Hermitian matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CHETRS_3.

Here is the call graph for this function:

◆ la_chesv_rook()

pure subroutine, public la_lapack_c::la_chesv_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHESV_ROOK: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman ("rook") diagonal pivoting method is used to factor A as A = U * D * U**T, if UPLO = 'U', or A = L * D * L**T, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_ROOK is called to compute the factorization of a complex Hermition matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling CHETRS_ROOK (uses BLAS 2).

Here is the call graph for this function:

◆ la_chesvx()

subroutine, public la_lapack_c::la_chesvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHESVX: uses the diagonal pivoting factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_cheswapr()

pure subroutine, public la_lapack_c::la_cheswapr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,n), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(in)	i1,
		integer(ilp), intent(in)	i2
	)

CHESWAPR: applies an elementary permutation on the rows and the columns of a hermitian matrix.

◆ la_chetd2()

pure subroutine, public la_lapack_c::la_chetd2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	d,
		real(sp), dimension(*), intent(out)	e,
		complex(sp), dimension(*), intent(out)	tau,
		integer(ilp), intent(out)	info
	)

CHETD2: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_chetf2()

pure subroutine, public la_lapack_c::la_chetf2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CHETF2: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**H or A = L*D*L**H where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**H is the conjugate transpose of U, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_chetf2_rk()

pure subroutine, public la_lapack_c::la_chetf2_rk	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	e,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CHETF2_RK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**H (or L**H) is the conjugate of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

Here is the call graph for this function:

◆ la_chetf2_rook()

pure subroutine, public la_lapack_c::la_chetf2_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CHETF2_ROOK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = U*D*U**H or A = L*D*L**H where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**H is the conjugate transpose of U, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_chetrd()

pure subroutine, public la_lapack_c::la_chetrd	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	d,
		real(sp), dimension(*), intent(out)	e,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHETRD: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_chetrd_hb2st()

pure subroutine, public la_lapack_c::la_chetrd_hb2st	(	character, intent(in)	stage1,
		character, intent(in)	vect,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	d,
		real(sp), dimension(*), intent(out)	e,
		complex(sp), dimension(*), intent(out)	hous,
		integer(ilp), intent(in)	lhous,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHETRD_HB2ST: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_chetrd_he2hb()

pure subroutine, public la_lapack_c::la_chetrd_he2hb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldab,*), intent(out)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHETRD_HE2HB: reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.

Here is the call graph for this function:

◆ la_chetrf()

pure subroutine, public la_lapack_c::la_chetrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHETRF: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U*D*U**H or A = L*D*L**H where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_chetrf_aa()

pure subroutine, public la_lapack_c::la_chetrf_aa	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHETRF_AA: computes the factorization of a complex hermitian matrix A using the Aasen's algorithm. The form of the factorization is A = U**H*T*U or A = L*T*L**H where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a hermitian tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_chetrf_rk()

pure subroutine, public la_lapack_c::la_chetrf_rk	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	e,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHETRF_RK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**H (or L**H) is the conjugate of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

Here is the call graph for this function:

◆ la_chetrf_rook()

pure subroutine, public la_lapack_c::la_chetrf_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHETRF_ROOK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_chetri()

pure subroutine, public la_lapack_c::la_chetri	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CHETRI: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF.

◆ la_chetri_rook()

pure subroutine, public la_lapack_c::la_chetri_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CHETRI_ROOK: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF_ROOK.

◆ la_chetrs()

pure subroutine, public la_lapack_c::la_chetrs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CHETRS: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF.

Here is the call graph for this function:

◆ la_chetrs2()

pure subroutine, public la_lapack_c::la_chetrs2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CHETRS2: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF and converted by CSYCONV.

Here is the call graph for this function:

◆ la_chetrs_3()

pure subroutine, public la_lapack_c::la_chetrs_3	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	e,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CHETRS_3: solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by CHETRF_RK or CHETRF_BK: A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**H (or L**H) is the conjugate of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

◆ la_chetrs_aa()

pure subroutine, public la_lapack_c::la_chetrs_aa	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHETRS_AA: solves a system of linear equations A*X = B with a complex hermitian matrix A using the factorization A = U**H*T*U or A = L*T*L**H computed by CHETRF_AA.

Here is the call graph for this function:

◆ la_chetrs_rook()

pure subroutine, public la_lapack_c::la_chetrs_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CHETRS_ROOK: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF_ROOK.

Here is the call graph for this function:

◆ la_chfrk()

pure subroutine, public la_lapack_c::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.

◆ la_chgeqz()

subroutine, public la_lapack_c::la_chgeqz	(	character, intent(in)	job,
		character, intent(in)	compq,
		character, intent(in)	compz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	alpha,
		complex(sp), dimension(*), intent(out)	beta,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHGEQZ: computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1*H*Z1**H, B = Q1*T*Z1**H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**H, T = Q*P*Z**H, where Q and Z are unitary matrices and S and P are upper triangular. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized Hessenberg form, then the output matrices Q1*Q and Z1*Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**H, B = (Q1*Q)*P*(Z1*Z)**H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. The values of alpha and beta for the i-th eigenvalue can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241–256.

Here is the call graph for this function:

◆ la_chpcon()

pure subroutine, public la_lapack_c::la_chpcon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CHPCON: estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_chpev()

subroutine, public la_lapack_c::la_chpev	(	character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHPEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.

Here is the call graph for this function:

◆ la_chpevd()

subroutine, public la_lapack_c::la_chpevd	(	character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CHPEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Here is the call graph for this function:

◆ la_chpevx()

subroutine, public la_lapack_c::la_chpevx	(	character, intent(in)	jobz,
		character, intent(in)	range,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		real(sp), intent(in)	vl,
		real(sp), intent(in)	vu,
		integer(ilp), intent(in)	il,
		integer(ilp), intent(in)	iu,
		real(sp), intent(in)	abstol,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), dimension(*), intent(out)	ifail,
		integer(ilp), intent(out)	info
	)

CHPEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. Eigenvalues/vectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_chpgst()

pure subroutine, public la_lapack_c::la_chpgst	(	integer(ilp), intent(in)	itype,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		complex(sp), dimension(*), intent(in)	bp,
		integer(ilp), intent(out)	info
	)

CHPGST: reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by CPPTRF.

◆ la_chpgv()

subroutine, public la_lapack_c::la_chpgv	(	integer(ilp), intent(in)	itype,
		character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		complex(sp), dimension(*), intent(inout)	bp,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHPGV: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.

Here is the call graph for this function:

◆ la_chpgvd()

subroutine, public la_lapack_c::la_chpgvd	(	integer(ilp), intent(in)	itype,
		character, intent(in)	jobz,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		complex(sp), dimension(*), intent(inout)	bp,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CHPGVD: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Here is the call graph for this function:

◆ la_chpgvx()

subroutine, public la_lapack_c::la_chpgvx	(	integer(ilp), intent(in)	itype,
		character, intent(in)	jobz,
		character, intent(in)	range,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		complex(sp), dimension(*), intent(inout)	bp,
		real(sp), intent(in)	vl,
		real(sp), intent(in)	vu,
		integer(ilp), intent(in)	il,
		integer(ilp), intent(in)	iu,
		real(sp), intent(in)	abstol,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), dimension(*), intent(out)	ifail,
		integer(ilp), intent(out)	info
	)

CHPGVX: computes selected eigenvalues and, optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_chprfs()

pure subroutine, public la_lapack_c::la_chprfs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(*), intent(in)	afp,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_chpsv()

pure subroutine, public la_lapack_c::la_chpsv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(inout)	ap,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CHPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * U**H, if UPLO = 'U', or A = L * D * L**H, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_chpsvx()

subroutine, public la_lapack_c::la_chpsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(*), intent(inout)	afp,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CHPSVX: uses the diagonal pivoting factorization A = U*D*U**H or A = L*D*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_chptrd()

pure subroutine, public la_lapack_c::la_chptrd	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		real(sp), dimension(*), intent(out)	d,
		real(sp), dimension(*), intent(out)	e,
		complex(sp), dimension(*), intent(out)	tau,
		integer(ilp), intent(out)	info
	)

CHPTRD: reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_chptrf()

pure subroutine, public la_lapack_c::la_chptrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CHPTRF: computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**H or A = L*D*L**H where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

Here is the call graph for this function:

◆ la_chptri()

pure subroutine, public la_lapack_c::la_chptri	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CHPTRI: computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = U*D*U**H or A = L*D*L**H computed by CHPTRF.

◆ la_chptrs()

pure subroutine, public la_lapack_c::la_chptrs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	ap,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CHPTRS: solves a system of linear equations A*X = B with a complex Hermitian matrix A stored in packed format using the factorization A = U*D*U**H or A = L*D*L**H computed by CHPTRF.

Here is the call graph for this function:

◆ la_chsein()

subroutine, public la_lapack_c::la_chsein	(	character, intent(in)	side,
		character, intent(in)	eigsrc,
		character, intent(in)	initv,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), dimension(*), intent(inout)	w,
		complex(sp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	ifaill,
		integer(ilp), dimension(*), intent(out)	ifailr,
		integer(ilp), intent(out)	info
	)

CHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.

Here is the call graph for this function:

◆ la_chseqr()

pure subroutine, public la_lapack_c::la_chseqr	(	character, intent(in)	job,
		character, intent(in)	compz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CHSEQR: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*T*(QZ)**H.

Here is the call graph for this function:

◆ la_cla_gbamv()

subroutine, public la_lapack_c::la_cla_gbamv	(	integer(ilp), intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		real(sp), intent(in)	alpha,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(sp), intent(in)	beta,
		real(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy
	)

CLA_GBAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

Here is the call graph for this function:

◆ la_cla_gbrcond_c()

real(sp) function, public la_lapack_c::la_cla_gbrcond_c	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldafb,*), intent(in)	afb,
		integer(ilp), intent(in)	ldafb,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), dimension(*), intent(in)	c,
		logical(lk), intent(in)	capply,
		integer(ilp), intent(out)	info,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork
	)

CLA_GBRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

Here is the call graph for this function:

◆ la_cla_gbrpvgrw()

pure real(sp) function, public la_lapack_c::la_cla_gbrpvgrw	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	ncols,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldafb,*), intent(in)	afb,
		integer(ilp), intent(in)	ldafb
	)

CLA_GBRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

Here is the call graph for this function:

◆ la_cla_geamv()

subroutine, public la_lapack_c::la_cla_geamv	(	integer(ilp), intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(sp), intent(in)	alpha,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(sp), intent(in)	beta,
		real(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy
	)

CLA_GEAMV: performs one of the matrix-vector operations y := alpha*abs(A)*abs(x) + beta*abs(y), or y := alpha*abs(A)**T*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

Here is the call graph for this function:

◆ la_cla_gercond_c()

real(sp) function, public la_lapack_c::la_cla_gercond_c	(	character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), dimension(*), intent(in)	c,
		logical(lk), intent(in)	capply,
		integer(ilp), intent(out)	info,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork
	)

CLA_GERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

Here is the call graph for this function:

◆ la_cla_gerpvgrw()

pure real(sp) function, public la_lapack_c::la_cla_gerpvgrw	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ncols,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf
	)

CLA_GERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

Here is the call graph for this function:

◆ la_cla_heamv()

subroutine, public la_lapack_c::la_cla_heamv	(	integer(ilp), intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(sp), intent(in)	alpha,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(sp), intent(in)	beta,
		real(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy
	)

CLA_SYAMV performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

Here is the call graph for this function:

◆ la_cla_hercond_c()

real(sp) function, public la_lapack_c::la_cla_hercond_c	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), dimension(*), intent(in)	c,
		logical(lk), intent(in)	capply,
		integer(ilp), intent(out)	info,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork
	)

CLA_HERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

Here is the call graph for this function:

◆ la_cla_herpvgrw()

real(sp) function, public la_lapack_c::la_cla_herpvgrw	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	info,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), dimension(*), intent(out)	work
	)

CLA_HERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

Here is the call graph for this function:

◆ la_cla_lin_berr()

pure subroutine, public la_lapack_c::la_cla_lin_berr	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nz,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(n,nrhs), intent(in)	res,
		real(sp), dimension(n,nrhs), intent(in)	ayb,
		real(sp), dimension(nrhs), intent(out)	berr
	)

CLA_LIN_BERR: computes componentwise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the componentwise absolute value of the matrix or vector Z.

Here is the call graph for this function:

◆ la_cla_porcond_c()

real(sp) function, public la_lapack_c::la_cla_porcond_c	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		real(sp), dimension(*), intent(in)	c,
		logical(lk), intent(in)	capply,
		integer(ilp), intent(out)	info,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork
	)

CLA_PORCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

Here is the call graph for this function:

◆ la_cla_porpvgrw()

real(sp) function, public la_lapack_c::la_cla_porpvgrw	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	ncols,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		real(sp), dimension(*), intent(out)	work
	)

CLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

Here is the call graph for this function:

◆ la_cla_syamv()

subroutine, public la_lapack_c::la_cla_syamv	(	integer(ilp), intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(sp), intent(in)	alpha,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(sp), intent(in)	beta,
		real(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy
	)

CLA_SYAMV: performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

◆ la_cla_syrcond_c()

real(sp) function, public la_lapack_c::la_cla_syrcond_c	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), dimension(*), intent(in)	c,
		logical(lk), intent(in)	capply,
		integer(ilp), intent(out)	info,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork
	)

CLA_SYRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

Here is the call graph for this function:

◆ la_cla_syrpvgrw()

real(sp) function, public la_lapack_c::la_cla_syrpvgrw	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	info,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), dimension(*), intent(out)	work
	)

CLA_SYRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

Here is the call graph for this function:

◆ la_cla_wwaddw()

pure subroutine, public la_lapack_c::la_cla_wwaddw	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	x,
		complex(sp), dimension(*), intent(inout)	y,
		complex(sp), dimension(*), intent(in)	w
	)

CLA_WWADDW: adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.

◆ la_clabrd()

pure subroutine, public la_lapack_c::la_clabrd	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	d,
		real(sp), dimension(*), intent(out)	e,
		complex(sp), dimension(*), intent(out)	tauq,
		complex(sp), dimension(*), intent(out)	taup,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		complex(sp), dimension(ldy,*), intent(out)	y,
		integer(ilp), intent(in)	ldy
	)

CLABRD: reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by CGEBRD.

Here is the call graph for this function:

◆ la_clacgv()

pure subroutine, public la_lapack_c::la_clacgv	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	x,
		integer(ilp), intent(in)	incx
	)

CLACGV: conjugates a complex vector of length N.

◆ la_clacn2()

pure subroutine, public la_lapack_c::la_clacn2	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(out)	v,
		complex(sp), dimension(*), intent(inout)	x,
		real(sp), intent(inout)	est,
		integer(ilp), intent(inout)	kase,
		integer(ilp), dimension(3), intent(inout)	isave
	)

CLACN2: estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products.

◆ la_clacon()

subroutine, public la_lapack_c::la_clacon	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(n), intent(out)	v,
		complex(sp), dimension(n), intent(inout)	x,
		real(sp), intent(inout)	est,
		integer(ilp), intent(inout)	kase
	)

CLACON: estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products.

◆ la_clacp2()

pure subroutine, public la_lapack_c::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.

◆ la_clacpy()

pure subroutine, public la_lapack_c::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.

◆ la_clacrm()

pure subroutine, public la_lapack_c::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.

◆ la_clacrt()

pure subroutine, public la_lapack_c::la_clacrt	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	cx,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(inout)	cy,
		integer(ilp), intent(in)	incy,
		complex(sp), intent(in)	c,
		complex(sp), intent(in)	s
	)

CLACRT: performs the operation ( c s )( x ) ==> ( x ) ( -s c )( y ) ( y ) where c and s are complex and the vectors x and y are complex.

◆ la_cladiv()

pure complex(sp) function, public la_lapack_c::la_cladiv	(	complex(sp), intent(in)	x,
		complex(sp), intent(in)	y
	)

CLADIV: := X / Y, where X and Y are complex. The computation of X / Y will not overflow on an intermediary step unless the results overflows.

Here is the call graph for this function:

◆ la_claed0()

pure subroutine, public la_lapack_c::la_claed0	(	integer(ilp), intent(in)	qsiz,
		integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	e,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldqs,*), intent(out)	qstore,
		integer(ilp), intent(in)	ldqs,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

Using the divide and conquer method, CLAED0: computes all eigenvalues of a symmetric tridiagonal matrix which is one diagonal block of those from reducing a dense or band Hermitian matrix and corresponding eigenvectors of the dense or band matrix.

Here is the call graph for this function:

◆ la_claed7()

pure subroutine, public la_lapack_c::la_claed7	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	cutpnt,
		integer(ilp), intent(in)	qsiz,
		integer(ilp), intent(in)	tlvls,
		integer(ilp), intent(in)	curlvl,
		integer(ilp), intent(in)	curpbm,
		real(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		real(sp), intent(inout)	rho,
		integer(ilp), dimension(*), intent(out)	indxq,
		real(sp), dimension(*), intent(inout)	qstore,
		integer(ilp), dimension(*), intent(inout)	qptr,
		integer(ilp), dimension(*), intent(inout)	prmptr,
		integer(ilp), dimension(*), intent(inout)	perm,
		integer(ilp), dimension(*), intent(inout)	givptr,
		integer(ilp), dimension(2,*), intent(inout)	givcol,
		real(sp), dimension(2,*), intent(inout)	givnum,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CLAED7: computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense or banded Hermitian matrix that has been reduced to tridiagonal form. T = Q(in) ( D(in) + RHO * Z*Z**H ) Q**H(in) = Q(out) * D(out) * Q**H(out) where Z = Q**Hu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine SLAED4 (as called by SLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.

Here is the call graph for this function:

◆ la_claed8()

pure subroutine, public la_lapack_c::la_claed8	(	integer(ilp), intent(out)	k,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	qsiz,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), intent(inout)	rho,
		integer(ilp), intent(in)	cutpnt,
		real(sp), dimension(*), intent(inout)	z,
		real(sp), dimension(*), intent(out)	dlamda,
		complex(sp), dimension(ldq2,*), intent(out)	q2,
		integer(ilp), intent(in)	ldq2,
		real(sp), dimension(*), intent(out)	w,
		integer(ilp), dimension(*), intent(out)	indxp,
		integer(ilp), dimension(*), intent(out)	indx,
		integer(ilp), dimension(*), intent(inout)	indxq,
		integer(ilp), dimension(*), intent(out)	perm,
		integer(ilp), intent(out)	givptr,
		integer(ilp), dimension(2,*), intent(out)	givcol,
		real(sp), dimension(2,*), intent(out)	givnum,
		integer(ilp), intent(out)	info
	)

CLAED8: merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.

Here is the call graph for this function:

◆ la_claein()

pure subroutine, public la_lapack_c::la_claein	(	logical(lk), intent(in)	rightv,
		logical(lk), intent(in)	noinit,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), intent(in)	w,
		complex(sp), dimension(*), intent(inout)	v,
		complex(sp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(*), intent(out)	rwork,
		real(sp), intent(in)	eps3,
		real(sp), intent(in)	smlnum,
		integer(ilp), intent(out)	info
	)

CLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.

Here is the call graph for this function:

◆ la_claesy()

pure subroutine, public la_lapack_c::la_claesy	(	complex(sp), intent(in)	a,
		complex(sp), intent(in)	b,
		complex(sp), intent(in)	c,
		complex(sp), intent(out)	rt1,
		complex(sp), intent(out)	rt2,
		complex(sp), intent(out)	evscal,
		complex(sp), intent(out)	cs1,
		complex(sp), intent(out)	sn1
	)

CLAESY: computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ].

◆ la_claev2()

pure subroutine, public la_lapack_c::la_claev2	(	complex(sp), intent(in)	a,
		complex(sp), intent(in)	b,
		complex(sp), intent(in)	c,
		real(sp), intent(out)	rt1,
		real(sp), intent(out)	rt2,
		real(sp), intent(out)	cs1,
		complex(sp), intent(out)	sn1
	)

CLAEV2: computes the eigendecomposition of a 2-by-2 Hermitian matrix [ A B ] [ CONJG(B) C ]. On return, RT1 is the eigenvalue of larger absolute value, RT2 is the eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right eigenvector for RT1, giving the decomposition [ CS1 CONJG(SN1) ] [ A B ] [ CS1 -CONJG(SN1) ] = [ RT1 0 ] [-SN1 CS1 ] [ CONJG(B) C ] [ SN1 CS1 ] [ 0 RT2 ].

◆ la_clag2z()

pure subroutine, public la_lapack_c::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_clags2()

pure subroutine, public la_lapack_c::la_clags2	(	logical(lk), intent(in)	upper,
		real(sp), intent(in)	a1,
		complex(sp), intent(in)	a2,
		real(sp), intent(in)	a3,
		real(sp), intent(in)	b1,
		complex(sp), intent(in)	b2,
		real(sp), intent(in)	b3,
		real(sp), intent(out)	csu,
		complex(sp), intent(out)	snu,
		real(sp), intent(out)	csv,
		complex(sp), intent(out)	snv,
		real(sp), intent(out)	csq,
		complex(sp), intent(out)	snq
	)

CLAGS2: computes 2-by-2 unitary matrices U, V and Q, such that if ( UPPER ) then U**H *A*Q = U**H *( A1 A2 )*Q = ( x 0 ) ( 0 A3 ) ( x x ) and V**H*B*Q = V**H *( B1 B2 )*Q = ( x 0 ) ( 0 B3 ) ( x x ) or if ( .NOT.UPPER ) then U**H *A*Q = U**H *( A1 0 )*Q = ( x x ) ( A2 A3 ) ( 0 x ) and V**H *B*Q = V**H *( B1 0 )*Q = ( x x ) ( B2 B3 ) ( 0 x ) where U = ( CSU SNU ), V = ( CSV SNV ), ( -SNU**H CSU ) ( -SNV**H CSV ) Q = ( CSQ SNQ ) ( -SNQ**H CSQ ) The rows of the transformed A and B are parallel. Moreover, if the input 2-by-2 matrix A is not zero, then the transformed (1,1) entry of A is not zero. If the input matrices A and B are both not zero, then the transformed (2,2) element of B is not zero, except when the first rows of input A and B are parallel and the second rows are zero.

Here is the call graph for this function:

◆ la_clagtm()

pure subroutine, public la_lapack_c::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.

◆ la_clahef()

pure subroutine, public la_lapack_c::la_clahef	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		integer(ilp), intent(out)	kb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldw,*), intent(out)	w,
		integer(ilp), intent(in)	ldw,
		integer(ilp), intent(out)	info
	)

CLAHEF: computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**H U22**H ) A = ( L11 0 ) ( D 0 ) ( L11**H L21**H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. CLAHEF is an auxiliary routine called by CHETRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

Here is the call graph for this function:

◆ la_clahef_aa()

pure subroutine, public la_lapack_c::la_clahef_aa	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	j1,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), dimension(*), intent(out)	work
	)

CLAHEF_AA: factorizes a panel of a complex hermitian matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

Here is the call graph for this function:

◆ la_clahef_rk()

pure subroutine, public la_lapack_c::la_clahef_rk	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		integer(ilp), intent(out)	kb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	e,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldw,*), intent(out)	w,
		integer(ilp), intent(in)	ldw,
		integer(ilp), intent(out)	info
	)

CLAHEF_RK: computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**H U22**H ) A = ( L11 0 ) ( D 0 ) ( L11**H L21**H ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLAHEF_RK is an auxiliary routine called by CHETRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

Here is the call graph for this function:

◆ la_clahef_rook()

pure subroutine, public la_lapack_c::la_clahef_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		integer(ilp), intent(out)	kb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldw,*), intent(out)	w,
		integer(ilp), intent(in)	ldw,
		integer(ilp), intent(out)	info
	)

CLAHEF_ROOK: computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**H U22**H ) A = ( L11 0 ) ( D 0 ) ( L11**H L21**H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. CLAHEF_ROOK is an auxiliary routine called by CHETRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

Here is the call graph for this function:

◆ la_clahqr()

pure subroutine, public la_lapack_c::la_clahqr	(	logical(lk), intent(in)	wantt,
		logical(lk), intent(in)	wantz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), dimension(*), intent(out)	w,
		integer(ilp), intent(in)	iloz,
		integer(ilp), intent(in)	ihiz,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), intent(out)	info
	)

CLAHQR: is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.

Here is the call graph for this function:

◆ la_clahr2()

pure subroutine, public la_lapack_c::la_clahr2	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(nb), intent(out)	tau,
		complex(sp), dimension(ldt,nb), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldy,nb), intent(out)	y,
		integer(ilp), intent(in)	ldy
	)

CLAHR2: reduces the first NB columns of A complex general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an unitary similarity transformation Q**H * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*v**H, and also the matrix Y = A * V * T. This is an auxiliary routine called by CGEHRD.

Here is the call graph for this function:

◆ la_claic1()

pure subroutine, public la_lapack_c::la_claic1	(	integer(ilp), intent(in)	job,
		integer(ilp), intent(in)	j,
		complex(sp), dimension(j), intent(in)	x,
		real(sp), intent(in)	sest,
		complex(sp), dimension(j), intent(in)	w,
		complex(sp), intent(in)	gamma,
		real(sp), intent(out)	sestpr,
		complex(sp), intent(out)	s,
		complex(sp), intent(out)	c
	)

CLAIC1: applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(L*x) = sest Then CLAIC1 computes sestpr, s, c such that the vector [ s*x ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ w**H gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]**H and sestpr**2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = x**H*w.

◆ la_clals0()

pure subroutine, public la_lapack_c::la_clals0	(	integer(ilp), intent(in)	icompq,
		integer(ilp), intent(in)	nl,
		integer(ilp), intent(in)	nr,
		integer(ilp), intent(in)	sqre,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldbx,*), intent(out)	bx,
		integer(ilp), intent(in)	ldbx,
		integer(ilp), dimension(*), intent(in)	perm,
		integer(ilp), intent(in)	givptr,
		integer(ilp), dimension(ldgcol,*), intent(in)	givcol,
		integer(ilp), intent(in)	ldgcol,
		real(sp), dimension(ldgnum,*), intent(in)	givnum,
		integer(ilp), intent(in)	ldgnum,
		real(sp), dimension(ldgnum,*), intent(in)	poles,
		real(sp), dimension(*), intent(in)	difl,
		real(sp), dimension(ldgnum,*), intent(in)	difr,
		real(sp), dimension( *), intent(in)	z,
		integer(ilp), intent(in)	k,
		real(sp), intent(in)	c,
		real(sp), intent(in)	s,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CLALS0: applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).

Here is the call graph for this function:

◆ la_clalsa()

pure subroutine, public la_lapack_c::la_clalsa	(	integer(ilp), intent(in)	icompq,
		integer(ilp), intent(in)	smlsiz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldbx,*), intent(out)	bx,
		integer(ilp), intent(in)	ldbx,
		real(sp), dimension(ldu,*), intent(in)	u,
		integer(ilp), intent(in)	ldu,
		real(sp), dimension(ldu,*), intent(in)	vt,
		integer(ilp), dimension(*), intent(in)	k,
		real(sp), dimension(ldu,*), intent(in)	difl,
		real(sp), dimension(ldu,*), intent(in)	difr,
		real(sp), dimension(ldu,*), intent(in)	z,
		real(sp), dimension(ldu,*), intent(in)	poles,
		integer(ilp), dimension(*), intent(in)	givptr,
		integer(ilp), dimension(ldgcol,*), intent(in)	givcol,
		integer(ilp), intent(in)	ldgcol,
		integer(ilp), dimension(ldgcol,*), intent(in)	perm,
		real(sp), dimension(ldu,*), intent(in)	givnum,
		real(sp), dimension(*), intent(in)	c,
		real(sp), dimension( *), intent(in)	s,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CLALSA: is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, CLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, CLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by CLALSA.

Here is the call graph for this function:

◆ la_clalsd()

pure subroutine, public la_lapack_c::la_clalsd	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	smlsiz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	e,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), intent(in)	rcond,
		integer(ilp), intent(out)	rank,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CLALSD: uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

Here is the call graph for this function:

◆ la_clamswlq()

pure subroutine, public la_lapack_c::la_clamswlq	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	mb,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CLAMSWLQ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CLASWLQ)

Here is the call graph for this function:

◆ la_clamtsqr()

pure subroutine, public la_lapack_c::la_clamtsqr	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	mb,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CLAMTSQR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CLATSQR)

Here is the call graph for this function:

◆ la_clangb()

real(sp) function, public la_lapack_c::la_clangb	(	character, intent(in)	norm,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	work
	)

CLANGB: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.

Here is the call graph for this function:

◆ la_clange()

real(sp) function, public la_lapack_c::la_clange	(	character, intent(in)	norm,
		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(*), intent(out)	work
	)

CLANGE: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex matrix A.

Here is the call graph for this function:

◆ la_clangt()

pure real(sp) function, public la_lapack_c::la_clangt	(	character, intent(in)	norm,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	dl,
		complex(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	du
	)

CLANGT: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex tridiagonal matrix A.

Here is the call graph for this function:

◆ la_clanhb()

real(sp) function, public la_lapack_c::la_clanhb	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	work
	)

CLANHB: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n hermitian band matrix A, with k super-diagonals.

Here is the call graph for this function:

◆ la_clanhe()

real(sp) function, public la_lapack_c::la_clanhe	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	work
	)

CLANHE: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A.

Here is the call graph for this function:

◆ la_clanhf()

real(sp) function, public la_lapack_c::la_clanhf	(	character, intent(in)	norm,
		character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(0:*), intent(in)	a,
		real(sp), dimension(0:*), intent(out)	work
	)

CLANHF: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix A in RFP format.

Here is the call graph for this function:

◆ la_clanhp()

real(sp) function, public la_lapack_c::la_clanhp	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		real(sp), dimension(*), intent(out)	work
	)

CLANHP: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A, supplied in packed form.

Here is the call graph for this function:

◆ la_clanhs()

real(sp) function, public la_lapack_c::la_clanhs	(	character, intent(in)	norm,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	work
	)

CLANHS: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.

Here is the call graph for this function:

◆ la_clanht()

pure real(sp) function, public la_lapack_c::la_clanht	(	character, intent(in)	norm,
		integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	e
	)

CLANHT: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian tridiagonal matrix A.

Here is the call graph for this function:

◆ la_clansb()

real(sp) function, public la_lapack_c::la_clansb	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	work
	)

CLANSB: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.

Here is the call graph for this function:

◆ la_clansp()

real(sp) function, public la_lapack_c::la_clansp	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		real(sp), dimension(*), intent(out)	work
	)

CLANSP: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A, supplied in packed form.

Here is the call graph for this function:

◆ la_clansy()

real(sp) function, public la_lapack_c::la_clansy	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	work
	)

CLANSY: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A.

Here is the call graph for this function:

◆ la_clantb()

real(sp) function, public la_lapack_c::la_clantb	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	work
	)

CLANTB: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.

Here is the call graph for this function:

◆ la_clantp()

real(sp) function, public la_lapack_c::la_clantp	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		real(sp), dimension(*), intent(out)	work
	)

CLANTP: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.

Here is the call graph for this function:

◆ la_clantr()

real(sp) function, public la_lapack_c::la_clantr	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		character, intent(in)	diag,
		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(*), intent(out)	work
	)

CLANTR: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.

Here is the call graph for this function:

◆ la_clapll()

pure subroutine, public la_lapack_c::la_clapll	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy,
		real(sp), intent(out)	ssmin
	)

Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.

Here is the call graph for this function:

◆ la_clapmr()

pure subroutine, public la_lapack_c::la_clapmr	(	logical(lk), intent(in)	forwrd,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		integer(ilp), dimension(*), intent(inout)	k
	)

CLAPMR: rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),*) is moved X(I,*) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,*) is moved to X(K(I),*) for I = 1,2,...,M.

◆ la_clapmt()

pure subroutine, public la_lapack_c::la_clapmt	(	logical(lk), intent(in)	forwrd,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		integer(ilp), dimension(*), intent(inout)	k
	)

CLAPMT: rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(*,K(J)) is moved X(*,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N.

◆ la_claqgb()

pure subroutine, public la_lapack_c::la_claqgb	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(in)	r,
		real(sp), dimension(*), intent(in)	c,
		real(sp), intent(in)	rowcnd,
		real(sp), intent(in)	colcnd,
		real(sp), intent(in)	amax,
		character, intent(out)	equed
	)

CLAQGB: equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.

◆ la_claqge()

pure subroutine, public la_lapack_c::la_claqge	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(in)	r,
		real(sp), dimension(*), intent(in)	c,
		real(sp), intent(in)	rowcnd,
		real(sp), intent(in)	colcnd,
		real(sp), intent(in)	amax,
		character, intent(out)	equed
	)

CLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.

◆ la_claqhb()

pure subroutine, public la_lapack_c::la_claqhb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	s,
		real(sp), intent(in)	scond,
		real(sp), intent(in)	amax,
		character, intent(out)	equed
	)

CLAQHB: equilibrates an Hermitian band matrix A using the scaling factors in the vector S.

◆ la_claqhe()

pure subroutine, public la_lapack_c::la_claqhe	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(in)	s,
		real(sp), intent(in)	scond,
		real(sp), intent(in)	amax,
		character, intent(out)	equed
	)

CLAQHE: equilibrates a Hermitian matrix A using the scaling factors in the vector S.

◆ la_claqhp()

pure subroutine, public la_lapack_c::la_claqhp	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		real(sp), dimension(*), intent(in)	s,
		real(sp), intent(in)	scond,
		real(sp), intent(in)	amax,
		character, intent(out)	equed
	)

CLAQHP: equilibrates a Hermitian matrix A using the scaling factors in the vector S.

◆ la_claqp2()

pure subroutine, public la_lapack_c::la_claqp2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	offset,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(inout)	jpvt,
		complex(sp), dimension(*), intent(out)	tau,
		real(sp), dimension(*), intent(inout)	vn1,
		real(sp), dimension(*), intent(inout)	vn2,
		complex(sp), dimension(*), intent(out)	work
	)

CLAQP2: computes a QR factorization with column pivoting of the block A(OFFSET+1:M,1:N). The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

Here is the call graph for this function:

◆ la_claqps()

pure subroutine, public la_lapack_c::la_claqps	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	offset,
		integer(ilp), intent(in)	nb,
		integer(ilp), intent(out)	kb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(inout)	jpvt,
		complex(sp), dimension(*), intent(out)	tau,
		real(sp), dimension(*), intent(inout)	vn1,
		real(sp), dimension(*), intent(inout)	vn2,
		complex(sp), dimension(*), intent(inout)	auxv,
		complex(sp), dimension(ldf,*), intent(inout)	f,
		integer(ilp), intent(in)	ldf
	)

CLAQPS: computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

Here is the call graph for this function:

◆ la_claqr0()

pure subroutine, public la_lapack_c::la_claqr0	(	logical(lk), intent(in)	wantt,
		logical(lk), intent(in)	wantz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), dimension(*), intent(out)	w,
		integer(ilp), intent(in)	iloz,
		integer(ilp), intent(in)	ihiz,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H.

Here is the call graph for this function:

◆ la_claqr1()

pure subroutine, public la_lapack_c::la_claqr1	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), intent(in)	s1,
		complex(sp), intent(in)	s2,
		complex(sp), dimension(*), intent(out)	v
	)

Given a 2-by-2 or 3-by-3 matrix H, CLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - s1*I)*(H - s2*I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.

◆ la_claqr2()

pure subroutine, public la_lapack_c::la_claqr2	(	logical(lk), intent(in)	wantt,
		logical(lk), intent(in)	wantz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ktop,
		integer(ilp), intent(in)	kbot,
		integer(ilp), intent(in)	nw,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		integer(ilp), intent(in)	iloz,
		integer(ilp), intent(in)	ihiz,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), intent(out)	ns,
		integer(ilp), intent(out)	nd,
		complex(sp), dimension(*), intent(out)	sh,
		complex(sp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(in)	nh,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		integer(ilp), intent(in)	nv,
		complex(sp), dimension(ldwv,*), intent(out)	wv,
		integer(ilp), intent(in)	ldwv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork
	)

CLAQR2: is identical to CLAQR3 except that it avoids recursion by calling CLAHQR instead of CLAQR4. Aggressive early deflation: This subroutine accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.

Here is the call graph for this function:

◆ la_claqr3()

pure subroutine, public la_lapack_c::la_claqr3	(	logical(lk), intent(in)	wantt,
		logical(lk), intent(in)	wantz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ktop,
		integer(ilp), intent(in)	kbot,
		integer(ilp), intent(in)	nw,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		integer(ilp), intent(in)	iloz,
		integer(ilp), intent(in)	ihiz,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), intent(out)	ns,
		integer(ilp), intent(out)	nd,
		complex(sp), dimension(*), intent(out)	sh,
		complex(sp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(in)	nh,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		integer(ilp), intent(in)	nv,
		complex(sp), dimension(ldwv,*), intent(out)	wv,
		integer(ilp), intent(in)	ldwv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork
	)

Aggressive early deflation: CLAQR3: accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.

Here is the call graph for this function:

◆ la_claqr4()

pure subroutine, public la_lapack_c::la_claqr4	(	logical(lk), intent(in)	wantt,
		logical(lk), intent(in)	wantz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), dimension(*), intent(out)	w,
		integer(ilp), intent(in)	iloz,
		integer(ilp), intent(in)	ihiz,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CLAQR4: implements one level of recursion for CLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by CLAQR0 and, for large enough deflation window size, it may be called by CLAQR3. This subroutine is identical to CLAQR0 except that it calls CLAQR2 instead of CLAQR3. CLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H.

Here is the call graph for this function:

◆ la_claqr5()

pure subroutine, public la_lapack_c::la_claqr5	(	logical(lk), intent(in)	wantt,
		logical(lk), intent(in)	wantz,
		integer(ilp), intent(in)	kacc22,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ktop,
		integer(ilp), intent(in)	kbot,
		integer(ilp), intent(in)	nshfts,
		complex(sp), dimension(*), intent(inout)	s,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		integer(ilp), intent(in)	iloz,
		integer(ilp), intent(in)	ihiz,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		integer(ilp), intent(in)	nv,
		complex(sp), dimension(ldwv,*), intent(out)	wv,
		integer(ilp), intent(in)	ldwv,
		integer(ilp), intent(in)	nh,
		complex(sp), dimension(ldwh,*), intent(out)	wh,
		integer(ilp), intent(in)	ldwh
	)

CLAQR5: called by CLAQR0 performs a single small-bulge multi-shift QR sweep.

Here is the call graph for this function:

◆ la_claqsb()

pure subroutine, public la_lapack_c::la_claqsb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(in)	s,
		real(sp), intent(in)	scond,
		real(sp), intent(in)	amax,
		character, intent(out)	equed
	)

CLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

◆ la_claqsp()

pure subroutine, public la_lapack_c::la_claqsp	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		real(sp), dimension(*), intent(in)	s,
		real(sp), intent(in)	scond,
		real(sp), intent(in)	amax,
		character, intent(out)	equed
	)

CLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S.

◆ la_claqsy()

pure subroutine, public la_lapack_c::la_claqsy	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(in)	s,
		real(sp), intent(in)	scond,
		real(sp), intent(in)	amax,
		character, intent(out)	equed
	)

CLAQSY: equilibrates a symmetric matrix A using the scaling factors in the vector S.

◆ la_claqz0()

recursive subroutine, public la_lapack_c::la_claqz0	(	character, intent(in)	wants,
		character, intent(in)	wantq,
		character, intent(in)	wantz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(inout)	alpha,
		complex(sp), dimension(*), intent(inout)	beta,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(inout)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	rec,
		integer(ilp), intent(out)	info
	)

CLAQZ0: computes the eigenvalues of a matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a matrix pair (A,B): A = Q1*H*Z1**H, B = Q1*T*Z1**H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**H, T = Q*P*Z**H, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**H, B = (Q1*Q)*P*(Z1*Z)**H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241–256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199–227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation".

Here is the call graph for this function:

◆ la_claqz1()

pure subroutine, public la_lapack_c::la_claqz1	(	logical(lk), intent(in)	ilq,
		logical(lk), intent(in)	ilz,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	istartm,
		integer(ilp), intent(in)	istopm,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(in)	nq,
		integer(ilp), intent(in)	qstart,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		integer(ilp), intent(in)	nz,
		integer(ilp), intent(in)	zstart,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz
	)

CLAQZ1: chases a 1x1 shift bulge in a matrix pencil down a single position.

Here is the call graph for this function:

◆ la_claqz2()

recursive subroutine, public la_lapack_c::la_claqz2	(	logical(lk), intent(in)	ilschur,
		logical(lk), intent(in)	ilq,
		logical(lk), intent(in)	ilz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		integer(ilp), intent(in)	nw,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), intent(out)	ns,
		integer(ilp), intent(out)	nd,
		complex(sp), dimension(*), intent(inout)	alpha,
		complex(sp), dimension(*), intent(inout)	beta,
		complex(sp), dimension(ldqc,*), intent(inout)	qc,
		integer(ilp), intent(in)	ldqc,
		complex(sp), dimension(ldzc,*), intent(inout)	zc,
		integer(ilp), intent(in)	ldzc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	rec,
		integer(ilp), intent(out)	info
	)

CLAQZ2: performs AED.

Here is the call graph for this function:

◆ la_claqz3()

pure subroutine, public la_lapack_c::la_claqz3	(	logical(lk), intent(in)	ilschur,
		logical(lk), intent(in)	ilq,
		logical(lk), intent(in)	ilz,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		integer(ilp), intent(in)	nshifts,
		integer(ilp), intent(in)	nblock_desired,
		complex(sp), dimension(*), intent(inout)	alpha,
		complex(sp), dimension(*), intent(inout)	beta,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension( ldqc,*), intent(inout)	qc,
		integer(ilp), intent(in)	ldqc,
		complex(sp), dimension(ldzc,*), intent(inout)	zc,
		integer(ilp), intent(in)	ldzc,
		complex(sp), dimension(*), intent(inout)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CLAQZ3: Executes a single multishift QZ sweep.

Here is the call graph for this function:

◆ la_clar1v()

pure subroutine, public la_lapack_c::la_clar1v	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	b1,
		integer(ilp), intent(in)	bn,
		real(sp), intent(in)	lambda,
		real(sp), dimension(*), intent(in)	d,
		real(sp), dimension(*), intent(in)	l,
		real(sp), dimension(*), intent(in)	ld,
		real(sp), dimension(*), intent(in)	lld,
		real(sp), intent(in)	pivmin,
		real(sp), intent(in)	gaptol,
		complex(sp), dimension(*), intent(inout)	z,
		logical(lk), intent(in)	wantnc,
		integer(ilp), intent(out)	negcnt,
		real(sp), intent(out)	ztz,
		real(sp), intent(out)	mingma,
		integer(ilp), intent(inout)	r,
		integer(ilp), dimension(*), intent(out)	isuppz,
		real(sp), intent(out)	nrminv,
		real(sp), intent(out)	resid,
		real(sp), intent(out)	rqcorr,
		real(sp), dimension(*), intent(out)	work
	)

CLAR1V: computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D L**T - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D L**T - sigma I = L(+) D(+) L(+)**T, (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T, (c) Computation of the diagonal elements of the inverse of L D L**T - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.

◆ la_clar2v()

pure subroutine, public la_lapack_c::la_clar2v	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	x,
		complex(sp), dimension(*), intent(inout)	y,
		complex(sp), dimension(*), intent(inout)	z,
		integer(ilp), intent(in)	incx,
		real(sp), dimension(*), intent(in)	c,
		complex(sp), dimension(*), intent(in)	s,
		integer(ilp), intent(in)	incc
	)

CLAR2V: applies a vector of complex plane rotations with real cosines from both sides to a sequence of 2-by-2 complex Hermitian matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( conjg(z(i)) y(i) ) ( c(i) conjg(s(i)) ) ( x(i) z(i) ) ( c(i) -conjg(s(i)) ) ( -s(i) c(i) ) ( conjg(z(i)) y(i) ) ( s(i) c(i) )

◆ la_clarcm()

pure subroutine, public la_lapack_c::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.

◆ la_clarf()

pure subroutine, public la_lapack_c::la_clarf	(	character, intent(in)	side,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	v,
		integer(ilp), intent(in)	incv,
		complex(sp), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work
	)

CLARF: applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**H where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply H**H (the conjugate transpose of H), supply conjg(tau) instead tau.

◆ la_clarfb()

pure subroutine, public la_lapack_c::la_clarfb	(	character, intent(in)	side,
		character, intent(in)	trans,
		character, intent(in)	direct,
		character, intent(in)	storev,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(ldv,*), intent(in)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork
	)

CLARFB: applies a complex block reflector H or its transpose H**H to a complex M-by-N matrix C, from either the left or the right.

Here is the call graph for this function:

◆ la_clarfb_gett()

pure subroutine, public la_lapack_c::la_clarfb_gett	(	character, intent(in)	ident,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork
	)

CLARFB_GETT: applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

◆ la_clarfg()

pure subroutine, public la_lapack_c::la_clarfg	(	integer(ilp), intent(in)	n,
		complex(sp), intent(inout)	alpha,
		complex(sp), dimension(*), intent(inout)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), intent(out)	tau
	)

CLARFG: generates a complex elementary reflector H of order n, such that H**H * ( alpha ) = ( beta ), H**H * H = I. ( x ) ( 0 ) where alpha and beta are scalars, with beta real, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1 .

Here is the call graph for this function:

◆ la_clarfgp()

subroutine, public la_lapack_c::la_clarfgp	(	integer(ilp), intent(in)	n,
		complex(sp), intent(inout)	alpha,
		complex(sp), dimension(*), intent(inout)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), intent(out)	tau
	)

CLARFGP: generates a complex elementary reflector H of order n, such that H**H * ( alpha ) = ( beta ), H**H * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is real and non-negative, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix.

Here is the call graph for this function:

◆ la_clarft()

pure subroutine, public la_lapack_c::la_clarft	(	character, intent(in)	direct,
		character, intent(in)	storev,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(ldv,*), intent(in)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt
	)

CLARFT: forms the triangular factor T of a complex block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**H If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**H * T * V.

◆ la_clarfx()

pure subroutine, public la_lapack_c::la_clarfx	(	character, intent(in)	side,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	v,
		complex(sp), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work
	)

CLARFX: applies a complex elementary reflector H to a complex m by n matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**H where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix This version uses inline code if H has order < 11.

Here is the call graph for this function:

◆ la_clarfy()

pure subroutine, public la_lapack_c::la_clarfy	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	v,
		integer(ilp), intent(in)	incv,
		complex(sp), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work
	)

CLARFY: applies an elementary reflector, or Householder matrix, H, to an n x n Hermitian matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.

◆ la_clargv()

pure subroutine, public la_lapack_c::la_clargv	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy,
		real(sp), dimension(*), intent(out)	c,
		integer(ilp), intent(in)	incc
	)

CLARGV: generates a vector of complex plane rotations with real cosines, determined by elements of the complex vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( r(i) ) ( -conjg(s(i)) c(i) ) ( y(i) ) = ( 0 ) where c(i)**2 + ABS(s(i))**2 = 1 The following conventions are used (these are the same as in CLARTG, but differ from the BLAS1 routine CROTG): If y(i)=0, then c(i)=1 and s(i)=0. If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real.

◆ la_clarnv()

pure subroutine, public la_lapack_c::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.

◆ la_clarrv()

pure subroutine, public la_lapack_c::la_clarrv	(	integer(ilp), intent(in)	n,
		real(sp), intent(in)	vl,
		real(sp), intent(in)	vu,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	l,
		real(sp), intent(in)	pivmin,
		integer(ilp), dimension(*), intent(in)	isplit,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	dol,
		integer(ilp), intent(in)	dou,
		real(sp), intent(in)	minrgp,
		real(sp), intent(inout)	rtol1,
		real(sp), intent(inout)	rtol2,
		real(sp), dimension(*), intent(inout)	w,
		real(sp), dimension(*), intent(inout)	werr,
		real(sp), dimension(*), intent(inout)	wgap,
		integer(ilp), dimension(*), intent(in)	iblock,
		integer(ilp), dimension(*), intent(in)	indexw,
		real(sp), dimension(*), intent(in)	gers,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), dimension(*), intent(out)	isuppz,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CLARRV: computes the eigenvectors of the tridiagonal matrix T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T. The input eigenvalues should have been computed by SLARRE.

Here is the call graph for this function:

◆ la_clartg()

pure subroutine, public la_lapack_c::la_clartg	(	complex(sp), intent(in)	f,
		complex(sp), intent(in)	g,
		real(sp), intent(out)	c,
		complex(sp), intent(out)	s,
		complex(sp), intent(out)	r
	)

!

CLARTG: generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -conjg(S) C ] [ G ] [ 0 ] where C is real and C**2 + |S|**2 = 1. The mathematical formulas used for C and S are sgn(x) = { x / |x|, x != 0 { 1, x = 0 R = sgn(F) * sqrt(|F|**2 + |G|**2) C = |F| / sqrt(|F|**2 + |G|**2) S = sgn(F) * conjg(G) / sqrt(|F|**2 + |G|**2) When F and G are real, the formulas simplify to C = F/R and S = G/R, and the returned values of C, S, and R should be identical to those returned by CLARTG. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This is a faster version of the BLAS1 routine CROTG, except for the following differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0, then C=0 and S is chosen so that R is real. Below, wp=>sp stands for single precision from LA_CONSTANTS module.

◆ la_clartv()

pure subroutine, public la_lapack_c::la_clartv	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy,
		real(sp), dimension(*), intent(in)	c,
		complex(sp), dimension(*), intent(in)	s,
		integer(ilp), intent(in)	incc
	)

CLARTV: applies a vector of complex plane rotations with real cosines to elements of the complex vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -conjg(s(i)) c(i) ) ( y(i) )

◆ la_clarz()

pure subroutine, public la_lapack_c::la_clarz	(	character, intent(in)	side,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	l,
		complex(sp), dimension(*), intent(in)	v,
		integer(ilp), intent(in)	incv,
		complex(sp), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work
	)

CLARZ: applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**H where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply H**H (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by CTZRZF.

Here is the call graph for this function:

◆ la_clarzb()

pure subroutine, public la_lapack_c::la_clarzb	(	character, intent(in)	side,
		character, intent(in)	trans,
		character, intent(in)	direct,
		character, intent(in)	storev,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	l,
		complex(sp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork
	)

CLARZB: applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

Here is the call graph for this function:

◆ la_clarzt()

pure subroutine, public la_lapack_c::la_clarzt	(	character, intent(in)	direct,
		character, intent(in)	storev,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt
	)

CLARZT: forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**H If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**H * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

Here is the call graph for this function:

◆ la_clascl()

pure subroutine, public la_lapack_c::la_clascl	(	character, intent(in)	type,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		real(sp), intent(in)	cfrom,
		real(sp), intent(in)	cto,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info
	)

CLASCL: multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.

◆ la_claset()

pure subroutine, public la_lapack_c::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.

◆ la_clasr()

pure subroutine, public la_lapack_c::la_clasr	(	character, intent(in)	side,
		character, intent(in)	pivot,
		character, intent(in)	direct,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(in)	c,
		real(sp), dimension(*), intent(in)	s,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda
	)

CLASR: applies a sequence of real plane rotations to a complex matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := P*A and when SIDE = 'R', the transformation takes the form A := A*P**T where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and P**T is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.

◆ la_classq()

pure subroutine, public la_lapack_c::la_classq	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(sp), intent(inout)	scl,
		real(sp), intent(inout)	sumsq
	)

!

CLASSQ: returns the values scl and smsq such that ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, where x( i ) = X( 1 + ( i - 1 )*INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINY*EPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig – upper threshold for values whose square is representable; sbig – scaling constant for big numbers;

See also: la_constants.f90 tsml – lower threshold for values whose square is representable; ssml – scaling constant for small numbers;; la_constants.f90 and TINY*EPS – tiniest representable number; HUGE – biggest representable number.

◆ la_claswlq()

pure subroutine, public la_lapack_c::la_claswlq	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	mb,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CLASWLQ: computes a blocked Tall-Skinny LQ factorization of a complex M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.

Here is the call graph for this function:

◆ la_claswp()

pure subroutine, public la_lapack_c::la_claswp	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(in)	k1,
		integer(ilp), intent(in)	k2,
		integer(ilp), dimension(*), intent(in)	ipiv,
		integer(ilp), intent(in)	incx
	)

CLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

◆ la_clasyf()

pure subroutine, public la_lapack_c::la_clasyf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		integer(ilp), intent(out)	kb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldw,*), intent(out)	w,
		integer(ilp), intent(in)	ldw,
		integer(ilp), intent(out)	info
	)

CLASYF: computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**T U22**T ) A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. CLASYF is an auxiliary routine called by CSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

◆ la_clasyf_aa()

pure subroutine, public la_lapack_c::la_clasyf_aa	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	j1,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), dimension(*), intent(out)	work
	)

DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

Here is the call graph for this function:

◆ la_clasyf_rk()

pure subroutine, public la_lapack_c::la_clasyf_rk	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		integer(ilp), intent(out)	kb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	e,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldw,*), intent(out)	w,
		integer(ilp), intent(in)	ldw,
		integer(ilp), intent(out)	info
	)

CLASYF_RK: computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**T U22**T ) A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLASYF_RK is an auxiliary routine called by CSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

◆ la_clasyf_rook()

pure subroutine, public la_lapack_c::la_clasyf_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		integer(ilp), intent(out)	kb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldw,*), intent(out)	w,
		integer(ilp), intent(in)	ldw,
		integer(ilp), intent(out)	info
	)

CLASYF_ROOK: computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**T U22**T ) A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLASYF_ROOK is an auxiliary routine called by CSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

◆ la_clatbs()

pure subroutine, public la_lapack_c::la_clatbs	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		character, intent(in)	normin,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(*), intent(inout)	x,
		real(sp), intent(out)	scale,
		real(sp), dimension(*), intent(inout)	cnorm,
		integer(ilp), intent(out)	info
	)

CLATBS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_clatdf()

pure subroutine, public la_lapack_c::la_clatdf	(	integer(ilp), intent(in)	ijob,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(inout)	rhs,
		real(sp), intent(inout)	rdsum,
		real(sp), intent(inout)	rdscal,
		integer(ilp), dimension(*), intent(in)	ipiv,
		integer(ilp), dimension(*), intent(in)	jpiv
	)

CLATDF: computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by CGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by CGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.

Here is the call graph for this function:

◆ la_clatps()

pure subroutine, public la_lapack_c::la_clatps	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		character, intent(in)	normin,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(*), intent(inout)	x,
		real(sp), intent(out)	scale,
		real(sp), dimension(*), intent(inout)	cnorm,
		integer(ilp), intent(out)	info
	)

CLATPS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here A**T denotes the transpose of A, A**H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_clatrd()

pure subroutine, public la_lapack_c::la_clatrd	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	e,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(ldw,*), intent(out)	w,
		integer(ilp), intent(in)	ldw
	)

CLATRD: reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q**H * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', CLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', CLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by CHETRD.

Here is the call graph for this function:

◆ la_clatrs()

pure subroutine, public la_lapack_c::la_clatrs	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		character, intent(in)	normin,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(inout)	x,
		real(sp), intent(out)	scale,
		real(sp), dimension(*), intent(inout)	cnorm,
		integer(ilp), intent(out)	info
	)

CLATRS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, A**T denotes the transpose of A, A**H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_clatrz()

pure subroutine, public la_lapack_c::la_clatrz	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	l,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work
	)

CLATRZ: factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.

Here is the call graph for this function:

◆ la_clatsqr()

pure subroutine, public la_lapack_c::la_clatsqr	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	mb,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CLATSQR: computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

Here is the call graph for this function:

◆ la_claunhr_col_getrfnp()

pure subroutine, public la_lapack_c::la_claunhr_col_getrfnp	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	d,
		integer(ilp), intent(out)	info
	)

CLAUNHR_COL_GETRFNP: computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine CLAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

Here is the call graph for this function:

◆ la_claunhr_col_getrfnp2()

pure recursive subroutine, public la_lapack_c::la_claunhr_col_getrfnp2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	d,
		integer(ilp), intent(out)	info
	)

CLAUNHR_COL_GETRFNP2: computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ --—|--— ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. CLAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine CLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, CLAUNHR_COL_GETRFNP2 is self-sufficient and can be used without CLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

Here is the call graph for this function:

◆ la_clauu2()

pure subroutine, public la_lapack_c::la_clauu2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info
	)

CLAUU2: computes the product U * U**H or L**H * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the unblocked form of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_clauum()

pure subroutine, public la_lapack_c::la_clauum	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info
	)

CLAUUM: computes the product U * U**H or L**H * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_cpbcon()

pure subroutine, public la_lapack_c::la_cpbcon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_cpbequ()

pure subroutine, public la_lapack_c::la_cpbequ	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(out)	s,
		real(sp), intent(out)	scond,
		real(sp), intent(out)	amax,
		integer(ilp), intent(out)	info
	)

CPBEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

◆ la_cpbrfs()

pure subroutine, public la_lapack_c::la_cpbrfs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldafb,*), intent(in)	afb,
		integer(ilp), intent(in)	ldafb,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_cpbstf()

pure subroutine, public la_lapack_c::la_cpbstf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), intent(out)	info
	)

CPBSTF: computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with CHBGST. The factorization has the form A = S**H*S where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.

Here is the call graph for this function:

◆ la_cpbsv()

pure subroutine, public la_lapack_c::la_cpbsv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CPBSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_cpbsvx()

subroutine, public la_lapack_c::la_cpbsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	s,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPBSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_cpbtf2()

pure subroutine, public la_lapack_c::la_cpbtf2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), intent(out)	info
	)

CPBTF2: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix, U**H is the conjugate transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_cpbtrf()

pure subroutine, public la_lapack_c::la_cpbtrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), intent(out)	info
	)

CPBTRF: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

Here is the call graph for this function:

◆ la_cpbtrs()

pure subroutine, public la_lapack_c::la_cpbtrs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CPBTRS: solves a system of linear equations A*X = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPBTRF.

◆ la_cpftrf()

pure subroutine, public la_lapack_c::la_cpftrf	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(0:*), intent(inout)	a,
		integer(ilp), intent(out)	info
	)

CPFTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_cpftri()

pure subroutine, public la_lapack_c::la_cpftri	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(0:*), intent(inout)	a,
		integer(ilp), intent(out)	info
	)

CPFTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPFTRF.

Here is the call graph for this function:

◆ la_cpftrs()

pure subroutine, public la_lapack_c::la_cpftrs	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(0:*), intent(in)	a,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CPFTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPFTRF.

Here is the call graph for this function:

◆ la_cpocon()

pure subroutine, public la_lapack_c::la_cpocon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_cpoequ()

pure subroutine, public la_lapack_c::la_cpoequ	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		real(sp), intent(out)	scond,
		real(sp), intent(out)	amax,
		integer(ilp), intent(out)	info
	)

CPOEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

◆ la_cpoequb()

pure subroutine, public la_lapack_c::la_cpoequb	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		real(sp), intent(out)	scond,
		real(sp), intent(out)	amax,
		integer(ilp), intent(out)	info
	)

CPOEQUB: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from CPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

◆ la_cporfs()

pure subroutine, public la_lapack_c::la_cporfs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_cposv()

pure subroutine, public la_lapack_c::la_cposv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**H* U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_cposvx()

subroutine, public la_lapack_c::la_cposvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	s,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPOSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_cpotf2()

pure subroutine, public la_lapack_c::la_cpotf2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info
	)

CPOTF2: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_cpotrf()

pure subroutine, public la_lapack_c::la_cpotrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info
	)

CPOTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_cpotrf2()

pure recursive subroutine, public la_lapack_c::la_cpotrf2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info
	)

CPOTRF2: computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.

Here is the call graph for this function:

◆ la_cpotri()

pure subroutine, public la_lapack_c::la_cpotri	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info
	)

CPOTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPOTRF.

Here is the call graph for this function:

◆ la_cpotrs()

pure subroutine, public la_lapack_c::la_cpotrs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CPOTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPOTRF.

◆ la_cppcon()

pure subroutine, public la_lapack_c::la_cppcon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_cppequ()

pure subroutine, public la_lapack_c::la_cppequ	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		real(sp), dimension(*), intent(out)	s,
		real(sp), intent(out)	scond,
		real(sp), intent(out)	amax,
		integer(ilp), intent(out)	info
	)

CPPEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.

◆ la_cpprfs()

pure subroutine, public la_lapack_c::la_cpprfs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(*), intent(in)	afp,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_cppsv()

pure subroutine, public la_lapack_c::la_cppsv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(inout)	ap,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CPPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_cppsvx()

subroutine, public la_lapack_c::la_cppsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(inout)	ap,
		complex(sp), dimension(*), intent(inout)	afp,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	s,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPPSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_cpptrf()

pure subroutine, public la_lapack_c::la_cpptrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		integer(ilp), intent(out)	info
	)

CPPTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.

◆ la_cpptri()

pure subroutine, public la_lapack_c::la_cpptri	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		integer(ilp), intent(out)	info
	)

CPPTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPPTRF.

Here is the call graph for this function:

◆ la_cpptrs()

pure subroutine, public la_lapack_c::la_cpptrs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CPPTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPPTRF.

◆ la_cpstf2()

pure subroutine, public la_lapack_c::la_cpstf2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(n), intent(out)	piv,
		integer(ilp), intent(out)	rank,
		real(sp), intent(in)	tol,
		real(sp), dimension(2*n), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CPSTF2: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS.

Here is the call graph for this function:

◆ la_cpstrf()

pure subroutine, public la_lapack_c::la_cpstrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(n), intent(out)	piv,
		integer(ilp), intent(out)	rank,
		real(sp), intent(in)	tol,
		real(sp), dimension(2*n), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CPSTRF: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.

Here is the call graph for this function:

◆ la_cptcon()

pure subroutine, public la_lapack_c::la_cptcon	(	integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	e,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPTCON: computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = L*D*L**H or A = U**H*D*U computed by CPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

◆ la_cpteqr()

pure subroutine, public la_lapack_c::la_cpteqr	(	character, intent(in)	compz,
		integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	e,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CPTEQR: computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using SPTTRF and then calling CBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band positive definite Hermitian matrix can also be found if CHETRD, CHPTRD, or CHBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)

Here is the call graph for this function:

◆ la_cptrfs()

pure subroutine, public la_lapack_c::la_cptrfs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	e,
		real(sp), dimension(*), intent(in)	df,
		complex(sp), dimension(*), intent(in)	ef,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_cptsv()

pure subroutine, public la_lapack_c::la_cptsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(*), intent(inout)	e,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CPTSV: computes the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**H, and the factored form of A is then used to solve the system of equations.

Here is the call graph for this function:

◆ la_cptsvx()

pure subroutine, public la_lapack_c::la_cptsvx	(	character, intent(in)	fact,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	e,
		real(sp), dimension(*), intent(inout)	df,
		complex(sp), dimension(*), intent(inout)	ef,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CPTSVX: uses the factorization A = L*D*L**H to compute the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_cpttrf()

pure subroutine, public la_lapack_c::la_cpttrf	(	integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(*), intent(inout)	e,
		integer(ilp), intent(out)	info
	)

CPTTRF: computes the L*D*L**H factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**H *D*U.

◆ la_cpttrs()

pure subroutine, public la_lapack_c::la_cpttrs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	e,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CPTTRS: solves a tridiagonal system of the form A * X = B using the factorization A = U**H*D*U or A = L*D*L**H computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.

Here is the call graph for this function:

◆ la_cptts2()

pure subroutine, public la_lapack_c::la_cptts2	(	integer(ilp), intent(in)	iuplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	e,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb
	)

CPTTS2: solves a tridiagonal system of the form A * X = B using the factorization A = U**H*D*U or A = L*D*L**H computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.

◆ la_crot()

pure subroutine, public la_lapack_c::la_crot	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	cx,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(inout)	cy,
		integer(ilp), intent(in)	incy,
		real(sp), intent(in)	c,
		complex(sp), intent(in)	s
	)

CROT: applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

◆ la_cspcon()

pure subroutine, public la_lapack_c::la_cspcon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CSPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_cspmv()

pure subroutine, public la_lapack_c::la_cspmv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), intent(in)	beta,
		complex(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy
	)

CSPMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

◆ la_cspr()

pure subroutine, public la_lapack_c::la_cspr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(inout)	ap
	)

CSPR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.

◆ la_csprfs()

pure subroutine, public la_lapack_c::la_csprfs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(*), intent(in)	afp,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CSPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_cspsv()

pure subroutine, public la_lapack_c::la_cspsv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(inout)	ap,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CSPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * U**T, if UPLO = 'U', or A = L * D * L**T, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_cspsvx()

subroutine, public la_lapack_c::la_cspsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(*), intent(inout)	afp,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CSPSVX: uses the diagonal pivoting factorization A = U*D*U**T or A = L*D*L**T to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_csptrf()

pure subroutine, public la_lapack_c::la_csptrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CSPTRF: computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

Here is the call graph for this function:

◆ la_csptri()

pure subroutine, public la_lapack_c::la_csptri	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CSPTRI: computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = U*D*U**T or A = L*D*L**T computed by CSPTRF.

Here is the call graph for this function:

◆ la_csptrs()

pure subroutine, public la_lapack_c::la_csptrs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	ap,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CSPTRS: solves a system of linear equations A*X = B with a complex symmetric matrix A stored in packed format using the factorization A = U*D*U**T or A = L*D*L**T computed by CSPTRF.

◆ la_csrscl()

pure subroutine, public la_lapack_c::la_csrscl	(	integer(ilp), intent(in)	n,
		real(sp), intent(in)	sa,
		complex(sp), dimension(*), intent(inout)	sx,
		integer(ilp), intent(in)	incx
	)

CSRSCL: multiplies an n-element complex vector x by the real scalar 1/a. This is done without overflow or underflow as long as the final result x/a does not overflow or underflow.

◆ la_cstedc()

pure subroutine, public la_lapack_c::la_cstedc	(	character, intent(in)	compz,
		integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	e,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CSTEDC: computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See SLAED3 for details.

Here is the call graph for this function:

◆ la_cstegr()

pure subroutine, public la_lapack_c::la_cstegr	(	character, intent(in)	jobz,
		character, intent(in)	range,
		integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	e,
		real(sp), intent(in)	vl,
		real(sp), intent(in)	vu,
		integer(ilp), intent(in)	il,
		integer(ilp), intent(in)	iu,
		real(sp), intent(in)	abstol,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), dimension(*), intent(out)	isuppz,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CSTEGR: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. CSTEGR is a compatibility wrapper around the improved CSTEMR routine. See SSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : CSTEGR and CSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.

Here is the call graph for this function:

◆ la_cstein()

pure subroutine, public la_lapack_c::la_cstein	(	integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(in)	d,
		real(sp), dimension(*), intent(in)	e,
		integer(ilp), intent(in)	m,
		real(sp), dimension(*), intent(in)	w,
		integer(ilp), dimension(*), intent(in)	iblock,
		integer(ilp), dimension(*), intent(in)	isplit,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), dimension(*), intent(out)	ifail,
		integer(ilp), intent(out)	info
	)

CSTEIN: computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5). Although the eigenvectors are real, they are stored in a complex array, which may be passed to CUNMTR or CUPMTR for back transformation to the eigenvectors of a complex Hermitian matrix which was reduced to tridiagonal form.

◆ la_cstemr()

pure subroutine, public la_lapack_c::la_cstemr	(	character, intent(in)	jobz,
		character, intent(in)	range,
		integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	e,
		real(sp), intent(in)	vl,
		real(sp), intent(in)	vu,
		integer(ilp), intent(in)	il,
		integer(ilp), intent(in)	iu,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	w,
		complex(sp), dimension(ldz,*), intent(out)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), intent(in)	nzc,
		integer(ilp), dimension(*), intent(out)	isuppz,
		logical(lk), intent(inout)	tryrac,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CSTEMR: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see:

Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,

Also LAPACK Working Note 154.

Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.CSTEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors.

LAPACK routines can be used to reduce a complex Hermitean matrix to real symmetric tridiagonal form. (Any complex Hermitean tridiagonal matrix has real values on its diagonal and potentially complex numbers on its off-diagonals. By applying a similarity transform with an appropriate diagonal matrix diag(1,e^{i \phy_1}, ... , e^{i \phy_{n-1}}), the complex Hermitean matrix can be transformed into a real symmetric matrix and complex arithmetic can be entirely avoided.) While the eigenvectors of the real symmetric tridiagonal matrix are real, the eigenvectors of original complex Hermitean matrix have complex entries in general. Since LAPACK drivers overwrite the matrix data with the eigenvectors, CSTEMR accepts complex workspace to facilitate interoperability with CUNMTR or CUPMTR.

Here is the call graph for this function:

◆ la_csteqr()

pure subroutine, public la_lapack_c::la_csteqr	(	character, intent(in)	compz,
		integer(ilp), intent(in)	n,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	e,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CSTEQR: computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form.

Here is the call graph for this function:

◆ la_csycon()

pure subroutine, public la_lapack_c::la_csycon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CSYCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_csycon_rook()

pure subroutine, public la_lapack_c::la_csycon_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(sp), intent(in)	anorm,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CSYCON_ROOK: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_csyconv()

pure subroutine, public la_lapack_c::la_csyconv	(	character, intent(in)	uplo,
		character, intent(in)	way,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(*), intent(out)	e,
		integer(ilp), intent(out)	info
	)

CSYCONV: convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.

◆ la_csyconvf()

pure subroutine, public la_lapack_c::la_csyconvf	(	character, intent(in)	uplo,
		character, intent(in)	way,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(inout)	e,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		integer(ilp), intent(out)	info
	)

If parameter WAY = 'C': CSYCONVF: converts the factorization output format used in CSYTRF provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF into the format used in CSYTRF_RK (or CSYTRF_BK). If parameter WAY = 'R': CSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF_RK (or CSYTRF_BK) into the format used in CSYTRF. CSYCONVF can also convert in Hermitian matrix case, i.e. between formats used in CHETRF and CHETRF_RK (or CHETRF_BK).

◆ la_csyconvf_rook()

pure subroutine, public la_lapack_c::la_csyconvf_rook	(	character, intent(in)	uplo,
		character, intent(in)	way,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(inout)	e,
		integer(ilp), dimension(*), intent(in)	ipiv,
		integer(ilp), intent(out)	info
	)

If parameter WAY = 'C': CSYCONVF_ROOK: converts the factorization output format used in CSYTRF_ROOK provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': CSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF_ROOK that is stored on exit in parameter A. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. CSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in CHETRF_ROOK and CHETRF_RK (or CHETRF_BK).

◆ la_csyequb()

pure subroutine, public la_lapack_c::la_csyequb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		real(sp), intent(out)	scond,
		real(sp), intent(out)	amax,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CSYEQUB: computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

Here is the call graph for this function:

◆ la_csymv()

pure subroutine, public la_lapack_c::la_csymv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), intent(in)	beta,
		complex(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy
	)

CSYMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.

◆ la_csyr()

pure subroutine, public la_lapack_c::la_csyr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda
	)

CSYR: performs the symmetric rank 1 operation A := alpha*x*x**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.

◆ la_csyrfs()

pure subroutine, public la_lapack_c::la_csyrfs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CSYRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_csysv()

pure subroutine, public la_lapack_c::la_csysv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CSYSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * U**T, if UPLO = 'U', or A = L * D * L**T, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_csysv_aa()

pure subroutine, public la_lapack_c::la_csysv_aa	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = U**T * T * U, if UPLO = 'U', or A = L * T * L**T, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_csysv_rk()

pure subroutine, public la_lapack_c::la_csysv_rk	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	e,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CSYSV_RK: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = P*U*D*(U**T)*(P**T), if UPLO = 'U', or A = P*L*D*(L**T)*(P**T), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, U**T (or L**T) is the transpose of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_RK is called to compute the factorization of a complex symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CSYTRS_3.

Here is the call graph for this function:

◆ la_csysv_rook()

pure subroutine, public la_lapack_c::la_csysv_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CSYSV_ROOK: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * U**T, if UPLO = 'U', or A = L * D * L**T, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_ROOK is called to compute the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling CSYTRS_ROOK.

Here is the call graph for this function:

◆ la_csysvx()

subroutine, public la_lapack_c::la_csysvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CSYSVX: uses the diagonal pivoting factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_csyswapr()

pure subroutine, public la_lapack_c::la_csyswapr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,n), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(in)	i1,
		integer(ilp), intent(in)	i2
	)

CSYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix.

◆ la_csytf2()

pure subroutine, public la_lapack_c::la_csytf2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CSYTF2: computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_csytf2_rk()

pure subroutine, public la_lapack_c::la_csytf2_rk	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	e,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CSYTF2_RK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**T (or L**T) is the transpose of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.

Here is the call graph for this function:

◆ la_csytf2_rook()

pure subroutine, public la_lapack_c::la_csytf2_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info
	)

CSYTF2_ROOK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_csytrf()

pure subroutine, public la_lapack_c::la_csytrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CSYTRF: computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_csytrf_aa()

pure subroutine, public la_lapack_c::la_csytrf_aa	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CSYTRF_AA: computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = U**T*T*U or A = L*T*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_csytrf_rk()

pure subroutine, public la_lapack_c::la_csytrf_rk	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	e,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CSYTRF_RK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**T (or L**T) is the transpose of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.

Here is the call graph for this function:

◆ la_csytrf_rook()

pure subroutine, public la_lapack_c::la_csytrf_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CSYTRF_ROOK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_csytri()

pure subroutine, public la_lapack_c::la_csytri	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CSYTRI: computes the inverse of a complex symmetric indefinite matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF.

Here is the call graph for this function:

◆ la_csytri_rook()

pure subroutine, public la_lapack_c::la_csytri_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CSYTRI_ROOK: computes the inverse of a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF_ROOK.

Here is the call graph for this function:

◆ la_csytrs()

pure subroutine, public la_lapack_c::la_csytrs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CSYTRS: solves a system of linear equations A*X = B with a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF.

◆ la_csytrs2()

pure subroutine, public la_lapack_c::la_csytrs2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CSYTRS2: solves a system of linear equations A*X = B with a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF and converted by CSYCONV.

Here is the call graph for this function:

◆ la_csytrs_3()

pure subroutine, public la_lapack_c::la_csytrs_3	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	e,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CSYTRS_3: solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by CSYTRF_RK or CSYTRF_BK: A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**T (or L**T) is the transpose of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

◆ la_csytrs_aa()

pure subroutine, public la_lapack_c::la_csytrs_aa	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CSYTRS_AA: solves a system of linear equations A*X = B with a complex symmetric matrix A using the factorization A = U**T*T*U or A = L*T*L**T computed by CSYTRF_AA.

Here is the call graph for this function:

◆ la_csytrs_rook()

pure subroutine, public la_lapack_c::la_csytrs_rook	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CSYTRS_ROOK: solves a system of linear equations A*X = B with a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF_ROOK.

◆ la_ctbcon()

subroutine, public la_lapack_c::la_ctbcon	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CTBCON: estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_ctbrfs()

pure subroutine, public la_lapack_c::la_ctbrfs	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(in)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CTBRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by CTBTRS or some other means before entering this routine. CTBRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_ctbtrs()

pure subroutine, public la_lapack_c::la_ctbtrs	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(in)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CTBTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

◆ la_ctfsm()

pure subroutine, public la_lapack_c::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.

◆ la_ctftri()

pure subroutine, public la_lapack_c::la_ctftri	(	character, intent(in)	transr,
		character, intent(in)	uplo,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(0:*), intent(inout)	a,
		integer(ilp), intent(out)	info
	)

CTFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_ctfttp()

pure subroutine, public la_lapack_c::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).

◆ la_ctfttr()

pure subroutine, public la_lapack_c::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).

◆ la_ctgevc()

pure subroutine, public la_lapack_c::la_ctgevc	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lds,*), intent(in)	s,
		integer(ilp), intent(in)	lds,
		complex(sp), dimension(ldp,*), intent(in)	p,
		integer(ilp), intent(in)	ldp,
		complex(sp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CTGEVC: computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = Q*S*Z**H, B = Q*P*Z**H as computed by CGGHRD + CHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B).

Here is the call graph for this function:

◆ la_ctgex2()

pure subroutine, public la_lapack_c::la_ctgex2	(	logical(lk), intent(in)	wantq,
		logical(lk), intent(in)	wantz,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), intent(in)	j1,
		integer(ilp), intent(out)	info
	)

CTGEX2: swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22) in an upper triangular matrix pair (A, B) by an unitary equivalence transformation. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H.

Here is the call graph for this function:

◆ la_ctgexc()

pure subroutine, public la_lapack_c::la_ctgexc	(	logical(lk), intent(in)	wantq,
		logical(lk), intent(in)	wantz,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), intent(in)	ifst,
		integer(ilp), intent(inout)	ilst,
		integer(ilp), intent(out)	info
	)

CTGEXC: reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * Z**H, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H.

Here is the call graph for this function:

◆ la_ctgsen()

pure subroutine, public la_lapack_c::la_ctgsen	(	integer(ilp), intent(in)	ijob,
		logical(lk), intent(in)	wantq,
		logical(lk), intent(in)	wantz,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	alpha,
		complex(sp), dimension(*), intent(out)	beta,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldz,*), intent(inout)	z,
		integer(ilp), intent(in)	ldz,
		integer(ilp), intent(out)	m,
		real(sp), intent(out)	pl,
		real(sp), intent(out)	pr,
		real(sp), dimension(*), intent(out)	dif,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info
	)

CTGSEN: reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. CTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.

Here is the call graph for this function:

◆ la_ctgsja()

pure subroutine, public la_lapack_c::la_ctgsja	(	character, intent(in)	jobu,
		character, intent(in)	jobv,
		character, intent(in)	jobq,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	l,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), intent(in)	tola,
		real(sp), intent(in)	tolb,
		real(sp), dimension(*), intent(out)	alpha,
		real(sp), dimension(*), intent(out)	beta,
		complex(sp), dimension(ldu,*), intent(inout)	u,
		integer(ilp), intent(in)	ldu,
		complex(sp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	ncycle,
		integer(ilp), intent(out)	info
	)

CTGSJA: computes the generalized singular value decomposition (GSVD) of two complex upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine CGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, U**H A*Q = D1( 0 R ), V**H B*Q = D2( 0 R ), where U, V and Q are unitary matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are `‘diagonal’' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C**2 + S**2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C**2 + S**2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the unitary transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.

Here is the call graph for this function:

◆ la_ctgsna()

pure subroutine, public la_lapack_c::la_ctgsna	(	character, intent(in)	job,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		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), dimension(ldvl,*), intent(in)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(in)	vr,
		integer(ilp), intent(in)	ldvr,
		real(sp), dimension(*), intent(out)	s,
		real(sp), dimension(*), intent(out)	dif,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.

Here is the call graph for this function:

◆ la_ctgsy2()

pure subroutine, public la_lapack_c::la_ctgsy2	(	character, intent(in)	trans,
		integer(ilp), intent(in)	ijob,
		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(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(ldd,*), intent(in)	d,
		integer(ilp), intent(in)	ldd,
		complex(sp), dimension(lde,*), intent(in)	e,
		integer(ilp), intent(in)	lde,
		complex(sp), dimension(ldf,*), intent(inout)	f,
		integer(ilp), intent(in)	ldf,
		real(sp), intent(out)	scale,
		real(sp), intent(inout)	rdsum,
		real(sp), intent(inout)	rdscal,
		integer(ilp), intent(out)	info
	)

CTGSY2: solves the generalized Sylvester equation A * R - L * B = scale * C (1) D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Zx = scale * b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Ik is the identity matrix of size k and X**H is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H*y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = = sigma_min(Z) using reverse communication with CLACON. CTGSY2 also (IJOB >= 1) contributes to the computation in CTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of two matrix pairs in CTGSYL.

Here is the call graph for this function:

◆ la_ctgsyl()

pure subroutine, public la_lapack_c::la_ctgsyl	(	character, intent(in)	trans,
		integer(ilp), intent(in)	ijob,
		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(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(ldd,*), intent(in)	d,
		integer(ilp), intent(in)	ldd,
		complex(sp), dimension(lde,*), intent(in)	e,
		integer(ilp), intent(in)	lde,
		complex(sp), dimension(ldf,*), intent(inout)	f,
		integer(ilp), intent(in)	ldf,
		real(sp), intent(out)	scale,
		real(sp), intent(out)	dif,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Here Ix is the identity matrix of size x and X**H is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H *y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using CLACON. If IJOB >= 1, CTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.

Here is the call graph for this function:

◆ la_ctpcon()

subroutine, public la_lapack_c::la_ctpcon	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CTPCON: estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_ctplqt()

pure subroutine, public la_lapack_c::la_ctplqt	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	l,
		integer(ilp), intent(in)	mb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CTPLQT: computes a blocked LQ factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

Here is the call graph for this function:

◆ la_ctplqt2()

pure subroutine, public la_lapack_c::la_ctplqt2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	l,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		integer(ilp), intent(out)	info
	)

CTPLQT2: computes a LQ a factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

Here is the call graph for this function:

◆ la_ctpmlqt()

pure subroutine, public la_lapack_c::la_ctpmlqt	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	l,
		integer(ilp), intent(in)	mb,
		complex(sp), dimension(ldv,*), intent(in)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CTPMLQT: applies a complex unitary matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

Here is the call graph for this function:

◆ la_ctpmqrt()

pure subroutine, public la_lapack_c::la_ctpmqrt	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	l,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(ldv,*), intent(in)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CTPMQRT: applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

Here is the call graph for this function:

◆ la_ctpqrt()

pure subroutine, public la_lapack_c::la_ctpqrt	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	l,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CTPQRT: computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

Here is the call graph for this function:

◆ la_ctpqrt2()

pure subroutine, public la_lapack_c::la_ctpqrt2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	l,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		integer(ilp), intent(out)	info
	)

CTPQRT2: computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

Here is the call graph for this function:

◆ la_ctprfb()

pure subroutine, public la_lapack_c::la_ctprfb	(	character, intent(in)	side,
		character, intent(in)	trans,
		character, intent(in)	direct,
		character, intent(in)	storev,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	l,
		complex(sp), dimension(ldv,*), intent(in)	v,
		integer(ilp), intent(in)	ldv,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork
	)

CTPRFB: applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.

◆ la_ctprfs()

pure subroutine, public la_lapack_c::la_ctprfs	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(in)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CTPRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by CTPTRS or some other means before entering this routine. CTPRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_ctptri()

pure subroutine, public la_lapack_c::la_ctptri	(	character, intent(in)	uplo,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		integer(ilp), intent(out)	info
	)

CTPTRI: computes the inverse of a complex upper or lower triangular matrix A stored in packed format.

◆ la_ctptrs()

pure subroutine, public la_lapack_c::la_ctptrs	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CTPTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

◆ la_ctpttf()

pure subroutine, public la_lapack_c::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).

◆ la_ctpttr()

pure subroutine, public la_lapack_c::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).

◆ la_ctrcon()

subroutine, public la_lapack_c::la_ctrcon	(	character, intent(in)	norm,
		character, intent(in)	uplo,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), intent(out)	rcond,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CTRCON: estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_ctrevc()

pure subroutine, public la_lapack_c::la_ctrevc	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CTREVC: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.

Here is the call graph for this function:

◆ la_ctrevc3()

pure subroutine, public la_lapack_c::la_ctrevc3	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info
	)

CTREVC3: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

Here is the call graph for this function:

◆ la_ctrexc()

pure subroutine, public la_lapack_c::la_ctrexc	(	character, intent(in)	compq,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		integer(ilp), intent(in)	ifst,
		integer(ilp), intent(in)	ilst,
		integer(ilp), intent(out)	info
	)

CTREXC: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.

Here is the call graph for this function:

◆ la_ctrrfs()

pure subroutine, public la_lapack_c::la_ctrrfs	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		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), dimension(ldx,*), intent(in)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CTRRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by CTRTRS or some other means before entering this routine. CTRRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_ctrsen()

subroutine, public la_lapack_c::la_ctrsen	(	character, intent(in)	job,
		character, intent(in)	compq,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(*), intent(out)	w,
		integer(ilp), intent(out)	m,
		real(sp), intent(out)	s,
		real(sp), intent(out)	sep,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CTRSEN: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.

Here is the call graph for this function:

◆ la_ctrsna()

pure subroutine, public la_lapack_c::la_ctrsna	(	character, intent(in)	job,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldvl,*), intent(in)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(in)	vr,
		integer(ilp), intent(in)	ldvr,
		real(sp), dimension(*), intent(out)	s,
		real(sp), dimension(*), intent(out)	sep,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(sp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info
	)

CTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix Q*T*Q**H with Q unitary).

Here is the call graph for this function:

◆ la_ctrsyl()

subroutine, public la_lapack_c::la_ctrsyl	(	character, intent(in)	trana,
		character, intent(in)	tranb,
		integer(ilp), intent(in)	isgn,
		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(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		real(sp), intent(out)	scale,
		integer(ilp), intent(out)	info
	)

CTRSYL: solves the complex Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.

Here is the call graph for this function:

◆ la_ctrti2()

pure subroutine, public la_lapack_c::la_ctrti2	(	character, intent(in)	uplo,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info
	)

CTRTI2: computes the inverse of a complex upper or lower triangular matrix. This is the Level 2 BLAS version of the algorithm.

◆ la_ctrtri()

pure subroutine, public la_lapack_c::la_ctrtri	(	character, intent(in)	uplo,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(out)	info
	)

CTRTRI: computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_ctrtrs()

pure subroutine, public la_lapack_c::la_ctrtrs	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info
	)

CTRTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

◆ la_ctrttf()

pure subroutine, public la_lapack_c::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) .

◆ la_ctrttp()

pure subroutine, public la_lapack_c::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).

◆ la_ctzrzf()

pure subroutine, public la_lapack_c::la_ctzrzf	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(out)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CTZRZF: reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.

Here is the call graph for this function:

◆ la_cunbdb()

subroutine, public la_lapack_c::la_cunbdb	(	character, intent(in)	trans,
		character, intent(in)	signs,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		integer(ilp), intent(in)	q,
		complex(sp), dimension(ldx11,*), intent(inout)	x11,
		integer(ilp), intent(in)	ldx11,
		complex(sp), dimension(ldx12,*), intent(inout)	x12,
		integer(ilp), intent(in)	ldx12,
		complex(sp), dimension(ldx21,*), intent(inout)	x21,
		integer(ilp), intent(in)	ldx21,
		complex(sp), dimension(ldx22,*), intent(inout)	x22,
		integer(ilp), intent(in)	ldx22,
		real(sp), dimension(*), intent(out)	theta,
		real(sp), dimension(*), intent(out)	phi,
		complex(sp), dimension(*), intent(out)	taup1,
		complex(sp), dimension(*), intent(out)	taup2,
		complex(sp), dimension(*), intent(out)	tauq1,
		complex(sp), dimension(*), intent(out)	tauq2,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [--------—] = [------—] [-------------—] [------—] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

Here is the call graph for this function:

◆ la_cunbdb1()

subroutine, public la_lapack_c::la_cunbdb1	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		integer(ilp), intent(in)	q,
		complex(sp), dimension(ldx11,*), intent(inout)	x11,
		integer(ilp), intent(in)	ldx11,
		complex(sp), dimension(ldx21,*), intent(inout)	x21,
		integer(ilp), intent(in)	ldx21,
		real(sp), dimension(*), intent(out)	theta,
		real(sp), dimension(*), intent(out)	phi,
		complex(sp), dimension(*), intent(out)	taup1,
		complex(sp), dimension(*), intent(out)	taup2,
		complex(sp), dimension(*), intent(out)	tauq1,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNBDB1: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines CUNBDB2, CUNBDB3, and CUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.

Here is the call graph for this function:

◆ la_cunbdb2()

subroutine, public la_lapack_c::la_cunbdb2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		integer(ilp), intent(in)	q,
		complex(sp), dimension(ldx11,*), intent(inout)	x11,
		integer(ilp), intent(in)	ldx11,
		complex(sp), dimension(ldx21,*), intent(inout)	x21,
		integer(ilp), intent(in)	ldx21,
		real(sp), dimension(*), intent(out)	theta,
		real(sp), dimension(*), intent(out)	phi,
		complex(sp), dimension(*), intent(out)	taup1,
		complex(sp), dimension(*), intent(out)	taup2,
		complex(sp), dimension(*), intent(out)	tauq1,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNBDB2: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines CUNBDB1, CUNBDB3, and CUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.

Here is the call graph for this function:

◆ la_cunbdb3()

subroutine, public la_lapack_c::la_cunbdb3	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		integer(ilp), intent(in)	q,
		complex(sp), dimension(ldx11,*), intent(inout)	x11,
		integer(ilp), intent(in)	ldx11,
		complex(sp), dimension(ldx21,*), intent(inout)	x21,
		integer(ilp), intent(in)	ldx21,
		real(sp), dimension(*), intent(out)	theta,
		real(sp), dimension(*), intent(out)	phi,
		complex(sp), dimension(*), intent(out)	taup1,
		complex(sp), dimension(*), intent(out)	taup2,
		complex(sp), dimension(*), intent(out)	tauq1,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNBDB3: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines CUNBDB1, CUNBDB2, and CUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.

Here is the call graph for this function:

◆ la_cunbdb4()

subroutine, public la_lapack_c::la_cunbdb4	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		integer(ilp), intent(in)	q,
		complex(sp), dimension(ldx11,*), intent(inout)	x11,
		integer(ilp), intent(in)	ldx11,
		complex(sp), dimension(ldx21,*), intent(inout)	x21,
		integer(ilp), intent(in)	ldx21,
		real(sp), dimension(*), intent(out)	theta,
		real(sp), dimension(*), intent(out)	phi,
		complex(sp), dimension(*), intent(out)	taup1,
		complex(sp), dimension(*), intent(out)	taup2,
		complex(sp), dimension(*), intent(out)	tauq1,
		complex(sp), dimension(*), intent(out)	phantom,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNBDB4: simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [--—] = [------—] [--—] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines CUNBDB1, CUNBDB2, and CUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.

Here is the call graph for this function:

◆ la_cunbdb5()

pure subroutine, public la_lapack_c::la_cunbdb5	(	integer(ilp), intent(in)	m1,
		integer(ilp), intent(in)	m2,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	x1,
		integer(ilp), intent(in)	incx1,
		complex(sp), dimension(*), intent(inout)	x2,
		integer(ilp), intent(in)	incx2,
		complex(sp), dimension(ldq1,*), intent(in)	q1,
		integer(ilp), intent(in)	ldq1,
		complex(sp), dimension(ldq2,*), intent(in)	q2,
		integer(ilp), intent(in)	ldq2,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNBDB5: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.

Here is the call graph for this function:

◆ la_cunbdb6()

pure subroutine, public la_lapack_c::la_cunbdb6	(	integer(ilp), intent(in)	m1,
		integer(ilp), intent(in)	m2,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	x1,
		integer(ilp), intent(in)	incx1,
		complex(sp), dimension(*), intent(inout)	x2,
		integer(ilp), intent(in)	incx2,
		complex(sp), dimension(ldq1,*), intent(in)	q1,
		integer(ilp), intent(in)	ldq1,
		complex(sp), dimension(ldq2,*), intent(in)	q2,
		integer(ilp), intent(in)	ldq2,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNBDB6: orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.

Here is the call graph for this function:

◆ la_cuncsd()

recursive subroutine, public la_lapack_c::la_cuncsd	(	character, intent(in)	jobu1,
		character, intent(in)	jobu2,
		character, intent(in)	jobv1t,
		character, intent(in)	jobv2t,
		character, intent(in)	trans,
		character, intent(in)	signs,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		integer(ilp), intent(in)	q,
		complex(sp), dimension(ldx11,*), intent(inout)	x11,
		integer(ilp), intent(in)	ldx11,
		complex(sp), dimension(ldx12,*), intent(inout)	x12,
		integer(ilp), intent(in)	ldx12,
		complex(sp), dimension(ldx21,*), intent(inout)	x21,
		integer(ilp), intent(in)	ldx21,
		complex(sp), dimension(ldx22,*), intent(inout)	x22,
		integer(ilp), intent(in)	ldx22,
		real(sp), dimension(*), intent(out)	theta,
		complex(sp), dimension(ldu1,*), intent(out)	u1,
		integer(ilp), intent(in)	ldu1,
		complex(sp), dimension(ldu2,*), intent(out)	u2,
		integer(ilp), intent(in)	ldu2,
		complex(sp), dimension(ldv1t,*), intent(out)	v1t,
		integer(ilp), intent(in)	ldv1t,
		complex(sp), dimension(ldv2t,*), intent(out)	v2t,
		integer(ilp), intent(in)	ldv2t,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CUNCSD: computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [--------—] = [------—] [------------------—] [------—] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).

Here is the call graph for this function:

◆ la_cuncsd2by1()

subroutine, public la_lapack_c::la_cuncsd2by1	(	character, intent(in)	jobu1,
		character, intent(in)	jobu2,
		character, intent(in)	jobv1t,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	p,
		integer(ilp), intent(in)	q,
		complex(sp), dimension(ldx11,*), intent(inout)	x11,
		integer(ilp), intent(in)	ldx11,
		complex(sp), dimension(ldx21,*), intent(inout)	x21,
		integer(ilp), intent(in)	ldx21,
		real(sp), dimension(*), intent(out)	theta,
		complex(sp), dimension(ldu1,*), intent(out)	u1,
		integer(ilp), intent(in)	ldu1,
		complex(sp), dimension(ldu2,*), intent(out)	u2,
		integer(ilp), intent(in)	ldu2,
		complex(sp), dimension(ldv1t,*), intent(out)	v1t,
		integer(ilp), intent(in)	ldv1t,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info
	)

CUNCSD2BY1: computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [--—] = [------—] [-------—] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

Here is the call graph for this function:

◆ la_cung2l()

pure subroutine, public la_lapack_c::la_cung2l	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUNG2L: generates an m by n complex matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by CGEQLF.

Here is the call graph for this function:

◆ la_cung2r()

pure subroutine, public la_lapack_c::la_cung2r	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUNG2R: generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by CGEQRF.

Here is the call graph for this function:

◆ la_cungbr()

pure subroutine, public la_lapack_c::la_cungbr	(	character, intent(in)	vect,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNGBR: generates one of the complex unitary matrices Q or P**H determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * P**H. Q and P**H are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and CUNGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and CUNGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and P**H is of order N: if k < n, P**H = G(k) . . . G(2) G(1) and CUNGBR returns the first m rows of P**H, where n >= m >= k; if k >= n, P**H = G(n-1) . . . G(2) G(1) and CUNGBR returns P**H as an N-by-N matrix.

Here is the call graph for this function:

◆ la_cunghr()

pure subroutine, public la_lapack_c::la_cunghr	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNGHR: generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

Here is the call graph for this function:

◆ la_cungl2()

pure subroutine, public la_lapack_c::la_cungl2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUNGL2: generates an m-by-n complex matrix Q with orthonormal rows, which is defined as the first m rows of a product of k elementary reflectors of order n Q = H(k)**H . . . H(2)**H H(1)**H as returned by CGELQF.

Here is the call graph for this function:

◆ la_cunglq()

pure subroutine, public la_lapack_c::la_cunglq	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNGLQ: generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k)**H . . . H(2)**H H(1)**H as returned by CGELQF.

Here is the call graph for this function:

◆ la_cungql()

pure subroutine, public la_lapack_c::la_cungql	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNGQL: generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by CGEQLF.

Here is the call graph for this function:

◆ la_cungqr()

pure subroutine, public la_lapack_c::la_cungqr	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNGQR: generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by CGEQRF.

Here is the call graph for this function:

◆ la_cungr2()

pure subroutine, public la_lapack_c::la_cungr2	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUNGR2: generates an m by n complex matrix Q with orthonormal rows, which is defined as the last m rows of a product of k elementary reflectors of order n Q = H(1)**H H(2)**H . . . H(k)**H as returned by CGERQF.

Here is the call graph for this function:

◆ la_cungrq()

pure subroutine, public la_lapack_c::la_cungrq	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNGRQ: generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)**H H(2)**H . . . H(k)**H as returned by CGERQF.

Here is the call graph for this function:

◆ la_cungtr()

pure subroutine, public la_lapack_c::la_cungtr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by CHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

Here is the call graph for this function:

◆ la_cungtsqr()

pure subroutine, public la_lapack_c::la_cungtsqr	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	mb,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNGTSQR: generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by CLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for CLATSQR.

Here is the call graph for this function:

◆ la_cungtsqr_row()

pure subroutine, public la_lapack_c::la_cungtsqr_row	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	mb,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNGTSQR_ROW: generates an M-by-N complex matrix Q_out with orthonormal columns from the output of CLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by CLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of CLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine CLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which CLATSQR generates the output blocks.

Here is the call graph for this function:

◆ la_cunhr_col()

pure subroutine, public la_lapack_c::la_cunhr_col	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldt,*), intent(out)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	d,
		integer(ilp), intent(out)	info
	)

CUNHR_COL: takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as CGEQRT).

Here is the call graph for this function:

◆ la_cunm22()

pure subroutine, public la_lapack_c::la_cunm22	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	n1,
		integer(ilp), intent(in)	n2,
		complex(sp), dimension(ldq,*), intent(in)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

Here is the call graph for this function:

◆ la_cunm2l()

pure subroutine, public la_lapack_c::la_cunm2l	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUNM2L: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q**H* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cunm2r()

pure subroutine, public la_lapack_c::la_cunm2r	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUNM2R: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q**H* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cunmbr()

pure subroutine, public la_lapack_c::la_cunmbr	(	character, intent(in)	vect,
		character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

If VECT = 'Q', CUNMBR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H If VECT = 'P', CUNMBR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'C': P**H * C C * P**H Here Q and P**H are the unitary matrices determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * P**H. Q and P**H are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the unitary matrix Q or P**H that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

Here is the call graph for this function:

◆ la_cunmhr()

pure subroutine, public la_lapack_c::la_cunmhr	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNMHR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

Here is the call graph for this function:

◆ la_cunml2()

pure subroutine, public la_lapack_c::la_cunml2	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUNML2: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q**H* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)**H . . . H(2)**H H(1)**H as returned by CGELQF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cunmlq()

pure subroutine, public la_lapack_c::la_cunmlq	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNMLQ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)**H . . . H(2)**H H(1)**H as returned by CGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cunmql()

pure subroutine, public la_lapack_c::la_cunmql	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNMQL: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cunmqr()

pure subroutine, public la_lapack_c::la_cunmqr	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNMQR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cunmr2()

pure subroutine, public la_lapack_c::la_cunmr2	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUNMR2: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q**H* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)**H H(2)**H . . . H(k)**H as returned by CGERQF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cunmr3()

pure subroutine, public la_lapack_c::la_cunmr3	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	l,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUNMR3: overwrites the general complex m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q**H* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cunmrq()

pure subroutine, public la_lapack_c::la_cunmrq	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNMRQ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)**H H(2)**H . . . H(k)**H as returned by CGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cunmrz()

pure subroutine, public la_lapack_c::la_cunmrz	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		integer(ilp), intent(in)	l,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNMRZ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

Here is the call graph for this function:

◆ la_cunmtr()

pure subroutine, public la_lapack_c::la_cunmtr	(	character, intent(in)	side,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info
	)

CUNMTR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

Here is the call graph for this function:

◆ la_cupgtr()

pure subroutine, public la_lapack_c::la_cupgtr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	ap,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldq,*), intent(out)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUPGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

Here is the call graph for this function:

◆ la_cupmtr()

pure subroutine, public la_lapack_c::la_cupmtr	(	character, intent(in)	side,
		character, intent(in)	uplo,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	ap,
		complex(sp), dimension(*), intent(in)	tau,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info
	)

CUPMTR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

Here is the call graph for this function:

Functions/Subroutines

Function/Subroutine Documentation

◆ la_cbbcsd()

◆ la_cbdsqr()

◆ la_cgbbrd()

◆ la_cgbcon()

◆ la_cgbequ()

◆ la_cgbequb()

◆ la_cgbrfs()

◆ la_cgbsv()

◆ la_cgbsvx()

◆ la_cgbtf2()

◆ la_cgbtrf()

◆ la_cgbtrs()

◆ la_cgebak()

◆ la_cgebal()

◆ la_cgebd2()

◆ la_cgebrd()

◆ la_cgecon()

◆ la_cgeequ()

◆ la_cgeequb()

◆ la_cgees()

◆ la_cgeesx()

◆ la_cgeev()

◆ la_cgeevx()

◆ la_cgehd2()

◆ la_cgehrd()

◆ la_cgejsv()

◆ la_cgelq()

◆ la_cgelq2()

◆ la_cgelqf()

◆ la_cgelqt()

◆ la_cgelqt3()

◆ la_cgels()

◆ la_cgelsd()

◆ la_cgelss()

◆ la_cgelsy()

◆ la_cgemlq()

◆ la_cgemlqt()

◆ la_cgemqr()

◆ la_cgemqrt()

◆ la_cgeql2()

◆ la_cgeqlf()

◆ la_cgeqp3()

◆ la_cgeqr()

◆ la_cgeqr2()

◆ la_cgeqr2p()

◆ la_cgeqrf()

◆ la_cgeqrfp()

◆ la_cgeqrt()

◆ la_cgeqrt2()

◆ la_cgeqrt3()

◆ la_cgerfs()

◆ la_cgerq2()

◆ la_cgerqf()

◆ la_cgesc2()

◆ la_cgesdd()

◆ la_cgesv()

◆ la_cgesvd()

◆ la_cgesvdq()

◆ la_cgesvj()

◆ la_cgesvx()

◆ la_cgetc2()

◆ la_cgetf2()

◆ la_cgetrf()

◆ la_cgetrf2()

◆ la_cgetri()

◆ la_cgetrs()

◆ la_cgetsls()

◆ la_cgetsqrhrt()

◆ la_cggbak()

◆ la_cggbal()

◆ la_cgges()

◆ la_cgges3()

◆ la_cggesx()

◆ la_cggev()

◆ la_cggev3()

◆ la_cggevx()

◆ la_cggglm()

◆ la_cgghd3()