--- name: "hesv_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/hesv_aa" --- # hesv\_aa(3) {he,sy}sv\_aa: Aasen ## NAME hesv\_aa - {he,sy}sv\_aa: Aasen ## SYNOPSIS ### Functions subroutine **chesv\_aa** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)\ **CHESV\_AA computes the solution to system of linear equations A \* X = B for HE matrices** subroutine **csysv\_aa** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)\ **CSYSV\_AA computes the solution to system of linear equations A \* X = B for SY matrices** subroutine **dsysv\_aa** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)\ **DSYSV\_AA computes the solution to system of linear equations A \* X = B for SY matrices** subroutine **ssysv\_aa** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)\ **SSYSV\_AA computes the solution to system of linear equations A \* X = B for SY matrices** subroutine **zhesv\_aa** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)\ **ZHESV\_AA computes the solution to system of linear equations A \* X = B for HE matrices** subroutine **zsysv\_aa** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)\ **ZSYSV\_AA computes the solution to system of linear equations A \* X = B for SY matrices** ## Detailed Description ## Function Documentation ### subroutine chesv\_aa (character uplo, integer n, integer nrhs, complex, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, complex, dimension( ldb, \* ) b, integer ldb, complex, dimension( \* ) work, integer lwork, integer info) **CHESV\_AA computes the solution to system of linear equations A \* X = B for HE matrices** **Purpose:** ``` !> !> CHESV_AA computes the solution to a complex system of linear equations !> A * X = B, !> where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS !> matrices. !> !> Aasen's algorithm is used to factor A as !> A = U**H * T * U, if UPLO = 'U', or !> A = L * T * L**H, if UPLO = 'L', !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices, and T is Hermitian and tridiagonal. The factored form !> of A is then used to solve the system of equations A * X = B. !> ``` **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 number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> ``` *NRHS* ``` !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 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, if INFO = 0, the tridiagonal matrix T and the !> multipliers used to obtain the factor U or L from the !> factorization A = U**H*T*U or A = L*T*L**H as computed by !> CHETRF_AA. !> ``` *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). !> ``` *B* ``` !> B is COMPLEX array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *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,3*N-2), and for best !> performance LWORK >= MAX(1,N*NB), where NB is the optimal !> blocksize for CHETRF. !> !> 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 !> > 0: if INFO = i, D(i,i) is exactly zero. The factorization !> has been completed, but the block diagonal matrix D is !> exactly singular, so the solution could not be computed. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **160** of file **chesv\_aa.f**. ### subroutine csysv\_aa (character uplo, integer n, integer nrhs, complex, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, complex, dimension( ldb, \* ) b, integer ldb, complex, dimension( \* ) work, integer lwork, integer info) **CSYSV\_AA computes the solution to system of linear equations A \* X = B for SY matrices** **Purpose:** ``` !> !> 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. !> ``` **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 number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> ``` *NRHS* ``` !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 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, if INFO = 0, the tridiagonal matrix T and the !> multipliers used to obtain the factor U or L from the !> factorization A = U**T*T*U or A = L*T*L**T as computed by !> CSYTRF. !> ``` *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). !> ``` *B* ``` !> B is COMPLEX array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *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(2*N, 3*N-2), and for !> the best performance, LWORK >= max(1,N*NB), where NB is !> the optimal blocksize for CSYTRF_AA. !> !> 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 !> > 0: if INFO = i, D(i,i) is exactly zero. The factorization !> has been completed, but the block diagonal matrix D is !> exactly singular, so the solution could not be computed. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **160** of file **csysv\_aa.f**. ### subroutine dsysv\_aa (character uplo, integer n, integer nrhs, double precision, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, double precision, dimension( ldb, \* ) b, integer ldb, double precision, dimension( \* ) work, integer lwork, integer info) **DSYSV\_AA computes the solution to system of linear equations A \* X = B for SY matrices** **Purpose:** ``` !> !> DSYSV computes the solution to a real 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. !> ``` **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 number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> ``` *NRHS* ``` !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 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, if INFO = 0, the tridiagonal matrix T and the !> multipliers used to obtain the factor U or L from the !> factorization A = U**T*T*U or A = L*T*L**T as computed by !> DSYTRF. !> ``` *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). !> ``` *B* ``` !> B is DOUBLE PRECISION array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *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 >= MAX(1,2*N,3*N-2), and for !> the best performance, LWORK >= MAX(1,N*NB), where NB is !> the optimal blocksize for DSYTRF_AA. !> !> 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 !> > 0: if INFO = i, D(i,i) is exactly zero. The factorization !> has been completed, but the block diagonal matrix D is !> exactly singular, so the solution could not be computed. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **160** of file **dsysv\_aa.f**. ### subroutine ssysv\_aa (character uplo, integer n, integer nrhs, real, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, real, dimension( ldb, \* ) b, integer ldb, real, dimension( \* ) work, integer lwork, integer info) **SSYSV\_AA computes the solution to system of linear equations A \* X = B for SY matrices** **Purpose:** ``` !> !> SSYSV computes the solution to a real 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. !> ``` **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 number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> ``` *NRHS* ``` !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 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, if INFO = 0, the tridiagonal matrix T and the !> multipliers used to obtain the factor U or L from the !> factorization A = U**T*T*U or A = L*T*L**T as computed by !> SSYTRF. !> ``` *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). !> ``` *B* ``` !> B is REAL array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *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 >= MAX(1,2*N,3*N-2), and for !> the best performance, LWORK >= MAX(1,N*NB), where NB is !> the optimal blocksize for SSYTRF_AA. !> !> 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 !> > 0: if INFO = i, D(i,i) is exactly zero. The factorization !> has been completed, but the block diagonal matrix D is !> exactly singular, so the solution could not be computed. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **160** of file **ssysv\_aa.f**. ### subroutine zhesv\_aa (character uplo, integer n, integer nrhs, complex\*16, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, complex\*16, dimension( ldb, \* ) b, integer ldb, complex\*16, dimension( \* ) work, integer lwork, integer info) **ZHESV\_AA computes the solution to system of linear equations A \* X = B for HE matrices** **Purpose:** ``` !> !> ZHESV_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. !> ``` **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 number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> ``` *NRHS* ``` !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 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, if INFO = 0, the tridiagonal matrix T and the !> multipliers used to obtain the factor U or L from the !> factorization A = U**H*T*U or A = L*T*L**H as computed by !> ZHETRF_AA. !> ``` *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). !> ``` *B* ``` !> B is COMPLEX*16 array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *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,3*N-2), and for best !> performance LWORK >= max(1,N*NB), where NB is the optimal !> blocksize for ZHETRF_AA. !> !> 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 !> > 0: if INFO = i, D(i,i) is exactly zero. The factorization !> has been completed, but the block diagonal matrix D is !> exactly singular, so the solution could not be computed. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **160** of file **zhesv\_aa.f**. ### subroutine zsysv\_aa (character uplo, integer n, integer nrhs, complex\*16, dimension( lda, \* ) a, integer lda, integer, dimension( \* ) ipiv, complex\*16, dimension( ldb, \* ) b, integer ldb, complex\*16, dimension( \* ) work, integer lwork, integer info) **ZSYSV\_AA computes the solution to system of linear equations A \* X = B for SY matrices** **Purpose:** ``` !> !> ZSYSV 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. !> ``` **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 number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> ``` *NRHS* ``` !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 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, if INFO = 0, the tridiagonal matrix T and the !> multipliers used to obtain the factor U or L from the !> factorization A = U**T*T*U or A = L*T*L**T as computed by !> ZSYTRF. !> ``` *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). !> ``` *B* ``` !> B is COMPLEX*16 array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *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,3*N-2), and for !> the best performance, LWORK >= MAX(1,N*NB), where NB is !> the optimal blocksize for ZSYTRF_AA. !> !> 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 !> > 0: if INFO = i, D(i,i) is exactly zero. The factorization !> has been completed, but the block diagonal matrix D is !> exactly singular, so the solution could not be computed. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **160** of file **zsysv\_aa.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.