Here are the data types with brief descriptions:

[detail level 12]

►Mla_blas	Precision-agnostic BLAS interface
Caxpy	AXPY: constant times a vector plus a vector
Ccopy	COPY: copies a vector x to a vector y
Cdot	DOT: forms the dot product of two vectors. uses unrolled loops for increments equal to one
Cdotc	DOTC: forms the dot product of two complex vectors DOTC = X^H * Y
Cdotu	DOTU: forms the dot product of two complex vectors DOTU = X^T * Y
Cgbmv	GBMV: performs one of the matrix-vector operations y := alphaAx + betay, or y := alphaA*Tx + betay, or y := alphaA*Hx + beta*y, where alpha and beta are scalars, x and y are vectors and A is an m by n band matrix, with kl sub-diagonals and ku super-diagonals
Cgemm	GEMM: performs one of the matrix-matrix operations C := alphaop( A )op( B ) + betaC, where op( X ) is one of op( X ) = X or op( X ) = XT or op( X ) = X*H, alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix
Cgemv	GEMV: performs one of the matrix-vector operations y := alphaAx + betay, or y := alphaA*Tx + betay, or y := alphaA*Hx + beta*y, where alpha and beta are scalars, x and y are vectors and A is an m by n matrix
Cger	GER: performs the rank 1 operation A := alphaxy**T + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix
Cgerc	GERC: performs the rank 1 operation A := alphaxy**H + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix
Cgeru	GERU: performs the rank 1 operation A := alphaxy**T + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix
Chbmv	HBMV: 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 hermitian band matrix, with k super-diagonals
Chemm	HEMM: performs one of the matrix-matrix operations C := alphaAB + betaC, or C := alphaBA + betaC, where alpha and beta are scalars, A is an hermitian matrix and B and C are m by n matrices
Chemv	HEMV: 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 hermitian matrix
Cher	HER: performs the hermitian rank 1 operation A := alphaxx**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix
Cher2	HER2: performs the hermitian rank 2 operation A := alphaxy*H + conjg( alpha )yx*H + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix
Cher2k	HER2K: performs one of the hermitian rank 2k operations C := alphaAB*H + conjg( alpha )BAH + betaC, or C := alphaAHB + conjg( alpha )BHA + beta*C, where alpha and beta are scalars with beta real, C is an n by n hermitian matrix and A and B are n by k matrices in the first case and k by n matrices in the second case
Cherk	HERK: 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
Chpmv	HPMV: 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 hermitian matrix, supplied in packed form
Chpr	HPR: performs the hermitian rank 1 operation A := alphaxx**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix, supplied in packed form
Chpr2	HPR2: performs the hermitian rank 2 operation A := alphaxy*H + conjg( alpha )yx*H + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix, supplied in packed form
Cnrm2	!
Crot	ROT: applies a plane rotation
Crotg	!
Crotm	APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX (DXT) , WHERE T INDICATES TRANSPOSE. THE ELEMENTS OF DX ARE IN (DY*T) DX(LX+IINCX), I = 0 TO N-1, WHERE LX = 1 IF INCX >= 0, ELSE LX = (-INCX)*N, AND SIMILARLY FOR SY USING LY AND INCY. WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS.. DFLAG=-1._dp DFLAG=0._dp DFLAG=1._dp DFLAG=-2.D0 (DH11 DH12) (1._dp DH12) (DH11 1._dp) (1._dp 0._dp) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1._dp), (-1._dp DH22), (0._dp 1._dp). SEE ROTMG FOR A DESCRIPTION OF DATA STORAGE IN DPARAM
Crotmg	CONSTRUCT THE MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS THE SECOND COMPONENT OF THE 2-VECTOR (SQRT(DD1)DX1,SQRT(DD2) DY2)*T. WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS.. DFLAG=-1._dp DFLAG=0._dp DFLAG=1._dp DFLAG=-2.D0 (DH11 DH12) (1._dp DH12) (DH11 1._dp) (1._dp 0._dp) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1._dp), (-1._dp DH22), (0._dp 1._dp). LOCATIONS 2-4 OF DPARAM CONTAIN DH11, DH21, DH12, AND DH22 RESPECTIVELY. (VALUES OF 1._dp, -1._dp, OR 0._dp IMPLIED BY THE VALUE OF DPARAM(1) ARE NOT STORED IN DPARAM.) THE VALUES OF GAMSQ AND RGAMSQ SET IN THE DATA STATEMENT MAY BE INEXACT. THIS IS OK AS THEY ARE ONLY USED FOR TESTING THE SIZE OF DD1 AND DD2. ALL ACTUAL SCALING OF DATA IS DONE USING GAM
Csbmv	SBMV: 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 band matrix, with k super-diagonals
Cscal	SCAL: scales a vector by a constant
Csdot	Compute the inner product of two vectors with extended precision accumulation and result. Returns D.P. dot product accumulated in D.P., for S.P. SX and SY SDOT: = sum for I = 0 to N-1 of SX(LX+IINCX) SY(LY+IINCY), where LX = 1 if INCX >= 0, else LX = 1+(1-N)INCX, and LY is defined in a similar way using INCY
Cspmv	SPMV: 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
Cspr	SPR: performs the symmetric rank 1 operation A := alphaxx**T + A, where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form
Cspr2	SPR2: performs the symmetric rank 2 operation A := alphaxy*T + alphayx*T + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form
Csrot	SROT: applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78
Csscal	SSCAL: scales a complex vector by a real constant
Cswap	SWAP: interchanges two vectors
Csymm	SYMM: performs one of the matrix-matrix operations C := alphaAB + betaC, or C := alphaBA + betaC, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices
Csymv	SYMV: 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
Csyr	SYR: performs the symmetric rank 1 operation A := alphaxx**T + A, where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix
Csyr2	SYR2: performs the symmetric rank 2 operation A := alphaxy*T + alphayx*T + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix
Csyr2k	SYR2K: performs one of the symmetric rank 2k operations C := alphaAB*T + alphaBAT + betaC, or C := alphaATB + alphaBTA + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case
Csyrk	SYRK: performs one of the symmetric rank k operations C := alphaAA*T + betaC, or C := alphaATA + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case
Ctbmv	TBMV: performs one of the matrix-vector operations x := Ax, or x := ATx, or x := A*Hx, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular band matrix, with ( k + 1 ) diagonals
Ctbsv	TBSV: solves one of the systems of equations Ax = b, or ATx = b, or A*Hx = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular band matrix, with ( k + 1 ) diagonals. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine
Ctpmv	TPMV: performs one of the matrix-vector operations x := Ax, or x := ATx, or x := A*Hx, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular matrix, supplied in packed form
Ctpsv	TPSV: solves one of the systems of equations Ax = b, or ATx = b, or A*Hx = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular matrix, supplied in packed form. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine
Ctrmm	TRMM: performs one of the matrix-matrix operations B := alphaop( A )B, or B := alphaBop( A ) where alpha is a scalar, B is an m by n matrix, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = AT or op( A ) = AH
Ctrmv	TRMV: performs one of the matrix-vector operations x := Ax, or x := ATx, or x := A*Hx, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular matrix
Ctrsm	TRSM: solves one of the matrix equations 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 ) = AT or op( A ) = AH. The matrix X is overwritten on B
Ctrsv	TRSV: solves one of the systems of equations Ax = b, or ATx = b, or A*Hx = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular matrix. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine
►Mla_cholesky	Cholesky factorization of a matrix, based on LAPACK POTRF functions
Cchol	Computes the Cholesky factorization $ A = L \cdot L^T $, or $ A = U^T \cdot U $
Ccholesky	Computes the Cholesky factorization $ A = L \cdot L^T $, or $ A = U^T \cdot U $
►Mla_determinant	Determinant of a rectangular matrix
Cdet	Compute the determinant of a rectangular matrix
Coperator(.det.)	Compute the determinant of a square matrix using the `.det.` operator
►Mla_eig	Eigenvalues and Eigenvectors
Ceig	Eigendecomposition of a square matrix, returning eigenvalues and optionally eigenvectors
Ceigh	Eigendecomposition of a real symmetric or complex Hermitian matrix
Ceigvals	Eigenvalues of a square matrix
Ceigvalsh	Eigenvalues of a real symmetric or complex Hermitian matrix
►Mla_eye	Identity and diagonal matrices, matrix trace and elementary matrix products
Ccross_product
Cdiag
Ceye	Construct an identity matrix of size $m \times n$
Chermitian
Ckronecker_product
Couter_product
Ctrace
►Mla_inverse	Inverse of a square matrix
Cinv	Compute the inverse of a square matrix
Cinvert
Coperator(.inv.)
►Mla_lapack	Kind-agnostic LAPACK interface linking to internal or external implementations
Cbbcsd	BBCSD computes the CS decomposition of a unitary matrix in bidiagonal-block form
Cbdsdc	BDSDC: computes the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B: B = U * S * VT, using a divide and conquer method, where S is a diagonal matrix with non-negative diagonal elements (the singular values of B), and U and VT are orthogonal matrices of left and right singular vectors, respectively. BDSDC can be used to compute all singular values, and optionally, singular vectors or singular vectors in compact 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 DLASD3 for details. The code currently calls DLASDQ if singular values only are desired. However, it can be slightly modified to compute singular values using the divide and conquer method
Cbdsqr	BDSQR: 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
Cdisna	DISNA: computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general m-by-n matrix. The reciprocal condition number is the 'gap' between the corresponding eigenvalue or singular value and the nearest other one. The bound on the error, measured by angle in radians, in the I-th computed vector is given by DLAMCH( 'E' ) * ( ANORM / SEP( I ) ) where ANORM = 2-norm(A) = max( abs( D(j) ) ). SEP(I) is not allowed to be smaller than DLAMCH( 'E' )*ANORM in order to limit the size of the error bound. DISNA may also be used to compute error bounds for eigenvectors of the generalized symmetric definite eigenproblem
Cgbbrd	GBBRD: 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
Cgbcon	GBCON: 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)) )
Cgbequ	GBEQU: 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
Cgbequb	GBEQUB: 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)
Cgbrfs	GBRFS: 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
Cgbsv	GBSV: 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
Cgbtrf	GBTRF: 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
Cgbtrs	GBTRS: 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
Cgebak	GEBAK: 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
Cgebal	GEBAL: 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
Cgebrd	GEBRD: 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
Cgecon	GECON: 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)) )
Cgeequ	GEEQU: 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
Cgeequb	GEEQUB: 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)
Cgees	GEES: 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
Cgeesx	GEESX: computes for an N-by-N real nonsymmetric matrix A, the eigenvalues, the real Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z*T). Optionally, it also orders the eigenvalues on the diagonal of the real 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 of the LAPACK Users' Guide (where these quantities are called s and sep respectively). A real matrix is in real Schur form if it is upper quasi-triangular with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in the form [ a b ] [ c a ] where bc < 0. The eigenvalues of such a block are a +- sqrt(bc)
Cgeev	GEEV: 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
Cgeevx	GEEVX: computes for an N-by-N real 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 of the LAPACK Users' Guide
Cgehrd	GEHRD: reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q*H A * Q = H
Cgejsv	GEJSV: 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
Cgelq	GELQ: 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
Cgelqf	GELQF: 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
Cgelqt	GELQT: computes a blocked LQ factorization of a complex M-by-N matrix A using the compact WY representation of Q
Cgelqt3	GELQT3: 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
Cgels	GELS: 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:
Cgelsd	GELSD: 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
Cgelss	GELSS: 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
Cgelsy	GELSY: 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
Cgemlq	GEMLQ: 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)
Cgemlqt	GEMLQT: 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'
Cgemqr	GEMQR: 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)
Cgemqrt	GEMQRT: 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'
Cgeqlf	GEQLF: computes a QL factorization of a complex M-by-N matrix A: A = Q * L
Cgeqp3	GEQP3: computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS
Cgeqr	GEQR: 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
Cgeqr2p	GEQR2P: 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
Cgeqrf	GEQRF: 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
Cgeqrfp	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
Cgeqrt	GEQRT: computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q
Cgeqrt2	GEQRT2: computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q
Cgeqrt3	GEQRT3: 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
Cgerfs	GERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution
Cgerqf	GERQF: computes an RQ factorization of a complex M-by-N matrix A: A = R * Q
Cgesdd	GESDD: 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
Cgesv	GESV: 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
Cgesvd	GESVD: 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
Cgesvdq	GESVDQ: 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
Cgesvj	GESVJ: 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
Cgesvx	GESVX: uses the LU factorization to compute the solution to a real 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
Cgetrf	GETRF: 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
Cgetrf2	GETRF2: 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
Cgetri	GETRI: 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)
Cgetrs	GETRS: 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
Cgetsls	GETSLS: 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:
Cgetsqrhrt	GETSQRHRT: 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
Cggbak	GGBAK: 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
Cggbal	GGBAL: 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
Cgges	GGES: 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
Cgges3	GGES3: computes for a pair of N-by-N real nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized real Schur form (S,T), optionally, the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)*T, (VSL)T(VSR)T ) Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T.The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver GGEV 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 or both being zero. A pair of matrices (S,T) is in generalized real Schur form if T is upper triangular with non-negative diagonal and S is block upper triangular with 1-by-1 and 2-by-2 blocks. 1-by-1 blocks correspond to real generalized eigenvalues, while 2-by-2 blocks of S will be "standardized" by making the corresponding elements of T have the form: [ a 0 ] [ 0 b ] and the pair of corresponding 2-by-2 blocks in S and T will have a complex conjugate pair of generalized eigenvalues
Cggev	GGEV: 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)
Cggev3	GGEV3: computes for a pair of N-by-N real 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 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)
Cggglm	GGGLM: 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
Cgghd3	GGHD3: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal 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 orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Tx. The orthogonal 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*T = (Q1Q) * H * (Z1Z)T Q1 B * Z1*T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaBx, then GGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of GGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance
Cgghrd	GGHRD: 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 GGHRD reduces the original problem to generalized Hessenberg form
Cgglse	GGLSE: 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
Cggqrf	GGQRF: 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
Cggrqf	GGRQF: 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
Cgsvj0	GSVJ0: 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
Cgsvj1	GSVJ1: 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
Cgtcon	GTCON: 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)))
Cgtrfs	GTRFS: 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
Cgtsv	GTSV: 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
Cgttrf	GTTRF: 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
Cgttrs	GTTRS: 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
Chb2st_kernels	HB2ST_KERNELS: is an internal routine used by the CHETRD_HB2ST subroutine
Chbev	HBEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A
Chbevd	HBEVD: 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
Chbgst	HBGST: 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
Chbgv	HBGV: 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
Chbgvd	HBGVD: 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
Chbtrd	HBTRD: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q*H A * Q = T
Checon	HECON: 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)))
Checon_rook	HECON_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)))
Cheequb	HEEQUB: 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
Cheev	HEEV: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A
Cheevd	HEEVD: 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
Cheevr	HEEVR: 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. HEEVR first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, HEEVR 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:
Chegst	HEGST: 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
Chegv	HEGV: 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
Chegvd	HEGVD: 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
Cherfs	HERFS: 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
Chesv	HESV: 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
Chesv_aa	HESV_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
Chesv_rk	HESV_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
Chesv_rook	HESV_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)
Cheswapr	HESWAPR: applies an elementary permutation on the rows and the columns of a hermitian matrix
Chetf2_rk	HETF2_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
Chetf2_rook	HETF2_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
Chetrd	HETRD: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q*H A * Q = T
Chetrd_hb2st	HETRD_HB2ST: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q*H A * Q = T
Chetrd_he2hb	HETRD_HE2HB: reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q*H A * Q = AB
Chetrf	HETRF: 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
Chetrf_aa	HETRF_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
Chetrf_rk	HETRF_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
Chetrf_rook	HETRF_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
Chetri	HETRI: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDU*H or A = LDL*H computed by CHETRF
Chetri_rook	HETRI_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
Chetrs	HETRS: 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
Chetrs2	HETRS2: 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
Chetrs_3	HETRS_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
Chetrs_aa	HETRS_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
Chetrs_rook	HETRS_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
Chfrk	Level 3 BLAS like routine for C in RFP Format. HFRK: 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
Chgeqz	HGEQZ: 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
Chpcon	HPCON: 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)))
Chpev	HPEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage
Chpevd	HPEVD: 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
Chpgst	HPGST: 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
Chpgv	HPGV: 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
Chpgvd	HPGVD: 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
Chprfs	HPRFS: 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
Chpsv	HPSV: 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
Chptrd	HPTRD: 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
Chptrf	HPTRF: 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
Chptri	HPTRI: 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
Chptrs	HPTRS: 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
Chsein	HSEIN: 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
Chseqr	HSEQR: 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
Cisnan	ISNAN: returns .TRUE. if its argument is NaN, and .FALSE. otherwise. To be replaced by the Fortran 2003 intrinsic in the future
Cla_gbamv	LA_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
Cla_gbrcond	LA_GBRCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( \|inv(A)\|\|A\| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number
Cla_gbrcond_c	LA_GBRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector
Cla_gbrpvgrw	LA_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
Cla_geamv	LA_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
Cla_gercond	LA_GERCOND: estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( \|inv(A)\|\|A\| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number
Cla_gercond_c	LA_GERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector
Cla_gerpvgrw	LA_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
Cla_heamv	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
Cla_hercond_c	LA_HERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector
Cla_herpvgrw	LA_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
Cla_lin_berr	LA_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
Cla_porcond	LA_PORCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( \|inv(A)\|\|A\| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number
Cla_porcond_c	LA_PORCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector
Cla_porpvgrw	LA_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
Cla_syamv	LA_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
Cla_syrcond	LA_SYRCOND: estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( \|inv(A)\|\|A\| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number
Cla_syrcond_c	LA_SYRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector
Cla_syrpvgrw	LA_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
Cla_wwaddw	LA_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
Clabad	LABAD: takes as input the values computed by DLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by DLAMCH. This subroutine is needed because DLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray
Clabrd	LABRD: 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
Clacgv	LACGV: conjugates a complex vector of length N
Clacon	LACON: estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products
Clacpy	LACPY: copies all or part of a two-dimensional matrix A to another matrix B
Clacrm	LACRM: 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
Clacrt	LACRT: 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
Cladiv1
Cladiv2
Cladiv_f	LADIV_F: := X / Y, where X and Y are complex. The computation of X / Y will not overflow on an intermediary step unless the results overflows
Cladiv_s	LADIV_S: performs complex division in real arithmetic a + ib p + iq = ------— c + i*d The algorithm is due to Michael Baudin and Robert L. Smith and can be found in the paper "A Robust Complex Division in Scilab"
Claebz	LAEBZ: contains the iteration loops which compute and use the function N(w), which is the count of eigenvalues of a symmetric tridiagonal matrix T less than or equal to its argument w. It performs a choice of two types of loops: IJOB=1, followed by IJOB=2: It takes as input a list of intervals and returns a list of sufficiently small intervals whose union contains the same eigenvalues as the union of the original intervals. The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP. The output interval (AB(j,1),AB(j,2)] will contain eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT. IJOB=3: It performs a binary search in each input interval (AB(j,1),AB(j,2)] for a point w(j) such that N(w(j))=NVAL(j), and uses C(j) as the starting point of the search. If such a w(j) is found, then on output AB(j,1)=AB(j,2)=w. If no such w(j) is found, then on output (AB(j,1),AB(j,2)] will be a small interval containing the point where N(w) jumps through NVAL(j), unless that point lies outside the initial interval. Note that the intervals are in all cases half-open intervals, i.e., of the form (a,b] , which includes b but not a . To avoid underflow, the matrix should be scaled so that its largest element is no greater than overflow*(1/2) underflow*(1/4) in absolute value. To assure the most accurate computation of small eigenvalues, the matrix should be scaled to be not much smaller than that, either. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966 Note: the arguments are, in general, not* checked for unreasonable values
Claed0	Using the divide and conquer method, LAED0: 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
Claed1	LAED1: 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 eigenvectors of a tridiagonal matrix. DLAED7 handles the case in which eigenvalues only or eigenvalues and eigenvectors of a full symmetric matrix (which was reduced to tridiagonal form) are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) D(out) * QT(out) where Z = QT*u, 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 DLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine DLAED4 (as called by DLAED3). 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
Claed4	This subroutine computes the I-th updated eigenvalue of a symmetric rank-one modification to a diagonal matrix whose elements are given in the array d, and that D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions
Claed5	This subroutine computes the I-th eigenvalue of a symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) + RHO * Z * transpose(Z) . The diagonal elements in the array D are assumed to satisfy D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one
Claed6	LAED6: computes the positive or negative root (closest to the origin) of z(1) z(2) z(3) f(x) = rho + ------— + -------— + ------— d(1)-x d(2)-x d(3)-x It is assumed that if ORGATI = .true. the root is between d(2) and d(3); otherwise it is between d(1) and d(2) This routine will be called by DLAED4 when necessary. In most cases, the root sought is the smallest in magnitude, though it might not be in some extremely rare situations
Claed7	LAED7: 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
Claed8	LAED8: 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
Claed9	LAED9: finds the roots of the secular equation, as defined by the values in D, Z, and RHO, between KSTART and KSTOP. It makes the appropriate calls to DLAED4 and then stores the new matrix of eigenvectors for use in calculating the next level of Z vectors
Claeda	LAEDA: computes the Z vector corresponding to the merge step in the CURLVLth step of the merge process with TLVLS steps for the CURPBMth problem
Claein	LAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H
Claesy	LAESY: 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 ]
Claexc	LAEXC: swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign
Clagtf	LAGTF: factorizes the matrix (T - lambdaI), where T is an n by n tridiagonal matrix and lambda is a scalar, as T - lambdaI = PLU, where P is a permutation matrix, L is a unit lower tridiagonal matrix with at most one non-zero sub-diagonal elements per column and U is an upper triangular matrix with at most two non-zero super-diagonal elements per column. The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling. The parameter LAMBDA is included in the routine so that LAGTF may be used, in conjunction with DLAGTS, to obtain eigenvectors of T by inverse iteration
Clagtm	LAGTM: 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
Clagts	LAGTS: may be used to solve one of the systems of equations (T - lambdaI)x = y or (T - lambdaI)Tx = y, where T is an n by n tridiagonal matrix, for x, following the factorization of (T - lambdaI) as (T - lambdaI) = PLU , by routine DLAGTF. The choice of equation to be solved is controlled by the argument JOB, and in each case there is an option to perturb zero or very small diagonal elements of U, this option being intended for use in applications such as inverse iteration
Clahef	LAHEF: 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. LAHEF 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')
Clahef_aa	LAHEF_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
Clahef_rk	LAHEF_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. LAHEF_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')
Clahef_rook	LAHEF_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. LAHEF_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')
Clahqr	LAHQR: 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
Claic1	LAIC1: 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 LAIC1 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
Claisnan	This routine is not for general use. It exists solely to avoid over-optimization in DISNAN. LAISNAN: checks for NaNs by comparing its two arguments for inequality. NaN is the only floating-point value where NaN != NaN returns .TRUE. To check for NaNs, pass the same variable as both arguments. A compiler must assume that the two arguments are not the same variable, and the test will not be optimized away. Interprocedural or whole-program optimization may delete this test. The ISNAN functions will be replaced by the correct Fortran 03 intrinsic once the intrinsic is widely available
Clals0	LALS0: 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)
Clalsa	LALSA: 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, LALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, LALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by LALSA
Clalsd	LALSD: 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
Clamrg	LAMRG: will create a permutation list which will merge the elements of A (which is composed of two independently sorted sets) into a single set which is sorted in ascending order
Clamswlq	LAMSWLQ: 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)
Clamtsqr	LAMTSQR: 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)
Claneg	LANEG: computes the Sturm count, the number of negative pivots encountered while factoring tridiagonal T - sigma I = L D L^T. This implementation works directly on the factors without forming the tridiagonal matrix T. The Sturm count is also the number of eigenvalues of T less than sigma. This routine is called from DLARRB. The current routine does not use the PIVMIN parameter but rather requires IEEE-754 propagation of Infinities and NaNs. This routine also has no input range restrictions but does require default exception handling such that x/0 produces Inf when x is non-zero, and Inf/Inf produces NaN. For more information, see: Marques, Riedy, and Voemel, "Benefits of IEEE-754 Features in Modern Symmetric Tridiagonal Eigensolvers," SIAM Journal on Scientific Computing, v28, n5, 2006. DOI 10.1137/050641624 (Tech report version in LAWN 172 with the same title.)
Clangb	LANGB: 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
Clange	LANGE: 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
Clangt	LANGT: 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
Clanhb	LANHB: 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
Clanhe	LANHE: 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
Clanhf	LANHF: 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
Clanhp	LANHP: 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
Clanhs	LANHS: 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
Clanht	LANHT: 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
Clansb	LANSB: 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
Clansf	LANSF: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A in RFP format
Clansp	LANSP: 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
Clanst	LANST: returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric tridiagonal matrix A
Clansy	LANSY: 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
Clantb	LANTB: 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
Clantp	LANTP: 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
Clantr	LANTR: 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
Claorhr_col_getrfnp	LAORHR_COL_GETRFNP: computes the modified LU factorization without pivoting of a real 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 DORHR_COL. In DORHR_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 LAORHR_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
Claorhr_col_getrfnp2	LAORHR_COL_GETRFNP2: computes the modified LU factorization without pivoting of a real 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 DORHR_COL. In DORHR_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]. LAORHR_COL_GETRFNP2 is called to factorize a block by the blocked routine DLAORHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, LAORHR_COL_GETRFNP2 is self-sufficient and can be used without DLAORHR_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
Clapll	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
Clapmr	LAPMR: 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
Clapmt	LAPMT: 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
Claqgb	LAQGB: 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
Claqge	LAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C
Claqhb	LAQHB: equilibrates an Hermitian band matrix A using the scaling factors in the vector S
Claqhe	LAQHE: equilibrates a Hermitian matrix A using the scaling factors in the vector S
Claqhp	LAQHP: equilibrates a Hermitian matrix A using the scaling factors in the vector S
Claqps	LAQPS: 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
Claqr0	LAQR0: 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
Claqr1	Given a 2-by-2 or 3-by-3 matrix H, LAQR1: 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
Claqr4	LAQR4: 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. LAQR4 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
Claqr5	LAQR5: called by CLAQR0 performs a single small-bulge multi-shift QR sweep
Claqsb	LAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S
Claqsp	LAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S
Claqsy	LAQSY: equilibrates a symmetric matrix A using the scaling factors in the vector S
Claqtr	LAQTR: solves the real quasi-triangular system op(T)p = scalec, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)(p+iq) = scale(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or AT, AT denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine DTRSNA
Claqz0	LAQZ0: 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"
Claqz1	LAQZ1: chases a 1x1 shift bulge in a matrix pencil down a single position
Claqz4	LAQZ4: Executes a single multishift QZ sweep
Clar1v	LAR1V: 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
Clar2v	LAR2V: 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) )
Clarcm	LARCM: 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
Clarf	LARF: 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
Clarfb	LARFB: 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
Clarfb_gett	LARFB_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
Clarfg	LARFG: 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
Clarfgp	LARFGP: 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
Clarft	LARFT: 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
Clarfy	LARFY: 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
Clargv	LARGV: 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
Clarnv	LARNV: returns a vector of n random complex numbers from a uniform or normal distribution
Clarra	Compute the splitting points with threshold SPLTOL. LARRA: sets any "small" off-diagonal elements to zero
Clarrb	Given the relatively robust representation(RRR) L D L^T, LARRB: does "limited" bisection to refine the eigenvalues of L D L^T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses and their gaps are input in WERR and WGAP, respectively. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively
Clarrc	Find the number of eigenvalues of the symmetric tridiagonal matrix T that are in the interval (VL,VU] if JOBT = 'T', and of L D L^T if JOBT = 'L'
Clarrd	LARRD: computes the eigenvalues of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from DSTEMR. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow*(1/2) underflow**(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966
Clarre	To find the desired eigenvalues of a given real symmetric tridiagonal matrix T, LARRE: sets any "small" off-diagonal elements to zero, and for each unreduced block T_i, it finds (a) a suitable shift at one end of the block's spectrum, (b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and (c) eigenvalues of each L_i D_i L_i^T. The representations and eigenvalues found are then used by DSTEMR to compute the eigenvectors of T. The accuracy varies depending on whether bisection is used to find a few eigenvalues or the dqds algorithm (subroutine DLASQ2) to conpute all and then discard any unwanted one. As an added benefit, LARRE also outputs the n Gerschgorin intervals for the matrices L_i D_i L_i^T
Clarrf	Given the initial representation L D L^T and its cluster of close eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ... W( CLEND ), LARRF: finds a new relatively robust representation L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the eigenvalues of L(+) D(+) L(+)^T is relatively isolated
Clarrj	Given the initial eigenvalue approximations of T, LARRJ: does bisection to refine the eigenvalues of T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses in WERR. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively
Clarrk	LARRK: computes one eigenvalue of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from DSTEMR. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow*(1/2) underflow**(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966
Clarrr	Perform tests to decide whether the symmetric tridiagonal matrix T warrants expensive computations which guarantee high relative accuracy in the eigenvalues
Clarrv	LARRV: 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
Clartg	!
Clartgp	LARTGP: generates a plane rotation so that [ CS SN ] . [ F ] = [ R ] where CS2 + SN2 = 1. [ -SN CS ] [ G ] [ 0 ] This is a slower, more accurate version of the Level 1 BLAS routine DROTG, with the following other differences: F and G are unchanged on return. If G=0, then CS=(+/-)1 and SN=0. If F=0 and (G .ne. 0), then CS=0 and SN=(+/-)1. The sign is chosen so that R >= 0
Clartgs	LARTGS: generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2
Clartv	LARTV: 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) )
Claruv	LARUV: returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by DLARNV and ZLARNV
Clarz	LARZ: 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
Clarzb	LARZB: 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
Clarzt	LARZT: 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
Clascl	LASCL: 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
Clasd0	Using a divide and conquer approach, LASD0: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes orthogonal matrices U and VT such that B = U * S * VT. The singular values S are overwritten on D. A related subroutine, DLASDA, computes only the singular values, and optionally, the singular vectors in compact form
Clasd1	LASD1: computes the SVD of an upper bidiagonal N-by-M matrix B, where N = NL + NR + 1 and M = N + SQRE. LASD1 is called from DLASD0. A related subroutine DLASD7 handles the case in which the singular values (and the singular vectors in factored form) are desired. LASD1 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The left singular vectors of the original matrix are stored in U, and the transpose of the right singular vectors are stored in VT, and the singular values are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple singular values or when there are zeros 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 DLASD2. The second stage consists of calculating the updated singular values. This is done by finding the square roots of the roots of the secular equation via the routine DLASD4 (as called by DLASD3). This routine also calculates the singular vectors of the current problem. The final stage consists of computing the updated singular vectors directly using the updated singular values. The singular vectors for the current problem are multiplied with the singular vectors from the overall problem
Clasd4	This subroutine computes the square root of the I-th updated eigenvalue of a positive symmetric rank-one modification to a positive diagonal matrix whose entries are given as the squares of the corresponding entries in the array d, and that 0 <= D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) * diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions
Clasd5	This subroutine computes the square root of the I-th eigenvalue of a positive symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) * diag( D ) + RHO * Z * transpose(Z) . The diagonal entries in the array D are assumed to satisfy 0 <= D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one
Clasd6	LASD6: computes the SVD of an updated upper bidiagonal matrix B obtained by merging two smaller ones by appending a row. This routine is used only for the problem which requires all singular values and optionally singular vector matrices in factored form. B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE. A related subroutine, DLASD1, handles the case in which all singular values and singular vectors of the bidiagonal matrix are desired. LASD6 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The singular values of B can be computed using D1, D2, the first components of all the right singular vectors of the lower block, and the last components of all the right singular vectors of the upper block. These components are stored and updated in VF and VL, respectively, in LASD6. Hence U and VT are not explicitly referenced. The singular values are stored in D. The algorithm consists of two stages: The first stage consists of deflating the size of the problem when there are multiple singular values 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 DLASD7. The second stage consists of calculating the updated singular values. This is done by finding the roots of the secular equation via the routine DLASD4 (as called by DLASD8). This routine also updates VF and VL and computes the distances between the updated singular values and the old singular values. LASD6 is called from DLASDA
Clasd7	LASD7: merges the two sets of singular values 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 singular values are close together or if there is a tiny entry in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one. LASD7 is called from DLASD6
Clasd8	LASD8: finds the square roots of the roots of the secular equation, as defined by the values in DSIGMA and Z. It makes the appropriate calls to DLASD4, and stores, for each element in D, the distance to its two nearest poles (elements in DSIGMA). It also updates the arrays VF and VL, the first and last components of all the right singular vectors of the original bidiagonal matrix. LASD8 is called from DLASD6
Clasda	Using a divide and conquer approach, LASDA: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes the singular values in the SVD B = U * S * VT. The orthogonal matrices U and VT are optionally computed in compact form. A related subroutine, DLASD0, computes the singular values and the singular vectors in explicit form
Clasdq	LASDQ: computes the singular value decomposition (SVD) of a real (upper or lower) bidiagonal matrix with diagonal D and offdiagonal E, accumulating the transformations if desired. Letting B denote the input bidiagonal matrix, the algorithm computes orthogonal matrices Q and P such that B = Q * S * PT (PT denotes the transpose of P). The singular values S are overwritten on D. The input matrix U is changed to U * Q if desired. The input matrix VT is changed to P*T VT if desired. The input matrix C is changed to Q*T C if desired. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3, for a detailed description of the algorithm
Claset	LASET: initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals
Clasq1	LASQ1: computes the singular values of a real N-by-N bidiagonal matrix with diagonal D and off-diagonal E. The singular values are computed to high relative accuracy, in the absence of denormalization, underflow and overflow. The algorithm was first presented in "Accurate singular values and differential qd algorithms" by K. V. Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230, 1994, and the present implementation is described in "An implementation of the dqds Algorithm (Positive Case)", LAPACK Working Note
Clasq4	LASQ4: computes an approximation TAU to the smallest eigenvalue using values of d from the previous transform
Clasq5	LASQ5: computes one dqds transform in ping-pong form, one version for IEEE machines another for non IEEE machines
Clasq6	LASQ6: computes one dqd (shift equal to zero) transform in ping-pong form, with protection against underflow and overflow
Clasr	LASR: 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
Clasrt	Sort the numbers in D in increasing order (if ID = 'I') or in decreasing order (if ID = 'D' ). Use Quick Sort, reverting to Insertion sort on arrays of size <= 20. Dimension of STACK limits N to about 2**32
Classq	!
Claswlq	LASWLQ: 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
Claswp	LASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A
Clasyf	LASYF: 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. LASYF 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')
Clasyf_aa	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
Clasyf_rk	LASYF_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. LASYF_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')
Clasyf_rook	LASYF_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. LASYF_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')
Clatbs	LATBS: 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
Clatdf	LATDF: 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
Clatps	LATPS: 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
Clatrd	LATRD: 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', LATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', LATRD 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
Clatrs	LATRS: 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
Clatrz	LATRZ: 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
Clatsqr	LATSQR: 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
Claunhr_col_getrfnp	LAUNHR_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 LAUNHR_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
Claunhr_col_getrfnp2	LAUNHR_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]. LAUNHR_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, LAUNHR_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
Clauum	LAUUM: 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
Copgtr	OPGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by DSPTRD 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)
Copmtr	OPMTR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal 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 DSPTRD 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)
Corbdb	ORBDB: simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 \| B12 0 0 ] [ X11 \| X12 ] [ P1 \| ] [ 0 \| 0 -I 0 ] [ Q1 \| ]**T 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 DORCSD for details.) The orthogonal 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
Corbdb1	ORBDB1: 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 DORBDB2, DORBDB3, and DORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal 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
Corbdb2	ORBDB2: 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 DORBDB1, DORBDB3, and DORBDB4 handle cases in which P is not the minimum dimension. The orthogonal 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
Corbdb3	ORBDB3: 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 DORBDB1, DORBDB2, and DORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal 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
Corbdb4	ORBDB4: 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 DORBDB1, DORBDB2, and DORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal 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
Corbdb5	ORBDB5: 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
Corbdb6	ORBDB6: 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
Corcsd	ORCSD: computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 \| 0 0 0 ] [ 0 C 0 \| 0 -S 0 ] [ X11 \| X12 ] [ U1 \| ] [ 0 0 0 \| 0 0 -I ] [ V1 \| ]**T 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 orthogonal 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)
Corcsd2by1	ORCSD2BY1: 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 orthogonal 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)
Corg2l	ORG2L: generates an m by n real 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 DGEQLF
Corg2r	ORG2R: generates an m by n real 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 DGEQRF
Corgbr	ORGBR: generates one of the real orthogonal matrices Q or P*T determined by DGEBRD when reducing a real matrix A to bidiagonal form: A = Q B * PT. Q and PT 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 ORGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and ORGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PT is of order N: if k < n, PT = G(k) . . . G(2) G(1) and ORGBR returns the first m rows of PT, where n >= m >= k; if k >= n, PT = G(n-1) . . . G(2) G(1) and ORGBR returns P**T as an N-by-N matrix
Corghr	ORGHR: generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1)
Corglq	ORGLQ: generates an M-by-N real 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(2) H(1) as returned by DGELQF
Corgql	ORGQL: generates an M-by-N real 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 DGEQLF
Corgqr	ORGQR: generates an M-by-N real 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 GEQRF
Corgrq	ORGRQ: generates an M-by-N real 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(2) . . . H(k) as returned by DGERQF
Corgtr	ORGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by DSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1)
Corgtsqr	ORGTSQR: generates an M-by-N real matrix Q_out with orthonormal columns, which are the first N columns of a product of real orthogonal matrices of order M which are returned by DLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for DLATSQR
Corgtsqr_row	ORGTSQR_ROW: generates an M-by-N real matrix Q_out with orthonormal columns from the output of DLATSQR. 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 DLATSQR 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 DLATSQR 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 DLARFB_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 DLATSQR generates the output blocks
Corhr_col	ORHR_COL: takes an M-by-N real 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 DGEQRT)
Corm2l	ORM2L: overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*T C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'
Corm2r	ORM2R: overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*T C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'
Cormbr	If VECT = 'Q', ORMBR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q*T If VECT = 'P', ORMBR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P C C * P TRANS = 'T': P*T C C * PT Here Q and PT are the orthogonal matrices determined by DGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT 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 orthogonal matrix Q or P**T 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)
Cormhr	ORMHR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal 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 DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1)
Cormlq	ORMLQ: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'
Cormql	ORMQL: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'
Cormqr	ORMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'
Cormrq	ORMRQ: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'
Cormrz	ORMRZ: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'
Cormtr	ORMTR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal 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 DSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1)
Cpbcon	PBCON: 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)))
Cpbequ	PBEQU: 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
Cpbrfs	PBRFS: 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
Cpbstf	PBSTF: 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
Cpbsv	PBSV: 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
Cpbtrf	PBTRF: 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
Cpbtrs	PBTRS: 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
Cpftrf	PFTRF: 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
Cpftri	PFTRI: 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
Cpftrs	PFTRS: 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
Cpocon	POCON: 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)))
Cpoequ	POEQU: 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
Cpoequb	POEQUB: 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)
Cporfs	PORFS: 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
Cposv	POSV: 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
Cpotrf	POTRF: 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
Cpotrf2	POTRF2: 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
Cpotri	POTRI: 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
Cpotrs	POTRS: 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
Cppcon	PPCON: 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)))
Cppequ	PPEQU: 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
Cpprfs	PPRFS: 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
Cppsv	PPSV: 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
Cpptrf	PPTRF: 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
Cpptri	PPTRI: 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
Cpptrs	PPTRS: 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
Cpstrf	PSTRF: 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
Cptcon	PTCON: 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)))
Cpteqr	PTEQR: 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.)
Cptrfs	PTRFS: 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
Cptsv	PTSV: 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
Cpttrf	PTTRF: 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
Cpttrs	PTTRS: 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
Crot	ROT: applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex
Crscl	RSCL: multiplies an n-element real 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
Csb2st_kernels	SB2ST_KERNELS: is an internal routine used by the DSYTRD_SB2ST subroutine
Csbev	SBEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A
Csbevd	SBEVD: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric 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
Csbgst	SBGST: reduces a real symmetric-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 STS by DPBSTF, using a split Cholesky factorization. A is overwritten by C = X*TAX, where X = S(-1)Q and Q is an orthogonal matrix chosen to preserve the bandwidth of A
Csbgv	SBGV: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite
Csbgvd	SBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric 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
Csbtrd	SBTRD: reduces a real symmetric band matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q*T A * Q = T
Csfrk	Level 3 BLAS like routine for C in RFP Format. SFRK: performs one of the symmetric rank–k operations C := alphaAA*T + betaC, or C := alphaATA + beta*C, where alpha and beta are real scalars, C is an n–by–n symmetric matrix and A is an n–by–k matrix in the first case and a k–by–n matrix in the second case
Cspcon	SPCON: 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)))
Cspev	SPEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage
Cspevd	SPEVD: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric 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
Cspgst	SPGST: reduces a real symmetric-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by DPPTRF
Cspgv	SPGV: computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite
Cspgvd	SPGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, 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
Cspmv	SPMV: 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
Cspr	SPR: 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
Csprfs	SPRFS: 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
Cspsv	SPSV: 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
Csptrd	SPTRD: reduces a real symmetric matrix A stored in packed form to symmetric tridiagonal form T by an orthogonal similarity transformation: Q*T A * Q = T
Csptrf	SPTRF: 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
Csptri	SPTRI: 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
Csptrs	SPTRS: 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
Cstebz	STEBZ: computes the eigenvalues of a symmetric tridiagonal matrix T. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow*(1/2) underflow**(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966
Cstedc	STEDC: 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
Cstegr	STEGR: 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. STEGR 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 : STEGR 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
Cstein	STEIN: 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
Cstemr	STEMR: 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:
Csteqr	STEQR: 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
Csterf	STERF: computes all eigenvalues of a symmetric tridiagonal matrix using the Pal-Walker-Kahan variant of the QL or QR algorithm
Cstev	STEV: computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix A
Cstevd	STEVD: computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix. 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
Cstevr	STEVR: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. Whenever possible, STEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR 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 the i-th unreduced block of T, (a) Compute T - sigma_i = L_i D_i L_i^T, such that L_i D_i L_i^T is a relatively robust representation, (b) Compute the eigenvalues, lambda_j, of L_i D_i L_i^T to high relative accuracy by the dqds algorithm, (c) If there is a cluster of close eigenvalues, "choose" sigma_i close to the cluster, and go to step (a), (d) Given the approximate eigenvalue lambda_j of L_i D_i L_i^T, compute the corresponding eigenvector by forming a rank-revealing twisted factorization. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", by Inderjit Dhillon, Computer Science Division Technical Report No. UCB//CSD-97-971, UC Berkeley, May 1997. Note 1 : STEVR calls DSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. STEVR calls DSTEBZ and DSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of DSTEMR 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
Csycon	SYCON: 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)))
Csycon_rook	SYCON_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)))
Csyconv	SYCONV: 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
Csyconvf	If parameter WAY = 'C': SYCONVF: 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': SYCONVF 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. SYCONVF can also convert in Hermitian matrix case, i.e. between formats used in CHETRF and CHETRF_RK (or CHETRF_BK)
Csyconvf_rook	If parameter WAY = 'C': SYCONVF_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': SYCONVF_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. SYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in CHETRF_ROOK and CHETRF_RK (or CHETRF_BK)
Csyequb	SYEQUB: 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
Csyev	SYEV: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A
Csyevd	SYEVD: computes all eigenvalues and, optionally, eigenvectors of a real symmetric 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. Because of large use of BLAS of level 3, SYEVD needs N**2 more workspace than DSYEVX
Csyevr	SYEVR: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, SYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR 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 DSTEMR's documentation and:
Csygst	SYGST: reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by DPOTRF
Csygv	SYGV: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite
Csygvd	SYGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric 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
Csymv	SYMV: 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
Csyr	SYR: 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
Csyrfs	SYRFS: 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
Csysv	SYSV: 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
Csysv_aa	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
Csysv_rk	SYSV_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
Csysv_rook	SYSV_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
Csyswapr	SYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix
Csytf2_rk	SYTF2_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
Csytf2_rook	SYTF2_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
Csytrd	SYTRD: reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q*T A * Q = T
Csytrd_sb2st	SYTRD_SB2ST: reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q*T A * Q = T
Csytrd_sy2sb	SYTRD_SY2SB: reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q*T A * Q = AB
Csytrf	SYTRF: 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
Csytrf_aa	SYTRF_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
Csytrf_rk	SYTRF_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
Csytrf_rook	SYTRF_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
Csytri	SYTRI: computes the inverse of a complex symmetric indefinite matrix A using the factorization A = UDU*T or A = LDL*T computed by CSYTRF
Csytri_rook	SYTRI_ROOK: computes the inverse of a complex symmetric matrix A using the factorization A = UDU*T or A = LDL*T computed by CSYTRF_ROOK
Csytrs	SYTRS: 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
Csytrs2	SYTRS2: 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
Csytrs_3	SYTRS_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
Csytrs_aa	SYTRS_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
Csytrs_rook	SYTRS_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
Ctbcon	TBCON: 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)) )
Ctbrfs	TBRFS: 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. TBRFS does not do iterative refinement because doing so cannot improve the backward error
Ctbtrs	TBTRS: 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
Ctfsm	Level 3 BLAS like routine for A in RFP Format. TFSM: 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
Ctftri	TFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm
Ctfttp	TFTTP: copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP)
Ctfttr	TFTTR: copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR)
Ctgevc	TGEVC: 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)
Ctgexc	TGEXC: 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
Ctgsen	TGSEN: 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. TGSEN 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
Ctgsja	TGSJA: 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
Ctgsna	TGSNA: 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
Ctgsyl	TGSYL: 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, TGSYL 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
Ctpcon	TPCON: 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)) )
Ctplqt	TPLQT: 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
Ctplqt2	TPLQT2: 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
Ctpmlqt	TPMLQT: 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
Ctpmqrt	TPMQRT: 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
Ctpqrt	TPQRT: 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
Ctpqrt2	TPQRT2: 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
Ctprfb	TPRFB: 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
Ctprfs	TPRFS: 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. TPRFS does not do iterative refinement because doing so cannot improve the backward error
Ctptri	TPTRI: computes the inverse of a complex upper or lower triangular matrix A stored in packed format
Ctptrs	TPTRS: 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
Ctpttf	TPTTF: copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF)
Ctpttr	TPTTR: copies a triangular matrix A from standard packed format (TP) to standard full format (TR)
Ctrcon	TRCON: 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)) )
Ctrevc	TREVC: 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
Ctrevc3	TREVC3: 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
Ctrexc	TREXC: 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
Ctrrfs	TRRFS: 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. TRRFS does not do iterative refinement because doing so cannot improve the backward error
Ctrsen	TRSEN: 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
Ctrsna	TRSNA: 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)
Ctrsyl	TRSYL: 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
Ctrtri	TRTRI: computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm
Ctrtrs	TRTRS: 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
Ctrttf	TRTTF: copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF)
Ctrttp	TRTTP: copies a triangular matrix A from full format (TR) to standard packed format (TP)
Ctzrzf	TZRZF: 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
Cunbdb	UNBDB: 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
Cunbdb1	UNBDB1: 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
Cunbdb2	UNBDB2: 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
Cunbdb3	UNBDB3: 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
Cunbdb4	UNBDB4: 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
Cunbdb5	UNBDB5: 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
Cunbdb6	UNBDB6: 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
Cuncsd	UNCSD: 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)
Cuncsd2by1	UNCSD2BY1: 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)
Cung2l	UNG2L: 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
Cung2r	UNG2R: 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
Cungbr	UNGBR: 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 UNGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and UNGBR 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 UNGBR returns the first m rows of PH, where n >= m >= k; if k >= n, PH = G(n-1) . . . G(2) G(1) and UNGBR returns P**H as an N-by-N matrix
Cunghr	UNGHR: 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)
Cunglq	UNGLQ: 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
Cungql	UNGQL: 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
Cungqr	UNGQR: 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
Cungrq	UNGRQ: 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
Cungtr	UNGTR: 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)
Cungtsqr	UNGTSQR: 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
Cungtsqr_row	UNGTSQR_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
Cunhr_col	UNHR_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)
Cunm2l	UNM2L: 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'
Cunm2r	UNM2R: 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'
Cunmbr	If VECT = 'Q', UNMBR: 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', UNMBR 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)
Cunmhr	UNMHR: 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)
Cunmlq	UNMLQ: 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'
Cunmql	UNMQL: 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'
Cunmqr	UNMQR: 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'
Cunmrq	UNMRQ: 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'
Cunmrz	UNMRZ: 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'
Cunmtr	UNMTR: 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)
Cupgtr	UPGTR: 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)
Cupmtr	UPMTR: 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)
►Mla_lapack_aux	LAPACK helpers: environment enquiry, character decoding, index scans
Cla_selctg_c
Cla_selctg_d
Cla_selctg_q
Cla_selctg_s
Cla_selctg_w
Cla_selctg_z
Cla_select_c
Cla_select_d
Cla_select_q
Cla_select_s
Cla_select_w
Cla_select_z
►Mla_least_squares	Least squares solution interface
Cconstrained_lstsq
Cconstrained_lstsq_space
Clstsq	Compute a least squares solution to system $ A \cdot x = b $, i.e. such that the 2-norm $ \\|b - A \cdot x\\| $ is minimized
Clstsq_space
Csolve_constrained_lstsq
Csolve_lstsq
Csolve_weighted_lstsq
Cweighted_lstsq
►Mla_matrix_property_checks	Matrix property checks
Cis_diagonal
Cis_hermitian
Cis_hessenberg
Cis_skew_symmetric
Cis_square
Cis_symmetric
Cis_triangular
►Mla_norms	Matrix and Vector norms
Cget_norm	Vector norm: subroutine interface
Cmnorm	Matrix norm: function interface
Cnorm	Compute the norm of a vector or matrix using LAPACK-based routines
►Mla_pseudoinverse
Coperator(.pinv.)	Compute the pseudo-inverse of a matrix using the `.pinv.` operator
Cpinv	Compute the pseudo-inverse of a matrix
Cpseudoinvert	Compute the pseudo-inverse of a matrix (subroutine version)
►Mla_qr	QR factorization of a matrix
Cqr	Compute the QR factorization of a matrix
Cqr_space
►Mla_schur
Cschur	Compute the Schur decomposition of a matrix
Cschur_space	Compute the required workspace size for Schur decomposition
►Mla_solve
Csolve	Solve a system of linear equations A * X = B
Csolve_chol
Csolve_lower_chol
Csolve_lu
Csolve_upper_chol
►Mla_state_type	State and error handling module for linear algebra routines
Cla_state	Defines a state return type for a linear algebra routine
Coperator(/=)
Coperator(<)
Coperator(<=)
Coperator(==)	Comparison operators
Coperator(>)
Coperator(>=)
►Mla_svd	Singular Value Decomposition
Csvd	Compute the Singular Value Decomposition (SVD) of a matrix
Csvdvals