--- name: "hetrf_aa" section: "3" platform: "linux" package: "lapack-doc" version: "3.12.1-2" release: "Arch Linux 2026-11-01" platforms: ["linux"] url: "https://new.carta.tech/hetrf_aa" --- # hetrf\_aa(3) {he,sy}trf\_aa: triangular factor ## NAME hetrf\_aa - {he,sy}trf\_aa: triangular factor ## SYNOPSIS ### Functions subroutine **chetrf\_aa** (uplo, n, a, lda, ipiv, work, lwork, info)\ **CHETRF\_AA** subroutine **csytrf\_aa** (uplo, n, a, lda, ipiv, work, lwork, info)\ **CSYTRF\_AA** subroutine **dsytrf\_aa** (uplo, n, a, lda, ipiv, work, lwork, info)\ **DSYTRF\_AA** subroutine **ssytrf\_aa** (uplo, n, a, lda, ipiv, work, lwork, info)\ **SSYTRF\_AA** subroutine **zhetrf\_aa** (uplo, n, a, lda, ipiv, work, lwork, info)\ **ZHETRF\_AA** subroutine **zsytrf\_aa** (uplo, n, a, lda, ipiv, work, lwork, info)\ **ZSYTRF\_AA** ## Detailed Description ## Function Documentation ### subroutine chetrf\_aa (character uplo, integer n, complex, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, complex, dimension( \* ) work, integer lwork, integer info) **CHETRF\_AA** **Purpose:** ``` !> !> CHETRF_AA computes the factorization of a complex hermitian matrix A !> using the Aasen's algorithm. The form of the factorization is !> !> A = U**H*T*U or A = L*T*L**H !> !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices, and T is a hermitian tridiagonal matrix. !> !> This is the blocked version of the algorithm, calling Level 3 BLAS. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrix A. N >= 0. !> ``` *A* ``` !> A is COMPLEX array, dimension (LDA,N) !> On entry, the hermitian matrix A. If UPLO = 'U', the leading !> N-by-N upper triangular part of A contains the upper !> triangular part of the matrix A, and the strictly lower !> triangular part of A is not referenced. If UPLO = 'L', the !> leading N-by-N lower triangular part of A contains the lower !> triangular part of the matrix A, and the strictly upper !> triangular part of A is not referenced. !> !> On exit, the tridiagonal matrix is stored in the diagonals !> and the subdiagonals of A just below (or above) the diagonals, !> and L is stored below (or above) the subdiagonals, when UPLO !> is 'L' (or 'U'). !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> On exit, it contains the details of the interchanges, i.e., !> the row and column k of A were interchanged with the !> row and column IPIV(k). !> ``` *WORK* ``` !> WORK is COMPLEX array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The length of WORK. !> LWORK >= 1, if N <= 1, and LWORK >= 2*N, otherwise. !> For optimum performance LWORK >= N*(1+NB), where NB is !> the optimal blocksize, returned by ILAENV. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **133** of file **chetrf\_aa.f**. ### subroutine csytrf\_aa (character uplo, integer n, complex, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, complex, dimension( \* ) work, integer lwork, integer info) **CSYTRF\_AA** **Purpose:** ``` !> !> CSYTRF_AA computes the factorization of a complex symmetric matrix A !> using the Aasen's algorithm. The form of the factorization is !> !> A = U**T*T*U or A = L*T*L**T !> !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices, and T is a complex symmetric tridiagonal matrix. !> !> This is the blocked version of the algorithm, calling Level 3 BLAS. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrix A. N >= 0. !> ``` *A* ``` !> A is COMPLEX array, dimension (LDA,N) !> On entry, the symmetric matrix A. If UPLO = 'U', the leading !> N-by-N upper triangular part of A contains the upper !> triangular part of the matrix A, and the strictly lower !> triangular part of A is not referenced. If UPLO = 'L', the !> leading N-by-N lower triangular part of A contains the lower !> triangular part of the matrix A, and the strictly upper !> triangular part of A is not referenced. !> !> On exit, the tridiagonal matrix is stored in the diagonals !> and the subdiagonals of A just below (or above) the diagonals, !> and L is stored below (or above) the subdiagonals, when UPLO !> is 'L' (or 'U'). !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> On exit, it contains the details of the interchanges, i.e., !> the row and column k of A were interchanged with the !> row and column IPIV(k). !> ``` *WORK* ``` !> WORK is COMPLEX array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The length of WORK. LWORK >= MAX(1,2*N). For optimum performance !> LWORK >= N*(1+NB), where NB is the optimal blocksize. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **131** of file **csytrf\_aa.f**. ### subroutine dsytrf\_aa (character uplo, integer n, double precision, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, double precision, dimension( \* ) work, integer lwork, integer info) **DSYTRF\_AA** **Purpose:** ``` !> !> DSYTRF_AA computes the factorization of a real symmetric matrix A !> using the Aasen's algorithm. The form of the factorization is !> !> A = U**T*T*U or A = L*T*L**T !> !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices, and T is a symmetric tridiagonal matrix. !> !> This is the blocked version of the algorithm, calling Level 3 BLAS. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrix A. N >= 0. !> ``` *A* ``` !> A is DOUBLE PRECISION array, dimension (LDA,N) !> On entry, the symmetric matrix A. If UPLO = 'U', the leading !> N-by-N upper triangular part of A contains the upper !> triangular part of the matrix A, and the strictly lower !> triangular part of A is not referenced. If UPLO = 'L', the !> leading N-by-N lower triangular part of A contains the lower !> triangular part of the matrix A, and the strictly upper !> triangular part of A is not referenced. !> !> On exit, the tridiagonal matrix is stored in the diagonals !> and the subdiagonals of A just below (or above) the diagonals, !> and L is stored below (or above) the subdiagonals, when UPLO !> is 'L' (or 'U'). !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> On exit, it contains the details of the interchanges, i.e., !> the row and column k of A were interchanged with the !> row and column IPIV(k). !> ``` *WORK* ``` !> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The length of WORK. !> LWORK >= 1, if N <= 1, and LWORK >= 2*N, otherwise. !> For optimum performance LWORK >= N*(1+NB), where NB is !> the optimal blocksize, returned by ILAENV. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **133** of file **dsytrf\_aa.f**. ### subroutine ssytrf\_aa (character uplo, integer n, real, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, real, dimension( \* ) work, integer lwork, integer info) **SSYTRF\_AA** **Purpose:** ``` !> !> SSYTRF_AA computes the factorization of a real symmetric matrix A !> using the Aasen's algorithm. The form of the factorization is !> !> A = U**T*T*U or A = L*T*L**T !> !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices, and T is a symmetric tridiagonal matrix. !> !> This is the blocked version of the algorithm, calling Level 3 BLAS. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrix A. N >= 0. !> ``` *A* ``` !> A is REAL array, dimension (LDA,N) !> On entry, the symmetric matrix A. If UPLO = 'U', the leading !> N-by-N upper triangular part of A contains the upper !> triangular part of the matrix A, and the strictly lower !> triangular part of A is not referenced. If UPLO = 'L', the !> leading N-by-N lower triangular part of A contains the lower !> triangular part of the matrix A, and the strictly upper !> triangular part of A is not referenced. !> !> On exit, the tridiagonal matrix is stored in the diagonals !> and the subdiagonals of A just below (or above) the diagonals, !> and L is stored below (or above) the subdiagonals, when UPLO !> is 'L' (or 'U'). !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> On exit, it contains the details of the interchanges, i.e., !> the row and column k of A were interchanged with the !> row and column IPIV(k). !> ``` *WORK* ``` !> WORK is REAL array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The length of WORK. !> LWORK >= 1, if N <= 1, and LWORK >= 2*N, otherwise. !> For optimum performance LWORK >= N*(1+NB), where NB is !> the optimal blocksize, returned by ILAENV. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **133** of file **ssytrf\_aa.f**. ### subroutine zhetrf\_aa (character uplo, integer n, complex\*16, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, complex\*16, dimension( \* ) work, integer lwork, integer info) **ZHETRF\_AA** **Purpose:** ``` !> !> ZHETRF_AA computes the factorization of a complex hermitian matrix A !> using the Aasen's algorithm. The form of the factorization is !> !> A = U**H*T*U or A = L*T*L**H !> !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices, and T is a hermitian tridiagonal matrix. !> !> This is the blocked version of the algorithm, calling Level 3 BLAS. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrix A. N >= 0. !> ``` *A* ``` !> A is COMPLEX*16 array, dimension (LDA,N) !> On entry, the hermitian matrix A. If UPLO = 'U', the leading !> N-by-N upper triangular part of A contains the upper !> triangular part of the matrix A, and the strictly lower !> triangular part of A is not referenced. If UPLO = 'L', the !> leading N-by-N lower triangular part of A contains the lower !> triangular part of the matrix A, and the strictly upper !> triangular part of A is not referenced. !> !> On exit, the tridiagonal matrix is stored in the diagonals !> and the subdiagonals of A just below (or above) the diagonals, !> and L is stored below (or above) the subdiagonals, when UPLO !> is 'L' (or 'U'). !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> On exit, it contains the details of the interchanges, i.e., !> the row and column k of A were interchanged with the !> row and column IPIV(k). !> ``` *WORK* ``` !> WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The length of WORK. !> LWORK >= 1, if N >= 1, and LWORK >= 2*N, otherwise. !> For optimum performance LWORK >= N*(1+NB), where NB is !> the optimal blocksize, returned by ILAENV. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **133** of file **zhetrf\_aa.f**. ### subroutine zsytrf\_aa (character uplo, integer n, complex\*16, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, complex\*16, dimension( \* ) work, integer lwork, integer info) **ZSYTRF\_AA** **Purpose:** ``` !> !> ZSYTRF_AA computes the factorization of a complex symmetric matrix A !> using the Aasen's algorithm. The form of the factorization is !> !> A = U**T*T*U or A = L*T*L**T !> !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices, and T is a complex symmetric tridiagonal matrix. !> !> This is the blocked version of the algorithm, calling Level 3 BLAS. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrix A. N >= 0. !> ``` *A* ``` !> A is COMPLEX*16 array, dimension (LDA,N) !> On entry, the symmetric matrix A. If UPLO = 'U', the leading !> N-by-N upper triangular part of A contains the upper !> triangular part of the matrix A, and the strictly lower !> triangular part of A is not referenced. If UPLO = 'L', the !> leading N-by-N lower triangular part of A contains the lower !> triangular part of the matrix A, and the strictly upper !> triangular part of A is not referenced. !> !> On exit, the tridiagonal matrix is stored in the diagonals !> and the subdiagonals of A just below (or above) the diagonals, !> and L is stored below (or above) the subdiagonals, when UPLO !> is 'L' (or 'U'). !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> On exit, it contains the details of the interchanges, i.e., !> the row and column k of A were interchanged with the !> row and column IPIV(k). !> ``` *WORK* ``` !> WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The length of WORK. LWORK >=MAX(1,2*N). For optimum performance !> LWORK >= N*(1+NB), where NB is the optimal blocksize. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **131** of file **zsytrf\_aa.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.